static isc_result_t
configure_hint(const char *zfile, const char *zclass) {
- isc_result_t result;
dns_db_t *db = NULL;
dns_rdataclass_t rdclass;
isc_textregion_t r;
r.base = UNCONST(zclass);
r.length = strlen(zclass);
- result = dns_rdataclass_fromtext(&rdclass, &r);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = dns_rootns_create(isc_g_mctx, rdclass, zfile, &db);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdataclass_fromtext(&rdclass, &r));
+ RETERR(dns_rootns_create(isc_g_mctx, rdclass, zfile, &db));
dns_db_detach(&db);
return ISC_R_SUCCESS;
char *dot = strchr(in, '.');
int len;
if (dot != NULL) {
- isc_result_t result;
- result = reverse_octets(dot + 1, p, end);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
- result = append_str(".", 1, p, end);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(reverse_octets(dot + 1, p, end));
+ RETERR(append_str(".", 1, p, end));
len = (int)(dot - in);
} else {
len = strlen(in);
static isc_result_t
get_reverse(char *reverse, size_t len, char *value, bool strict) {
int r;
- isc_result_t result;
isc_netaddr_t addr;
addr.family = AF_INET6;
dns_name_t *name;
name = dns_fixedname_initname(&fname);
- result = dns_byaddr_createptrname(&addr, name);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_byaddr_createptrname(&addr, name));
dns_name_format(name, reverse, (unsigned int)len);
return ISC_R_SUCCESS;
} else {
if (strict && inet_pton(AF_INET, value, &addr.type.in) != 1) {
return DNS_R_BADDOTTEDQUAD;
}
- result = reverse_octets(value, &p, end);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
- result = append_str(".in-addr.arpa.", 15, &p, end);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(reverse_octets(value, &p, end));
+ RETERR(append_str(".in-addr.arpa.", 15, &p, end));
return ISC_R_SUCCESS;
}
}
unsigned int styleflags = 0;
if (query->lookup->trace || query->lookup->ns_search_only) {
- result = dns_rdatatype_totext(rdata->type, buf);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdatatype_totext(rdata->type, buf));
ADD_STRING(buf, " ");
}
count = 10;
}
for (i = 0; i < count; i++) {
- result = isc_netaddr_totext(&prefix[i].addr, buf);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
- result = isc_buffer_printf(buf, "/%u\n", prefix[i].prefixlen);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_netaddr_totext(&prefix[i].addr, buf));
+ RETERR(isc_buffer_printf(buf, "/%u\n", prefix[i].prefixlen));
}
return ISC_R_SUCCESS;
const char *dot = strchr(in, '.');
size_t len;
if (dot != NULL) {
- isc_result_t result;
- result = reverse_octets(dot + 1, p, end);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
- result = append(".", 1, p, end);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(reverse_octets(dot + 1, p, end));
+ RETERR(append(".", 1, p, end));
len = (int)(dot - in);
} else {
len = (int)strlen(in);
isc_result_t
get_reverse(char *reverse, size_t len, char *value, bool strict) {
int r;
- isc_result_t result;
isc_netaddr_t addr;
addr.family = AF_INET6;
dns_name_t *name;
name = dns_fixedname_initname(&fname);
- result = dns_byaddr_createptrname(&addr, name);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_byaddr_createptrname(&addr, name));
dns_name_format(name, reverse, (unsigned int)len);
return ISC_R_SUCCESS;
} else {
if (strict && inet_pton(AF_INET, value, &addr.type.in) != 1) {
return DNS_R_BADDOTTEDQUAD;
}
- result = reverse_octets(value, &p, end);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(reverse_octets(value, &p, end));
/* Append .in-addr.arpa. and a terminating NUL. */
- result = append(".in-addr.arpa.", 15, &p, end);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(append(".in-addr.arpa.", 15, &p, end));
return ISC_R_SUCCESS;
}
}
const char *section_name, bool headers, dig_query_t *query) {
dns_name_t *print_name;
isc_buffer_t target;
- isc_result_t result;
isc_region_t r;
dns_name_t empty_name;
char tbuf[4096] = { 0 };
continue;
}
if (!short_form) {
- result = dns_rdataset_totext(rdataset,
- print_name, false,
- no_rdata, &target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdataset_totext(rdataset, print_name,
+ false, no_rdata,
+ &target));
#ifdef USEINITALWS
if (first) {
print_name = &empty_name;
printrdata(dns_message_t *msg, dns_rdataset_t *rdataset,
const dns_name_t *owner, const char *set_name, bool headers) {
isc_buffer_t target;
- isc_result_t result;
isc_region_t r;
char tbuf[4096];
isc_buffer_init(&target, tbuf, sizeof(tbuf));
- result = dns_rdataset_totext(rdataset, owner, false, false, &target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdataset_totext(rdataset, owner, false, false, &target));
isc_buffer_usedregion(&target, &r);
printf("%.*s", (int)r.length, (char *)r.base);
if (!ISC_LIST_EMPTY(msg->sections[DNS_SECTION_QUESTION]) && !short_form)
{
printf("\n");
- result = printsection(msg, DNS_SECTION_QUESTION, "QUESTION",
- true, query);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(printsection(msg, DNS_SECTION_QUESTION, "QUESTION", true,
+ query));
}
if (!ISC_LIST_EMPTY(msg->sections[DNS_SECTION_ANSWER])) {
if (!short_form) {
printf("\n");
}
- result = printsection(msg, DNS_SECTION_ANSWER, "ANSWER",
- !short_form, query);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(printsection(msg, DNS_SECTION_ANSWER, "ANSWER",
+ !short_form, query));
}
if (!ISC_LIST_EMPTY(msg->sections[DNS_SECTION_AUTHORITY]) &&
!short_form)
{
printf("\n");
- result = printsection(msg, DNS_SECTION_AUTHORITY, "AUTHORITY",
- true, query);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(printsection(msg, DNS_SECTION_AUTHORITY, "AUTHORITY",
+ true, query));
}
if (!ISC_LIST_EMPTY(msg->sections[DNS_SECTION_ADDITIONAL]) &&
!short_form)
{
printf("\n");
- result = printsection(msg, DNS_SECTION_ADDITIONAL, "ADDITIONAL",
- true, query);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(printsection(msg, DNS_SECTION_ADDITIONAL, "ADDITIONAL",
+ true, query));
}
if ((tsig != NULL) && !short_form) {
printf("\n");
- result = printrdata(msg, tsig, tsigname, "PSEUDOSECTION TSIG",
- true);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(printrdata(msg, tsig, tsigname, "PSEUDOSECTION TSIG",
+ true));
}
if (!short_form) {
printf("\n");
dname = dns_fixedname_initname(&dfname);
isc_buffer_init(&b, owner, strlen(owner));
isc_buffer_add(&b, strlen(owner));
- result = dns_name_fromtext(dname, &b, dns_rootname, 0);
- if (result != ISC_R_SUCCESS) {
- goto cleanup;
- }
+ CHECK(dns_name_fromtext(dname, &b, dns_rootname, 0));
if (dns_name_compare(dname, name) != 0) {
result = DNS_R_BADOWNERNAME;
goto cleanup;
uint32_t old_serial, new_serial = 0;
dns_updatemethod_t used = dns_updatemethod_none;
- result = dns_db_getoriginnode(gdb, &node);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_getoriginnode(gdb, &node));
dns_rdataset_init(&rdataset);
origin = &node->bdb->common.origin;
isc_constregion_t r = { .base = type, .length = strlen(type) };
- result = dns_rdatatype_fromtext(&typeval, (isc_textregion_t *)&r);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdatatype_fromtext(&typeval, (isc_textregion_t *)&r));
isc_lex_create(mctx, 64, &lex);
isc_buffer_constinit(&b, data, datalen);
isc_buffer_add(&b, datalen);
- result = isc_lex_openbuffer(lex, &b);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_lex_openbuffer(lex, &b));
isc_buffer_allocate(mctx, &rb, DNS_RDATA_MAXLENGTH);
result = dns_rdata_fromtext(NULL, node->bdb->common.rdclass, typeval,
static isc_result_t
authors_lookup(bdbnode_t *node) {
- isc_result_t result;
const char **p = NULL;
static const char *authors[] = {
"Mark Andrews", "Curtis Blackburn",
}
for (p = authors; *p != NULL; p++) {
- result = puttxt(node, *p);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(puttxt(node, *p));
}
return ISC_R_SUCCESS;
}
static isc_result_t
ipv4only_lookup(bdbnode_t *node) {
- isc_result_t result;
unsigned char data[2][4] = { { 192, 0, 0, 170 }, { 192, 0, 0, 171 } };
for (int i = 0; i < 2; i++) {
- result = putrdata(node, dns_rdatatype_a, 3600, data[i], 4);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(putrdata(node, dns_rdatatype_a, 3600, data[i], 4));
}
return ISC_R_SUCCESS;
}
dns_name_getlabelsequence(name, 0, labels, &relname);
name = &relname;
- result = createnode(bdb, &node);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(createnode(bdb, &node));
result = builtin_lookup(bdb, name, node);
if (result != ISC_R_SUCCESS && (!isorigin || result != ISC_R_NOTFOUND))
named_builtin_init(void) {
isc_result_t result;
- result = dns_db_register("_builtin", create, &builtin, isc_g_mctx,
- &builtin.dbimp);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_register("_builtin", create, &builtin, isc_g_mctx,
+ &builtin.dbimp));
result = dns_db_register("_dns64", create, &dns64, isc_g_mctx,
&dns64.dbimp);
isc_result_t
named_config_getremotesdef(const cfg_obj_t *cctx, const char *list,
const char *name, const cfg_obj_t **ret) {
- isc_result_t result;
const cfg_obj_t *obj = NULL;
REQUIRE(cctx != NULL);
REQUIRE(name != NULL);
REQUIRE(ret != NULL && *ret == NULL);
- result = cfg_map_get(cctx, list, &obj);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(cfg_map_get(cctx, list, &obj));
CFG_LIST_FOREACH(obj, elt) {
obj = cfg_listelt_value(elt);
if (strcasecmp(cfg_obj_asstring(cfg_tuple_get(obj, "name")),
int i;
size_t len = 0;
uint16_t bits;
- isc_result_t result;
for (i = 0; algorithms[i].str != NULL; i++) {
len = strlen(algorithms[i].str);
return ISC_R_NOTFOUND;
}
if (str[len] == '-') {
- result = isc_parse_uint16(&bits, str + len + 1, 10);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_parse_uint16(&bits, str + len + 1, 10));
if (bits > algorithms[i].size) {
return ISC_R_RANGE;
}
static isc_result_t
getcommand(isc_lex_t *lex, char **cmdp) {
- isc_result_t result;
isc_token_t token;
REQUIRE(cmdp != NULL && *cmdp == NULL);
- result = isc_lex_gettoken(lex, ISC_LEXOPT_EOF, &token);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_lex_gettoken(lex, ISC_LEXOPT_EOF, &token));
isc_lex_ungettoken(lex, &token);
return ISC_R_FAILURE;
}
- result = isccc_cc_lookupstring(data, "type", &cmdline);
- if (result != ISC_R_SUCCESS) {
- /*
- * We have no idea what this is.
- */
- return result;
- }
+ RETERR(isccc_cc_lookupstring(data, "type", &cmdline));
isc_lex_create(isc_g_mctx, strlen(cmdline), &lex);
isc_buffer_constinit(&b, namestr, strlen(namestr));
isc_buffer_add(&b, strlen(namestr));
keyname = dns_fixedname_initname(&fkeyname);
- result = dns_name_fromtext(keyname, &b, dns_rootname, 0);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromtext(keyname, &b, dns_rootname, 0));
break;
case DST_R_UNSUPPORTEDALG:
case DST_R_BADKEYTYPE:
dns_orderopt_t mode = dns_order_none;
const char *str;
isc_buffer_t b;
- isc_result_t result;
bool addroot;
- result = named_config_getclass(cfg_tuple_get(ent, "class"),
- dns_rdataclass_any, &rdclass);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = named_config_gettype(cfg_tuple_get(ent, "type"),
- dns_rdatatype_any, &rdtype);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(named_config_getclass(cfg_tuple_get(ent, "class"),
+ dns_rdataclass_any, &rdclass));
+ RETERR(named_config_gettype(cfg_tuple_get(ent, "type"),
+ dns_rdatatype_any, &rdtype));
obj = cfg_tuple_get(ent, "name");
if (cfg_obj_isstring(obj)) {
isc_buffer_constinit(&b, str, strlen(str));
isc_buffer_add(&b, strlen(str));
dns_fixedname_init(&fixed);
- result = dns_name_fromtext(dns_fixedname_name(&fixed), &b, dns_rootname,
- 0);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromtext(dns_fixedname_name(&fixed), &b, dns_rootname,
+ 0));
obj = cfg_tuple_get(ent, "ordering");
INSIST(cfg_obj_isstring(obj));
static isc_result_t
configure_peer(const cfg_obj_t *cpeer, isc_mem_t *mctx, dns_peer_t **peerp) {
isc_netaddr_t na;
- dns_peer_t *peer;
- const cfg_obj_t *obj;
- const char *str;
- isc_result_t result;
+ dns_peer_t *peer = NULL;
+ const cfg_obj_t *obj = NULL;
+ isc_result_t result = ISC_R_SUCCESS;
unsigned int prefixlen;
cfg_obj_asnetprefix(cfg_map_getname(cpeer), &na, &prefixlen);
- peer = NULL;
- result = dns_peer_newprefix(mctx, &na, prefixlen, &peer);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_peer_newprefix(mctx, &na, prefixlen, &peer));
obj = NULL;
(void)cfg_map_get(cpeer, "bogus", &obj);
obj = NULL;
(void)cfg_map_get(cpeer, "transfer-format", &obj);
if (obj != NULL) {
- str = cfg_obj_asstring(obj);
+ const char *str = cfg_obj_asstring(obj);
if (strcasecmp(str, "many-answers") == 0) {
CHECK(dns_peer_settransferformat(peer,
dns_many_answers));
dlzconfigure_callback(dns_view_t *view, dns_dlzdb_t *dlzdb, dns_zone_t *zone) {
dns_name_t *origin = dns_zone_getorigin(zone);
dns_rdataclass_t zclass = view->rdclass;
- isc_result_t result;
- result = dns_zonemgr_managezone(named_g_server->zonemgr, zone);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_zonemgr_managezone(named_g_server->zonemgr, zone));
+
dns_zone_setstats(zone, named_g_server->zonestats);
return named_zone_configure_writeable_dlz(dlzdb, zone, zclass, origin);
}
str = cfg_obj_asstring(cfg_tuple_get(rpz_obj, "zone name"));
- result = configure_rpz_name(view, rpz_obj, &zone->origin, str, "zone");
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(configure_rpz_name(view, rpz_obj, &zone->origin, str, "zone"));
+
if (dns_name_equal(&zone->origin, dns_rootname)) {
cfg_obj_log(rpz_obj, DNS_RPZ_ERROR_LEVEL,
"invalid zone name '%s'", str);
*old_rpz_okp = false;
}
- result = configure_rpz_name2(view, rpz_obj, &zone->client_ip,
- DNS_RPZ_CLIENT_IP_ZONE, &zone->origin);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = configure_rpz_name2(view, rpz_obj, &zone->ip, DNS_RPZ_IP_ZONE,
- &zone->origin);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = configure_rpz_name2(view, rpz_obj, &zone->nsdname,
- DNS_RPZ_NSDNAME_ZONE, &zone->origin);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = configure_rpz_name2(view, rpz_obj, &zone->nsip,
- DNS_RPZ_NSIP_ZONE, &zone->origin);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = configure_rpz_name(view, rpz_obj, &zone->passthru,
- DNS_RPZ_PASSTHRU_NAME, "name");
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = configure_rpz_name(view, rpz_obj, &zone->drop,
- DNS_RPZ_DROP_NAME, "name");
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = configure_rpz_name(view, rpz_obj, &zone->tcp_only,
- DNS_RPZ_TCP_ONLY_NAME, "name");
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(configure_rpz_name2(view, rpz_obj, &zone->client_ip,
+ DNS_RPZ_CLIENT_IP_ZONE, &zone->origin));
+ RETERR(configure_rpz_name2(view, rpz_obj, &zone->ip, DNS_RPZ_IP_ZONE,
+ &zone->origin));
+ RETERR(configure_rpz_name2(view, rpz_obj, &zone->nsdname,
+ DNS_RPZ_NSDNAME_ZONE, &zone->origin));
+ RETERR(configure_rpz_name2(view, rpz_obj, &zone->nsip,
+ DNS_RPZ_NSIP_ZONE, &zone->origin));
+ RETERR(configure_rpz_name(view, rpz_obj, &zone->passthru,
+ DNS_RPZ_PASSTHRU_NAME, "name"));
+ RETERR(configure_rpz_name(view, rpz_obj, &zone->drop, DNS_RPZ_DROP_NAME,
+ "name"));
+ RETERR(configure_rpz_name(view, rpz_obj, &zone->tcp_only,
+ DNS_RPZ_TCP_ONLY_NAME, "name"));
obj = cfg_tuple_get(rpz_obj, "policy");
if (cfg_obj_isvoid(obj)) {
INSIST(zone->policy != DNS_RPZ_POLICY_ERROR);
if (zone->policy == DNS_RPZ_POLICY_CNAME) {
str = cfg_obj_asstring(cfg_tuple_get(obj, "cname"));
- result = configure_rpz_name(view, rpz_obj, &zone->cname,
- str, "cname");
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(configure_rpz_name(view, rpz_obj, &zone->cname,
+ str, "cname"));
}
}
if (*old_rpz_okp && (zone->policy != old->policy ||
const dns_rpz_zones_t *old = NULL;
bool pview_must_detach = false;
const dns_rpz_zone_t *old_zone = NULL;
- isc_result_t result;
+ isc_result_t result = ISC_R_SUCCESS;
*old_rpz_okp = false;
}
nsdname_on = nsdname_enabled ? DNS_RPZ_ALL_ZBITS : 0;
- result = dns_rpz_new_zones(view, &view->rpzs, first_time);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rpz_new_zones(view, &view->rpzs, first_time));
zones = view->rpzs;
catz_changeview(dns_catz_entry_t *entry, void *arg1, void *arg2) {
dns_view_t *pview = arg1;
dns_view_t *view = arg2;
-
dns_zone_t *zone = NULL;
+
isc_result_t result = dns_view_findzone(
pview, dns_catz_entry_getname(entry), DNS_ZTFIND_EXACT, &zone);
-
if (result != ISC_R_SUCCESS) {
return;
}
min_entries = 1;
}
}
- result = dns_rrl_init(&rrl, view, min_entries);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rrl_init(&rrl, view, min_entries));
i = ISC_MAX(20000, min_entries);
obj = NULL;
const cfg_obj_t *faddresses = NULL;
dns_fwdpolicy_t fwdpolicy = dns_fwdpolicy_none;
dns_forwarderlist_t fwdlist;
- isc_result_t result;
+ isc_result_t result = ISC_R_SUCCESS;
in_port_t port;
in_port_t tls_port;
const char *tls = NULL;
if (cfg_obj_isstring(tlspobj)) {
tls = cfg_obj_asstring(tlspobj);
if (tls != NULL) {
- result = validate_tls(config, view, tlspobj,
- tls, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(validate_tls(config, view, tlspobj, tls,
+ NULL));
}
}
}
dns_view_sfd_add(view, origin);
}
- result = ISC_R_SUCCESS;
-
cleanup:
ISC_LIST_FOREACH(fwdlist, fwd, link) {
static isc_result_t
find_view(const cfg_obj_t *vconfig, dns_viewlist_t *viewlist,
dns_view_t **viewp) {
- isc_result_t result;
const char *viewname = NULL;
dns_rdataclass_t viewclass;
dns_view_t *view = NULL;
- result = get_viewinfo(vconfig, &viewname, &viewclass);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = dns_viewlist_find(viewlist, viewname, viewclass, &view);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(get_viewinfo(vconfig, &viewname, &viewclass));
+ RETERR(dns_viewlist_find(viewlist, viewname, viewclass, &view));
*viewp = view;
return ISC_R_SUCCESS;
dns_rdataclass_t viewclass;
dns_view_t *view = NULL;
- result = get_viewinfo(vconfig, &viewname, &viewclass);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(get_viewinfo(vconfig, &viewname, &viewclass));
result = dns_viewlist_find(viewlist, viewname, viewclass, &view);
if (result == ISC_R_SUCCESS) {
ISC_LOG_INFO, "generating session key for dynamic DNS");
/* generate key */
- result = dst_key_generate(keyname, alg, bits, 1, 0, DNS_KEYPROTO_ANY,
- dns_rdataclass_in, NULL, mctx, &key, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dst_key_generate(keyname, alg, bits, 1, 0, DNS_KEYPROTO_ANY,
+ dns_rdataclass_in, NULL, mctx, &key, NULL));
/*
* Dump the key to the buffer for later use.
isc_buffer_constinit(&buffer, keynamestr, strlen(keynamestr));
isc_buffer_add(&buffer, strlen(keynamestr));
keyname = dns_fixedname_initname(&fname);
- result = dns_name_fromtext(keyname, &buffer, dns_rootname, 0);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromtext(keyname, &buffer, dns_rootname, 0));
obj = NULL;
result = named_config_get(maps, "session-keyalg", &obj);
cfg_obj_t *vconfig = cfg_listelt_value(element);
dns_view_t *view = NULL;
- result = find_view(vconfig, viewlist, &view);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(find_view(vconfig, viewlist, &view));
result = configure_view(view, viewlist, config, vconfig,
cachelist, &server->cachelist, kasplist,
*/
if (explicitviews == false) {
dns_view_t *view = NULL;
- result = find_view(NULL, viewlist, &view);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(find_view(NULL, viewlist, &view));
result = configure_view(view, viewlist, config, NULL, cachelist,
&server->cachelist, kasplist, bindkeys,
isc_g_mctx, aclctx, tlsctx_client_cache,
/*
* Create the built-in key store ("key-directory").
*/
- result = cfg_keystore_fromconfig(NULL, isc_g_mctx, keystorelist, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(cfg_keystore_fromconfig(NULL, isc_g_mctx, keystorelist, NULL));
/*
* Create the DNSSEC key stores.
CFG_LIST_FOREACH(keystores, element) {
cfg_obj_t *kconfig = cfg_listelt_value(element);
- result = cfg_keystore_fromconfig(kconfig, isc_g_mctx,
- keystorelist, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(cfg_keystore_fromconfig(kconfig, isc_g_mctx,
+ keystorelist, NULL));
}
return result;
cfg_obj_t *kconfig = cfg_listelt_value(element);
dns_kasp_t *kasp = NULL;
- result = cfg_kasp_fromconfig(kconfig, default_kasp, kaspopts,
- isc_g_mctx, keystorelist, kasplist,
- &kasp);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
+ RETERR(cfg_kasp_fromconfig(kconfig, default_kasp, kaspopts,
+ isc_g_mctx, keystorelist, kasplist,
+ &kasp));
INSIST(kasp != NULL);
dns_kasp_freeze(kasp);
isc_result_t
named_server_retransfercommand(named_server_t *server, isc_lex_t *lex,
isc_buffer_t *text) {
- isc_result_t result;
+ isc_result_t result = ISC_R_SUCCESS;
const char *arg = NULL;
dns_zone_t *zone = NULL;
dns_zone_t *raw = NULL;
arg = next_token(lex, text);
}
- result = zone_from_args(server, lex, arg, &zone, NULL, text, false);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(zone_from_args(server, lex, arg, &zone, NULL, text, false));
+
if (zone == NULL) {
return ISC_R_UNEXPECTEDEND;
}
isc_result_t
named_server_reloadcommand(named_server_t *server, isc_lex_t *lex,
isc_buffer_t *text) {
- isc_result_t result;
+ isc_result_t result = ISC_R_SUCCESS;
dns_zone_t *zone = NULL;
dns_zonetype_t type;
const char *msg = NULL;
REQUIRE(text != NULL);
- result = zone_from_args(server, lex, NULL, &zone, NULL, text, true);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(zone_from_args(server, lex, NULL, &zone, NULL, text, true));
+
if (zone == NULL) {
result = reload(server);
switch (result) {
isc_result_t
named_server_notifycommand(named_server_t *server, isc_lex_t *lex,
isc_buffer_t *text) {
- isc_result_t result;
dns_zone_t *zone = NULL;
const char msg[] = "zone notify queued";
REQUIRE(text != NULL);
- result = zone_from_args(server, lex, NULL, &zone, NULL, text, true);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(zone_from_args(server, lex, NULL, &zone, NULL, text, true));
+
if (zone == NULL) {
return ISC_R_UNEXPECTEDEND;
}
isc_result_t
named_server_refreshcommand(named_server_t *server, isc_lex_t *lex,
isc_buffer_t *text) {
- isc_result_t result;
dns_zone_t *zone = NULL, *raw = NULL;
const char msg1[] = "zone refresh queued";
const char msg2[] = "not a secondary, mirror, or stub zone";
REQUIRE(text != NULL);
- result = zone_from_args(server, lex, NULL, &zone, NULL, text, true);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(zone_from_args(server, lex, NULL, &zone, NULL, text, true));
+
if (zone == NULL) {
return ISC_R_UNEXPECTEDEND;
}
cfg_aclconfctx_t *aclctx, isc_mem_t *mctx,
uint16_t family, isc_tlsctx_cache_t *tlsctx_cache,
ns_listenlist_t **target) {
- isc_result_t result;
+ isc_result_t result = ISC_R_SUCCESS;
ns_listenlist_t *dlist = NULL;
REQUIRE(target != NULL && *target == NULL);
- result = ns_listenlist_create(mctx, &dlist);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(ns_listenlist_create(mctx, &dlist));
CFG_LIST_FOREACH(listenlist, element) {
ns_listenelt_t *delt = NULL;
cfg_aclconfctx_t *aclctx, isc_mem_t *mctx, uint16_t family,
isc_tlsctx_cache_t *tlsctx_cache,
ns_listenelt_t **target) {
- isc_result_t result;
+ isc_result_t result = ISC_R_SUCCESS;
const cfg_obj_t *ltup = NULL;
const cfg_obj_t *tlsobj = NULL, *httpobj = NULL;
const cfg_obj_t *portobj = NULL;
if (named_g_httpsport != 0) {
port = named_g_httpsport;
} else {
- result = named_config_getport(
- config, "https-port", &port);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(named_config_getport(
+ config, "https-port", &port));
}
} else if (http && !do_tls) {
if (named_g_httpport != 0) {
port = named_g_httpport;
} else {
- result = named_config_getport(
- config, "http-port", &port);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(named_config_getport(config, "http-port",
+ &port));
}
} else if (do_tls) {
if (named_g_tlsport != 0) {
port = named_g_tlsport;
} else {
- result = named_config_getport(
- config, "tls-port", &port);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(named_config_getport(config, "tls-port",
+ &port));
}
} else {
if (named_g_port != 0) {
port = named_g_port;
} else {
- result = named_config_getport(config, "port",
- &port);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(named_config_getport(config, "port",
+ &port));
}
}
} else {
isc_result_t
named_server_flushnode(named_server_t *server, isc_lex_t *lex, bool tree) {
- char *ptr, *viewname;
+ char *ptr = NULL, *viewname = NULL;
char target[DNS_NAME_FORMATSIZE];
bool flushed;
bool found;
- isc_result_t result;
+ isc_result_t result = ISC_R_SUCCESS;
isc_buffer_t b;
dns_fixedname_t fixed;
dns_name_t *name = NULL;
isc_buffer_constinit(&b, target, strlen(target));
isc_buffer_add(&b, strlen(target));
name = dns_fixedname_initname(&fixed);
- result = dns_name_fromtext(name, &b, dns_rootname, 0);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromtext(name, &b, dns_rootname, 0));
/* Look for the view name. */
viewname = next_token(lex, NULL);
*/
isc_result_t
named_server_rekey(named_server_t *server, isc_lex_t *lex, isc_buffer_t *text) {
- isc_result_t result;
+ isc_result_t result = ISC_R_SUCCESS;
dns_zone_t *zone = NULL;
dns_zonetype_t type;
bool fullsign = false;
- char *ptr;
+ char *ptr = NULL;
REQUIRE(text != NULL);
REQUIRE(text != NULL);
- result = zone_from_args(server, lex, NULL, &zone, NULL, text, false);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(zone_from_args(server, lex, NULL, &zone, NULL, text, false));
+
if (zone == NULL) {
return ISC_R_UNEXPECTEDEND; /* XXX: or do all zones? */
}
isc_result_t
named_server_sync(named_server_t *server, isc_lex_t *lex, isc_buffer_t *text) {
- isc_result_t result, tresult;
+ isc_result_t result = ISC_R_SUCCESS, tresult;
dns_zone_t *zone = NULL;
char classstr[DNS_RDATACLASS_FORMATSIZE];
char zonename[DNS_NAME_FORMATSIZE];
REQUIRE(text != NULL);
- result = zone_from_args(server, lex, arg, &zone, NULL, text, false);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(zone_from_args(server, lex, arg, &zone, NULL, text, false));
if (zone == NULL) {
isc_loopmgr_pause();
isc_result_t
named_server_freeze(named_server_t *server, bool freeze, isc_lex_t *lex,
isc_buffer_t *text) {
- isc_result_t result, tresult;
+ isc_result_t result = ISC_R_SUCCESS;
dns_zone_t *mayberaw = NULL, *raw = NULL;
dns_zonetype_t type;
char classstr[DNS_RDATACLASS_FORMATSIZE];
REQUIRE(text != NULL);
- result = zone_from_args(server, lex, NULL, &mayberaw, NULL, text, true);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(zone_from_args(server, lex, NULL, &mayberaw, NULL, text, true));
+
if (mayberaw == NULL) {
+ isc_result_t tresult = ISC_R_SUCCESS;
isc_loopmgr_pause();
- tresult = ISC_R_SUCCESS;
ISC_LIST_FOREACH(server->viewlist, view, link) {
- result = dns_view_freezezones(view, freeze);
- if (result != ISC_R_SUCCESS && tresult == ISC_R_SUCCESS)
+ tresult = dns_view_freezezones(view, freeze);
+ if (tresult != ISC_R_SUCCESS && result == ISC_R_SUCCESS)
{
- tresult = result;
+ result = tresult;
}
}
isc_loopmgr_resume();
isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
ISC_LOG_INFO, "%s all zones: %s",
freeze ? "freezing" : "thawing",
- isc_result_totext(tresult));
- return tresult;
+ isc_result_totext(result));
+ return result;
}
dns_zone_getraw(mayberaw, &raw);
if (raw != NULL) {
cfg_aclconfctx_t *aclctx, dns_zone_t *zone,
void (*setzacl)(dns_zone_t *, dns_acl_t *),
void (*clearzacl)(dns_zone_t *)) {
- isc_result_t result;
const cfg_obj_t *maps[6] = { 0 };
const cfg_obj_t *aclobj = NULL;
int i = 0;
}
parse_acl:
- result = cfg_acl_fromconfig(aclobj, config, aclctx, isc_g_mctx, 0,
- &acl);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(cfg_acl_fromconfig(aclobj, config, aclctx, isc_g_mctx, 0, &acl));
(*setzacl)(zone, acl);
/* Set the view default now */
isc_region_t region;
/* Create the DB beforehand */
- result = dns_db_create(mctx, dbtype, dns_zone_getorigin(zone),
- dns_dbtype_stub, dns_zone_getclass(zone), 0,
- NULL, &db);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_create(mctx, dbtype, dns_zone_getorigin(zone),
+ dns_dbtype_stub, dns_zone_getclass(zone), 0, NULL,
+ &db));
dns_rdataset_init(&rdataset);
static isc_result_t
strtoargvsub(isc_mem_t *mctx, char *s, unsigned int *argcp, char ***argvp,
unsigned int n) {
- isc_result_t result;
-
/* Discard leading whitespace. */
while (*s == ' ' || *s == '\t') {
s++;
*p++ = '\0';
}
- result = strtoargvsub(mctx, p, argcp, argvp, n + 1);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(strtoargvsub(mctx, p, argcp, argvp, n + 1));
(*argvp)[n] = s;
}
return ISC_R_SUCCESS;
isc_result_t result;
dns_zone_settype(zone, dns_zone_dlz);
- result = dns_sdlz_setdb(dlzdatabase, rdclass, name, &db);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_sdlz_setdb(dlzdatabase, rdclass, name, &db));
result = dns_zone_dlzpostload(zone, db);
dns_db_detach(&db);
return result;
isc_buffer_t addrb;
char addrbdata[DNS_NAME_FORMATSIZE];
isc_region_t addrr;
- isc_result_t result;
REQUIRE(DNS_NAME_VALID(synthname));
REQUIRE(na->family == AF_INET || na->family == AF_INET6);
isc_buffer_copyregion(&b, &inst->prefix);
isc_buffer_init(&addrb, addrbdata, sizeof(addrbdata));
- result = isc_netaddr_totext(na, &addrb);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_netaddr_totext(na, &addrb));
/*
* IDN compatibility, as an IPv6 begining or ending with `::` will be
dns_name_init(&inst->origin);
if (result == ISC_R_SUCCESS) {
originstr = cfg_obj_asstring(obj);
- result = dns_name_fromstring(&inst->origin, originstr, NULL, 0,
- inst->mctx);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromstring(&inst->origin, originstr, NULL, 0,
+ inst->mctx));
if (!dns_name_isabsolute(&inst->origin)) {
isc_log_write(NS_LOGCATEGORY_GENERAL,
return result;
}
- result = cfg_acl_fromconfig(obj, cfg, aclctx, inst->mctx, 0,
- &inst->allowedsynth);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(cfg_acl_fromconfig(obj, cfg, aclctx, inst->mctx, 0,
+ &inst->allowedsynth));
for (unsigned int i = 0; i < inst->allowedsynth->length; i++) {
switch (inst->allowedsynth->elements[i].type) {
loginfo("dlz_example: lookup connection from %s", buf);
found = true;
- result = state->putrr(lookup, "TXT", 0, buf);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(state->putrr(lookup, "TXT", 0, buf));
}
if (strcmp(name, "too-long") == 0 ||
}
buf[i] = '\0';
found = true;
- result = state->putrr(lookup, "TXT", 0, buf);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(state->putrr(lookup, "TXT", 0, buf));
}
/* Tests for DLZ redirection zones */
for (i = 0; i < MAX_RECORDS; i++) {
if (strcasecmp(state->current[i].name, full_name) == 0) {
found = true;
- result = state->putrr(lookup, state->current[i].type,
- state->current[i].ttl,
- state->current[i].data);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(state->putrr(lookup, state->current[i].type,
+ state->current[i].ttl,
+ state->current[i].data));
}
}
}
for (i = 0; i < MAX_RECORDS; i++) {
- isc_result_t result;
if (strlen(state->current[i].name) == 0U) {
continue;
}
- result = state->putnamedrr(allnodes, state->current[i].name,
- state->current[i].type,
- state->current[i].ttl,
- state->current[i].data);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(state->putnamedrr(allnodes, state->current[i].name,
+ state->current[i].type,
+ state->current[i].ttl,
+ state->current[i].data));
}
return ISC_R_SUCCESS;
loadzone(dns_db_t **db, const char *origin, const char *filename) {
isc_result_t result;
dns_fixedname_t fixed;
- dns_name_t *name = NULL;
+ dns_name_t *name = dns_fixedname_initname(&fixed);
- name = dns_fixedname_initname(&fixed);
-
- result = dns_name_fromstring(name, origin, dns_rootname, 0, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, name,
- dns_dbtype_zone, dns_rdataclass_in, 0, NULL, db);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromstring(name, origin, dns_rootname, 0, NULL));
+ RETERR(dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, name, dns_dbtype_zone,
+ dns_rdataclass_in, 0, NULL, db));
result = dns_db_load(*db, filename, dns_masterformat_text, 0);
if (result == DNS_R_SEENINCLUDE) {
*/
isc_result_t
dns_acl_merge(dns_acl_t *dest, dns_acl_t *source, bool pos) {
- isc_result_t result;
unsigned int nelem, i;
int max_node = 0, nodes;
* node_count value is set correctly afterward.
*/
nodes = max_node + dns_acl_node_count(dest);
- result = dns_iptable_merge(dest->iptable, source->iptable, pos);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_iptable_merge(dest->iptable, source->iptable, pos));
if (nodes > dns_acl_node_count(dest)) {
dns_acl_node_count(dest) = nodes;
}
static isc_result_t
putstr(isc_buffer_t *b, const char *str) {
- isc_result_t result;
-
- result = isc_buffer_reserve(b, strlen(str));
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_buffer_reserve(b, strlen(str)));
isc_buffer_putstr(b, str);
return ISC_R_SUCCESS;
isc_result_t
dns_cache_flush(dns_cache_t *cache) {
- dns_db_t *db = NULL, *olddb;
- isc_mem_t *tmctx = NULL, *oldtmctx;
- isc_mem_t *hmctx = NULL, *oldhmctx;
- isc_result_t result;
+ dns_db_t *db = NULL, *olddb = NULL;
+ isc_mem_t *tmctx = NULL, *oldtmctx = NULL;
+ isc_mem_t *hmctx = NULL, *oldhmctx = NULL;
- result = cache_create_db(cache, &db, &tmctx, &hmctx);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(cache_create_db(cache, &db, &tmctx, &hmctx));
LOCK(&cache->lock);
isc_mem_clearwater(cache->tmctx);
static isc_result_t
clearnode(dns_db_t *db, dns_dbnode_t *node) {
- isc_result_t result;
dns_rdatasetiter_t *iter = NULL;
- result = dns_db_allrdatasets(db, node, NULL, DNS_DB_STALEOK,
- (isc_stdtime_t)0, &iter);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_allrdatasets(db, node, NULL, DNS_DB_STALEOK,
+ (isc_stdtime_t)0, &iter));
DNS_RDATASETITER_FOREACH(iter) {
+ isc_result_t result;
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(iter, &rdataset);
}
dns_rdatasetiter_destroy(&iter);
- return result;
+ return ISC_R_SUCCESS;
}
static isc_result_t
return ISC_R_FAILURE;
}
- result = dns_rdataset_first(value);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdataset_first(value));
dns_rdata_init(&rdata);
dns_rdataset_current(value, &rdata);
- result = dns_rdata_tostruct(&rdata, &ptr, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdata_tostruct(&rdata, &ptr, NULL));
if (dns_name_countlabels(&ptr.ptr) == 0) {
CHECK(ISC_R_FAILURE);
return ISC_R_FAILURE;
}
- result = dns_rdataset_first(value);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdataset_first(value));
dns_rdata_init(&rdata);
dns_rdataset_current(value, &rdata);
- result = dns_rdata_tostruct(&rdata, &ptr, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdata_tostruct(&rdata, &ptr, NULL));
result = isc_ht_find(catz->entries, mhash->base, mhash->length,
(void **)&entry);
return ISC_R_FAILURE;
}
- result = dns_rdataset_first(value);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdataset_first(value));
dns_rdata_init(&rdata);
dns_rdataset_current(value, &rdata);
- result = dns_rdata_tostruct(&rdata, &rdatatxt, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdata_tostruct(&rdata, &rdatatxt, NULL));
CHECK(dns_rdata_txt_first(&rdatatxt));
RUNTIME_CHECK(result == ISC_R_SUCCESS);
dns_rdata_init(&rdata);
dns_rdataset_current(value, &rdata);
- result = dns_rdata_tostruct(&rdata, &rdata_apl, catz->catzs->mctx);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdata_tostruct(&rdata, &rdata_apl, catz->catzs->mctx));
isc_buffer_allocate(catz->catzs->mctx, &aclb, 16);
for (result = dns_rdata_apl_first(&rdata_apl); result == ISC_R_SUCCESS;
result = dns_rdata_apl_next(&rdata_apl))
nrres = dns_name_fullcompare(src_name, &catz->name, &order, &nlabels);
if (nrres == dns_namereln_equal) {
if (rdataset->type == dns_rdatatype_soa) {
- result = dns_rdataset_first(rdataset);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdataset_first(rdataset));
dns_rdataset_current(rdataset, &rdata);
result = dns_rdata_tostruct(&rdata, &soa, NULL);
}
dns_rdatacallbacks_init(&callbacks);
- result = dns_db_beginload(db, &callbacks);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_beginload(db, &callbacks));
result = dns_master_loadfile(filename, &db->origin, &db->origin,
db->rdclass, options, 0, &callbacks, NULL,
NULL, db->mctx, format, 0);
REQUIRE(dns_db_iszone(db) || dns_db_isstub(db));
- result = dns_db_findnode(db, dns_db_origin(db), false, &node);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_findnode(db, dns_db_origin(db), false, &node));
dns_rdataset_init(&rdataset);
result = dns_db_findrdataset(db, node, ver, dns_rdatatype_soa, 0,
*/
isc_sockaddr_anyofpf(&sa_any, isc_sockaddr_pf(localaddr));
if (!isc_sockaddr_eqaddr(&sa_any, localaddr)) {
- result = isc_nm_checkaddr(localaddr, isc_socktype_udp);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_nm_checkaddr(localaddr, isc_socktype_udp));
}
dispatch_allocate(mgr, isc_socktype_udp, tid, &disp);
}
if (transport_type == DNS_TRANSPORT_TLS) {
- isc_result_t result;
-
- result = dns_transport_get_tlsctx(
- resp->transport, &resp->peer, resp->tlsctx_cache,
- resp->mctx, &tlsctx, &sess_cache);
-
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_transport_get_tlsctx(resp->transport, &resp->peer,
+ resp->tlsctx_cache, resp->mctx,
+ &tlsctx, &sess_cache));
INSIST(tlsctx != NULL);
}
const dns_name_t *reqsigner, dns_aclenv_t *env,
unsigned int flags, unsigned char *a, unsigned char *aaaa) {
unsigned int nbytes, i;
- isc_result_t result;
int match;
if ((dns64->flags & DNS_DNS64_RECURSIVE_ONLY) != 0 &&
}
if (dns64->clients != NULL && reqaddr != NULL) {
- result = dns_acl_match(reqaddr, reqsigner, dns64->clients, env,
- &match, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_acl_match(reqaddr, reqsigner, dns64->clients, env,
+ &match, NULL));
if (match <= 0) {
return DNS_R_DISALLOWED;
}
memmove(&ina.s_addr, a, 4);
isc_netaddr_fromin(&netaddr, &ina);
- result = dns_acl_match(&netaddr, NULL, dns64->mapped, env,
- &match, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_acl_match(&netaddr, NULL, dns64->mapped, env, &match,
+ NULL));
if (match <= 0) {
return DNS_R_DISALLOWED;
}
digest_sig(dst_context_t *ctx, bool downcase, dns_rdata_t *sigrdata,
dns_rdata_rrsig_t *rrsig) {
isc_region_t r;
- isc_result_t ret;
dns_fixedname_t fname;
dns_rdata_toregion(sigrdata, &r);
INSIST(r.length >= 19);
r.length = 18;
- ret = dst_context_adddata(ctx, &r);
- if (ret != ISC_R_SUCCESS) {
- return ret;
- }
+ RETERR(dst_context_adddata(ctx, &r));
if (downcase) {
dns_fixedname_init(&fname);
sig.timesigned = *inception;
sig.timeexpire = *expire;
sig.keyid = dst_key_id(key);
- ret = dst_key_sigsize(key, &sigsize);
- if (ret != ISC_R_SUCCESS) {
- return ret;
- }
+ RETERR(dst_key_sigsize(key, &sigsize));
sig.siglen = sigsize;
/*
* The actual contents of sig.signature are not important yet, since
REQUIRE(mctx != NULL);
REQUIRE(sigrdata != NULL && sigrdata->type == dns_rdatatype_rrsig);
- ret = dns_rdata_tostruct(sigrdata, &sig, NULL);
- if (ret != ISC_R_SUCCESS) {
- return ret;
- }
+ RETERR(dns_rdata_tostruct(sigrdata, &sig, NULL));
if (set->type != sig.covered) {
return DNS_R_SIGINVALID;
isc_result_t
dns_dnssec_make_dnskey(dst_key_t *key, unsigned char *buf, int bufsize,
dns_rdata_t *target) {
- isc_result_t result;
isc_buffer_t b;
isc_region_t r;
isc_buffer_init(&b, buf, bufsize);
- result = dst_key_todns(key, &b);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dst_key_todns(key, &b));
dns_rdata_reset(target);
isc_buffer_usedregion(&b, &r);
delete_cds(dns_dnsseckey_t *key, dns_rdata_t *keyrdata, const char *keystr,
dns_rdataset_t *cds, unsigned int digesttype, dns_diff_t *diff,
isc_mem_t *mctx) {
- isc_result_t r;
unsigned char dsbuf[DNS_DS_BUFFERSIZE];
dns_rdata_t cdsrdata = DNS_RDATA_INIT;
dns_name_t *origin = dst_key_name(key->key);
- r = dns_ds_buildrdata(origin, keyrdata, digesttype, dsbuf,
- sizeof(dsbuf), &cdsrdata);
- if (r != ISC_R_SUCCESS) {
- return r;
- }
+ RETERR(dns_ds_buildrdata(origin, keyrdata, digesttype, dsbuf,
+ sizeof(dsbuf), &cdsrdata));
cdsrdata.type = dns_rdatatype_cds;
if (exists(cds, &cdsrdata)) {
dns_rdata_ds_t ds;
isc_buffer_t b;
- result = dns_ds_fromkeyrdata(owner, key, digest_type, digest, len, &ds);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_ds_fromkeyrdata(owner, key, digest_type, digest, len, &ds));
memset(buffer, 0, DNS_DS_BUFFERSIZE);
isc_buffer_init(&b, buffer, DNS_DS_BUFFERSIZE);
dst_key_t *key = NULL;
dns_keytag_t id, rid;
isc_region_t r;
- isc_result_t result;
isc_buffer_remainingregion(source, &r);
flags |= (extflags << 16);
}
- result = frombuffer(name, alg, flags, proto, rdclass, source, mctx,
- &key);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(frombuffer(name, alg, flags, proto, rdclass, source, mctx,
+ &key));
key->key_id = id;
key->key_rid = rid;
dst_key_t *key = NULL;
isc_result_t result;
- result = frombuffer(name, alg, flags, protocol, rdclass, source, mctx,
- &key);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(frombuffer(name, alg, flags, protocol, rdclass, source, mctx,
+ &key));
result = computeid(key);
if (result != ISC_R_SUCCESS) {
* Make the filename.
*/
isc_buffer_init(&fileb, filename, sizeof(filename));
- result = dst_key_buildfilename(key, DST_TYPE_STATE, directory, &fileb);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dst_key_buildfilename(key, DST_TYPE_STATE, directory, &fileb));
isc_buffer_init(&tmpb, tmpname, sizeof(tmpname));
- result = dst_key_buildfilename(key, DST_TYPE_TEMPLATE, directory,
- &tmpb);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dst_key_buildfilename(key, DST_TYPE_TEMPLATE, directory, &tmpb));
mode_t mode = issymmetric(key) ? S_IRUSR | S_IWUSR
: S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
isc_buffer_init(&textb, text_array, sizeof(text_array));
isc_buffer_init(&classb, class_array, sizeof(class_array));
- result = dst_key_todns(key, &keyb);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dst_key_todns(key, &keyb));
isc_buffer_usedregion(&keyb, &r);
dns_rdata_fromregion(&rdata, key->key_class, dns_rdatatype_dnskey, &r);
* Make the filename.
*/
isc_buffer_init(&fileb, filename, sizeof(filename));
- result = dst_key_buildfilename(key, DST_TYPE_PUBLIC, directory, &fileb);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dst_key_buildfilename(key, DST_TYPE_PUBLIC, directory, &fileb));
isc_buffer_init(&tmpb, tmpname, sizeof(tmpname));
- result = dst_key_buildfilename(key, DST_TYPE_TEMPLATE, directory,
- &tmpb);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dst_key_buildfilename(key, DST_TYPE_TEMPLATE, directory, &tmpb));
/* Create temporary public key file. */
mode_t mode = issymmetric(key) ? S_IRUSR | S_IWUSR
buildfilename(dns_name_t *name, dns_keytag_t id, unsigned int alg,
unsigned int type, const char *directory, isc_buffer_t *out) {
const char *suffix = "";
- isc_result_t result;
REQUIRE(out != NULL);
REQUIRE(alg != 0 && alg != DST_ALG_PRIVATEOID &&
return ISC_R_NOSPACE;
}
isc_buffer_putstr(out, "K");
- result = dns_name_tofilenametext(name, false, out);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_tofilenametext(name, false, out));
return isc_buffer_printf(out, "+%03d+%05d%s", alg, id, suffix);
}
}
isc_buffer_init(&fileb, filename, sizeof(filename));
- result = dst_key_buildfilename(key, DST_TYPE_PRIVATE, directory,
- &fileb);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dst_key_buildfilename(key, DST_TYPE_PRIVATE, directory, &fileb));
result = isc_file_mode(filename, &mode);
if (result == ISC_R_SUCCESS && mode != (S_IRUSR | S_IWUSR)) {
}
isc_buffer_init(&tmpb, tmpname, sizeof(tmpname));
- result = dst_key_buildfilename(key, DST_TYPE_TEMPLATE, directory,
- &tmpb);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dst_key_buildfilename(key, DST_TYPE_TEMPLATE, directory, &tmpb));
fp = dst_key_open(tmpname, S_IRUSR | S_IWUSR);
if (fp == NULL) {
hmac_parse(const isc_md_type_t *type, dst_key_t *key, isc_lex_t *lexer,
dst_key_t *pub) {
dst_private_t priv;
- isc_result_t result, tresult;
+ isc_result_t result = ISC_R_SUCCESS, tresult;
isc_buffer_t b;
isc_mem_t *mctx = key->mctx;
unsigned int i;
UNUSED(pub);
/* read private key file */
- result = dst__privstruct_parse(key, hmac__to_dst_alg(type), lexer, mctx,
- &priv);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dst__privstruct_parse(key, hmac__to_dst_alg(type), lexer, mctx,
+ &priv));
if (key->external) {
result = DST_R_EXTERNALKEY;
*/
isc_result_t
dns_iptable_merge(dns_iptable_t *tab, dns_iptable_t *source, bool pos) {
- isc_result_t result;
isc_radix_node_t *node, *new_node;
int i, max_node = 0;
RADIX_WALK(source->radix->head, node) {
new_node = NULL;
- result = isc_radix_insert(tab->radix, &new_node, node, NULL);
-
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_radix_insert(tab->radix, &new_node, node, NULL));
/*
* If we're negating a nested ACL, then we should
*/
static isc_result_t
journal_read_xhdr(dns_journal_t *j, journal_xhdr_t *xhdr) {
- isc_result_t result;
-
j->it.cpos.offset = j->offset;
switch (j->xhdr_version) {
case XHDR_VERSION1: {
journal_rawxhdr_ver1_t raw;
- result = journal_read(j, &raw, sizeof(raw));
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(journal_read(j, &raw, sizeof(raw)));
xhdr->size = decode_uint32(raw.size);
xhdr->count = 0;
xhdr->serial0 = decode_uint32(raw.serial0);
case XHDR_VERSION2: {
journal_rawxhdr_t raw;
- result = journal_read(j, &raw, sizeof(raw));
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(journal_read(j, &raw, sizeof(raw)));
xhdr->size = decode_uint32(raw.size);
xhdr->count = decode_uint32(raw.count);
xhdr->serial0 = decode_uint32(raw.serial0);
static isc_result_t
journal_read_rrhdr(dns_journal_t *j, journal_rrhdr_t *rrhdr) {
journal_rawrrhdr_t raw;
- isc_result_t result;
- result = journal_read(j, &raw, sizeof(raw));
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(journal_read(j, &raw, sizeof(raw)));
rrhdr->size = decode_uint32(raw.size);
return ISC_R_SUCCESS;
}
REQUIRE(DNS_JOURNAL_VALID(j));
- result = journal_seek(j, pos->offset);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(journal_seek(j, pos->offset));
if (pos->serial == j->header.end.serial) {
return ISC_R_NOMORE;
* Read the header of the current transaction.
* This will return ISC_R_NOMORE if we are at EOF.
*/
- result = journal_read_xhdr(j, &xhdr);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(journal_read_xhdr(j, &xhdr));
if (j->header_ver1) {
CHECK(maybe_fixup_xhdr(j, &xhdr, pos->serial, pos->offset));
*/
static isc_result_t
journal_find(dns_journal_t *j, uint32_t serial, journal_pos_t *pos) {
- isc_result_t result;
journal_pos_t current_pos;
REQUIRE(DNS_JOURNAL_VALID(j));
if (DNS_SERIAL_GT(current_pos.serial, serial)) {
return ISC_R_NOTFOUND;
}
- result = journal_next(j, ¤t_pos);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(journal_next(j, ¤t_pos));
}
*pos = current_pos;
return ISC_R_SUCCESS;
dns_rdatasetiter_t *rdsiter = NULL;
dns_difftuple_t *tuple = NULL;
- result = dns_dbiterator_current(dbit, &node, name);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_dbiterator_current(dbit, &node, name));
result = dns_db_allrdatasets(db, node, ver, 0, now, &rdsiter);
if (result != ISC_R_SUCCESS) {
dns_fixedname_init(&fixname[0]);
dns_fixedname_init(&fixname[1]);
- result = dns_db_createiterator(db[0], options, &dbit[0]);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_createiterator(db[0], options, &dbit[0]));
result = dns_db_createiterator(db[1], options, &dbit[1]);
if (result != ISC_R_SUCCESS) {
goto cleanup_iterator;
dns_journal_t *journal = NULL;
if (filename != NULL) {
- result = dns_journal_open(diff->mctx, filename,
- DNS_JOURNAL_CREATE, &journal);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_journal_open(diff->mctx, filename,
+ DNS_JOURNAL_CREATE, &journal));
}
CHECK(diff_namespace(dba, dbvera, dbb, dbverb, DNS_DB_NONSEC3, diff));
bool ksk = ((flags & DNS_KEYFLAG_KSK) != 0);
char timebuf[18];
isc_time_t now = isc_time_now();
- isc_result_t result;
dns_fixedname_t fname;
dns_name_t *pname = dns_fixedname_initname(&fname);
isc_buffer_putstr(buf, uri);
isc_buffer_putstr(buf, ";object=");
/* zone name */
- result = dns_name_tofilenametext(zname, false, buf);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_tofilenametext(zname, false, buf));
/*
* policy name
*
return ISC_R_NOSPACE;
}
isc_buffer_putstr(buf, "-");
- result = dns_name_fromstring(pname, policy, dns_rootname, 0, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
- result = dns_name_tofilenametext(pname, false, buf);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromstring(pname, policy, dns_rootname, 0, NULL));
+ RETERR(dns_name_tofilenametext(pname, false, buf));
/* key type + current time */
isc_time_formatshorttimestamp(&now, timebuf, sizeof(timebuf));
return isc_buffer_printf(buf, "-%s-%s", ksk ? "ksk" : "zsk", timebuf);
static isc_result_t
putstr(isc_buffer_t *b, const char *str) {
- isc_result_t result;
-
- result = isc_buffer_reserve(b, strlen(str));
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_buffer_reserve(b, strlen(str)));
isc_buffer_putstr(b, str);
return ISC_R_SUCCESS;
static isc_result_t
read_and_check(bool do_read, isc_buffer_t *buffer, size_t len, FILE *f,
uint32_t *totallen) {
- isc_result_t result;
-
REQUIRE(totallen != NULL);
if (do_read) {
INSIST(isc_buffer_availablelength(buffer) >= len);
- result = isc_stdio_read(isc_buffer_used(buffer), 1, len, f,
- NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_stdio_read(isc_buffer_used(buffer), 1, len, f,
+ NULL));
isc_buffer_add(buffer, (unsigned int)len);
if (*totallen < len) {
return ISC_R_RANGE;
dctx = DNS_DECOMPRESS_NEVER;
if (lctx->first) {
- result = load_header(lctx);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(load_header(lctx));
}
ISC_LIST_INIT(head);
INDENT_TO(ttl_column);
if ((ctx->style.flags & DNS_STYLEFLAG_TTL_UNITS) != 0) {
length = target->used;
- result = dns_ttl_totext(rdataset->ttl, false,
- false, target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_ttl_totext(rdataset->ttl, false,
+ false, target));
column += target->used - length;
} else {
length = snprintf(ttlbuf, sizeof(ttlbuf), "%u",
isc_loop_t *loop, dns_dumpdonefunc_t done,
void *done_arg, dns_dumpctx_t **dctxp) {
dns_dumpctx_t *dctx = NULL;
- isc_result_t result;
REQUIRE(loop != NULL);
REQUIRE(f != NULL);
REQUIRE(done != NULL);
- result = dumpctx_create(mctx, db, version, style, f, &dctx,
- dns_masterformat_text, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dumpctx_create(mctx, db, version, style, f, &dctx,
+ dns_masterformat_text, NULL));
dctx->done = done;
dctx->done_arg = done_arg;
dns_dumpctx_t *dctx = NULL;
isc_result_t result;
- result = dumpctx_create(mctx, db, version, style, f, &dctx, format,
- header);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dumpctx_create(mctx, db, version, style, f, &dctx, format,
+ header));
result = dumptostream(dctx);
INSIST(result != DNS_R_CONTINUE);
char *tempname;
dns_dumpctx_t *dctx = NULL;
- result = opentmp(mctx, filename, &tempname, &f);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(opentmp(mctx, filename, &tempname, &f));
CHECK(dumpctx_create(mctx, db, version, style, f, &dctx, format,
header));
* "current" buffer. (which is always the last on the list, for our
* uses)
*/
-static isc_result_t
+static void
newbuffer(dns_message_t *msg, unsigned int size) {
- isc_buffer_t *dynbuf;
+ isc_buffer_t *dynbuf = NULL;
- dynbuf = NULL;
isc_buffer_allocate(msg->mctx, &dynbuf, size);
ISC_LIST_APPEND(msg->scratchpad, dynbuf, link);
- return ISC_R_SUCCESS;
}
static isc_buffer_t *
if (result == ISC_R_NOSPACE) {
tries++;
- result = newbuffer(msg, SCRATCHPAD_SIZE);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
+ newbuffer(msg, SCRATCHPAD_SIZE);
scratch = currentbuffer(msg);
dns_name_reset(name);
} else {
trysize *= 2;
}
tries++;
- result = newbuffer(msg, trysize);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ newbuffer(msg, trysize);
scratch = currentbuffer(msg);
} else {
if (msg->tsigkey != NULL) {
dns_message_renderrelease(msg, msg->sig_reserved);
msg->sig_reserved = 0;
- result = dns_tsig_sign(msg);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_tsig_sign(msg));
count = 0;
result = renderset(msg->tsig, msg->tsigname, msg->id, msg->cctx,
msg->buffer, msg->reserved, 0, &count);
if (msg->sig0key != NULL) {
dns_message_renderrelease(msg, msg->sig_reserved);
msg->sig_reserved = 0;
- result = dns_dnssec_signmessage(msg, msg->sig0key);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_dnssec_signmessage(msg, msg->sig0key));
count = 0;
/*
* Note: dns_rootname is used here, not msg->sig0name, since
REQUIRE(msg->from_to_wire == DNS_MESSAGE_INTENTRENDER);
REQUIRE(msg->state == DNS_SECTION_ANY);
- result = buildopt(msg, &opt);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(buildopt(msg, &opt));
msgresetopt(msg);
isc_result_t
dns_message_getquerytsig(dns_message_t *msg, isc_mem_t *mctx,
isc_buffer_t **querytsig) {
- isc_result_t result;
dns_rdata_t rdata = DNS_RDATA_INIT;
isc_region_t r;
return ISC_R_SUCCESS;
}
- result = dns_rdataset_first(msg->tsig);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdataset_first(msg->tsig));
dns_rdataset_current(msg->tsig, &rdata);
dns_rdata_toregion(&rdata, &r);
INSIST(result == ISC_R_SUCCESS);
dns_rdataset_current(msg->sig0, &rdata);
- result = dns_rdata_tostruct(&rdata, &sig, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdata_tostruct(&rdata, &sig, NULL));
if (msg->verified_sig && msg->sig0status == dns_rcode_noerror) {
result = ISC_R_SUCCESS;
return ISC_R_UNEXPECTEDEND;
}
- result = dns_rdata_tostruct(&sigrdata, &sig, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdata_tostruct(&sigrdata, &sig, NULL));
dns_rdataset_init(&keyset);
if (view == NULL) {
switch (optcode) {
case DNS_OPT_LLQ:
if (optlen == 18U) {
- result = render_llq(&optbuf, msg, style,
- target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(render_llq(&optbuf, msg, style,
+ target));
ADD_STRING(target, "\n");
continue;
}
snprintf(buf, sizeof(buf), " %u", secs);
ADD_STRING(target, buf);
ADD_STRING(target, " (");
- result = dns_ttl_totext(secs, true,
- true, target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_ttl_totext(secs, true, true,
+ target));
ADD_STRING(target, ")\n");
continue;
}
dns_message_headertotext(dns_message_t *msg, const dns_master_style_t *style,
dns_messagetextflag_t flags, isc_buffer_t *target) {
char buf[sizeof("1234567890")];
- isc_result_t result;
+ isc_result_t result = ISC_R_SUCCESS;
REQUIRE(DNS_MESSAGE_VALID(msg));
REQUIRE(target != NULL);
ADD_STRING(target, "\n");
INDENT(style);
ADD_STRING(target, "status: ");
- result = dns_rcode_totext(msg->rcode, target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rcode_totext(msg->rcode, target));
ADD_STRING(target, "\n");
INDENT(style);
ADD_STRING(target, "id: ");
ADD_STRING(target, ";; ->>HEADER<<- opcode: ");
ADD_STRING(target, opcodetext[msg->opcode]);
ADD_STRING(target, ", status: ");
- result = dns_rcode_totext(msg->rcode, target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rcode_totext(msg->rcode, target));
ADD_STRING(target, ", id: ");
snprintf(buf, sizeof(buf), "%6u", msg->id);
ADD_STRING(target, buf);
isc_result_t
dns_message_totext(dns_message_t *msg, const dns_master_style_t *style,
dns_messagetextflag_t flags, isc_buffer_t *target) {
- isc_result_t result;
-
REQUIRE(DNS_MESSAGE_VALID(msg));
REQUIRE(target != NULL);
- result = dns_message_headertotext(msg, style, flags, target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = dns_message_pseudosectiontotext(msg, DNS_PSEUDOSECTION_OPT,
- style, flags, target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = dns_message_sectiontotext(msg, DNS_SECTION_QUESTION, style,
- flags, target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = dns_message_sectiontotext(msg, DNS_SECTION_ANSWER, style,
- flags, target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = dns_message_sectiontotext(msg, DNS_SECTION_AUTHORITY, style,
- flags, target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = dns_message_sectiontotext(msg, DNS_SECTION_ADDITIONAL, style,
- flags, target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = dns_message_pseudosectiontotext(msg, DNS_PSEUDOSECTION_TSIG,
- style, flags, target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
- result = dns_message_pseudosectiontotext(msg, DNS_PSEUDOSECTION_SIG0,
- style, flags, target);
- return result;
+ RETERR(dns_message_headertotext(msg, style, flags, target));
+ RETERR(dns_message_pseudosectiontotext(msg, DNS_PSEUDOSECTION_OPT,
+ style, flags, target));
+ RETERR(dns_message_sectiontotext(msg, DNS_SECTION_QUESTION, style,
+ flags, target));
+ RETERR(dns_message_sectiontotext(msg, DNS_SECTION_ANSWER, style, flags,
+ target));
+ RETERR(dns_message_sectiontotext(msg, DNS_SECTION_AUTHORITY, style,
+ flags, target));
+ RETERR(dns_message_sectiontotext(msg, DNS_SECTION_ADDITIONAL, style,
+ flags, target));
+ RETERR(dns_message_pseudosectiontotext(msg, DNS_PSEUDOSECTION_TSIG,
+ style, flags, target));
+ return dns_message_pseudosectiontotext(msg, DNS_PSEUDOSECTION_SIG0,
+ style, flags, target);
}
isc_region_t *
isc_result_t
dns_name_print(const dns_name_t *name, FILE *stream) {
- isc_result_t result;
isc_buffer_t b;
isc_region_t r;
char t[1024];
REQUIRE(DNS_NAME_VALID(name));
isc_buffer_init(&b, t, sizeof(t));
- result = dns_name_totext(name, 0, &b);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_totext(name, 0, &b));
isc_buffer_usedregion(&b, &r);
fprintf(stream, "%.*s", (int)r.length, (char *)r.base);
*/
isc_result_t
dns_name_tostring(const dns_name_t *name, char **target, isc_mem_t *mctx) {
- isc_result_t result;
isc_buffer_t buf;
isc_region_t reg;
char *p, txt[DNS_NAME_FORMATSIZE];
REQUIRE(target != NULL && *target == NULL);
isc_buffer_init(&buf, txt, sizeof(txt));
- result = dns_name_totext(name, 0, &buf);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_totext(name, 0, &buf));
isc_buffer_usedregion(&buf, ®);
p = isc_mem_allocate(mctx, reg.length + 1);
dns_name_fromstring(dns_name_t *target, const char *src,
const dns_name_t *origin, unsigned int options,
isc_mem_t *mctx) {
- isc_result_t result;
isc_buffer_t buf;
dns_fixedname_t fn;
dns_name_t *name;
name = dns_fixedname_initname(&fn);
}
- result = dns_name_fromtext(name, &buf, origin, options);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromtext(name, &buf, origin, options));
if (name != target) {
dns_name_dup(name, mctx, target);
}
- return result;
+
+ return ISC_R_SUCCESS;
}
void
isc_buffer_putuint16(buffer, (uint16_t)count);
DNS_RDATASET_FOREACH(rdataset) {
- isc_result_t result;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
/*
* Copy the rdata to the buffer.
*/
- result = isc_buffer_copyregion(buffer, &r);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_buffer_copyregion(buffer, &r));
}
return ISC_R_SUCCESS;
isc_buffer_init(&buffer, data, sizeof(data));
MSG_SECTION_FOREACH(message, DNS_SECTION_AUTHORITY, name) {
- result = ISC_R_SUCCESS;
-
if (name->attributes.ncache) {
ISC_LIST_FOREACH(name->list, rdataset, link) {
if (!rdataset->attributes.ncache) {
* Copy the owner name to the buffer.
*/
dns_name_toregion(name, &r);
- result = isc_buffer_copyregion(&buffer,
- &r);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_buffer_copyregion(&buffer,
+ &r));
/*
* Copy the type to the buffer.
*/
/*
* Copy the rdataset into the buffer.
*/
- result = copy_rdataset(rdataset,
- &buffer);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(copy_rdataset(rdataset,
+ &buffer));
if (next >= DNS_NCACHE_RDATA) {
return ISC_R_NOSPACE;
dns_nsec_buildrdata(dns_db_t *db, dns_dbversion_t *version, dns_dbnode_t *node,
const dns_name_t *target, unsigned char *buffer,
dns_rdata_t *rdata) {
- isc_result_t result;
isc_region_t r;
unsigned int i;
unsigned char *nsec_bits, *bm;
dns_nsec_setbit(bm, dns_rdatatype_nsec, 1);
max_type = dns_rdatatype_nsec;
rdsiter = NULL;
- result = dns_db_allrdatasets(db, node, version, 0, 0, &rdsiter);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_allrdatasets(db, node, version, 0, 0, &rdsiter));
DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(rdsiter, &rdataset);
dns_rdataset_init(&rdataset);
- result = dns_db_getoriginnode(db, &node);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_getoriginnode(db, &node));
result = dns_db_findrdataset(db, node, version, dns_rdatatype_dnskey, 0,
0, &rdataset, NULL);
return DNS_R_DNAME;
}
- result = dns_rdata_tostruct(&rdata, &nsec, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdata_tostruct(&rdata, &nsec, NULL));
relation = dns_name_fullcompare(&nsec.next, name, &order, &nlabels);
if (order == 0) {
dns_rdata_freestruct(&nsec);
size_t salt_length, const unsigned char *nexthash,
size_t hash_length, unsigned char *buffer,
dns_rdata_t *rdata) {
- isc_result_t result;
isc_region_t r;
unsigned int i;
bool found;
goto collapse_bitmap;
}
rdsiter = NULL;
- result = dns_db_allrdatasets(db, node, version, 0, 0, &rdsiter);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_allrdatasets(db, node, version, 0, 0, &rdsiter));
found = found_ns = need_rrsig = false;
DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
/*
* Find the NSEC3 parameters for this zone.
*/
- result = dns_db_getoriginnode(db, &node);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_getoriginnode(db, &node));
result = dns_db_findrdataset(db, node, version,
dns_rdatatype_nsec3param, 0, 0, &rdataset,
isc_result_t
dns_nsec3param_salttotext(dns_rdata_nsec3param_t *nsec3param, char *dst,
size_t dstlen) {
- isc_result_t result;
isc_region_t r;
isc_buffer_t b;
r.length = nsec3param->salt_length;
isc_buffer_init(&b, dst, (unsigned int)dstlen);
- result = isc_hex_totext(&r, 2, "", &b);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_hex_totext(&r, 2, "", &b));
if (isc_buffer_availablelength(&b) < 1) {
return ISC_R_NOSPACE;
dns_name_init(&next);
dns_rdataset_init(&rdataset);
- result = dns_db_getoriginnode(db, &node);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_getoriginnode(db, &node));
/*
* Cause all NSEC3 chains to be deleted.
/*
* Find the NSEC3 parameters for this zone.
*/
- result = dns_db_getoriginnode(db, &node);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_getoriginnode(db, &node));
result = dns_db_findrdataset(db, node, version, type, 0, 0, &prdataset,
NULL);
/*
* Find the NSEC3 parameters for this zone.
*/
- result = dns_db_getoriginnode(db, &node);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_getoriginnode(db, &node));
result = dns_db_findrdataset(db, node, version,
dns_rdatatype_nsec3param, 0, 0, &rdataset,
dns_rdataset_init(&rdataset);
- result = dns_db_getoriginnode(db, &node);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_getoriginnode(db, &node));
result = dns_db_findrdataset(db, node, version,
dns_rdatatype_nsec3param, 0, 0, &rdataset,
dns_rdataset_current(nsec3set, &rdata);
- result = dns_rdata_tostruct(&rdata, &nsec3, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdata_tostruct(&rdata, &nsec3, NULL));
(*logit)(arg, ISC_LOG_DEBUG(3), "looking for relevant NSEC3");
dns_name_getlabel(nsec3name, 0, &hashlabel);
isc_region_consume(&hashlabel, 1);
isc_buffer_init(&buffer, owner, sizeof(owner));
- result = isc_base32hex_decoderegion(&hashlabel, &buffer);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_base32hex_decoderegion(&hashlabel, &buffer));
/*
* The hash lengths should match. If not ignore the record.
static isc_result_t
putstr(isc_buffer_t *b, const char *str) {
- isc_result_t result;
-
- result = isc_buffer_reserve(b, strlen(str));
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_buffer_reserve(b, strlen(str)));
isc_buffer_putstr(b, str);
return ISC_R_SUCCESS;
static isc_result_t
opensslecdsa_generate(dst_key_t *key, int unused, void (*callback)(int)) {
- isc_result_t ret;
EVP_PKEY *pkey = NULL;
REQUIRE(opensslecdsa_valid_key_alg(key->key_alg));
UNUSED(unused);
UNUSED(callback);
- ret = opensslecdsa_generate_pkey(key->key_alg, key->label, &pkey);
- if (ret != ISC_R_SUCCESS) {
- return ret;
- }
+ RETERR(opensslecdsa_generate_pkey(key->key_alg, key->label, &pkey));
key->key_size = EVP_PKEY_bits(pkey);
key->keydata.pkeypair.priv = pkey;
key->keydata.pkeypair.pub = pkey;
- return ret;
+ return ISC_R_SUCCESS;
}
static isc_result_t
static isc_result_t
openssleddsa_fromdns(dst_key_t *key, isc_buffer_t *data) {
const eddsa_alginfo_t *alginfo = openssleddsa_alg_info(key->key_alg);
- isc_result_t ret;
isc_region_t r;
size_t len;
EVP_PKEY *pkey = NULL;
}
len = r.length;
- ret = raw_key_to_ossl(alginfo, 0, r.base, &len, &pkey);
- if (ret != ISC_R_SUCCESS) {
- return ret;
- }
+ RETERR(raw_key_to_ossl(alginfo, 0, r.base, &len, &pkey));
isc_buffer_forward(data, len);
key->keydata.pkeypair.pub = pkey;
dns_fixedname_init(&fname);
isc_buffer_constinit(&b, keyval, strlen(keyval));
isc_buffer_add(&b, strlen(keyval));
- result = dns_name_fromtext(dns_fixedname_name(&fname), &b, dns_rootname,
- 0);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromtext(dns_fixedname_name(&fname), &b, dns_rootname,
+ 0));
name = isc_mem_get(peer->mem, sizeof(dns_name_t));
* Lookup the predecessor in the normal namespace.
*/
node = NULL;
- result = dns_qp_getname(search->qpdb->tree, predecessor,
- DNS_DBNAMESPACE_NORMAL, (void **)&node, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_qp_getname(search->qpdb->tree, predecessor,
+ DNS_DBNAMESPACE_NORMAL, (void **)&node, NULL));
dns_name_copy(&node->name, fname);
nlock = &search->qpdb->buckets[node->locknum].lock;
static isc_result_t
unknown_totext(dns_rdata_t *rdata, dns_rdata_textctx_t *tctx,
isc_buffer_t *target) {
- isc_result_t result;
+ isc_result_t result = ISC_R_SUCCESS;
char buf[sizeof("65535")];
isc_region_t sr;
strlcpy(buf, "\\# ", sizeof(buf));
- result = str_totext(buf, target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(str_totext(buf, target));
dns_rdata_toregion(rdata, &sr);
INSIST(sr.length < 65536);
snprintf(buf, sizeof(buf), "%u", sr.length);
- result = str_totext(buf, target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(str_totext(buf, target));
if (sr.length != 0U) {
if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) {
- result = str_totext(" ( ", target);
+ RETERR(str_totext(" ( ", target));
} else {
- result = str_totext(" ", target);
- }
-
- if (result != ISC_R_SUCCESS) {
- return result;
+ RETERR(str_totext(" ", target));
}
if (tctx->width == 0) { /* No splitting */
additionaldata_lp(ARGS_ADDLDATA) {
dns_name_t name;
isc_region_t region;
- isc_result_t result;
REQUIRE(rdata->type == dns_rdatatype_lp);
isc_region_consume(®ion, 2);
dns_name_fromregion(&name, ®ion);
- result = (add)(arg, &name, dns_rdatatype_l32, NULL DNS__DB_FILELINE);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR((add)(arg, &name, dns_rdatatype_l32, NULL DNS__DB_FILELINE));
return (add)(arg, &name, dns_rdatatype_l64, NULL DNS__DB_FILELINE);
}
digest_minfo(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
- isc_result_t result;
REQUIRE(rdata->type == dns_rdatatype_minfo);
dns_rdata_toregion(rdata, &r);
dns_name_init(&name);
dns_name_fromregion(&name, &r);
- result = dns_name_digest(&name, digest, arg);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_digest(&name, digest, arg));
isc_region_consume(&r, name_length(&name));
dns_name_init(&name);
dns_name_fromregion(&name, &r);
return ISC_R_SUCCESS;
}
- result = (add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR((add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE));
dns_fixedname_init(&fixed);
result = dns_name_concatenate(&port25, &name,
digest_naptr(ARGS_DIGEST) {
isc_region_t r1, r2;
unsigned int length, n;
- isc_result_t result;
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_naptr);
* Digest the RR up to the replacement name.
*/
r1.length = length;
- result = (digest)(arg, &r1);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR((digest)(arg, &r1));
/*
* Replacement.
digest_nxt(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
- isc_result_t result;
REQUIRE(rdata->type == dns_rdatatype_nxt);
dns_rdata_toregion(rdata, &r);
dns_name_init(&name);
dns_name_fromregion(&name, &r);
- result = dns_name_digest(&name, digest, arg);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_digest(&name, digest, arg));
isc_region_consume(&r, name_length(&name));
return (digest)(arg, &r);
additionaldata_rt(ARGS_ADDLDATA) {
dns_name_t name;
isc_region_t region;
- isc_result_t result;
REQUIRE(rdata->type == dns_rdatatype_rt);
isc_region_consume(®ion, 2);
dns_name_fromregion(&name, ®ion);
- result = (add)(arg, &name, dns_rdatatype_x25, NULL DNS__DB_FILELINE);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
- result = (add)(arg, &name, dns_rdatatype_isdn, NULL DNS__DB_FILELINE);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR((add)(arg, &name, dns_rdatatype_x25, NULL DNS__DB_FILELINE));
+ RETERR((add)(arg, &name, dns_rdatatype_isdn, NULL DNS__DB_FILELINE));
return (add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE);
}
static isc_result_t
digest_rt(ARGS_DIGEST) {
isc_region_t r1, r2;
- isc_result_t result;
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_rt);
r2 = r1;
isc_region_consume(&r2, 2);
r1.length = 2;
- result = (digest)(arg, &r1);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR((digest)(arg, &r1));
dns_name_init(&name);
dns_name_fromregion(&name, &r2);
return dns_name_digest(&name, digest, arg);
static isc_result_t
generic_fromwire_txt(ARGS_FROMWIRE) {
- isc_result_t result;
-
UNUSED(type);
UNUSED(dctx);
UNUSED(rdclass);
do {
- result = txt_fromwire(source, target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(txt_fromwire(source, target));
} while (!buffer_empty(source));
return ISC_R_SUCCESS;
}
digest_in_a6(ARGS_DIGEST) {
isc_region_t r1, r2;
unsigned char prefixlen, octets;
- isc_result_t result;
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_a6);
octets = 1 + 16 - prefixlen / 8;
r1.length = octets;
- result = (digest)(arg, &r1);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR((digest)(arg, &r1));
if (prefixlen == 0) {
return ISC_R_SUCCESS;
}
digest_in_px(ARGS_DIGEST) {
isc_region_t r1, r2;
dns_name_t name;
- isc_result_t result;
REQUIRE(rdata->type == dns_rdatatype_px);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
r2 = r1;
isc_region_consume(&r2, 2);
r1.length = 2;
- result = (digest)(arg, &r1);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR((digest)(arg, &r1));
dns_name_init(&name);
dns_name_fromregion(&name, &r2);
- result = dns_name_digest(&name, digest, arg);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_digest(&name, digest, arg));
isc_region_consume(&r2, name_length(&name));
dns_name_init(&name);
dns_name_fromregion(&name, &r2);
return ISC_R_SUCCESS;
}
- result = (add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR((add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE));
dns_fixedname_init(&fixed);
snprintf(buf, sizeof(buf), "_%u._tcp", port);
}
DNS_RDATASET_FOREACH(rdataset) {
- isc_result_t result;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
- result = dns_rdata_additionaldata(&rdata, owner_name, add, arg);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdata_additionaldata(&rdata, owner_name, add, arg));
}
return ISC_R_SUCCESS;
isc_result_t
dns_request_getresponse(dns_request_t *request, dns_message_t *message,
unsigned int options) {
- isc_result_t result;
-
REQUIRE(VALID_REQUEST(request));
REQUIRE(request->tid == isc_tid());
REQUIRE(request->answer != NULL);
req_log(ISC_LOG_DEBUG(3), "%s: request %p", __func__, request);
dns_message_setquerytsig(message, request->tsig);
- result = dns_message_settsigkey(message, request->tsigkey);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
- result = dns_message_parse(message, request->answer, options);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_message_settsigkey(message, request->tsigkey));
+ RETERR(dns_message_parse(message, request->answer, options));
if (request->tsigkey != NULL) {
- result = dns_tsig_verify(request->answer, message, NULL, NULL);
+ RETERR(dns_tsig_verify(request->answer, message, NULL, NULL));
}
- return result;
+ return ISC_R_SUCCESS;
}
isc_buffer_t *
resconf_parsenameserver(irs_resconf_t *conf, FILE *fp) {
char word[RESCONFMAXLINELEN];
int cp;
- isc_result_t result;
cp = getword(fp, word, sizeof(word));
if (cp == EOF || strlen(word) == 0U) {
return ISC_R_SUCCESS;
}
- result = add_server(conf->mctx, word, &conf->nameservers);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(add_server(conf->mctx, word, &conf->nameservers));
conf->numns++;
return ISC_R_SUCCESS;
resconf_parsesearch(irs_resconf_t *conf, FILE *fp) {
int delim;
char word[RESCONFMAXLINELEN];
- isc_result_t result;
if (conf->domainname != NULL) {
/*
return ISC_R_UNEXPECTEDEND; /* Nothing else on line. */
}
do {
- result = add_search(conf, word);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(add_search(conf, word));
if (delim == '\n') {
break;
static isc_result_t
rctx_cachename(respctx_t *rctx, dns_message_t *message, dns_name_t *name) {
- isc_result_t result;
+ isc_result_t result = ISC_R_SUCCESS;
fetchctx_t *fctx = rctx->fctx;
resquery_t *query = rctx->query;
dns_resolver_t *res = fctx->res;
/*
* Find or create the cache node.
*/
- result = dns_db_findnode(fctx->cache, name, true, &node);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_findnode(fctx->cache, name, true, &node));
/*
* Cache or validate each cacheable rdataset.
result = rctx_cache_insecure(rctx, message, name, node,
rdataset, sigrdataset);
}
- if (result != ISC_R_SUCCESS) {
- goto cleanup;
- }
+ CHECK(result);
}
/*
static isc_result_t
in_rootns(dns_rdataset_t *rootns, dns_name_t *name) {
- isc_result_t result;
dns_rdata_ns_t ns;
if (!dns_rdataset_isassociated(rootns)) {
DNS_RDATASET_FOREACH(rootns) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rootns, &rdata);
- result = dns_rdata_tostruct(&rdata, &ns, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdata_tostruct(&rdata, &ns, NULL));
if (dns_name_compare(name, &ns.name) == 0) {
return ISC_R_SUCCESS;
}
isc_result_t
dns_rpz_new_zone(dns_rpz_zones_t *rpzs, dns_rpz_zone_t **rpzp) {
- isc_result_t result;
dns_rpz_zone_t *rpz = NULL;
REQUIRE(DNS_RPZ_ZONES_VALID(rpzs));
return ISC_R_NOSPACE;
}
- result = dns__rpz_shuttingdown(rpzs);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns__rpz_shuttingdown(rpzs));
rpz = isc_mem_get(rpzs->mctx, sizeof(*rpz));
*rpz = (dns_rpz_zone_t){
isc_result_t
dns_rriterator_init(dns_rriterator_t *it, dns_db_t *db, dns_dbversion_t *ver,
isc_stdtime_t now) {
- isc_result_t result;
it->magic = RRITERATOR_MAGIC;
it->db = db;
it->dbit = NULL;
it->ver = ver;
it->now = now;
it->node = NULL;
- result = dns_db_createiterator(it->db, 0, &it->dbit);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_createiterator(it->db, 0, &it->dbit));
it->rdatasetit = NULL;
dns_rdata_init(&it->rdata);
dns_rdataset_init(&it->rdataset);
dns_name_countlabels(&sdlz->common.origin);
dns_name_init(&relname);
dns_name_getlabelsequence(name, 0, labels, &relname);
- result = dns_name_totext(&relname, DNS_NAME_OMITFINALDOT, &b);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_totext(&relname, DNS_NAME_OMITFINALDOT, &b));
} else {
- result = dns_name_totext(name, DNS_NAME_OMITFINALDOT, &b);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_totext(name, DNS_NAME_OMITFINALDOT, &b));
}
isc_buffer_putuint8(&b, 0);
isc_buffer_init(&b2, zonestr, sizeof(zonestr));
- result = dns_name_totext(&sdlz->common.origin, DNS_NAME_OMITFINALDOT,
- &b2);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_totext(&sdlz->common.origin, DNS_NAME_OMITFINALDOT,
+ &b2));
isc_buffer_putuint8(&b2, 0);
- result = createnode(sdlz, &node);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(createnode(sdlz, &node));
isorigin = dns_name_equal(name, &sdlz->common.origin);
}
isc_buffer_init(&b, zonestr, sizeof(zonestr));
- result = dns_name_totext(&sdlz->common.origin, DNS_NAME_OMITFINALDOT,
- &b);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_totext(&sdlz->common.origin, DNS_NAME_OMITFINALDOT,
+ &b));
isc_buffer_putuint8(&b, 0);
sdlziter = isc_mem_get(sdlz->common.mctx, sizeof(sdlz_dbiterator_t));
/* Convert DNS name to ascii text */
isc_buffer_init(&b, namestr, sizeof(namestr));
- result = dns_name_totext(name, DNS_NAME_OMITFINALDOT, &b);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_totext(name, DNS_NAME_OMITFINALDOT, &b));
isc_buffer_putuint8(&b, 0);
/* convert client address to ascii text */
isc_buffer_init(&b2, clientstr, sizeof(clientstr));
isc_netaddr_fromsockaddr(&netaddr, clientaddr);
- result = isc_netaddr_totext(&netaddr, &b2);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_netaddr_totext(&netaddr, &b2));
isc_buffer_putuint8(&b2, 0);
/* make sure strings are always lowercase */
/* Convert DNS name to ascii text */
isc_buffer_init(&b, namestr, sizeof(namestr));
- result = dns_name_totext(name, DNS_NAME_OMITFINALDOT, &b);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_totext(name, DNS_NAME_OMITFINALDOT, &b));
isc_buffer_putuint8(&b, 0);
/* make sure strings are always lowercase */
r.base = type;
r.length = strlen(type);
- result = dns_rdatatype_fromtext(&typeval, (void *)&r);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdatatype_fromtext(&typeval, (void *)&r));
rdatalist = ISC_LIST_HEAD(lookup->lists);
while (rdatalist != NULL) {
dns_sdlznode_t *sdlznode;
isc_mem_t *mctx = sdlz->common.mctx;
isc_buffer_t b;
- isc_result_t result;
newname = dns_fixedname_initname(&fnewname);
isc_buffer_constinit(&b, name, strlen(name));
isc_buffer_add(&b, strlen(name));
- result = dns_name_fromtext(newname, &b, origin, 0);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromtext(newname, &b, origin, 0));
if (allnodes->common.relative_names) {
/* All names are relative to the root */
sdlznode = ISC_LIST_HEAD(allnodes->nodelist);
if (sdlznode == NULL || !dns_name_equal(&sdlznode->name, newname)) {
sdlznode = NULL;
- result = createnode(sdlz, &sdlznode);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(createnode(sdlz, &sdlznode));
dns_name_dup(newname, mctx, &sdlznode->name);
ISC_LIST_PREPEND(allnodes->nodelist, sdlznode, link);
if (allnodes->origin == NULL &&
isc_result_t
dns_skrbundle_getsig(dns_skrbundle_t *bundle, dst_key_t *key,
dns_rdatatype_t covering_type, dns_rdata_t *sigrdata) {
- isc_result_t result = ISC_R_SUCCESS;
-
REQUIRE(DNS_SKRBUNDLE_VALID(bundle));
REQUIRE(DNS_DIFF_VALID(&bundle->diff));
}
INSIST(tuple->rdata.type == dns_rdatatype_rrsig);
- result = dns_rdata_tostruct(&tuple->rdata, &rrsig, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdata_tostruct(&tuple->rdata, &rrsig, NULL));
/*
* Check if covering type matches, and if the signature is
isc_result_t
dns_time32_fromtext(const char *source, uint32_t *target) {
int64_t value64;
- isc_result_t result;
- result = dns_time64_fromtext(source, &value64);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+
+ RETERR(dns_time64_fromtext(source, &value64));
*target = (uint32_t)value64;
return ISC_R_SUCCESS;
result = dns_message_findtype(cur, dns_rdatatype_tkey, 0,
&tkeyset);
if (result == ISC_R_SUCCESS) {
- result = dns_rdataset_first(tkeyset);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdataset_first(tkeyset));
dns_rdataset_current(tkeyset, rdata);
*name = cur;
name = dns_fixedname_initname(&fname);
isc_buffer_init(&b, namestr, strlen(namestr));
isc_buffer_add(&b, strlen(namestr));
- result = dns_name_fromtext(name, &b, dns_rootname, 0);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromtext(name, &b, dns_rootname, 0));
creator = dns_fixedname_initname(&fcreator);
isc_buffer_init(&b, creatorstr, strlen(creatorstr));
isc_buffer_add(&b, strlen(creatorstr));
- result = dns_name_fromtext(creator, &b, dns_rootname, 0);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromtext(creator, &b, dns_rootname, 0));
algorithm = dns_fixedname_initname(&falgorithm);
isc_buffer_init(&b, algorithmstr, strlen(algorithmstr));
isc_buffer_add(&b, strlen(algorithmstr));
- result = dns_name_fromtext(algorithm, &b, dns_rootname, 0);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromtext(algorithm, &b, dns_rootname, 0));
dstalg = dns__tsig_algfromname(algorithm);
if (dstalg == DST_ALG_UNKNOWN) {
return DNS_R_BADALG;
}
- result = dst_key_restore(name, dstalg, DNS_KEYOWNER_ENTITY,
- DNS_KEYPROTO_DNSSEC, dns_rdataclass_in,
- ring->mctx, keystr, &dstkey);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dst_key_restore(name, dstalg, DNS_KEYOWNER_ENTITY,
+ DNS_KEYPROTO_DNSSEC, dns_rdataclass_in,
+ ring->mctx, keystr, &dstkey));
result = dns_tsigkey_createfromkey(name, dstalg, dstkey, true, true,
creator, inception, expire,
isc_buffer_init(&b, secret, length);
isc_buffer_add(&b, length);
- result = dst_key_frombuffer(
+ RETERR(dst_key_frombuffer(
name, algorithm, DNS_KEYOWNER_ENTITY,
DNS_KEYPROTO_DNSSEC, dns_rdataclass_in, &b,
- mctx, &dstkey);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ mctx, &dstkey));
}
} else if (length > 0) {
return DNS_R_BADALG;
* has validated at this point. This is why we include a
* MAC length > 0 in the reply.
*/
- result = dst_context_create(key->key, mctx,
- DNS_LOGCATEGORY_DNSSEC, true, &ctx);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dst_context_create(key->key, mctx,
+ DNS_LOGCATEGORY_DNSSEC, true, &ctx));
/*
* If this is a response, and if there was a TSIG in
*/
keyname = msg->tsigname;
- result = dns_rdataset_first(msg->tsig);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdataset_first(msg->tsig));
dns_rdataset_current(msg->tsig, &rdata);
- result = dns_rdata_tostruct(&rdata, &tsig, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdata_tostruct(&rdata, &tsig, NULL));
dns_rdata_reset(&rdata);
if (response) {
- result = dns_rdataset_first(msg->querytsig);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdataset_first(msg->querytsig));
dns_rdataset_current(msg->querytsig, &rdata);
- result = dns_rdata_tostruct(&rdata, &querytsig, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdata_tostruct(&rdata, &querytsig, NULL));
}
/*
if (result != ISC_R_SUCCESS) {
msg->tsigstatus = dns_tsigerror_badkey;
alg = dns__tsig_algfromname(&tsig.algorithm);
- result = dns_tsigkey_create(keyname, alg, NULL, 0, mctx,
- &msg->tsigkey);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_tsigkey_create(keyname, alg, NULL, 0, mctx,
+ &msg->tsigkey));
if (alg == DST_ALG_UNKNOWN) {
dns_name_clone(&tsig.algorithm,
&msg->tsigkey->algname);
* Check digest length.
*/
alg = dst_key_alg(key);
- result = dst_key_sigsize(key, &siglen);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dst_key_sigsize(key, &siglen));
if (dns__tsig_algvalid(alg)) {
if (tsig.siglen > siglen) {
tsig_log(msg->tsigkey, 2, "signature length too big");
sig_r.base = tsig.signature;
sig_r.length = tsig.siglen;
- result = dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC,
- false, &ctx);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC,
+ false, &ctx));
if (response) {
isc_buffer_init(&databuf, data, sizeof(data));
/*
* Extract and parse the previous TSIG
*/
- result = dns_rdataset_first(msg->querytsig);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdataset_first(msg->querytsig));
dns_rdataset_current(msg->querytsig, &rdata);
- result = dns_rdata_tostruct(&rdata, &querytsig, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdata_tostruct(&rdata, &querytsig, NULL));
dns_rdata_reset(&rdata);
/*
*/
static isc_result_t
foreach_node_rr_action(void *data, dns_rdataset_t *rdataset) {
- isc_result_t result;
foreach_node_rr_ctx_t *ctx = data;
DNS_RDATASET_FOREACH(rdataset) {
rr_t rr = { 0, DNS_RDATA_INIT };
dns_rdataset_current(rdataset, &rr.rdata);
rr.ttl = rdataset->ttl;
- result = (*ctx->rr_action)(ctx->rr_action_data, &rr);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR((*ctx->rr_action)(ctx->rr_action_data, &rr));
}
return ISC_R_SUCCESS;
* we had a key with trust level "answer" and
* a DS record for the zone has now been added.
*/
- result = create_validator(
+ RETERR(create_validator(
val, &siginfo->signer, dns_rdatatype_dnskey,
&val->frdataset, &val->fsigrdataset,
- validator_callback_dnskey, "seek_dnskey");
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ validator_callback_dnskey, "seek_dnskey"));
return DNS_R_WAIT;
} else if (val->frdataset.trust < dns_trust_secure) {
/*
/*
* We don't know anything about this key.
*/
- result = create_fetch(val, &siginfo->signer,
- dns_rdatatype_dnskey,
- fetch_callback_dnskey, "seek_dnskey");
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(create_fetch(val, &siginfo->signer, dns_rdatatype_dnskey,
+ fetch_callback_dnskey, "seek_dnskey"));
return DNS_R_WAIT;
case DNS_R_NCACHENXDOMAIN:
dst_key_t *dstkey = NULL;
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
- result = dns_dnssec_keyfromrdata(val->name, keyrdata, val->view->mctx,
- &dstkey);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_dnssec_keyfromrdata(val->name, keyrdata, val->view->mctx,
+ &dstkey));
dns_rdataset_clone(val->sigrdataset, &rdataset);
DNS_RDATASET_FOREACH(&rdataset) {
val_rdataset_first(dns_validator_t *val, dns_name_t **namep,
dns_rdataset_t **rdatasetp) {
dns_message_t *message = val->message;
- isc_result_t result;
+ isc_result_t result = ISC_R_SUCCESS;
REQUIRE(rdatasetp != NULL);
REQUIRE(namep != NULL);
}
if (message != NULL) {
- result = dns_message_firstname(message, DNS_SECTION_AUTHORITY);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_message_firstname(message, DNS_SECTION_AUTHORITY));
dns_message_currentname(message, DNS_SECTION_AUTHORITY, namep);
*rdatasetp = ISC_LIST_HEAD((*namep)->list);
INSIST(*rdatasetp != NULL);
dns_ncache_current(val->rdataset, *namep, *rdatasetp);
}
}
+
return result;
}
static isc_result_t
validate_neg_rrset(dns_validator_t *val, dns_name_t *name,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) {
- isc_result_t result;
-
/*
* If a signed zone is missing the zone key, bad
* things could happen. A query for data in the zone
{
dns_rdata_t nsec = DNS_RDATA_INIT;
- result = dns_rdataset_first(rdataset);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_rdataset_first(rdataset));
dns_rdataset_current(rdataset, &nsec);
if (dns_nsec_typepresent(&nsec, dns_rdatatype_soa)) {
return DNS_R_CONTINUE;
}
val->nxset = rdataset;
- result = create_validator(val, name, rdataset->type, rdataset,
- sigrdataset, validator_callback_nsec,
- "validate_neg_rrset");
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(create_validator(val, name, rdataset->type, rdataset,
+ sigrdataset, validator_callback_nsec,
+ "validate_neg_rrset"));
val->authcount++;
return DNS_R_WAIT;
if (FOUNDNOQNAME(val) && FOUNDCLOSEST(val) &&
((NEEDNODATA(val) && !FOUNDNODATA(val)) || NEEDNOWILDCARD(val)))
{
- result = checkwildcard(val, dns_rdatatype_nsec, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(checkwildcard(val, dns_rdatatype_nsec, NULL));
}
if ((NEEDNODATA(val) && (FOUNDNODATA(val) || FOUNDOPTOUT(val))) ||
isc_counter_t *nvalidations, isc_counter_t *nfails,
isc_counter_t *qc, isc_counter_t *gqc, fetchctx_t *parent,
dns_edectx_t *edectx, dns_validator_t **validatorp) {
- isc_result_t result = ISC_R_FAILURE;
dns_validator_t *val = NULL;
dns_keytable_t *kt = NULL;
REQUIRE(validatorp != NULL && *validatorp == NULL);
REQUIRE(edectx != NULL);
- result = dns_view_getsecroots(view, &kt);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_view_getsecroots(view, &kt));
val = isc_mem_get(view->mctx, sizeof(*val));
*val = (dns_validator_t){
REQUIRE(view->resolver == NULL);
REQUIRE(view->dispatchmgr != NULL);
- result = dns_resolver_create(view, options, tlsctx_cache, dispatchv4,
- dispatchv6, &view->resolver);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
-
+ RETERR(dns_resolver_create(view, options, tlsctx_cache, dispatchv4,
+ dispatchv6, &view->resolver));
isc_mem_create("ADB", &mctx);
dns_adb_create(mctx, view, &view->adb);
isc_mem_detach(&mctx);
dns_name_t *keyname = NULL;
dns_peer_t *peer = NULL;
- result = dns_peerlist_peerbyaddr(view->peers, peeraddr, &peer);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_peerlist_peerbyaddr(view->peers, peeraddr, &peer));
- result = dns_peer_getkey(peer, &keyname);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_peer_getkey(peer, &keyname));
result = dns_view_gettsig(view, keyname, keyp);
return (result == ISC_R_NOTFOUND) ? ISC_R_FAILURE : result;
isc_result_t
dns_view_flushcache(dns_view_t *view, bool fixuponly) {
- isc_result_t result;
dns_adb_t *adb = NULL;
REQUIRE(DNS_VIEW_VALID(view));
return ISC_R_SUCCESS;
}
if (!fixuponly) {
- result = dns_cache_flush(view->cache);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_cache_flush(view->cache));
}
dns_db_detach(&view->cachedb);
dns_cache_attachdb(view->cache, &view->cachedb);
static isc_result_t
add_opt(dns_message_t *message, uint16_t udpsize, bool reqnsid,
bool reqexpire) {
- isc_result_t result;
-
dns_message_ednsinit(message, 0, udpsize, 0, 0);
/* Set EDNS options if applicable. */
if (reqnsid) {
dns_ednsopt_t option = { .code = DNS_OPT_NSID };
- result = dns_message_ednsaddopt(message, &option);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_message_ednsaddopt(message, &option));
}
if (reqexpire) {
dns_ednsopt_t option = { .code = DNS_OPT_EXPIRE };
- result = dns_message_ednsaddopt(message, &option);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_message_ednsaddopt(message, &option));
}
return dns_message_setopt(message);
static isc_result_t
delete_keydata(dns_db_t *db, dns_dbversion_t *ver, dns_diff_t *diff,
dns_name_t *name, dns_rdataset_t *rdataset) {
- isc_result_t uresult;
-
DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
- uresult = update_one_rr(db, ver, diff, DNS_DIFFOP_DEL, name, 0,
- &rdata);
- if (uresult != ISC_R_SUCCESS) {
- return uresult;
- }
+ RETERR(update_one_rr(db, ver, diff, DNS_DIFFOP_DEL, name, 0,
+ &rdata));
}
return ISC_R_SUCCESS;
if ((rdata->flags & DNS_RDATA_OFFLINE) != 0) {
return ISC_R_SUCCESS;
}
- result = update_one_rr(db, ver, zonediff->diff, DNS_DIFFOP_DELRESIGN,
- name, ttl, rdata);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(update_one_rr(db, ver, zonediff->diff, DNS_DIFFOP_DELRESIGN,
+ name, ttl, rdata));
rdata->flags |= DNS_RDATA_OFFLINE;
result = update_one_rr(db, ver, zonediff->diff, DNS_DIFFOP_ADDRESIGN,
name, ttl, rdata);
static isc_result_t
add_opt(dns_message_t *message, uint16_t udpsize, bool reqnsid,
bool reqexpire) {
- isc_result_t result;
-
dns_message_ednsinit(message, 0, udpsize, 0, 0);
/* Set EDNS options if applicable. */
if (reqnsid) {
dns_ednsopt_t option = { .code = DNS_OPT_NSID };
- result = dns_message_ednsaddopt(message, &option);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_message_ednsaddopt(message, &option));
}
if (reqexpire) {
dns_ednsopt_t option = { .code = DNS_OPT_EXPIRE };
- result = dns_message_ednsaddopt(message, &option);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_message_ednsaddopt(message, &option));
}
return dns_message_setopt(message);
return result;
}
- result = check_nsec3param(zone, db);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(check_nsec3param(zone, db));
ver = NULL;
dns_db_currentversion(db, &ver);
static isc_result_t
make_dnskey(dst_key_t *key, unsigned char *buf, int bufsize,
dns_rdata_t *target) {
- isc_result_t result;
isc_buffer_t b;
isc_region_t r;
isc_buffer_init(&b, buf, bufsize);
- result = dst_key_todns(key, &b);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dst_key_todns(key, &b));
dns_rdata_reset(target);
isc_buffer_usedregion(&b, &r);
REQUIRE(DNS_ZONE_VALID(zone));
REQUIRE(errors != NULL);
- result = dns_db_getoriginnode(db, &node);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_getoriginnode(db, &node));
result = zone_count_ns_rr(zone, db, node, version, NULL, errors, false);
dns_db_detachnode(&node);
return result;
REQUIRE(DNS_ZONE_VALID(zone));
- result = dns_db_getoriginnode(db, &node);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_getoriginnode(db, &node));
dns_rdataset_init(&cds);
dns_rdataset_init(&dnskey);
return result;
}
- result = isoptout(vctx, &nsec3param, &optout);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isoptout(vctx, &nsec3param, &optout));
dns_fixedname_init(&fixed);
result = dns_nsec3_hashname(
dns_rdataset_t *nsec3paramset, bool delegation, bool empty,
const unsigned char types[8192], unsigned int maxtype,
isc_result_t *vresult) {
- isc_result_t result = ISC_R_NOMORE;
-
DNS_RDATASET_FOREACH(nsec3paramset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(nsec3paramset, &rdata);
- result = verifynsec3(vctx, name, &rdata, delegation, empty,
- types, maxtype, vresult);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(verifynsec3(vctx, name, &rdata, delegation, empty, types,
+ maxtype, vresult));
if (*vresult != ISC_R_SUCCESS) {
break;
}
}
- return result;
+ return ISC_R_SUCCESS;
}
static isc_result_t
*vresult = ISC_R_SUCCESS;
if (nsecset != NULL && dns_rdataset_isassociated(nsecset)) {
- result = verifynsec(vctx, name, node, nextname, &tvresult);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(verifynsec(vctx, name, node, nextname, &tvresult));
*vresult = tvresult;
}
if (nsec3paramset != NULL && dns_rdataset_isassociated(nsec3paramset)) {
- result = verifynsec3s(vctx, name, nsec3paramset, delegation,
- false, types, maxtype, &tvresult);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(verifynsec3s(vctx, name, nsec3paramset, delegation,
+ false, types, maxtype, &tvresult));
if (*vresult == ISC_R_SUCCESS) {
*vresult = tvresult;
}
int order;
unsigned int labels, nlabels, i;
dns_name_t suffix;
- isc_result_t result, tvresult = ISC_R_UNSET;
+ isc_result_t tvresult = ISC_R_UNSET;
*vresult = ISC_R_SUCCESS;
if (nsec3paramset != NULL &&
dns_rdataset_isassociated(nsec3paramset))
{
- result = verifynsec3s(
- vctx, &suffix, nsec3paramset,
- isdelegation, true, NULL, 0, &tvresult);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(verifynsec3s(vctx, &suffix,
+ nsec3paramset, isdelegation,
+ true, NULL, 0, &tvresult));
if (*vresult == ISC_R_SUCCESS) {
*vresult = tvresult;
}
isc_result_t
isc_commandline_strtoargv(isc_mem_t *mctx, char *s, unsigned int *argcp,
char ***argvp, unsigned int n) {
- isc_result_t result;
-
restart:
/* Discard leading whitespace. */
while (*s == ' ' || *s == '\t') {
*p++ = '\0';
}
- result = isc_commandline_strtoargv(mctx, p, argcp, argvp,
- n + 1);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_commandline_strtoargv(mctx, p, argcp, argvp, n + 1));
(*argvp)[n] = s;
}
isc_result_t
isc_file_absolutepath(const char *filename, char *path, size_t pathlen) {
- isc_result_t result;
- result = dir_current(path, pathlen);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dir_current(path, pathlen));
+
if (strlen(path) + strlen(filename) + 1 > pathlen) {
return ISC_R_NOSPACE;
}
strlcat(path, filename, pathlen);
+
return ISC_R_SUCCESS;
}
unsigned int digestlen;
char hash[ISC_MAX_MD_SIZE * 2 + 1];
size_t l = 0;
- isc_result_t err;
REQUIRE(base != NULL);
REQUIRE(path != NULL);
}
/* Check whether the full-length SHA256 hash filename exists */
- err = isc_md(ISC_MD_SHA256, (const unsigned char *)base, strlen(base),
- digest, &digestlen);
- if (err != ISC_R_SUCCESS) {
- return err;
- }
+ RETERR(isc_md(ISC_MD_SHA256, (const unsigned char *)base, strlen(base),
+ digest, &digestlen));
- err = digest2hex(digest, digestlen, hash, sizeof(hash));
- if (err != ISC_R_SUCCESS) {
- return err;
- }
+ RETERR(digest2hex(digest, digestlen, hash, sizeof(hash)));
snprintf(buf, sizeof(buf), "%s%s%s%s%s", dir != NULL ? dir : "",
dir != NULL ? "/" : "", hash, ext != NULL ? "." : "",
}
if (d != NULL) {
- isc_result_t iresult;
-
- iresult = isc_netscope_pton(AF_INET6, d + 1,
- &in6, &zone);
-
- if (iresult != ISC_R_SUCCESS) {
- return iresult;
- }
+ RETERR(isc_netscope_pton(AF_INET6, d + 1, &in6,
+ &zone));
}
isc_netaddr_fromin6(&na, &in6);
size_t path_len = 0;
struct phr_header headers[HTTP_HEADERS_NUM];
size_t num_headers;
- isc_result_t result;
num_headers = ARRAY_SIZE(headers);
/*
* Parse the URL
*/
- result = isc_url_parse(path, path_len, 0, &httpd->up);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_url_parse(path, path_len, 0, &httpd->up));
httpd->path = path;
/*
static inline isc_result_t
isc_buffer_copyregion(isc_buffer_t *restrict b,
const isc_region_t *restrict r) {
- isc_result_t result;
-
REQUIRE(ISC_BUFFER_VALID(b));
REQUIRE(r != NULL);
if (b->mctx) {
- result = isc_buffer_reserve(b, r->length);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_buffer_reserve(b, r->length));
}
if (r->length > isc_buffer_availablelength(b)) {
static inline isc_result_t
isc_buffer_printf(isc_buffer_t *restrict b, const char *restrict format, ...) {
- va_list ap;
- int n;
- isc_result_t result;
+ va_list ap;
+ int n;
REQUIRE(ISC_BUFFER_VALID(b));
}
if (b->mctx) {
- result = isc_buffer_reserve(b, n + 1);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_buffer_reserve(b, n + 1));
}
if (isc_buffer_availablelength(b) < (unsigned int)n + 1) {
isc_result_t
isc_lex_openfile(isc_lex_t *lex, const char *filename) {
- isc_result_t result;
FILE *stream = NULL;
/*
REQUIRE(VALID_LEX(lex));
- result = isc_stdio_open(filename, "r", &stream);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_stdio_open(filename, "r", &stream));
new_source(lex, true, true, stream, filename);
return ISC_R_SUCCESS;
bnamelen = strlen(bname);
isc_dir_init(&dir);
- result = isc_dir_open(&dir, dirname);
-
- /*
- * Return if the directory open failed.
- */
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_dir_open(&dir, dirname));
while (isc_dir_read(&dir) == ISC_R_SUCCESS) {
if (dir.entry.length > bnamelen &&
bnamelen = strlen(bname);
isc_dir_init(&dir);
- result = isc_dir_open(&dir, dirname);
-
- /*
- * Return if the directory open failed.
- */
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_dir_open(&dir, dirname));
last = last_to_keep(versions, &dir, bname, bnamelen);
* Get the largest existing version and remove any
* version greater than the permitted version.
*/
- result = greatest_version(file, file->versions, &greatest);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(greatest_version(file, file->versions, &greatest));
/*
* Increment if greatest is not the actual maximum value.
#ifdef USE_ROUTE_SOCKET
static isc_result_t
route_socket(uv_os_sock_t *fdp) {
- isc_result_t result;
uv_os_sock_t fd = -1;
#ifdef USE_NETLINK
struct sockaddr_nl sa;
int r;
#endif
- result = isc__nm_socket(ROUTE_SOCKET_PF, SOCK_RAW,
- ROUTE_SOCKET_PROTOCOL, &fd);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc__nm_socket(ROUTE_SOCKET_PF, SOCK_RAW, ROUTE_SOCKET_PROTOCOL,
+ &fd));
#ifdef USE_NETLINK
sa.nl_family = PF_NETLINK;
return ISC_R_SHUTTINGDOWN;
}
- result = route_socket(&fd);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(route_socket(&fd));
sock = isc_mempool_get(worker->nmsocket_pool);
isc__nmsocket_init(sock, worker, isc_nm_udpsocket, NULL, NULL);
isc_result_t
isc_parse_uint16(uint16_t *uip, const char *string, int base) {
uint32_t val;
- isc_result_t result;
- result = isc_parse_uint32(&val, string, base);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+
+ RETERR(isc_parse_uint32(&val, string, base));
if (val > 0xFFFF) {
return ISC_R_RANGE;
}
isc_result_t
isc_parse_uint8(uint8_t *uip, const char *string, int base) {
uint32_t val;
- isc_result_t result;
- result = isc_parse_uint32(&val, string, base);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+
+ RETERR(isc_parse_uint32(&val, string, base));
if (val > 0xFF) {
return ISC_R_RANGE;
}
int *restrict psocktype,
isc_sockaddr_t *restrict psrc_addr,
isc_sockaddr_t *restrict pdst_addr) {
- isc_result_t result;
size_t ret;
isc_region_t header_region = { 0 };
isc_buffer_t buf = { 0 };
INSIST(handler->expect_data == 0);
- result = isc__proxy2_handler_get_addresses(
- (isc_proxy2_handler_t *)handler, &buf, psrc_addr, pdst_addr);
-
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc__proxy2_handler_get_addresses(
+ (isc_proxy2_handler_t *)handler, &buf, psrc_addr, pdst_addr));
SET_IF_NOT_NULL(psocktype,
proxy2_socktype_to_socktype(handler->proxy_socktype));
return ISC_R_RANGE;
}
- result = isc_proxy2_subtlv_tls_header_data(tls_tlv_data, &client_flags,
- &client_cert_verified);
-
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_proxy2_subtlv_tls_header_data(tls_tlv_data, &client_flags,
+ &client_cert_verified));
p = tls_tlv_data->base;
p += ISC_PROXY2_TLS_SUBHEADER_MIN_SIZE;
isc_result_t
isc_proxy2_tlv_data_verify(const isc_region_t *restrict tlv_data) {
- isc_result_t result;
tlv_verify_cbarg_t cbarg = { .verify_result = ISC_R_SUCCESS };
- result = isc_proxy2_tlv_iterate(tlv_data, isc_proxy2_tlv_verify_cb,
- &cbarg);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_proxy2_tlv_iterate(tlv_data, isc_proxy2_tlv_verify_cb,
+ &cbarg));
return cbarg.verify_result;
}
*target = node;
return ISC_R_SUCCESS;
} else {
- result = _ref_prefix(radix->mctx, &node->prefix,
- prefix);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(_ref_prefix(radix->mctx, &node->prefix, prefix));
}
INSIST(node->data[RADIX_V4] == NULL &&
node->node_num[RADIX_V4] == -1 &&
isc_result_t
isc_sockaddr_totext(const isc_sockaddr_t *sockaddr, isc_buffer_t *target) {
- isc_result_t result;
isc_netaddr_t netaddr;
char pbuf[sizeof("65000")];
unsigned int plen;
INSIST(plen < sizeof(pbuf));
isc_netaddr_fromsockaddr(&netaddr, sockaddr);
- result = isc_netaddr_totext(&netaddr, target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_netaddr_totext(&netaddr, target));
if (1 + plen + 1 > isc_buffer_availablelength(target)) {
return ISC_R_NOSPACE;
}
if (up->field_set & (1 << ISC_UF_HOST)) {
- isc_result_t result;
-
- result = http_parse_host(buf, up, found_at);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(http_parse_host(buf, up, found_at));
}
/* CONNECT requests can only contain "hostname:port" */
const char *wordbreak, isccc_region_t *target) {
isc_region_t sr;
isc_buffer_t tb;
- isc_result_t result;
sr.base = source->rstart;
sr.length = (unsigned int)(source->rend - source->rstart);
isc_buffer_init(&tb, target->rstart,
(unsigned int)(target->rend - target->rstart));
- result = isc_base64_totext(&sr, wordlength, wordbreak, &tb);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_base64_totext(&sr, wordlength, wordbreak, &tb));
source->rstart = source->rend;
target->rstart = isc_buffer_used(&tb);
return ISC_R_SUCCESS;
isc_result_t
isccc_base64_decode(const char *cstr, isccc_region_t *target) {
isc_buffer_t b;
- isc_result_t result;
isc_buffer_init(&b, target->rstart,
(unsigned int)(target->rend - target->rstart));
- result = isc_base64_decodestring(cstr, &b);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_base64_decodestring(cstr, &b));
target->rstart = isc_buffer_used(&b);
return ISC_R_SUCCESS;
}
/*
* Emit the table.
*/
- result = table_towire(elt, buffer);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(table_towire(elt, buffer));
len = (*buffer)->used - used;
/*
/*
* Emit the list.
*/
- result = list_towire(elt, buffer);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(list_towire(elt, buffer));
len = (*buffer)->used - used;
/*
/*
* Emit the value.
*/
- result = value_towire(v, buffer);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(value_towire(v, buffer));
}
return ISC_R_SUCCESS;
static isc_result_t
list_towire(isccc_sexpr_t *list, isc_buffer_t **buffer) {
- isc_result_t result;
-
while (list != NULL) {
- result = value_towire(ISCCC_SEXPR_CAR(list), buffer);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(value_towire(ISCCC_SEXPR_CAR(list), buffer));
list = ISCCC_SEXPR_CDR(list);
}
sign(unsigned char *data, unsigned int length, unsigned char *out,
uint32_t algorithm, isccc_region_t *secret) {
const isc_md_type_t *md_type;
- isc_result_t result;
isccc_region_t source, target;
unsigned char digest[ISC_MAX_MD_SIZE];
unsigned int digestlen = sizeof(digest);
return ISC_R_NOTIMPLEMENTED;
}
- result = isc_hmac(md_type, secret->rstart, REGION_SIZE(*secret), data,
- length, digest, &digestlen);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_hmac(md_type, secret->rstart, REGION_SIZE(*secret), data,
+ length, digest, &digestlen));
source.rend = digest + digestlen;
memset(digestb64, 0, sizeof(digestb64));
target.rstart = digestb64;
target.rend = digestb64 + sizeof(digestb64);
- result = isccc_base64_encode(&source, 64, "", &target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isccc_base64_encode(&source, 64, "", &target));
if (algorithm == ISCCC_ALG_HMACMD5) {
PUT_MEM(digestb64, HMD5_LENGTH, out);
} else {
/*
* Emit the message.
*/
- result = table_towire(alist, buffer);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(table_towire(alist, buffer));
if (secret != NULL) {
return sign((unsigned char *)(*buffer)->base + signed_base,
(*buffer)->used - signed_base,
const isc_md_type_t *md_type;
isccc_region_t source;
isccc_region_t target;
- isc_result_t result;
isccc_sexpr_t *_auth, *hmacvalue;
unsigned char digest[ISC_MAX_MD_SIZE];
unsigned int digestlen = sizeof(digest);
return ISC_R_NOTIMPLEMENTED;
}
- result = isc_hmac(md_type, secret->rstart, REGION_SIZE(*secret), data,
- length, digest, &digestlen);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_hmac(md_type, secret->rstart, REGION_SIZE(*secret), data,
+ length, digest, &digestlen));
source.rend = digest + digestlen;
target.rstart = digestb64;
target.rend = digestb64 + sizeof(digestb64);
memset(digestb64, 0, sizeof(digestb64));
- result = isccc_base64_encode(&source, 64, "", &target);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isccc_base64_encode(&source, 64, "", &target));
/*
* Verify.
* Create the ack.
*/
ack = NULL;
- result = createmessage(1, _to, _frm, serial, t, 0, &ack, false);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(createmessage(1, _to, _frm, serial, t, 0, &ack, false));
_ctrl = isccc_alist_lookup(ack, "_ctrl");
if (_ctrl == NULL) {
* Create the response.
*/
alist = NULL;
- result = isccc_cc_createmessage(1, _to, _frm, serial, now, expires,
- &alist);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isccc_cc_createmessage(1, _to, _frm, serial, now, expires,
+ &alist));
_ctrl = isccc_alist_lookup(alist, "_ctrl");
if (_ctrl == NULL) {
*/
static isc_result_t
get_acl_def(const cfg_obj_t *cctx, const char *name, const cfg_obj_t **ret) {
- isc_result_t result;
const cfg_obj_t *acls = NULL;
- result = cfg_map_get(cctx, "acl", &acls);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(cfg_map_get(cctx, "acl", &acls));
CFG_LIST_FOREACH(acls, elt) {
const cfg_obj_t *acl = cfg_listelt_value(elt);
const char *aclname =
} else if (cfg_obj_islist(ce)) {
bool negative;
uint32_t sub;
- result = count_acl_elements(ce, cctx, ctx, mctx, &sub,
- &negative);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(count_acl_elements(ce, cctx, ctx, mctx, &sub,
+ &negative));
n += sub;
if (negative) {
n++;
uint32_t nelem;
if (nest_level == 0) {
- result = count_acl_elements(caml, cctx, ctx, mctx,
- &nelem, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(count_acl_elements(caml, cctx, ctx, mctx, &nelem,
+ NULL));
} else {
nelem = cfg_list_length(caml, false);
}
return ISC_R_FAILURE;
}
if (forwarders != NULL) {
- isc_result_t result = ISC_R_SUCCESS;
const cfg_obj_t *tlspobj = cfg_tuple_get(forwarders, "tls");
if (tlspobj != NULL && cfg_obj_isstring(tlspobj)) {
const char *tls = cfg_obj_asstring(tlspobj);
if (tls != NULL) {
- result = validate_tls(config, tlspobj, tls);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(validate_tls(config, tlspobj, tls));
}
}
const cfg_obj_t *forwarder = cfg_listelt_value(element);
const char *tls = cfg_obj_getsockaddrtls(forwarder);
if (tls != NULL) {
- result = validate_tls(config, faddresses, tls);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(validate_tls(config, faddresses, tls));
}
}
}
static isc_result_t
get_remotes(const cfg_obj_t *cctx, const char *list, const char *name,
const cfg_obj_t **ret) {
- isc_result_t result = ISC_R_SUCCESS;
const cfg_obj_t *obj = NULL;
- result = cfg_map_get(cctx, list, &obj);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(cfg_map_get(cctx, list, &obj));
CFG_LIST_FOREACH(obj, elt) {
const char *listname = NULL;
result = tresult;
continue;
}
- tresult = isccfg_check_key(key);
- if (tresult != ISC_R_SUCCESS) {
- return tresult;
- }
+ RETERR(isccfg_check_key(key));
dns_name_format(name, namebuf, sizeof(namebuf));
keyname = isc_mem_strdup(mctx, namebuf);
isc_result_t
cfg_parse_obj(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
- isc_result_t result;
-
REQUIRE(pctx != NULL);
REQUIRE(type != NULL);
REQUIRE(ret != NULL && *ret == NULL);
- result = type->parse(pctx, type, ret);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(type->parse(pctx, type, ret));
ENSURE(*ret != NULL);
return ISC_R_SUCCESS;
}
isc_result_t
cfg_parse_boolean(cfg_parser_t *pctx, const cfg_type_t *type ISC_ATTR_UNUSED,
cfg_obj_t **ret) {
- isc_result_t result;
bool value;
cfg_obj_t *obj = NULL;
REQUIRE(pctx != NULL);
REQUIRE(ret != NULL && *ret == NULL);
- result = cfg_gettoken(pctx, 0);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(cfg_gettoken(pctx, 0));
if (pctx->token.type != isc_tokentype_string) {
goto bad_boolean;
isc_result_t
cfg_map_get(const cfg_obj_t *mapobj, const char *name, const cfg_obj_t **obj) {
- isc_result_t result;
isc_symvalue_t val;
const cfg_map_t *map;
map = &mapobj->value.map;
- result = isc_symtab_lookup(map->symtab, name, SYMTAB_DUMMY_TYPE, &val);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_symtab_lookup(map->symtab, name, SYMTAB_DUMMY_TYPE, &val));
*obj = val.as_pointer;
return ISC_R_SUCCESS;
}
if (inet_pton(AF_INET6, buf, &in6a) == 1) {
if (d != NULL) {
- isc_result_t result;
-
- result = isc_netscope_pton(
- AF_INET6, d + 1, &in6a, &zone);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_netscope_pton(
+ AF_INET6, d + 1, &in6a, &zone));
}
isc_netaddr_fromin6(na, &in6a);
*/
static isc_result_t
cfg_getstringtoken(cfg_parser_t *pctx) {
- isc_result_t result;
-
- result = cfg_gettoken(pctx, CFG_LEXOPT_QSTRING);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(cfg_gettoken(pctx, CFG_LEXOPT_QSTRING));
if (pctx->token.type != isc_tokentype_string &&
pctx->token.type != isc_tokentype_qstring)
.value = (unsigned char *)nsidp,
.length = (uint16_t)strlen(nsidp),
};
- result = dns_message_ednsaddopt(message, &option);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_message_ednsaddopt(message, &option));
}
}
dns_ednsopt_t option = { .code = DNS_OPT_COOKIE,
.length = COOKIE_SIZE,
.value = cookie };
- result = dns_message_ednsaddopt(message, &option);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_message_ednsaddopt(message, &option));
}
if ((client->inner.attributes & NS_CLIENTATTR_HAVEEXPIRE) != 0) {
dns_ednsopt_t option = { .code = DNS_OPT_EXPIRE,
.value = expire,
.length = 4 };
- result = dns_message_ednsaddopt(message, &option);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_message_ednsaddopt(message, &option));
}
if (((client->inner.attributes & NS_CLIENTATTR_HAVEECS) != 0) &&
dns_ednsopt_t option = { .code = DNS_OPT_CLIENT_SUBNET,
.length = addrl + 4,
.value = ecs };
- result = dns_message_ednsaddopt(message, &option);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_message_ednsaddopt(message, &option));
}
if (TCP_CLIENT(client) && USEKEEPALIVE(client)) {
dns_ednsopt_t option = { .code = DNS_OPT_TCP_KEEPALIVE,
.length = 2,
.value = advtimo };
- result = dns_message_ednsaddopt(message, &option);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_message_ednsaddopt(message, &option));
}
for (size_t i = 0; i < DNS_EDE_MAX_ERRORS; i++) {
dns_ednsopt_t option = { .code = DNS_OPT_EDE,
.length = ede->length,
.value = ede->value };
- result = dns_message_ednsaddopt(message, &option);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_message_ednsaddopt(message, &option));
}
if ((client->inner.attributes & NS_CLIENTATTR_HAVEZONEVERSION) != 0) {
dns_ednsopt_t option = {
.length = client->inner.zoneversionlength,
.value = client->inner.zoneversion
};
- result = dns_message_ednsaddopt(message, &option);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_message_ednsaddopt(message, &option));
}
if (WANTRC(client)) {
.length = rad->length,
.value = rad->ndata,
};
- result = dns_message_ednsaddopt(message, &option);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_message_ednsaddopt(message, &option));
}
}
/* First add localhost address */
prefixlen = (netaddr->family == AF_INET) ? 32 : 128;
- result = dns_iptable_addprefix(localhost->iptable, netaddr, prefixlen,
- true);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_iptable_addprefix(localhost->iptable, netaddr, prefixlen,
+ true));
/* Then add localnets prefix */
result = isc_netaddr_masktoprefixlen(&interface->netmask, &prefixlen);
return ISC_R_SUCCESS;
}
- result = dns_iptable_addprefix(localnets->iptable, netaddr, prefixlen,
- true);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_iptable_addprefix(localnets->iptable, netaddr, prefixlen,
+ true));
return ISC_R_SUCCESS;
}
isc_netaddr_any(&zero_address);
isc_netaddr_any6(&zero_address6);
- result = isc_interfaceiter_create(mgr->mctx, &iter);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_interfaceiter_create(mgr->mctx, &iter));
dns_acl_create(mgr->mctx, 0, &localhost);
dns_acl_create(mgr->mctx, 0, &localnets);
version = NULL;
dns_db_detach(&db);
dns_getdb_options_t options = { .nolog = true };
- result = query_getzonedb(client, name, type, options, &zone,
- &db, &version);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(query_getzonedb(client, name, type, options, &zone, &db,
+ &version));
dns_zone_detach(&zone);
CTRACE(ISC_LOG_DEBUG(3), "query_additionalauth: other zone");
continue;
}
- result = rpz_rewrite_ip(client, &netaddr, qtype,
- rpz_type, zbits, p_rdatasetp);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(rpz_rewrite_ip(client, &netaddr, qtype, rpz_type,
+ zbits, p_rdatasetp));
}
} while (!done &&
client->query.rpz_st->m.policy == DNS_RPZ_POLICY_MISS);
inc_stats(client, ns_statscounter_recursion);
}
- result = acquire_recursionquota(client);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(acquire_recursionquota(client));
/*
* Invoke the resolver.
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_cname_t cname;
- result = query_synthwildcard(qctx, rdataset, sigrdataset);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(query_synthwildcard(qctx, rdataset, sigrdataset));
qctx->client->query.attributes |= NS_QUERYATTR_PARTIALANSWER;
*/
static isc_result_t
foreach_node_rr_action(void *data, dns_rdataset_t *rdataset) {
- isc_result_t result;
foreach_node_rr_ctx_t *ctx = data;
DNS_RDATASET_FOREACH(rdataset) {
rr_t rr = { 0, DNS_RDATA_INIT };
dns_rdataset_current(rdataset, &rr.rdata);
rr.ttl = rdataset->ttl;
- result = (*ctx->rr_action)(ctx->rr_action_data, &rr);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR((*ctx->rr_action)(ctx->rr_action_data, &rr));
}
return ISC_R_SUCCESS;
}
dns_rdata_t *update_rdata, bool *ok) {
uint32_t db_serial;
uint32_t update_serial;
- isc_result_t result;
update_serial = dns_soa_getserial(update_rdata);
- result = dns_db_getsoaserial(db, ver, &db_serial);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_getsoaserial(db, ver, &db_serial));
if (DNS_SERIAL_GE(db_serial, update_serial)) {
*ok = false;
dns_rdataset_init(&rdataset);
- result = dns_db_getoriginnode(db, &node);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_getoriginnode(db, &node));
result = dns_db_findrdataset(db, node, ver, dns_rdatatype_nsec3param, 0,
(isc_stdtime_t)0, &rdataset, NULL);
if (result == ISC_R_NOTFOUND) {
char classbuf[DNS_RDATACLASS_FORMATSIZE];
update_t *uev = NULL;
- result = checkupdateacl(client, dns_zone_getforwardacl(zone),
- "update forwarding", dns_zone_getorigin(zone),
- true, false);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(checkupdateacl(client, dns_zone_getforwardacl(zone),
+ "update forwarding", dns_zone_getorigin(zone),
+ true, false));
result = isc_quota_acquire(&client->manager->sctx->updquota);
if (result != ISC_R_SUCCESS) {
static isc_result_t
axfr_rrstream_first(rrstream_t *rs) {
axfr_rrstream_t *s = (axfr_rrstream_t *)rs;
- isc_result_t result;
- result = dns_rriterator_first(&s->it);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+
+ RETERR(dns_rriterator_first(&s->it));
+
/* Skip SOA records. */
for (;;) {
dns_name_t *name_dummy = NULL;
if (rdata->type != dns_rdatatype_soa) {
break;
}
- result = dns_rriterator_next(&s->it);
- if (result != ISC_R_SUCCESS) {
- break;
- }
+ RETERR(dns_rriterator_next(&s->it));
}
- return result;
+
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_dispatch_t *disp = NULL;
isc_sockaddr_any(&any);
- result = dns_dispatch_createudp(dispatchmgr, &any, &disp);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_dispatch_createudp(dispatchmgr, &any, &disp));
result = dns_dispatchset_create(isc_g_mctx, disp, dsetp, ndisps);
dns_dispatch_detach(&disp);
static isc_result_t
setup_master(void (*warn)(struct dns_rdatacallbacks *, const char *, ...),
void (*error)(struct dns_rdatacallbacks *, const char *, ...)) {
- isc_result_t result;
int len;
isc_buffer_t source;
isc_buffer_setactive(&source, len);
dns_master_initrawheader(&header);
- result = dns_name_fromtext(dns_origin, &source, dns_rootname, 0);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromtext(dns_origin, &source, dns_rootname, 0));
dns_rdatacallbacks_init_stdio(&callbacks);
callbacks.add = add_callback;
callbacks.error = error;
}
headerset = false;
- return result;
+ return ISC_R_SUCCESS;
}
static isc_result_t
void (*error)(struct dns_rdatacallbacks *, const char *, ...)) {
isc_result_t result;
- result = setup_master(warn, error);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(setup_master(warn, error));
dns_rdatacallbacks_init_stdio(&callbacks);
callbacks.add = add_callback;
}
if (workdir != NULL) {
- result = isc_dir_chdir(workdir);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_dir_chdir(workdir));
}
result = dns_master_loadfile(testfile, dns_origin, dns_origin,
dns_dispatchmgr_t *dispatchmgr = NULL;
if (with_dispatchmgr) {
- result = dns_dispatchmgr_create(isc_g_mctx, &dispatchmgr);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_dispatchmgr_create(isc_g_mctx, &dispatchmgr));
}
dns_view_create(isc_g_mctx, dispatchmgr, dns_rdataclass_in, name,
name = dns_fixedname_initname(&fixed);
- result = dns_name_fromstring(name, origin, dns_rootname, 0, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromstring(name, origin, dns_rootname, 0, NULL));
- result = dns_db_create(isc_g_mctx, dbimp, name, dbtype,
- dns_rdataclass_in, 0, NULL, db);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_create(isc_g_mctx, dbimp, name, dbtype, dns_rdataclass_in,
+ 0, NULL, db));
result = dns_db_load(*db, testfile, dns_masterformat_text, 0);
return result;
isc_result_t
dns_test_getdata(const char *file, unsigned char *buf, size_t bufsiz,
size_t *sizep) {
- isc_result_t result;
+ isc_result_t result = ISC_R_SUCCESS;
unsigned char *bp;
char *rp, *wp;
char s[BUFSIZ];
FILE *f = NULL;
int n;
- result = isc_stdio_open(file, "r", &f);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_stdio_open(file, "r", &f));
bp = buf;
while (fgets(s, sizeof(s), f) != NULL) {
/*
* Prepare zone structure for further processing.
*/
- result = dns_test_makezone(zonename, &served_zone, view, false);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_test_makezone(zonename, &served_zone, view, false));
/*
* Start zone manager.
name = dns_fixedname_initname(&fixed);
- result = dns_name_fromstring(name, origin, dns_rootname, 0, NULL);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_name_fromstring(name, origin, dns_rootname, 0, NULL));
- result = dns_db_create(isc_g_mctx, dbimp, name, dbtype,
- dns_rdataclass_in, 0, NULL, db);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(dns_db_create(isc_g_mctx, dbimp, name, dbtype, dns_rdataclass_in,
+ 0, NULL, db));
result = dns_db_load(*db, testfile, dns_masterformat_text, 0);
return result;
FILE *f = NULL;
int n;
- result = isc_stdio_open(file, "r", &f);
- if (result != ISC_R_SUCCESS) {
- return result;
- }
+ RETERR(isc_stdio_open(file, "r", &f));
bp = buf;
while (fgets(s, sizeof(s), f) != NULL) {
projects / thirdparty / bind9.git / commitdiff
