isc_result_t result;
if (symtab == NULL) {
- return (false);
+ return false;
}
result = isc_symtab_lookup(symtab, key, value, NULL);
if (result == ISC_R_SUCCESS) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static bool
aaaa->type == dns_rdatatype_aaaa);
if (a == NULL || aaaa == NULL) {
- return (answer);
+ return answer;
}
memset(&hints, 0, sizeof(hints));
add(namebuf, ERR_NO_ADDRESSES);
}
/* XXX950 make fatal for 9.5.0 */
- return (true);
+ return true;
default:
if (!logged(namebuf, ERR_LOOKUP_FAILURE)) {
gai_strerror(result));
add(namebuf, ERR_LOOKUP_FAILURE);
}
- return (true);
+ return true;
}
/*
}
}
freeaddrinfo(ai);
- return (answer);
+ return answer;
}
static bool
}
}
freeaddrinfo(ai);
- return (answer);
+ return answer;
case EAI_NONAME:
#if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME)
add(namebuf, ERR_NO_ADDRESSES);
}
/* XXX950 make fatal for 9.5.0. */
- return (true);
+ return true;
default:
if (!logged(namebuf, ERR_LOOKUP_FAILURE)) {
gai_strerror(result));
add(namebuf, ERR_LOOKUP_FAILURE);
}
- return (true);
+ return true;
}
}
}
}
freeaddrinfo(ai);
- return (answer);
+ return answer;
case EAI_NONAME:
#if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME)
add(namebuf, ERR_NO_ADDRESSES);
}
/* XXX950 make fatal for 9.5.0. */
- return (true);
+ return true;
default:
if (!logged(namebuf, ERR_LOOKUP_FAILURE)) {
gai_strerror(result));
add(namebuf, ERR_LOOKUP_FAILURE);
}
- return (true);
+ return true;
}
}
ISC_R_SUCCESS);
*logp = log;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*% load the zone */
if (zone != NULL) {
dns_zone_detach(&zone);
}
- return (result);
+ return result;
}
/*% dump the zone */
"could not open output "
"file \"%s\" for writing\n",
filename);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
(void)isc_stdio_close(output);
}
- return (result);
+ return result;
}
cfg_obj_log(obj, logc, ISC_LOG_ERROR,
"change directory to '%s' failed: %s\n", directory,
isc_result_totext(result));
- return (result);
+ return result;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
int i;
for (i = 0;; i++) {
if (maps[i] == NULL) {
- return (false);
+ return false;
}
if (cfg_map_get(maps[i], name, obj) == ISC_R_SUCCESS) {
- return (true);
+ return true;
}
}
}
for (i = 0;; i++) {
if (maps[i] == NULL) {
- return (false);
+ return false;
}
checknames = NULL;
result = cfg_map_get(maps[i], "check-names", &checknames);
}
if (checknames != NULL && !cfg_obj_islist(checknames)) {
*obj = checknames;
- return (true);
+ return true;
}
for (element = cfg_list_first(checknames); element != NULL;
element = cfg_list_next(element))
continue;
}
*obj = cfg_tuple_get(value, "mode");
- return (true);
+ return true;
}
}
}
isc_textregion_t r;
if (zfile == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
DE_CONST(zclass, r.base);
r.length = strlen(zclass);
result = dns_rdataclass_fromtext(&rdclass, &r);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_rootns_create(mctx, rdclass, zfile, &db);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_db_detach(&db);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*% configure the zone */
printf("%s %s %s in-view %s\n", zname, zclass, view, inview);
}
if (inviewobj != NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
cfg_map_get(zoptions, "type", &typeobj);
if (typeobj == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (list) {
const char *ztype = cfg_obj_asstring(typeobj);
printf("%s %s %s %s\n", zname, zclass, view, ztype);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (dbobj != NULL && strcmp("rbt", cfg_obj_asstring(dbobj)) != 0 &&
strcmp("rbt64", cfg_obj_asstring(dbobj)) != 0)
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
cfg_map_get(zoptions, "dlz", &dlzobj);
if (dlzobj != NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
cfg_map_get(zoptions, "file", &fileobj);
* master and redirect
*/
if (strcasecmp(cfg_obj_asstring(typeobj), "hint") == 0) {
- return (configure_hint(zfile, zclass, mctx));
+ return configure_hint(zfile, zclass, mctx);
} else if ((strcasecmp(cfg_obj_asstring(typeobj), "primary") != 0) &&
(strcasecmp(cfg_obj_asstring(typeobj), "master") != 0) &&
(strcasecmp(cfg_obj_asstring(typeobj), "redirect") != 0))
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
}
if (primariesobj != NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
if (zfile == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
obj = NULL;
fprintf(stderr, "%s/%s/%s: %s\n", view, zname, zclass,
isc_result_totext(result));
}
- return (result);
+ return result;
}
/*% configure a view */
result = tresult;
}
}
- return (result);
+ return result;
}
static isc_result_t
if (!cfg_obj_isstring(classobj)) {
*classp = defclass;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
DE_CONST(cfg_obj_asstring(classobj), r.base);
r.length = strlen(r.base);
- return (dns_rdataclass_fromtext(classp, &r));
+ return dns_rdataclass_fromtext(classp, &r);
}
/*% load zones from the configuration */
}
cleanup:
- return (result);
+ return result;
}
static void
isc_mem_destroy(&mctx);
- return (exit_status);
+ return exit_status;
}
}
isc_mem_destroy(&mctx);
- return ((result == ISC_R_SUCCESS) ? 0 : 1);
+ return (result == ISC_R_SUCCESS) ? 0 : 1;
}
}
if (strcasecmp(p, "md5") == 0) {
- return (DST_ALG_HMACMD5);
+ return DST_ALG_HMACMD5;
}
if (strcasecmp(p, "sha1") == 0) {
- return (DST_ALG_HMACSHA1);
+ return DST_ALG_HMACSHA1;
}
if (strcasecmp(p, "sha224") == 0) {
- return (DST_ALG_HMACSHA224);
+ return DST_ALG_HMACSHA224;
}
if (strcasecmp(p, "sha256") == 0) {
- return (DST_ALG_HMACSHA256);
+ return DST_ALG_HMACSHA256;
}
if (strcasecmp(p, "sha384") == 0) {
- return (DST_ALG_HMACSHA384);
+ return DST_ALG_HMACSHA384;
}
if (strcasecmp(p, "sha512") == 0) {
- return (DST_ALG_HMACSHA512);
+ return DST_ALG_HMACSHA512;
}
- return (DST_ALG_UNKNOWN);
+ return DST_ALG_UNKNOWN;
}
/*%
alg_bits(dns_secalg_t alg) {
switch (alg) {
case DST_ALG_HMACMD5:
- return (128);
+ return 128;
case DST_ALG_HMACSHA1:
- return (160);
+ return 160;
case DST_ALG_HMACSHA224:
- return (224);
+ return 224;
case DST_ALG_HMACSHA256:
- return (256);
+ return 256;
case DST_ALG_HMACSHA384:
- return (384);
+ return 384;
case DST_ALG_HMACSHA512:
- return (512);
+ return 512;
default:
- return (0);
+ return 0;
}
}
pw = getpwnam(user);
if (pw == NULL) {
errno = EINVAL;
- return (-1);
+ return -1;
}
- return (fchown(fileno(fd), pw->pw_uid, -1));
+ return fchown(fileno(fd), pw->pw_uid, -1);
}
isc_mem_destroy(&mctx);
- return (0);
+ return 0;
}
isc_mem_destroy(&mctx);
- return (0);
+ return 0;
}
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(owner, namebuf, sizeof(namebuf));
delv_log(ISC_LOG_DEBUG(4), "WARN: empty rdataset %s", namebuf);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (!showdnssec && rdataset->type == dns_rdatatype_rrsig) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (first || rdataset->trust != trust) {
isc_mem_put(mctx, t, len);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
if (result == ISC_R_SUCCESS) {
*stylep = style;
}
- return (result);
+ return result;
}
static isc_result_t
if (result != ISC_R_SUCCESS) {
delv_log(ISC_LOG_ERROR, "failed to convert QNAME %s: %s", text,
isc_result_totext(result));
- return (result);
+ return result;
}
*name = n;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
CHECK(convert_name(&fkeyname, &keyname, keynamestr));
if (!root_validation) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (anchor_name) {
}
if (!match_root) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (!root_validation) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
delv_log(ISC_LOG_DEBUG(3), "adding trust anchor %s", trust_anchor);
result = ISC_R_FAILURE;
}
- return (result);
+ return result;
}
static isc_result_t
if (result == DST_R_NOCRYPTO) {
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
static isc_result_t
const char *filename = anchorfile;
if (!root_validation) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (filename == NULL) {
delv_log(ISC_LOG_ERROR, "setup_dnsseckeys: %s",
isc_result_totext(result));
}
- return (result);
+ return result;
}
static isc_result_t
if (gaierror != 0) {
delv_log(ISC_LOG_ERROR, "getaddrinfo failed: %s",
gai_strerror(gaierror));
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
result = ISC_R_SUCCESS;
isc_result_totext(result));
}
- return (result);
+ return result;
}
static isc_result_t
if (resconf != NULL) {
irs_resconf_destroy(&resconf);
}
- return (result);
+ return result;
}
static isc_result_t
if (result != ISC_R_SUCCESS) {
printf("invalid %s '%s': %s\n", desc, value,
isc_result_totext(result));
- return (result);
+ return result;
}
*uip = n;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
if (strlen(option) > 1U) {
option = &option[1];
} else {
- return (false);
+ return false;
}
}
opt = option[0];
switch (opt) {
case 'a':
anchorfile = isc_mem_strdup(mctx, value);
- return (value_from_next);
+ return value_from_next;
case 'b':
hash = strchr(value, '#');
if (hash != NULL) {
if (hash != NULL) {
*hash = '#';
}
- return (value_from_next);
+ return value_from_next;
case 'c':
if (classset) {
warn("extra query class");
} else {
warn("ignoring invalid class");
}
- return (value_from_next);
+ return value_from_next;
case 'd':
result = parse_uint(&num, value, 99, "debug level");
if (result != ISC_R_SUCCESS) {
fatal("Couldn't parse debug level");
}
loglevel = num;
- return (value_from_next);
+ return value_from_next;
case 'p':
port = value;
- return (value_from_next);
+ return value_from_next;
case 'q':
if (curqname != NULL) {
warn("extra query name");
isc_mem_free(mctx, curqname);
}
curqname = isc_mem_strdup(mctx, value);
- return (value_from_next);
+ return value_from_next;
case 't':
*open_type_class = false;
tr.base = value;
} else {
warn("ignoring invalid type");
}
- return (value_from_next);
+ return value_from_next;
case 'x':
result = get_reverse(textname, sizeof(textname), value, false);
if (result == ISC_R_SUCCESS) {
fprintf(stderr, "Invalid IP address %s\n", value);
exit(EXIT_FAILURE);
}
- return (value_from_next);
+ return value_from_next;
invalid_option:
default:
fprintf(stderr, "Invalid option: -%s\n", option);
usage();
}
UNREACHABLE();
- return (false);
+ return false;
}
/*
static isc_result_t
append_str(const char *text, int len, char **p, char *end) {
if (len > end - *p) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(*p, text, len);
*p += len;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_result_t result;
result = reverse_octets(dot + 1, p, end);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = append_str(".", 1, p, end);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
len = (int)(dot - in);
} else {
len = strlen(in);
}
- return (append_str(in, len, p, end));
+ return append_str(in, len, p, end);
}
static isc_result_t
name = dns_fixedname_initname(&fname);
result = dns_byaddr_createptrname(&addr, options, name);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_name_format(name, reverse, (unsigned int)len);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
/*
* Not a valid IPv6 address. Assume IPv4.
char *p = reverse;
char *end = reverse + len;
if (strict && inet_pton(AF_INET, value, &addr.type.in) != 1) {
- return (DNS_R_BADDOTTEDQUAD);
+ return DNS_R_BADDOTTEDQUAD;
}
result = reverse_octets(value, &p, end);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = append_str(".in-addr.arpa.", 15, &p, end);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
dst_lib_destroy();
- return (0);
+ return 0;
}
RUNTIME_CHECK(result == ISC_R_SUCCESS);
if (strspn(buf + 1, "0123456789") == strlen(buf + 1)) {
buf[0] = '?';
- return (buf);
+ return buf;
}
- return (buf + 1);
+ return buf + 1;
}
/*% print usage */
if (query->lookup->trace || query->lookup->ns_search_only) {
result = dns_rdatatype_totext(rdata->type, buf);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
ADD_STRING(buf, " ");
}
result = dns_rdata_tofmttext(rdata, NULL, styleflags, 0, splitwidth,
" ", buf);
if (result == ISC_R_NOSPACE) {
- return (result);
+ return result;
}
check_result(result, "dns_rdata_totext");
if (query->lookup->identify) {
ADD_STRING(buf, store);
}
ADD_STRING(buf, "\n");
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
dns_rdatatype_aaaa, dns_rdatatype_none,
NULL, &rdataset);
if (result == DNS_R_NXDOMAIN || result == DNS_R_NXRRSET) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_dns64_findprefix(rdataset, prefix, &count);
if (result == ISC_R_NOTFOUND) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (count > 10) {
count = 10;
for (i = 0; i < count; i++) {
result = isc_netaddr_totext(&prefix[i].addr, buf);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = isc_buffer_printf(buf, "/%u\n", prefix[i].prefixlen);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
dns_name_init(&empty_name, NULL);
result = dns_message_firstname(msg, DNS_SECTION_ANSWER);
if (result == ISC_R_NOMORE) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (;;) {
dns_rdataset_current(rdataset, &rdata);
result = say_message(&rdata, query, buf);
if (result == ISC_R_NOSPACE) {
- return (result);
+ return result;
}
check_result(result, "say_message");
loopresult = dns_rdataset_next(rdataset);
if (result == ISC_R_NOMORE) {
break;
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
dns_name_t *name = NULL;
dns_message_currentname(msg, DNS_SECTION_QUESTION, &name);
if (dns_name_issubdomain(name, &local)) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
/*
dig_idnsetup(query->lookup, false);
- return (result);
+ return result;
}
/*%
if ((cmd = strtok_r(option, "=", &last)) == NULL) {
printf(";; Invalid option %s\n", option);
- return (lookup);
+ return lookup;
}
if (strncasecmp(cmd, "no", 2) == 0) {
cmd += 2;
if (value != NULL) {
value[-1] = '=';
}
- return (lookup);
+ return lookup;
#if !TARGET_OS_IPHONE
exit_or_usage:
} else {
fatal("can't find IPv4 networking");
UNREACHABLE();
- return (false);
+ return false;
}
break;
case '6':
} else {
fatal("can't find IPv6 networking");
UNREACHABLE();
- return (false);
+ return false;
}
break;
case 'd':
cmd = option;
FULLCHECK("debug");
debugging = true;
- return (false);
+ return false;
} else {
debugging = true;
}
if (strlen(option) > 1U) {
option = &option[1];
} else {
- return (false);
+ return false;
}
}
opt = option[0];
*hash = '#';
}
specified_source = true;
- return (value_from_next);
+ return value_from_next;
case 'c':
if ((*lookup)->rdclassset) {
fprintf(stderr, ";; Warning, extra class option\n");
"invalid class %s\n",
value);
}
- return (value_from_next);
+ return value_from_next;
case 'f':
atomic_store(&batchname, (uintptr_t)value);
- return (value_from_next);
+ return value_from_next;
case 'k':
strlcpy(keyfile, value, sizeof(keyfile));
- return (value_from_next);
+ return value_from_next;
case 'p':
result = parse_uint(&num, value, MAXPORT, "port number");
if (result != ISC_R_SUCCESS) {
}
port = num;
port_set = true;
- return (value_from_next);
+ return value_from_next;
case 'q':
if (!config_only) {
if (*need_clone) {
ISC_LIST_APPEND(lookup_list, (*lookup), link);
debug("looking up %s", (*lookup)->textname);
}
- return (value_from_next);
+ return value_from_next;
case 't':
*open_type_class = false;
if (strncasecmp(value, "ixfr=", 5) == 0) {
"invalid type %s\n",
value);
}
- return (value_from_next);
+ return value_from_next;
case 'y':
if ((ptr = strtok_r(value, ":", &last)) == NULL) {
usage();
ptr[-1] = ':';
}
ptr2[-1] = ':';
- return (value_from_next);
+ return value_from_next;
case 'x':
if (*need_clone) {
*lookup = clone_lookup(default_lookup, true);
fprintf(stderr, "Invalid IP address %s\n", value);
exit(EXIT_FAILURE);
}
- return (value_from_next);
+ return value_from_next;
invalid_option:
default:
fprintf(stderr, "Invalid option: -%s\n", option);
usage();
}
UNREACHABLE();
- return (false);
+ return false;
}
/*%
{
debug("%s %d: %s", msg, bargc, bargv[bargc]);
}
- return (bargc);
+ return bargc;
}
static void
dig_startup();
dig_shutdown();
- return (exitcode);
+ return exitcode;
}
}
s++;
}
- return (i);
+ return i;
}
static void
static isc_result_t
append(const char *text, size_t len, char **p, char *end) {
if (*p + len > end) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(*p, text, len);
*p += len;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_result_t result;
result = reverse_octets(dot + 1, p, end);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = append(".", 1, p, end);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
len = (int)(dot - in);
} else {
len = (int)strlen(in);
}
- return (append(in, len, p, end));
+ return append(in, len, p, end);
}
isc_result_t
name = dns_fixedname_initname(&fname);
result = dns_byaddr_createptrname(&addr, options, name);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_name_format(name, reverse, (unsigned int)len);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
/*
* Not a valid IPv6 address. Assume IPv4.
char *p = reverse;
char *end = reverse + len;
if (strict && inet_pton(AF_INET, value, &addr.type.in) != 1) {
- return (DNS_R_BADDOTTEDQUAD);
+ return DNS_R_BADDOTTEDQUAD;
}
result = reverse_octets(value, &p, end);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/* Append .in-addr.arpa. and a terminating NUL. */
result = append(".in-addr.arpa.", 15, &p, end);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
strlcpy(srv->servername, servname, MXNAME);
strlcpy(srv->userarg, userarg, MXNAME);
ISC_LINK_INIT(srv, link);
- return (srv);
+ return srv;
}
/*%
debug("make_empty_lookup() = %p->references = %" PRIuFAST32, looknew,
isc_refcount_current(&looknew->references));
- return (looknew);
+ return looknew;
}
#define EDNSOPT_OPTIONS 100U
looknew->magic = DIG_LOOKUP_MAGIC;
- return (looknew);
+ return looknew;
}
/*%
ISC_LIST_PREPEND(lookup_list, looknew, link);
debug("after insertion, init -> %p, new = %p, new -> %p", lookold,
looknew, looknew->link.next);
- return (looknew);
+ return looknew;
}
void
if (result != ISC_R_SUCCESS) {
printf("invalid %s '%s': %s\n", desc, value,
isc_result_totext(result));
- return (result);
+ return result;
}
*uip = n;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
parse_uint(uint32_t *uip, const char *value, uint32_t max, const char *desc) {
- return (parse_uint_helper(uip, value, max, desc, 10));
+ return parse_uint_helper(uip, value, max, desc, 10);
}
isc_result_t
parse_xint(uint32_t *uip, const char *value, uint32_t max, const char *desc) {
- return (parse_uint_helper(uip, value, max, desc, 0));
+ return parse_uint_helper(uip, value, max, desc, 0);
}
static uint32_t
fatal("couldn't parse digest bits");
}
tmp = (tmp + 7) & ~0x7U;
- return (tmp);
+ return tmp;
}
isc_result_t
sa->length = prefix_length;
*sap = sa;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
isc_result_t result;
if (!isc_file_exists(keyfile)) {
- return (ISC_R_FILENOTFOUND);
+ return ISC_R_FILENOTFOUND;
}
result = cfg_parser_create(mctx, NULL, &pctx);
cfg_parser_destroy(&pctx);
}
- return (result);
+ return result;
}
void
strlcpy(search->origin, domain, MXNAME);
search->origin[MXNAME - 1] = 0;
ISC_LINK_INIT(search, link);
- return (search);
+ return search;
}
static void
if (!q->started || isc_refcount_current(&q->references) > 1) {
if (!q->canceled && q != except_q) {
debug("there is a pending query %p", q);
- return (false);
+ return false;
}
}
q = ISC_LIST_NEXT(q, link);
}
- return (true);
+ return true;
}
static void
result = dns_message_findtype(name, dns_rdatatype_soa,
0, &rdataset);
if (result == ISC_R_SUCCESS) {
- return (0);
+ return 0;
}
}
rdataset = NULL;
if (lookup == NULL && section == DNS_SECTION_ANSWER &&
(query->lookup->trace || query->lookup->ns_search_only))
{
- return (followup_lookup(msg, query, DNS_SECTION_AUTHORITY));
+ return followup_lookup(msg, query, DNS_SECTION_AUTHORITY);
}
/*
link);
}
- return (numLookups);
+ return numLookups;
}
/*%
* We're not using a search list, so don't even think
* about finding the next entry.
*/
- return (false);
+ return false;
}
/*
(dns_name_isabsolute(name) ||
(int)dns_name_countlabels(name) > ndots))
{
- return (false);
+ return false;
}
if (oldlookup->origin == NULL && !oldlookup->need_search) {
/*
* Then we just did rootorg; there's nothing left.
*/
- return (false);
+ return false;
}
if (oldlookup->origin == NULL && oldlookup->need_search) {
newlookup = requeue_lookup(oldlookup, true);
} else {
search = ISC_LIST_NEXT(oldlookup->origin, link);
if (search == NULL && oldlookup->done_as_is) {
- return (false);
+ return false;
}
newlookup = requeue_lookup(oldlookup, true);
newlookup->origin = search;
}
cancel_lookup(oldlookup);
- return (true);
+ return true;
}
/*%
ISC_LINK_INIT(query, link);
query->magic = DIG_QUERY_MAGIC;
- return (query);
+ return query;
}
/*%
dns_message_puttempname(lookup->sendmsg,
&lookup->oname);
if (result == DNS_R_NAMETOOLONG) {
- return (false);
+ return false;
}
fatal("'%s' is not in legal name syntax (%s)",
lookup->textname,
lookup->textname, isc_result_totext(result));
#if TARGET_OS_IPHONE
clear_current_lookup();
- return (false);
+ return false;
#else /* if TARGET_OS_IPHONE */
cleanup_openssl_refs();
digexit();
ISC_LIST_ENQUEUE(lookup->q, query, link);
}
- return (true);
+ return true;
}
/*%
if (query->lookup->tls_key_file_set != query->lookup->tls_cert_file_set)
{
- return (NULL);
+ return NULL;
}
isc_sockaddr_format(&query->sockaddr, tlsctxname, sizeof(tlsctxname));
INSIST(*psess_cache == NULL);
*psess_cache = sess_cache;
}
- return (ctx);
+ return ctx;
}
if (psess_cache != NULL) {
}
INSIST(!query->lookup->tls_ca_set || found_store != NULL);
- return (found_ctx);
+ return found_ctx;
failure:
if (ctx != NULL) {
isc_tlsctx_free(&ctx);
if (store != NULL && store != found_store) {
isc_tls_cert_store_free(&store);
}
- return (NULL);
+ return NULL;
}
static void
current_query = lookup->current_query;
if (current_query == NULL || !ISC_LINK_LINKED(current_query, link)) {
- return (false);
+ return false;
}
next_query = ISC_LIST_NEXT(current_query, link);
if (next_query == NULL) {
- return (false);
+ return false;
}
debug("trying next server...");
start_udp(next_query);
}
- return (true);
+ return true;
}
static void
result = dns_message_firstname(msg, DNS_SECTION_ANSWER);
if (result != ISC_R_SUCCESS) {
puts("; Transfer failed.");
- return (true);
+ return true;
}
do {
dns_name_t *name;
{
puts("; Transfer failed. "
"Didn't start with SOA answer.");
- return (true);
+ return true;
}
if ((!query->second_rr_rcvd) &&
(rdata.type != dns_rdatatype_soa))
isc_nmhandle_detach(&query->readhandle);
launch_next_query(query);
query_detach(&query);
- return (false);
+ return false;
doexit:
dighost_received(len, peer, query);
- return (true);
+ return true;
}
static void
static int
ednsvers(dns_rdataset_t *opt) {
- return ((opt->ttl >> 16) & 0xff);
+ return (opt->ttl >> 16) & 0xff;
}
/*%
if (l->tcp_mode) {
bool fail = true;
if (result == ISC_R_SUCCESS) {
- if ((!query->first_soa_rcvd || query->warn_id))
- {
+ if (!query->first_soa_rcvd || query->warn_id) {
dighost_warning("%s: ID mismatch: "
"expected ID %u, got "
"%u",
isc_app_unblock();
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
INSIST(count == 1);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
int
fatal("couldn't get address for '%s': %s", host,
isc_result_totext(result));
}
- return (0);
+ return 0;
}
for (i = 0; i < count; i++) {
ISC_LIST_APPEND(lookup->my_server_list, srv, link);
}
- return (count);
+ return count;
}
/*%
idn2_free(dst);
}
- return (result);
+ return result;
}
/*%
bool
dig_lookup_is_tls(const dig_lookup_t *lookup) {
if (lookup->tls_mode || (lookup->tls_ca_set && !lookup->https_mode)) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
} else {
totext.consttext = rcodetext[rcode];
}
- return (totext.deconsttext);
+ return totext.deconsttext;
}
noreturn static void
result = dns_message_firstname(msg, sectionid);
if (result == ISC_R_NOMORE) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (;;) {
print_name, false,
no_rdata, &target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
#ifdef USEINITALWS
if (first) {
if (result == ISC_R_NOMORE) {
break;
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
result = dns_rdataset_totext(rdataset, owner, false, false, &target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_usedregion(&target, &r);
printf("%.*s", (int)r.length, (char *)r.base);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
: query->lookup->textname,
msg->rcode, rcode_totext(msg->rcode));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (default_lookups && query->lookup->rdtype == dns_rdatatype_a) {
result = printsection(msg, DNS_SECTION_QUESTION, "QUESTION",
true, query);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
if (!ISC_LIST_EMPTY(msg->sections[DNS_SECTION_ANSWER])) {
result = printsection(msg, DNS_SECTION_ANSWER, "ANSWER",
!short_form, query);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
result = printsection(msg, DNS_SECTION_AUTHORITY, "AUTHORITY",
true, query);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
if (!ISC_LIST_EMPTY(msg->sections[DNS_SECTION_ADDITIONAL]) &&
result = printsection(msg, DNS_SECTION_ADDITIONAL, "ADDITIONAL",
true, query);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
if ((tsig != NULL) && !short_form) {
result = printrdata(msg, tsig, tsigname, "PSEUDOSECTION TSIG",
true);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
if (!short_form) {
printf("%s has no %s record\n", namestr, typestr);
}
seen_error = force_error;
- return (result);
+ return result;
}
static const char *optstring = "46aAc:dilnm:p:rst:vVwCDN:R:TUW:";
cancel_all();
destroy_libs();
isc_app_finish();
- return ((seen_error == 0) ? 0 : 1);
+ return (seen_error == 0) ? 0 : 1;
}
} else {
totext.consttext = rcodetext[rcode];
}
- return (totext.deconsttext);
+ return totext.deconsttext;
}
static void
result = dns_message_firstname(msg, section);
if (result == ISC_R_NOMORE) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (;;) {
name = NULL;
if (result == ISC_R_NOMORE) {
break;
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
result = dns_message_firstname(msg, section);
if (result == ISC_R_NOMORE) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (;;) {
name = NULL;
if (result == ISC_R_NOMORE) {
break;
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
/* the lookup failed */
print_error |= 1;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (default_lookups && query->lookup->rdtype == dns_rdatatype_a) {
printsection(query, msg, headers, DNS_SECTION_AUTHORITY);
printsection(query, msg, headers, DNS_SECTION_ADDITIONAL);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
tr.length = strlen(typetext);
result = dns_rdatatype_fromtext(&rdtype, &tr);
if (result == ISC_R_SUCCESS) {
- return (true);
+ return true;
} else {
printf("unknown query type: %s\n", typetext);
- return (false);
+ return false;
}
}
tr.length = strlen(typetext);
result = dns_rdataclass_fromtext(&rdclass, &tr);
if (result == ISC_R_SUCCESS) {
- return (true);
+ return true;
} else {
printf("unknown query class: %s\n", typetext);
- return (false);
+ return false;
}
}
destroy_libs();
isc_app_finish();
- return (query_error | print_error);
+ return query_error | print_error;
}
line = fgets(buf, RL_MAXCMD, stdin);
if (line == NULL) {
free(buf);
- return (NULL);
+ return NULL;
}
- return (buf);
+ return buf;
};
#define add_history(line)
}
isc_buffer_putuint8(buf, 0);
- return (buf);
+ return buf;
}
static void
vbprintf(1, "found matching %s %d %d %d\n",
c ? "CDS" : "DS", ds.key_tag, ds.algorithm,
ds.digest_type);
- return (true);
+ return true;
} else if (strictness == TIGHT) {
vbprintf(0,
"key does not match %s %d %d %d "
"when it looks like it should\n",
c ? "CDS" : "DS", ds.key_tag, ds.algorithm,
ds.digest_type);
- return (false);
+ return false;
}
}
ki->rdata.type == dns_rdatatype_cdnskey ? "CDNSKEY" : "DNSKEY",
ki->tag, ki->algo);
- return (false);
+ return false;
}
/*
}
}
- return (keytable);
+ return keytable;
}
static void
}
}
- return (algo);
+ return algo;
}
/*
}
}
isc_mem_put(mctx, algo, nkey);
- return (ok);
+ return ok;
}
/*
}
isc_mem_put(mctx, algo, nkey);
- return (all_ok);
+ return all_ok;
}
/*
ds.common.rdtype = dns_rdatatype_ds;
if (ds.digest_type != dt) {
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
- return (dns_rdata_fromstruct(rds, rdclass, dns_rdatatype_ds, &ds, buf));
+ return dns_rdata_fromstruct(rds, rdclass, dns_rdatatype_ds, &ds, buf);
}
static isc_result_t
isc_buffer_availableregion(buf, &r);
if (r.length < DNS_DS_BUFFERSIZE) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
result = dns_ds_buildrdata(name, cdnskey, dt, r.base, ds);
isc_buffer_add(buf, DNS_DS_BUFFERSIZE);
}
- return (result);
+ return result;
}
static isc_result_t
continue;
case ISC_R_NOSPACE:
isc_mem_put(mctx, ds, sizeof(*ds));
- return (result);
+ return result;
default:
isc_mem_put(mctx, ds, sizeof(*ds));
check_result(result, "ds_from_rdata()");
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
static int
rdata_cmp(const void *rdata1, const void *rdata2) {
- return (dns_rdata_compare((const dns_rdata_t *)rdata1,
- (const dns_rdata_t *)rdata2));
+ return dns_rdata_compare((const dns_rdata_t *)rdata1,
+ (const dns_rdata_t *)rdata2);
}
/*
isc_mem_put(mctx, ds, n * sizeof(dns_rdata_ds_t));
isc_mem_put(mctx, arrdata, n * sizeof(dns_rdata_t));
- return (match);
+ return match;
}
static void
print_mem_stats = true;
cleanup();
- return (0);
+ return 0;
}
isc_buffer_init(&buf, setname, strlen(setname));
isc_buffer_add(&buf, strlen(setname));
result = dns_name_fromtext(name, &buf, dns_rootname, 0, NULL);
- return (result);
+ return result;
}
static void
if (db != NULL) {
dns_db_detach(&db);
}
- return (result);
+ return result;
}
static isc_result_t
if (dirname != NULL) {
/* allow room for a trailing slash */
if (strlen(dirname) >= isc_buffer_availablelength(&buf)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putstr(&buf, dirname);
if (dirname[strlen(dirname) - 1] != '/') {
}
if (isc_buffer_availablelength(&buf) < 7) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putstr(&buf, "keyset-");
result = dns_name_tofilenametext(name, false, &buf);
check_result(result, "dns_name_tofilenametext()");
if (isc_buffer_availablelength(&buf) == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint8(&buf, 0);
- return (loadset(filename, rdataset));
+ return loadset(filename, rdataset);
}
static void
fflush(stdout);
if (ferror(stdout)) {
fprintf(stderr, "write error\n");
- return (1);
+ return 1;
} else {
- return (0);
+ return 0;
}
}
isc_buffer_init(&buf, setname, strlen(setname));
isc_buffer_add(&buf, strlen(setname));
result = dns_name_fromtext(name, &buf, dns_rootname, 0, NULL);
- return (result);
+ return result;
}
static void
if (db != NULL) {
dns_db_detach(&db);
}
- return (result);
+ return result;
}
static void
fflush(stdout);
if (ferror(stdout)) {
fprintf(stderr, "write error\n");
- return (1);
+ return 1;
} else {
- return (0);
+ return 0;
}
}
free(freeit);
}
- return (0);
+ return 0;
}
free(freeit);
}
- return (0);
+ return 0;
}
}
isc_mem_destroy(&mctx);
- return (0);
+ return 0;
}
isc_mem_free(mctx, directory);
isc_mem_destroy(&mctx);
- return (0);
+ return 0;
}
result = dns_fixedname_initname(fzonecut);
dns_name_copy(name, result);
- return (result);
+ return result;
}
static void
static bool
issigningkey(dns_dnsseckey_t *key) {
- return (key->force_sign || key->hint_sign);
+ return key->force_sign || key->hint_sign;
}
static bool
ispublishedkey(dns_dnsseckey_t *key) {
- return ((key->force_publish || key->hint_publish) && !key->hint_remove);
+ return (key->force_publish || key->hint_publish) && !key->hint_remove;
}
static bool
iszonekey(dns_dnsseckey_t *key) {
- return (dns_name_equal(dst_key_name(key->key), gorigin) &&
- dst_key_iszonekey(key->key));
+ return dns_name_equal(dst_key_name(key->key), gorigin) &&
+ dst_key_iszonekey(key->key);
}
static bool
isksk(dns_dnsseckey_t *key) {
- return (key->ksk);
+ return key->ksk;
}
static bool
iszsk(dns_dnsseckey_t *key) {
- return (ignore_kskflag || !key->ksk);
+ return ignore_kskflag || !key->ksk;
}
/*%
rrsig->algorithm == dst_key_alg(key->key) &&
dns_name_equal(&rrsig->signer, dst_key_name(key->key)))
{
- return (key);
+ return key;
}
}
- return (NULL);
+ return NULL;
}
/*%
key = keythatsigned_unlocked(rrsig);
RWUNLOCK(&keylist_lock, isc_rwlocktype_read);
if (key != NULL) {
- return (key);
+ return key;
}
/*
key = keythatsigned_unlocked(rrsig);
if (key != NULL) {
isc_rwlock_unlock(&keylist_lock, isc_rwlocktype_write);
- return (key);
+ return key;
}
result = dst_key_fromfile(&rrsig->signer, rrsig->keyid,
mctx, &pubkey);
if (result != ISC_R_SUCCESS) {
isc_rwlock_unlock(&keylist_lock, isc_rwlocktype_write);
- return (NULL);
+ return NULL;
}
result = dst_key_fromfile(
}
isc_rwlock_unlock(&keylist_lock, isc_rwlocktype_write);
- return (key);
+ return key;
}
/*%
case ISC_R_SUCCESS:
case DNS_R_NXDOMAIN:
case DNS_R_NXRRSET:
- return (true);
+ return true;
case DNS_R_DELEGATION:
case DNS_R_CNAME:
case DNS_R_DNAME:
- return (false);
+ return false;
default:
break;
}
fatal("failure looking for '%s DNSKEY' in database: %s", namestr,
isc_result_totext(result));
UNREACHABLE();
- return (false); /* removes a warning */
+ return false; /* removes a warning */
}
static bool
result = dns_dnssec_verify(name, set, key, false, 0, mctx, rrsig, NULL);
if (result == ISC_R_SUCCESS || result == DNS_R_FROMWILDCARD) {
INCSTAT(nverified);
- return (true);
+ return true;
} else {
INCSTAT(nverifyfailed);
- return (false);
+ return false;
}
}
static int
hashlist_comp(const void *a, const void *b) {
- return (memcmp(a, b, hash_length + 1));
+ return memcmp(a, b, hash_length + 1);
}
static void
continue;
}
if (isc_safe_memequal(current, next, l->length - 1)) {
- return (true);
+ return true;
}
current = next;
}
- return (false);
+ return false;
}
static const unsigned char *
}
} while (entries-- > 1U);
INSIST(entries != 0U);
- return (next);
+ return next;
}
static bool
hashlist_exists(const hashlist_t *l,
const unsigned char hash[NSEC3_MAX_HASH_LENGTH]) {
if (bsearch(hash, l->hashbuf, l->entries, l->length, hashlist_comp)) {
- return (true);
+ return true;
} else {
- return (false);
+ return false;
}
}
vbprintf(2, "found DS records\n");
dsset->ttl = ttl;
dns_db_detach(&db);
- return (result);
+ return result;
}
}
dns_db_detach(&db);
/* No DS records found; try again, looking for DNSKEY records */
opendb("keyset-", name, gclass, &db);
if (db == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
result = dns_db_findnode(db, name, false, &node);
if (result != ISC_R_SUCCESS) {
dns_db_detach(&db);
- return (result);
+ return result;
}
dns_rdataset_init(&keyset);
if (result != ISC_R_SUCCESS) {
dns_db_detachnode(db, &node);
dns_db_detach(&db);
- return (result);
+ return result;
}
vbprintf(2, "found DNSKEY records\n");
dns_rdataset_disassociate(&keyset);
dns_db_detachnode(db, &node);
dns_db_detach(&db);
- return (result);
+ return result;
}
static bool
isc_result_t result;
if (dns_name_equal(name, gorigin)) {
- return (false);
+ return false;
}
dns_rdataset_init(&dsset);
dns_rdataset_disassociate(&dsset);
}
- return (result == ISC_R_SUCCESS);
+ return result == ISC_R_SUCCESS;
}
static bool
isc_result_t result;
if (dns_name_equal(name, origin)) {
- return (false);
+ return false;
}
dns_rdataset_init(&nsset);
dns_rdataset_disassociate(&nsset);
}
- return ((result == ISC_R_SUCCESS));
+ return result == ISC_R_SUCCESS;
}
/*%
dns_rdataset_disassociate(&dnameset);
}
- return ((result == ISC_R_SUCCESS));
+ return result == ISC_R_SUCCESS;
}
/*%
}
dns_rdatasetiter_destroy(&rdsiter);
- return (active);
+ return active;
}
/*%
result = dns_db_getoriginnode(gdb, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_init(&rdataset);
}
dns_rdata_reset(&rdata);
- return (result);
+ return result;
}
/*%
&sign_finish);
}
- return (vresult == ISC_R_SUCCESS ? 0 : 1);
+ return vresult == ISC_R_SUCCESS ? 0 : 1;
}
(void)isc_app_finish();
- return (result == ISC_R_SUCCESS ? 0 : 1);
+ return result == ISC_R_SUCCESS ? 0 : 1;
}
switch (suffix[0]) {
case 'Y':
case 'y':
- return (offset * (365 * 24 * 3600));
+ return offset * (365 * 24 * 3600);
case 'M':
case 'm':
switch (suffix[1]) {
case 'O':
case 'o':
- return (offset * (30 * 24 * 3600));
+ return offset * (30 * 24 * 3600);
case 'I':
case 'i':
- return (offset * 60);
+ return offset * 60;
case '\0':
fatal("'%s' ambiguous: use 'mi' for minutes "
"or 'mo' for months",
break;
case 'W':
case 'w':
- return (offset * (7 * 24 * 3600));
+ return offset * (7 * 24 * 3600);
case 'D':
case 'd':
- return (offset * (24 * 3600));
+ return offset * (24 * 3600);
case 'H':
case 'h':
- return (offset * 3600);
+ return offset * 3600;
case 'S':
case 's':
case '\0':
- return (offset);
+ return offset;
default:
fatal("time value %s is invalid", str);
}
UNREACHABLE();
- return (0); /* silence compiler warning */
+ return 0; /* silence compiler warning */
}
static bool
isnone(const char *str) {
- return ((strcasecmp(str, "none") == 0) ||
- (strcasecmp(str, "never") == 0) ||
- (strcasecmp(str, "unset") == 0));
+ return (strcasecmp(str, "none") == 0) ||
+ (strcasecmp(str, "never") == 0) ||
+ (strcasecmp(str, "unset") == 0);
}
dns_ttl_t
char *endp;
if (isnone(str)) {
- return ((dns_ttl_t)0);
+ return (dns_ttl_t)0;
}
ttl = strtol(str, &endp, 0);
fatal("TTL must be numeric");
}
ttl = time_units(ttl, endp, orig);
- return (ttl);
+ return ttl;
}
dst_key_state_t
strtokeystate(const char *str) {
if (isnone(str)) {
- return (DST_KEY_STATE_NA);
+ return DST_KEY_STATE_NA;
}
for (int i = 0; i < KEYSTATES_NVALUES; i++) {
if (keystates[i] != NULL && strcasecmp(str, keystates[i]) == 0)
{
- return ((dst_key_state_t)i);
+ return (dst_key_state_t)i;
}
}
fatal("unknown key state %s", str);
if (setp != NULL) {
*setp = false;
}
- return ((isc_stdtime_t)0);
+ return (isc_stdtime_t)0;
}
if (setp != NULL) {
}
if ((str[0] == '0' || str[0] == '-') && str[1] == '\0') {
- return ((isc_stdtime_t)0);
+ return (isc_stdtime_t)0;
}
/*
}
if (str[0] == '\0') {
- return ((isc_stdtime_t)base);
+ return (isc_stdtime_t)base;
} else if (str[0] == '+') {
offset = strtol(str + 1, &endp, 0);
offset = time_units((isc_stdtime_t)offset, endp, orig);
fatal("time value %s is invalid", orig);
}
- return ((isc_stdtime_t)val);
+ return (isc_stdtime_t)val;
}
dns_rdataclass_t
isc_result_t result;
if (str == NULL) {
- return (dns_rdataclass_in);
+ return dns_rdataclass_in;
}
DE_CONST(str, r.base);
r.length = strlen(str);
if (result != ISC_R_SUCCESS) {
fatal("unknown class %s", str);
}
- return (rdclass);
+ return rdclass;
}
unsigned int
if (result != ISC_R_SUCCESS) {
fatal("unknown DS algorithm %s", str);
}
- return (alg);
+ return alg;
}
static int
cmp_dtype(const void *ap, const void *bp) {
int a = *(const uint8_t *)ap;
int b = *(const uint8_t *)bp;
- return (a - b);
+ return a - b;
}
void
if (result == ISC_R_SUCCESS) {
isc_dir_close(&d);
}
- return (result);
+ return result;
}
/*
result = dst_key_buildfilename(dstkey, DST_TYPE_PRIVATE, dir,
&fileb);
if (result != ISC_R_SUCCESS) {
- return (true);
+ return true;
}
- return (isc_file_exists(filename));
+ return isc_file_exists(filename);
}
ISC_LIST_INIT(matchkeys);
isc_stdtime_get(&now);
result = dns_dnssec_findmatchingkeys(name, dir, now, mctx, &matchkeys);
if (result == ISC_R_NOTFOUND) {
- return (false);
+ return false;
}
while (!ISC_LIST_EMPTY(matchkeys) && !conflict) {
dns_dnsseckey_destroy(mctx, &key);
}
- return (conflict);
+ return conflict;
}
bool
isc_commandline_argument = argv[isc_commandline_index];
/* skip to next argument */
isc_commandline_index++;
- return (true);
+ return true;
}
- return (false);
+ return false;
}
}
}
memmove(&rdata[j], "\07in-addr\04arpa", 14);
- return (j + 14);
+ return j + 14;
}
static isc_result_t
zlen = zone->length;
nlen = name->length;
if ((zlen + nlen) > 74U || zlen < 10U || (nlen % 2) != 0U) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
while (j != 0U) {
INSIST((i / 2) < sizeof(v));
if (ndata[0] != 1) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
n = hex16[ndata[1] & 0xff];
if (n == 1) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
v[i / 2] = n | (v[i / 2] >> 4);
j -= 2;
* to exist in the zone.
*/
if (nlen > 16U && v[(nlen - 1) / 4 - 4] != 0) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
* If the total length is not 74 then this is a empty node
* so return success.
*/
if (nlen + zlen != 74U) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
len = dns64_rdata(v, 8, rdata);
break;
* to exist in the zone.
*/
if (nlen > 12U && v[(nlen - 1) / 4 - 3] != 0) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
* If the total length is not 74 then this is a empty node
* so return success.
*/
if (nlen + zlen != 74U) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
len = dns64_rdata(v, 6, rdata);
break;
* to exist in the zone.
*/
if (nlen > 8U && v[(nlen - 1) / 4 - 2] != 0) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
* If the total length is not 74 then this is a empty node
* so return success.
*/
if (nlen + zlen != 74U) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
len = dns64_rdata(v, 5, rdata);
break;
* to exist in the zone.
*/
if (nlen > 4U && v[(nlen - 1) / 4 - 1] != 0) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
* If the total length is not 74 then this is a empty node
* so return success.
*/
if (nlen + zlen != 74U) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
len = dns64_rdata(v, 4, rdata);
break;
* to exist in the zone.
*/
if (v[(nlen - 1) / 4] != 0) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
* If the total length is not 74 then this is a empty node
* so return success.
*/
if (nlen + zlen != 74U) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
len = dns64_rdata(v, 3, rdata);
break;
* so return success.
*/
if (nlen + zlen != 74U) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
len = dns64_rdata(v, 0, rdata);
break;
* This should never be reached unless someone adds a
* zone declaration with this internal type to named.conf.
*/
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
if ((v[0] == 170 || v[0] == 171) && v[1] == 0 && v[2] == 0 &&
v[3] == 192)
{
- return (dns_sdb_putrdata(lookup, dns_rdatatype_ptr, 3600,
- ipv4only, sizeof(ipv4only)));
+ return dns_sdb_putrdata(lookup, dns_rdatatype_ptr, 3600,
+ ipv4only, sizeof(ipv4only));
}
- return (dns_sdb_putrdata(lookup, dns_rdatatype_cname, 600, rdata,
- (unsigned int)len));
+ return dns_sdb_putrdata(lookup, dns_rdatatype_cname, 600, rdata,
+ (unsigned int)len);
}
static isc_result_t
UNUSED(clientinfo);
if (strcmp(name, "@") == 0) {
- return (b->do_lookup(lookup));
+ return b->do_lookup(lookup);
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
UNUSED(clientinfo);
if (name->labels == 0 && name->length == 0) {
- return (b->do_lookup(lookup));
+ return b->do_lookup(lookup);
} else {
- return (dns64_cname(zone, name, lookup));
+ return dns64_cname(zone, name, lookup);
}
}
}
buf[0] = len;
memmove(&buf[1], text, len);
- return (dns_sdb_putrdata(lookup, dns_rdatatype_txt, 0, buf, len + 1));
+ return dns_sdb_putrdata(lookup, dns_rdatatype_txt, 0, buf, len + 1);
}
static isc_result_t
do_version_lookup(dns_sdblookup_t *lookup) {
if (named_g_server->version_set) {
if (named_g_server->version == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (put_txt(lookup, named_g_server->version));
+ return put_txt(lookup, named_g_server->version);
}
} else {
- return (put_txt(lookup, PACKAGE_VERSION));
+ return put_txt(lookup, PACKAGE_VERSION);
}
}
do_hostname_lookup(dns_sdblookup_t *lookup) {
if (named_g_server->hostname_set) {
if (named_g_server->hostname == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (put_txt(lookup, named_g_server->hostname));
+ return put_txt(lookup, named_g_server->hostname);
}
} else {
char buf[256];
if (gethostname(buf, sizeof(buf)) != 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (put_txt(lookup, buf));
+ return put_txt(lookup, buf);
}
}
* If a version string is specified, disable the authors.bind zone.
*/
if (named_g_server->version_set) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
for (p = authors; *p != NULL; p++) {
result = put_txt(lookup, *p);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
if (named_g_server->sctx->usehostname) {
char buf[256];
if (gethostname(buf, sizeof(buf)) != 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (put_txt(lookup, buf));
+ return put_txt(lookup, buf);
} else if (named_g_server->sctx->server_id != NULL) {
- return (put_txt(lookup, named_g_server->sctx->server_id));
+ return put_txt(lookup, named_g_server->sctx->server_id);
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
static isc_result_t
do_dns64_lookup(dns_sdblookup_t *lookup) {
UNUSED(lookup);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
do_empty_lookup(dns_sdblookup_t *lookup) {
UNUSED(lookup);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
result = dns_sdb_putrdata(lookup, dns_rdatatype_a, 3600,
data[i], 4);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
result = dns_sdb_putrdata(lookup, dns_rdatatype_ptr, 3600, ipv4only,
sizeof(ipv4only));
- return (result);
+ return result;
}
static isc_result_t
result = dns_sdb_putsoa(lookup, server, contact, 0);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
result = dns_sdb_putrr(lookup, "ns", 0, server);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
strcmp(argv[0], "ipv4reverse") == 0)
{
if (argc != 3) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
} else if (argc != 1) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
if (strcmp(argv[0], "authors") == 0) {
char *contact;
if (argc != 3) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
/*
*dbdata = empty;
}
} else {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
DNS_SDBFLAG_DNS64,
named_g_mctx,
&dns64_impl) == ISC_R_SUCCESS);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_buffer_init(&b, defaultconf, sizeof(defaultconf) - 1);
isc_buffer_add(&b, sizeof(defaultconf) - 1);
- return (cfg_parse_buffer(parser, &b, __FILE__, 0, &cfg_type_namedconf,
- CFG_PCTX_NODEPRECATED, conf));
+ return cfg_parse_buffer(parser, &b, __FILE__, 0, &cfg_type_namedconf,
+ CFG_PCTX_NODEPRECATED, conf);
}
const char *
named_config_getdefault(void) {
- return (defaultconf);
+ return defaultconf;
}
isc_result_t
for (i = 0; maps[i] != NULL; i++) {
if (cfg_map_get(maps[i], name, obj) == ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
isc_result_t
*/
if (checknames != NULL && !cfg_obj_islist(checknames)) {
*obj = checknames;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
for (element = cfg_list_first(checknames);
element != NULL; element = cfg_list_next(element))
{
*obj = cfg_tuple_get(value,
"mode");
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
}
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
int
i++;
}
- return (i);
+ return i;
}
isc_result_t
if (!cfg_obj_isstring(classobj)) {
*classp = defclass;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
DE_CONST(cfg_obj_asstring(classobj), r.base);
r.length = strlen(r.base);
cfg_obj_log(classobj, named_g_lctx, ISC_LOG_ERROR,
"unknown class '%s'", r.base);
}
- return (result);
+ return result;
}
isc_result_t
if (!cfg_obj_isstring(typeobj)) {
*typep = deftype;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
DE_CONST(cfg_obj_asstring(typeobj), r.base);
r.length = strlen(r.base);
cfg_obj_log(typeobj, named_g_lctx, ISC_LOG_ERROR,
"unknown type '%s'", r.base);
}
- return (result);
+ return result;
}
dns_zonetype_t
} else {
UNREACHABLE();
}
- return (ztype);
+ return ztype;
}
isc_result_t
if (val > UINT16_MAX) {
cfg_obj_log(portobj, named_g_lctx, ISC_LOG_ERROR,
"port '%u' out of range", val);
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
port = (in_port_t)val;
} else if (defport != 0) {
} else {
result = named_config_getport(config, "port", &port);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
*addrsp = addrs;
*countp = count;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
result = cfg_map_get(cctx, list, &obj);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
elt = cfg_list_first(obj);
while (elt != NULL) {
name) == 0)
{
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
elt = cfg_list_next(elt);
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
isc_result_t
isc_result_t result;
if (strcmp(list, "parental-agents") == 0) {
- return (getremotesdef(cctx, list, name, ret));
+ return getremotesdef(cctx, list, name, ret);
} else if (strcmp(list, "primaries") == 0) {
result = getremotesdef(cctx, list, name, ret);
if (result != ISC_R_SUCCESS) {
result = getremotesdef(cctx, "masters", name, ret);
}
- return (result);
+ return result;
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
static isc_result_t
if (!cfg_obj_isstring(obj)) {
*namep = NULL;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
*namep = isc_mem_get(mctx, sizeof(**namep));
if (result != ISC_R_SUCCESS) {
isc_mem_put(mctx, *namep, sizeof(**namep));
*namep = NULL;
- return (result);
+ return result;
}
dns_name_dup(dns_fixedname_name(&fname), mctx, *namep);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#define grow_array(mctx, array, newlen, oldlen) \
ipkl->count = addrcount;
ipkl->allocated = addrcount;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (addrs != NULL) {
if (stack != NULL) {
isc_mem_put(mctx, stack, stackcount * sizeof(stack[0]));
}
- return (result);
+ return result;
}
isc_result_t
cfg_obj_log(portobj, named_g_lctx, ISC_LOG_ERROR,
"port '%u' out of range",
cfg_obj_asuint32(portobj));
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
*portp = (in_port_t)cfg_obj_asuint32(portobj);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
struct keyalgorithms {
isc_result_t
named_config_getkeyalgorithm(const char *str, const dns_name_t **name,
uint16_t *digestbits) {
- return (named_config_getkeyalgorithm2(str, name, NULL, digestbits));
+ return named_config_getkeyalgorithm2(str, name, NULL, digestbits);
}
isc_result_t
}
}
if (algorithms[i].str == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (str[len] == '-') {
result = isc_parse_uint16(&bits, str + len + 1, 10);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (bits > algorithms[i].size) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
} else if (algorithms[i].size == 0) {
bits = 128;
if (digestbits != NULL) {
*digestbits = bits;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = isc_lex_gettoken(lex, ISC_LEXOPT_EOF, &token);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_lex_ungettoken(lex, &token);
if (token.type != isc_tokentype_string) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
*cmdp = token.value.as_textregion.base;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
command_compare(const char *str, const char *command) {
- return (strcasecmp(str, command) == 0);
+ return strcasecmp(str, command) == 0;
}
/*%
/*
* No data section.
*/
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
result = isccc_cc_lookupstring(data, "type", &cmdline);
/*
* We have no idea what this is.
*/
- return (result);
+ return result;
}
result = isc_lex_create(named_g_mctx, strlen(cmdline), &lex);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_init(&src, cmdline, strlen(cmdline));
isc_lex_destroy(&lex);
}
- return (result);
+ return result;
}
/* ACL doesn't apply to unix domain sockets */
if (listener->type != isc_socktype_tcp) {
- return (true);
+ return true;
}
isc_netaddr_fromsockaddr(&netaddr, sockaddr);
result = dns_acl_match(&netaddr, NULL, listener->acl, env, &match,
NULL);
- return (result == ISC_R_SUCCESS && match > 0);
+ return result == ISC_R_SUCCESS && match > 0;
}
static void
if (result == ISC_R_SHUTTINGDOWN) {
shutdown_listener(listener);
}
- return (result);
+ return result;
}
peeraddr = isc_nmhandle_peeraddr(handle);
NAMED_LOGMODULE_CONTROL, ISC_LOG_WARNING,
"rejected command channel message from %s",
socktext);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
newconnection(listener, handle);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
}
}
if (element == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
obj = cfg_listelt_value(element);
*objp = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
NAMED_LOGMODULE_CONTROL, ISC_LOG_INFO,
"configuring command channel from '%s'", named_g_keyfile);
if (!isc_file_exists(named_g_keyfile)) {
- return (ISC_R_FILENOTFOUND);
+ return ISC_R_FILENOTFOUND;
}
CHECK(cfg_parser_create(mctx, named_g_lctx, &pctx));
if (pctx != NULL) {
cfg_parser_destroy(&pctx);
}
- return (result);
+ return result;
}
/*
cfg_obj_log(controls, named_g_lctx, ISC_LOG_ERROR,
"UNIX domain sockets not yet supported");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
#if 0
/* XXX: no unix domain socket support in netmgr */
* down will be taken care of by listen_done().
*/
ISC_LIST_APPENDLIST(cp->listeners, new_listeners, link);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (result != ISC_R_SUCCESS) {
isc_mutex_destroy(&controls->symtab_lock);
isc_mem_put(server->mctx, controls, sizeof(*controls));
- return (result);
+ return result;
}
*ctrlsp = controls;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
UNUSED(driverarg);
if (cd->dlz_allnodes == NULL) {
- return (ISC_R_NOPERM);
+ return ISC_R_NOPERM;
}
MAYBE_LOCK(cd);
result = cd->dlz_allnodes(zone, cd->dbdata, allnodes);
MAYBE_UNLOCK(cd);
- return (result);
+ return result;
}
static isc_result_t
UNUSED(driverarg);
if (cd->dlz_allowzonexfr == NULL) {
- return (ISC_R_NOPERM);
+ return ISC_R_NOPERM;
}
MAYBE_LOCK(cd);
result = cd->dlz_allowzonexfr(cd->dbdata, name, client);
MAYBE_UNLOCK(cd);
- return (result);
+ return result;
}
static isc_result_t
UNUSED(driverarg);
if (cd->dlz_authority == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
MAYBE_LOCK(cd);
result = cd->dlz_authority(zone, cd->dbdata, lookup);
MAYBE_UNLOCK(cd);
- return (result);
+ return result;
}
static isc_result_t
MAYBE_LOCK(cd);
result = cd->dlz_findzonedb(cd->dbdata, name, methods, clientinfo);
MAYBE_UNLOCK(cd);
- return (result);
+ return result;
}
static isc_result_t
result = cd->dlz_lookup(zone, name, cd->dbdata, lookup, methods,
clientinfo);
MAYBE_UNLOCK(cd);
- return (result);
+ return result;
}
/*
}
}
- return (ptr);
+ return ptr;
}
static void
"dlz_dlopen driver for '%s' needs a path to "
"the shared library",
dlzname);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
isc_mem_create(&mctx);
*dbdata = cd;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failed:
dlopen_log(ISC_LOG_ERROR, "dlz_dlopen of '%s' failed", dlzname);
dlopen_dlz_destroy(NULL, cd);
- return (result);
+ return result;
}
/*
UNUSED(driverarg);
if (cd->dlz_newversion == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
MAYBE_LOCK(cd);
result = cd->dlz_newversion(zone, cd->dbdata, versionp);
MAYBE_UNLOCK(cd);
- return (result);
+ return result;
}
/*
UNUSED(driverarg);
if (cd->dlz_configure == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
MAYBE_LOCK(cd);
cd->in_configure = false;
MAYBE_UNLOCK(cd);
- return (result);
+ return result;
}
/*
UNUSED(driverarg);
if (cd->dlz_ssumatch == NULL) {
- return (false);
+ return false;
}
MAYBE_LOCK(cd);
keydata, cd->dbdata);
MAYBE_UNLOCK(cd);
- return (ret);
+ return ret;
}
/*
UNUSED(driverarg);
if (cd->dlz_addrdataset == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
MAYBE_LOCK(cd);
result = cd->dlz_addrdataset(name, rdatastr, cd->dbdata, version);
MAYBE_UNLOCK(cd);
- return (result);
+ return result;
}
/*
UNUSED(driverarg);
if (cd->dlz_subrdataset == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
MAYBE_LOCK(cd);
result = cd->dlz_subrdataset(name, rdatastr, cd->dbdata, version);
MAYBE_UNLOCK(cd);
- return (result);
+ return result;
}
/*
UNUSED(driverarg);
if (cd->dlz_delrdataset == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
MAYBE_LOCK(cd);
result = cd->dlz_delrdataset(name, type, cd->dbdata, version);
MAYBE_UNLOCK(cd);
- return (result);
+ return result;
}
static dns_sdlzmethods_t dlz_dlopen_methods = {
result = ISC_R_UNEXPECTED;
}
- return (result);
+ return result;
}
/*
named_server_flushonshutdown(named_g_server,
false);
isc_app_shutdown();
- return (NULL);
+ return NULL;
}
raise(SIGSTOP);
goto next;
named_server_flushonshutdown(named_g_server, false);
isc_app_shutdown();
- return (NULL);
+ return NULL;
}
/*
named_server_flushonshutdown(named_g_server,
false);
isc_app_shutdown();
- return (NULL);
+ return NULL;
}
raise(SIGSTOP);
continue;
__AFL_LOOP(0);
#endif /* ifdef __AFL_LOOP */
- return (NULL);
+ return NULL;
}
/*
named_server_flushonshutdown(named_g_server, false);
isc_app_shutdown();
- return (NULL);
+ return NULL;
}
#endif /* ENABLE_AFL */
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"GeoIP2 database '%s/%s': path too long", dir,
dbfile);
- return (NULL);
+ return NULL;
}
ret = MMDB_open(pathbuf, MMDB_MODE_MMAP, mmdb);
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"opened GeoIP2 database '%s'", pathbuf);
- return (mmdb);
+ return mmdb;
}
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
"unable to open GeoIP2 database '%s' (status %d)",
pathbuf, ret);
- return (NULL);
+ return NULL;
}
#endif /* HAVE_GEOIP2 */
named_log_setdefaultsslkeylogfile(lcfg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
isc_log_destroy(&named_g_lctx);
isc_log_setcontext(NULL);
dns_log_setcontext(NULL);
- return (result);
+ return result;
}
void
}
cleanup:
- return (result);
+ return result;
}
isc_result_t
result = isc_log_usechannel(lcfg, "null", NAMED_LOGCATEGORY_UNMATCHED,
NULL);
- return (result);
+ return result;
}
void
/*
* Allow further processing by returning success.
*/
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (logconfig == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
module = NULL;
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"logging channel '%s': %s", channelname,
isc_result_totext(result));
- return (result);
+ return result;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
"channel '%s': exactly one of file, syslog, "
"null, and stderr must be present",
channelname);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
type = ISC_LOG_TONULL;
}
done:
- return (result);
+ return result;
}
isc_result_t
CHECK(named_log_setunmatchedcategory(logconfig));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
- return (result);
+ return result;
}
if (tmp < 0 || tmp != ltmp) {
named_main_earlyfatal("%s '%s' out of range", desc, arg);
}
- return (tmp);
+ return tmp;
}
static struct flag_def {
0 /* quantum */, &named_g_netmgr,
&named_g_taskmgr, &named_g_timermgr);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_nm_maxudp(named_g_netmgr, maxudp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNEXPECTED_ERROR("scf_handle_create() failed: %s",
scf_strerror(scf_error()));
}
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (scf_handle_bind(h) == -1) {
scf_strerror(scf_error()));
}
scf_handle_destroy(h);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if ((namelen = scf_myname(h, NULL, 0)) == -1) {
scf_strerror(scf_error()));
}
scf_handle_destroy(h);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if ((instance = isc_mem_allocate(mctx, namelen + 1)) == NULL) {
"allocation failed: %s",
isc_result_totext(ISC_R_NOMEMORY));
scf_handle_destroy(h);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (scf_myname(h, instance, namelen + 1) == -1) {
}
scf_handle_destroy(h);
isc_mem_free(mctx, instance);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
scf_handle_destroy(h);
*ins_name = instance;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#endif /* HAVE_LIBSCF */
ProfilerStop();
#endif /* ifdef HAVE_GPERFTOOLS_PROFILER */
- return (0);
+ return 0;
}
static bool
all_digits(const char *s) {
if (*s == '\0') {
- return (false);
+ return false;
}
while (*s != '\0') {
if (!isdigit((unsigned char)(*s))) {
- return (false);
+ return false;
}
s++;
}
- return (true);
+ return true;
}
void
uid_t
ns_os_uid(void) {
if (runas_pw == NULL) {
- return (0);
+ return 0;
}
- return (runas_pw->pw_uid);
+ return runas_pw->pw_uid;
}
void
if (stat(filename, &sb) == -1) {
if (errno != ENOENT) {
- return (-1);
+ return -1;
}
} else if ((sb.st_mode & S_IFREG) == 0) {
errno = EOPNOTSUPP;
- return (-1);
+ return -1;
}
if (append) {
fd = open(filename, O_WRONLY | O_CREAT | O_APPEND, mode);
} else {
if (unlink(filename) < 0 && errno != ENOENT) {
- return (-1);
+ return -1;
}
fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, mode);
}
- return (fd);
+ return fd;
}
static void
!strcmp(slash + 1, ".."))
{
*slash = '/';
- return (0);
+ return 0;
}
mode = S_IRUSR | S_IWUSR | S_IXUSR; /* u=rwx */
mode |= S_IRGRP | S_IXGRP; /* g=rx */
}
*slash = '/';
}
- return (0);
+ return 0;
error:
*slash = '/';
- return (-1);
+ return -1;
}
#if !HAVE_SYS_CAPABILITY_H
strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlywarning("couldn't strdup() '%s': %s", filename,
strbuf);
- return (NULL);
+ return NULL;
}
if (mkdirpath(f, named_main_earlywarning) == -1) {
free(f);
- return (NULL);
+ return NULL;
}
free(f);
strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlywarning("could not open file '%s': %s",
filename, strbuf);
- return (NULL);
+ return NULL;
}
fp = fdopen(fd, "w");
filename, strbuf);
}
- return (fp);
+ return fp;
}
void
struct flock lock;
if (singletonfd != -1) {
- return (true);
+ return true;
}
if (strcasecmp(filename, "none") == 0) {
- return (true);
+ return true;
}
/*
named_main_earlywarning("couldn't create '%s'",
filename);
cleanup_lockfile(false);
- return (false);
+ return false;
}
}
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if (singletonfd == -1) {
cleanup_lockfile(false);
- return (false);
+ return false;
}
memset(&lock, 0, sizeof(lock));
/* Non-blocking (does not wait for lock) */
if (fcntl(singletonfd, F_SETLK, &lock) == -1) {
cleanup_lockfile(false);
- return (false);
+ return false;
}
- return (true);
+ return true;
}
void
if (unamep == NULL) {
getuname();
}
- return (unamep);
+ return unamep;
}
/*
* No value available. *aclp == NULL.
*/
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (acltuplename != NULL) {
result = cfg_acl_fromconfig(aclobj, config, named_g_lctx, actx, mctx, 0,
aclp);
- return (result);
+ return result;
}
/*%
(void)named_config_get(maps, "sortlist", &aclobj);
if (aclobj == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
result = cfg_acl_fromconfig(aclobj, config, named_g_lctx, actx, mctx, 3,
aclp);
- return (result);
+ return result;
}
static isc_result_t
/*
* No value available. *rbtp == NULL.
*/
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (conftuplename != NULL) {
obj = cfg_tuple_get(obj, conftuplename);
if (cfg_obj_isvoid(obj)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
result = dns_rbt_create(mctx, NULL, NULL, rbtp);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
name = dns_fixedname_initname(&fixed);
}
}
- return (result);
+ return result;
cleanup:
dns_rbt_destroy(rbtp);
- return (result);
+ return result;
}
static isc_result_t
UNREACHABLE();
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
- return (result);
+ return result;
}
static void
keyname = dns_fixedname_initname(&fkeyname);
result = dns_name_fromtext(keyname, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
break;
case DST_R_UNSUPPORTEDALG:
"ignoring %s for '%s': %s",
initializing ? "initial-key" : "static-key",
namestr, isc_result_totext(result));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
case DST_R_NOCRYPTO:
/*
* Crypto support is not available.
"ignoring %s for '%s': no crypto support",
initializing ? "initial-key" : "static-key",
namestr);
- return (result);
+ return result;
default:
/*
* Something unexpected happened; we have no choice but to
"configuring %s for '%s': %s",
initializing ? "initial-key" : "static-key",
namestr, isc_result_totext(result));
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
&ds, sfd_add, view);
done:
- return (result);
+ return result;
}
/*
if (result == DST_R_NOCRYPTO) {
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
/*%
result = dns_view_getsecroots(view, &secroots);
if (result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
result = dns_keytable_find(secroots, name, &keynode);
dns_keytable_detach(&secroots);
}
- return (result == ISC_R_SUCCESS);
+ return result == ISC_R_SUCCESS;
}
/*%
if (strcmp(view->name, "_bind") == 0 &&
view->rdclass == dns_rdataclass_chaos)
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (vconfig != NULL) {
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"couldn't create keytable");
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
result = dns_view_initntatable(view, named_g_taskmgr, named_g_timermgr);
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"couldn't create NTA table");
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
if (auto_root && view->rdclass == dns_rdataclass_in) {
CHECK(add_keydata_zone(view, directory, named_g_mctx));
cleanup:
- return (result);
+ return result;
}
static isc_result_t
result = ISC_R_SUCCESS;
cleanup:
- return (result);
+ return result;
}
/*%
UNREACHABLE();
}
if (result != ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
break;
}
if (isc_sockaddr_equal(&sa, &any)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_sockaddr_format(&sa, buf, sizeof(buf));
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"could not get query source dispatcher (%s)",
buf);
- return (result);
+ return result;
}
*dispatchp = disp;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
result = named_config_getclass(cfg_tuple_get(ent, "class"),
dns_rdataclass_any, &rdclass);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = named_config_gettype(cfg_tuple_get(ent, "type"),
dns_rdatatype_any, &rdtype);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
obj = cfg_tuple_get(ent, "name");
result = dns_name_fromtext(dns_fixedname_name(&fixed), &b, dns_rootname,
0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
obj = cfg_tuple_get(ent, "ordering");
result = dns_order_add(order, dns_rootname, rdtype, rdclass,
mode);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
- return (dns_order_add(order, dns_fixedname_name(&fixed), rdtype,
- rdclass, mode));
+ return dns_order_add(order, dns_fixedname_name(&fixed), rdtype, rdclass,
+ mode);
}
static isc_result_t
peer = NULL;
result = dns_peer_newprefix(mctx, &na, prefixlen, &peer);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
obj = NULL;
}
*peerp = peer;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_peer_detach(&peer);
- return (result);
+ return result;
}
static isc_result_t
"dynamic database '%s' configuration failed: %s",
name, isc_result_totext(result));
}
- return (result);
+ return result;
}
static isc_result_t
CHECK(dns_resolver_disable_algorithm(resolver, name, alg));
}
cleanup:
- return (result);
+ return result;
}
static isc_result_t
CHECK(dns_resolver_disable_ds_digest(resolver, name, digest));
}
cleanup:
- return (result);
+ return result;
}
static bool
result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
if (dns_name_equal(name, zonename)) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static isc_result_t
cleanup:
isc_mem_free(mctx, argv);
- return (result);
+ return result;
}
static isc_result_t
result = isc_stats_create(mctx, &zoneqrystats,
ns_statscounter_max);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
dns_zone_setrequeststats(zone, zoneqrystats);
isc_stats_detach(&zoneqrystats);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static named_cache_t *
if (nsc->rdclass == rdclass &&
strcmp(dns_cache_getname(nsc->cache), cachename) == 0)
{
- return (nsc);
+ return nsc;
}
}
- return (NULL);
+ return NULL;
}
static bool
originview->maxcachettl != view->maxcachettl ||
originview->maxncachettl != view->maxncachettl)
{
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static bool
* shared with other views.
*/
if (!cache_reusable(originview, view, new_zero_no_soattl)) {
- return (false);
+ return false;
}
/*
new_stale_refresh_time ||
dns_cache_getcachesize(originview->cache) != new_max_cache_size)
{
- return (false);
+ return false;
}
- return (true);
+ return true;
}
/*
result = dns_zonemgr_managezone(named_g_server->zonemgr, zone);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_zone_setstats(zone, named_g_server->zonestats);
- return (named_zone_configure_writeable_dlz(dlzdb, zone, zclass,
- origin));
+ return named_zone_configure_writeable_dlz(dlzdb, zone, zclass, origin);
}
static isc_result_t
if (zone != NULL) {
dns_zone_detach(&zone);
}
- return (result);
+ return result;
}
#ifdef USE_DNSRPS
va_end(args);
if (cur_len + new_len <= ctx->cstr_size) {
- return (true);
+ return true;
}
new_cstr_size = ((cur_len + new_len) / 256 + 1) * 256;
va_start(args, p);
vsnprintf(ctx->cstr + cur_len, ctx->cstr_size - cur_len, p, args);
va_end(args);
- return (true);
+ return true;
}
/*
conf_dnsrps_ctx_t *ctx) {
if (ctx != NULL && ctx->result != ISC_R_SUCCESS) {
*sub_obj = NULL;
- return (false);
+ return false;
}
*sub_obj = cfg_tuple_get(obj, name);
*sub_obj = NULL;
}
}
- return (true);
+ return true;
}
/*
*rps_cstr = NULL;
*rps_cstr_size = 0;
}
- return (ctx.result);
+ return ctx.result;
}
#endif /* ifdef USE_DNSRPS */
cfg_obj_log(obj, named_g_lctx, DNS_RPZ_ERROR_LEVEL,
"invalid %s '%s'", msg, str);
}
- return (result);
+ return result;
}
static isc_result_t
cfg_obj_log(obj, named_g_lctx, DNS_RPZ_ERROR_LEVEL,
"invalid zone '%s'", str);
}
- return (result);
+ return result;
}
static isc_result_t
cfg_obj_log(rpz_obj, named_g_lctx, DNS_RPZ_ERROR_LEVEL,
"limit of %d response policy zones exceeded",
DNS_RPZ_MAX_ZONES);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
result = dns_rpz_new_zone(view->rpzs, &zone);
cfg_obj_log(rpz_obj, named_g_lctx, DNS_RPZ_ERROR_LEVEL,
"Error creating new RPZ zone : %s",
isc_result_totext(result));
- return (result);
+ return result;
}
obj = cfg_tuple_get(rpz_obj, "recursive-only");
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);
+ return result;
}
if (dns_name_equal(&zone->origin, dns_rootname)) {
cfg_obj_log(rpz_obj, named_g_lctx, DNS_RPZ_ERROR_LEVEL,
"invalid zone name '%s'", str);
- return (DNS_R_EMPTYLABEL);
+ return DNS_R_EMPTYLABEL;
}
if (!view->rpzs->p.dnsrps_enabled) {
for (rpz_num = 0; rpz_num < view->rpzs->p.num_zones - 1;
DNS_RPZ_ERROR_LEVEL,
"duplicate '%s'", str);
result = DNS_R_DUPLICATE;
- return (result);
+ return result;
}
}
}
result = configure_rpz_name2(view, rpz_obj, &zone->client_ip,
DNS_RPZ_CLIENT_IP_ZONE, &zone->origin);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = configure_rpz_name2(view, rpz_obj, &zone->ip, DNS_RPZ_IP_ZONE,
&zone->origin);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = configure_rpz_name2(view, rpz_obj, &zone->nsdname,
DNS_RPZ_NSDNAME_ZONE, &zone->origin);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = configure_rpz_name2(view, rpz_obj, &zone->nsip,
DNS_RPZ_NSIP_ZONE, &zone->origin);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = configure_rpz_name(view, rpz_obj, &zone->passthru,
DNS_RPZ_PASSTHRU_NAME, "name");
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = configure_rpz_name(view, rpz_obj, &zone->drop,
DNS_RPZ_DROP_NAME, "name");
if (result != ISC_R_SUCCESS) {
- return (result);
+ 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);
+ return result;
}
obj = cfg_tuple_get(rpz_obj, "policy");
result = configure_rpz_name(view, rpz_obj, &zone->cname,
str, "cname");
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
}
*old_rpz_okp = false;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
zone_element = cfg_list_first(cfg_tuple_get(rpz_obj, "zone list"));
if (zone_element == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
nsip_enabled = true;
cfg_obj_log(rpz_obj, named_g_lctx, DNS_RPZ_ERROR_LEVEL,
"\"dnsrps-enable yes\" but"
" without `./configure --enable-dnsrps`");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
#else /* ifndef USE_DNSRPS */
if (dnsrps_enabled) {
cfg_obj_log(rpz_obj, named_g_lctx, DNS_RPZ_ERROR_LEVEL,
"\"dnsrps-enable yes\" but %s",
librpz_lib_open_emsg.c);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
&nsip_on, &nsdname_on, &rps_cstr,
&rps_cstr_size, rpz_obj, zone_element);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
#endif /* ifndef USE_DNSRPS */
named_g_timermgr, rps_cstr, rps_cstr_size,
&view->rpzs);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
zones = view->rpzs;
if (pview_must_detach) {
dns_view_detach(&pview);
}
- return (result);
+ return result;
}
}
dns_view_detach(&pview);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
result = isc_taskmgr_excltask(taskmgr, &task);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
switch (type) {
isc_task_send(task, ISC_EVENT_PTR(&event));
isc_task_detach(&task);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
catz_addzone(dns_catz_entry_t *entry, dns_catz_zone_t *origin, dns_view_t *view,
isc_taskmgr_t *taskmgr, void *udata) {
- return (catz_create_chg_task(entry, origin, view, taskmgr, udata,
- DNS_EVENT_CATZADDZONE));
+ return catz_create_chg_task(entry, origin, view, taskmgr, udata,
+ DNS_EVENT_CATZADDZONE);
}
static isc_result_t
catz_delzone(dns_catz_entry_t *entry, dns_catz_zone_t *origin, dns_view_t *view,
isc_taskmgr_t *taskmgr, void *udata) {
- return (catz_create_chg_task(entry, origin, view, taskmgr, udata,
- DNS_EVENT_CATZDELZONE));
+ return catz_create_chg_task(entry, origin, view, taskmgr, udata,
+ DNS_EVENT_CATZDELZONE);
}
static isc_result_t
catz_modzone(dns_catz_entry_t *entry, dns_catz_zone_t *origin, dns_view_t *view,
isc_taskmgr_t *taskmgr, void *udata) {
- return (catz_create_chg_task(entry, origin, view, taskmgr, udata,
- DNS_EVENT_CATZMODZONE));
+ return catz_create_chg_task(entry, origin, view, taskmgr, udata,
+ DNS_EVENT_CATZMODZONE);
}
static void
cleanup:
dns_name_free(&origin, view->mctx);
- return (result);
+ return result;
}
static catz_cb_data_t ns_catz_cbdata;
zone_element = cfg_list_first(cfg_tuple_get(catz_obj, "zone list"));
if (zone_element == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
CHECK(dns_catz_new_zones(view->mctx, named_g_taskmgr, named_g_timermgr,
dns_view_detach(&pview);
}
- return (result);
+ return result;
}
#define CHECK_RRL(cond, pat, val1, val2) \
}
result = dns_rrl_init(&rrl, view, min_entries);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
i = ISC_MAX(20000, min_entries);
rrl->log_only = false;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_rrl_view_destroy(view);
- return (result);
+ return result;
}
static isc_result_t
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
static isc_result_t
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
static isc_result_t
INSIST(version == NULL);
- return (result);
+ return result;
}
static isc_result_t
if (zone != NULL) {
dns_zone_detach(&zone);
}
- return (result);
+ return result;
}
#ifdef HAVE_DNSTAP
result = named_config_get(maps, "dnstap", &dlist);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
for (element = cfg_list_first(dlist); element != NULL;
}
if (named_g_server->dtenv == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
obj = NULL;
fstrm_iothr_options_destroy(&fopt);
}
- return (result);
+ return result;
}
#endif /* HAVE_DNSTAP */
result = dns_acl_create(named_g_mctx, 1, &acl);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_iptable_addprefix(acl->iptable, &addr, 96, true);
dns_acl_attach(acl, &named_g_mapped);
}
dns_acl_detach(&acl);
- return (result);
+ return result;
}
/*%
"%s: plugin configuration failed: "
"unable to get full plugin path: %s",
plugin_path, isc_result_totext(result));
- return (result);
+ return result;
}
result = ns_plugin_register(full_path, parameters, config,
isc_result_totext(result));
}
- return (result);
+ return result;
}
/*
(void)named_config_get(maps, "recursion", &obj);
INSIST(obj != NULL);
if (cfg_obj_asboolean(obj)) {
- return (false);
+ return false;
}
/*
obj = NULL;
(void)named_config_get(optionmaps, "max-cache-size", &obj);
if (obj != NULL) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static const char *const response_synonyms[] = { "response", NULL };
algorithm_name(unsigned int alg) {
switch (alg) {
case DST_ALG_HMACMD5:
- return (dns_tsig_hmacmd5_name);
+ return dns_tsig_hmacmd5_name;
case DST_ALG_HMACSHA1:
- return (dns_tsig_hmacsha1_name);
+ return dns_tsig_hmacsha1_name;
case DST_ALG_HMACSHA224:
- return (dns_tsig_hmacsha224_name);
+ return dns_tsig_hmacsha224_name;
case DST_ALG_HMACSHA256:
- return (dns_tsig_hmacsha256_name);
+ return dns_tsig_hmacsha256_name;
case DST_ALG_HMACSHA384:
- return (dns_tsig_hmacsha384_name);
+ return dns_tsig_hmacsha384_name;
case DST_ALG_HMACSHA512:
- return (dns_tsig_hmacsha512_name);
+ return dns_tsig_hmacsha512_name;
case DST_ALG_GSSAPI:
- return (dns_tsig_gssapi_name);
+ return dns_tsig_gssapi_name;
default:
UNREACHABLE();
}
dns_dyndb_destroyctx(&dctx);
}
- return (result);
+ return result;
}
static isc_result_t
dns_db_detach(&db);
}
- return (result);
+ return result;
}
static isc_result_t
cfg_obj_log(portobj, named_g_lctx,
ISC_LOG_ERROR,
"port '%u' out of range", val);
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
port = (in_port_t)val;
}
ISC_LOG_ERROR,
"port '%u' out of range",
val);
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
myport = (in_port_t)val;
}
}
cleanup:
- return (result);
+ return result;
}
static isc_result_t
cfg_obj_log(portobj, named_g_lctx,
ISC_LOG_ERROR,
"port '%u' out of range", val);
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
port = (in_port_t)val;
}
isc_mem_put(view->mctx, fwd, sizeof(dns_forwarder_t));
}
- return (result);
+ return result;
}
static isc_result_t
*classp = viewclass;
cleanup:
- return (result);
+ return result;
}
/*
result = get_viewinfo(vconfig, &viewname, &viewclass);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_viewlist_find(viewlist, viewname, viewclass, &view);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
*viewp = view;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
result = get_viewinfo(vconfig, &viewname, &viewclass);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_viewlist_find(viewlist, viewname, viewclass, &view);
if (result == ISC_R_SUCCESS) {
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
if (result != ISC_R_NOTFOUND) {
- return (result);
+ return result;
}
INSIST(view == NULL);
result = dns_view_create(named_g_mctx, viewclass, viewname, &view);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_nonce_buf(view->secret, sizeof(view->secret));
ISC_LIST_APPEND(*viewlist, view, link);
dns_view_attach(view, viewp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
/*
* Determine if we need to set up inline signing.
*/
- zone_maybe_inline = ((strcasecmp(ztypestr, "primary") == 0 ||
- strcasecmp(ztypestr, "master") == 0 ||
- strcasecmp(ztypestr, "secondary") == 0 ||
- strcasecmp(ztypestr, "slave") == 0));
+ zone_maybe_inline = (strcasecmp(ztypestr, "primary") == 0 ||
+ strcasecmp(ztypestr, "master") == 0 ||
+ strcasecmp(ztypestr, "secondary") == 0 ||
+ strcasecmp(ztypestr, "slave") == 0);
if (zone_maybe_inline) {
inline_signing = named_zone_inlinesigning(zconfig);
dns_view_detach(&pview);
}
- return (result);
+ return result;
}
/*
result = dns_viewlist_find(&named_g_server->viewlist, view->name,
view->rdclass, &pview);
if (result != ISC_R_NOTFOUND && result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (pview != NULL) {
dns_zone_setviewcommit(pview->managed_keys);
dns_view_detach(&pview);
dns_zone_synckeyzone(view->managed_keys);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_view_detach(&pview);
dns_acl_detach(&none);
}
- return (result);
+ return result;
}
/*
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"directory '%s' is not writable", directory);
- return (ISC_R_NOPERM);
+ return ISC_R_NOPERM;
}
result = isc_dir_chdir(directory);
cfg_obj_log(obj, named_g_lctx, ISC_LOG_ERROR,
"change directory to '%s' failed: %s", directory,
isc_result_totext(result));
- return (result);
+ return result;
}
char cwd[PATH_MAX];
"the working directory is now '%s'", cwd);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
const uint16_t ida = *(const uint16_t *)a;
const uint16_t idb = *(const uint16_t *)b;
if (ida < idb) {
- return (-1);
+ return -1;
} else if (ida > idb) {
- return (1);
+ return 1;
} else {
- return (0);
+ return 0;
}
}
}
if (n == 0) {
- return (DNS_R_EMPTYNAME);
+ return DNS_R_EMPTYNAME;
}
if (n > 1) {
r.length = sizeof(label);
m = snprintf(r.base, r.length, "_ta");
if (m < 0 || (unsigned)m > r.length) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
isc_textregion_consume(&r, m);
for (i = 0; i < n; i++) {
m = snprintf(r.base, r.length, "-%04x", ids[i]);
if (m < 0 || (unsigned)m > r.length) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
isc_textregion_consume(&r, m);
}
- return (dns_name_fromstring2(target, label, keyname, 0, NULL));
+ return dns_name_fromstring2(target, label, keyname, 0, NULL);
}
static void
}
*field = copy;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
static isc_result_t
setoptstring(named_server_t *server, char **field, const cfg_obj_t *obj) {
if (cfg_obj_isvoid(obj)) {
- return (setstring(server, field, NULL));
+ return setstring(server, field, NULL);
} else {
- return (setstring(server, field, cfg_obj_asstring(obj)));
+ return setstring(server, field, cfg_obj_asstring(obj));
}
}
static isc_result_t
removed(dns_zone_t *zone, void *uap) {
if (dns_zone_getview(zone) != uap) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_zone_log(zone, ISC_LOG_INFO, "(%s) removed",
dns_zonetype_name(dns_zone_gettype(zone)));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
DNS_KEYPROTO_ANY, dns_rdataclass_in, mctx,
&key, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
}
*keyp = key;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
dst_key_free(&key);
}
- return (result);
+ return result;
}
static isc_result_t
keyname = dns_fixedname_initname(&fname);
result = dns_name_fromtext(keyname, &buffer, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
obj = NULL;
"session-keyalg: "
"unsupported or unknown algorithm '%s'%s",
algstr, server->session_keyfile != NULL ? s : "");
- return (result);
+ return result;
}
/* See if we need to (re)generate a new key. */
&server->sessionkey));
}
- return (result);
+ return result;
cleanup:
cleanup_session_key(server, mctx);
- return (result);
+ return result;
}
#ifndef HAVE_LMDB
/* The new zone file may not exist. That is OK. */
if (!isc_file_exists(view->new_zone_file)) {
*num_zonesp = 0;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
view->new_zone_file, isc_result_totext(result));
}
- return (result);
+ return result;
}
#else /* HAVE_LMDB */
UNLOCK(&view->new_zone_lock);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#endif /* HAVE_LMDB */
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"invalid new-zones-directory %s: %s", dir,
isc_result_totext(result));
- return (result);
+ return result;
}
if (!isc_file_isdirwritable(dir)) {
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
"new-zones-directory '%s' "
"is not writable",
dir);
- return (ISC_R_NOPERM);
+ return ISC_R_NOPERM;
}
dns_view_setnewzonedir(view, dir);
"%" PRId64 "' "
"is too small",
mapsize);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
} else if (mapsize > (1ULL << 40)) { /* 1 terabyte */
cfg_obj_log(obj, named_g_lctx, ISC_LOG_ERROR,
"'lmdb-mapsize "
"%" PRId64 "' "
"is too large",
mapsize);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
#else /* ifdef HAVE_LMDB */
if (num_zones != NULL) {
*num_zones = 0;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
nzcfg = isc_mem_get(view->mctx, sizeof(*nzcfg));
mapsize);
if (result != ISC_R_SUCCESS) {
dns_view_setnewzones(view, false, NULL, NULL, 0ULL);
- return (result);
+ return result;
}
cfg_obj_attach(config, &nzcfg->config);
}
result = count_newzones(view, nzcfg, num_zones);
- return (result);
+ return result;
}
static void
nzctx = view->new_zone_config;
if (nzctx == NULL || nzctx->nzf_config == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
configure_zone_setviewcommit(result, zconfig, view);
}
- return (result);
+ return result;
}
#else /* HAVE_LMDB */
cfg_obj_destroy(named_g_addparser, &zoneconf);
}
- return (result);
+ return result;
}
/*%
status = mdb_cursor_open(txn, dbi, &cursor);
if (status != MDB_SUCCESS) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
for (status = mdb_cursor_get(cursor, &key, &data, MDB_FIRST);
}
mdb_cursor_close(cursor);
- return (result);
+ return result;
}
/*%
configure_newzone(const cfg_obj_t *zconfig, cfg_obj_t *config,
cfg_obj_t *vconfig, isc_mem_t *mctx, dns_view_t *view,
cfg_aclconfctx_t *actx) {
- return (configure_zone(
+ return configure_zone(
config, zconfig, vconfig, mctx, view, &named_g_server->viewlist,
- &named_g_server->kasplist, actx, true, false, false, false));
+ &named_g_server->kasplist, actx, true, false, false, false);
}
/*%
configure_zone_setviewcommit(ISC_R_FAILURE, zconfig, view);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
MDB_dbi dbi;
if (view->new_zone_config == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
LOCK(&view->new_zone_lock);
result = nzd_open(view, MDB_RDONLY, &txn, &dbi);
if (result != ISC_R_SUCCESS) {
UNLOCK(&view->new_zone_lock);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
UNLOCK(&view->new_zone_lock);
- return (result);
+ return result;
}
static isc_result_t
isc_buffer_free(&text);
}
- return (result);
+ return result;
}
#endif /* HAVE_LMDB */
n++;
}
- return (n);
+ return n;
}
static isc_result_t
"server is restarted");
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (obj != NULL) {
}
if (server->lockfile == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (named_os_issingleton(server->lockfile)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
"could not lock %s; another named "
"process may be running",
server->lockfile);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
static isc_result_t
NAMED_LOGMODULE_SERVER, ISC_LOG_DEBUG(1),
"load_configuration: %s", isc_result_totext(result));
- return (result);
+ return result;
}
static isc_result_t
"running");
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_task_endexclusive(server->task);
}
- return (result);
+ return result;
}
static void
(message->flags & DNS_MESSAGEFLAG_RD) == 0))
{
dns_view_attach(view, viewp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
void
atomic_store(&server->reload_status, NAMED_RELOAD_FAILED);
}
- return (result);
+ return result;
}
static isc_result_t
atomic_store(&server->reload_status, NAMED_RELOAD_FAILED);
}
cleanup:
- return (result);
+ return result;
}
/*
(void)putstr(text, "token too large");
(void)putnull(text);
}
- return (NULL);
+ return NULL;
default:
if (text != NULL) {
(void)putstr(text, isc_result_totext(result));
(void)putnull(text);
}
- return (NULL);
+ return NULL;
}
if (token.type == isc_tokentype_string ||
token.type == isc_tokentype_qstring)
{
- return (token.value.as_textregion.base);
+ return token.value.as_textregion.base;
}
- return (NULL);
+ return NULL;
}
/*
/* Skip the command name. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
}
zonetxt = next_token(lex, text);
}
if (zonetxt == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* Copy zonetxt because it'll be overwritten by next_token() */
dns_view_detach(&view);
}
- return (result);
+ return result;
}
/*
result = zone_from_args(server, lex, NULL, &zone, NULL, text, true);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (zone == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
dns_zone_getraw(zone, &raw);
if (raw != NULL) {
result = ISC_R_FAILURE;
}
dns_zone_detach(&zone);
- return (result);
+ return result;
}
/*
result = zone_from_args(server, lex, NULL, &zone, NULL, text, true);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (zone == NULL) {
result = reload(server);
(void)putstr(text, msg);
(void)putnull(text);
}
- return (result);
+ return result;
}
/*
atomic_store(&server->reload_status, NAMED_RELOAD_FAILED);
}
cleanup:
- return (result);
+ return result;
}
/*
result = zone_from_args(server, lex, NULL, &zone, NULL, text, true);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (zone == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
dns_zone_notify(zone);
(void)putstr(text, msg);
(void)putnull(text);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
result = zone_from_args(server, lex, NULL, &zone, NULL, text, true);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (zone == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
dns_zone_getraw(zone, &raw);
dns_zone_detach(&zone);
(void)putstr(text, msg1);
(void)putnull(text);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_zone_detach(&zone);
(void)putstr(text, msg2);
(void)putnull(text);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
isc_result_t
/* Skip the command name. */
ptr = next_token(lex, NULL);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
prev = ns_server_getoption(server->sctx, NS_SERVER_LOGQUERIES);
{
value = false;
} else {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
if (value == prev) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
ns_server_setoption(server->sctx, NS_SERVER_LOGQUERIES, value);
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"query logging is now %s", value ? "on" : "off");
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
result = ns_listenlist_create(mctx, &dlist);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (element = cfg_list_first(listenlist); element != NULL;
ISC_LIST_APPEND(dlist->elts, delt, link);
}
*target = dlist;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
ns_listenlist_detach(&dlist);
- return (result);
+ return result;
}
static const cfg_obj_t *
result = cfg_map_get(config, listname, &maplist);
if (result != ISC_R_SUCCESS) {
- return (NULL);
+ return NULL;
}
for (elt = cfg_list_first(maplist); elt != NULL;
if (strcasecmp(cfg_obj_asstring(cfg_map_getname(map)), name) ==
0)
{
- return (map);
+ return map;
}
}
- return (NULL);
+ return NULL;
}
/*
cfg_obj_log(tlsobj, named_g_lctx, ISC_LOG_ERROR,
"tls '%s' is not defined",
cfg_obj_asstring(tlsobj));
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
CHECK(cfg_map_get(tlsmap, "key-file", &keyobj));
const char *httpname = cfg_obj_asstring(httpobj);
if (!do_tls && !no_tls) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
http_server = find_maplist(config, "http", httpname);
cfg_obj_log(httpobj, named_g_lctx, ISC_LOG_ERROR,
"http '%s' is not defined",
cfg_obj_asstring(httpobj));
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
http = true;
result = named_config_getport(
config, "https-port", &port);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
} else if (http && !do_tls) {
result = named_config_getport(
config, "http-port", &port);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
} else if (do_tls) {
result = named_config_getport(
config, "tls-port", &port);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
} else {
result = named_config_getport(config, "port",
&port);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
}
} else {
if (cfg_obj_asuint32(portobj) >= UINT16_MAX) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
port = (in_port_t)cfg_obj_asuint32(portobj);
}
&delt->acl);
if (result != ISC_R_SUCCESS) {
ns_listenelt_destroy(delt);
- return (result);
+ return result;
}
*target = delt;
cleanup:
- return (result);
+ return result;
}
#ifdef HAVE_LIBNGHTTP2
*target = delt;
- return (result);
+ return result;
error:
if (delt != NULL) {
ns_listenelt_destroy(delt);
}
- return (result);
+ return result;
}
#endif /* HAVE_LIBNGHTTP2 */
"dumpstats failed: %s",
isc_result_totext(result));
}
- return (result);
+ return result;
}
static isc_result_t
dns_zone_attach(zone, &zle->zone);
ISC_LINK_INIT(zle, link);
ISC_LIST_APPEND(ISC_LIST_TAIL(dctx->viewlist)->zonelist, zle, link);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
vle = ISC_LIST_NEXT(vle, link))
{
if (vle->view == view) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
result = dns_zt_apply(view->zonetable, isc_rwlocktype_read,
true, NULL, add_zone_tolist, dctx);
}
- return (result);
+ return result;
}
static void
/* Skip the command name. */
ptr = next_token(lex, NULL);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
dctx = isc_mem_get(server->mctx, sizeof(*dctx));
CHECK(putnull(text));
result = ISC_R_NOTFOUND;
dumpdone(dctx, result);
- return (result);
+ return result;
}
ptr = next_token(lex, NULL);
if (ptr != NULL) {
}
}
dumpdone(dctx, ISC_R_SUCCESS);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dumpcontext_destroy(dctx);
- return (result);
+ return result;
}
isc_result_t
/* Skip the command name. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/* "-" here means print the output instead of dumping to file */
"dumpsecroots failed: %s",
isc_result_totext(result));
}
- return (result);
+ return result;
}
isc_result_t
"dumprecursing failed: %s",
isc_result_totext(result));
}
- return (result);
+ return result;
}
isc_result_t
/* Skip the command name. */
ptr = next_token(lex, NULL);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/* Look for the new level name. */
} else {
newlevel = strtol(ptr, &endp, 10);
if (*endp != '\0' || newlevel < 0 || newlevel > 99) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
named_g_debuglevel = (unsigned int)newlevel;
}
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
"debug level is now %u", named_g_debuglevel);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
/* Skip the command name. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/* Find out what we are to do. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (!strcasecmp(ptr, "on") || !strcasecmp(ptr, "yes") ||
} else if (!strcasecmp(ptr, "check") || !strcasecmp(ptr, "status")) {
set = false;
} else {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
/* Look for the view name. */
}
cleanup:
isc_task_endexclusive(server->task);
- return (result);
+ return result;
}
isc_result_t
/* Skip the command name. */
ptr = next_token(lex, NULL);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/* Look for the view name. */
}
}
isc_task_endexclusive(server->task);
- return (result);
+ return result;
}
isc_result_t
/* Skip the command name. */
ptr = next_token(lex, NULL);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/* Find the domain name to flush. */
ptr = next_token(lex, NULL);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
strlcpy(target, ptr, DNS_NAME_FORMATSIZE);
name = dns_fixedname_initname(&fixed);
result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/* Look for the view name. */
result = ISC_R_FAILURE;
}
isc_task_endexclusive(server->task);
- return (result);
+ return result;
}
isc_result_t
CHECK(putstr(text, "server is up and running"));
CHECK(putnull(text));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
- return (result);
+ return result;
}
isc_result_t
/* Skip the command name. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
ptr = next_token(lex, text);
CHECK(putnull(text));
cleanup:
- return (result);
+ return result;
}
static isc_result_t
result = dns_rbtnodechain_first(&chain, ring->keys, &foundname, origin);
if (result == ISC_R_NOTFOUND) {
dns_rbtnodechain_invalidate(&chain);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS && result != DNS_R_NEWORIGIN) {
dns_rbtnodechain_invalidate(&chain);
- return (result);
+ return result;
}
for (;;) {
}
if (result != ISC_R_SUCCESS && result != DNS_R_NEWORIGIN) {
dns_rbtnodechain_invalidate(&chain);
- return (result);
+ return result;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
strlcpy(target, ptr, DNS_NAME_FORMATSIZE);
isc_rwlocktype_write);
if (result != ISC_R_SUCCESS) {
isc_task_endexclusive(server->task);
- return (result);
+ return result;
}
}
}
CHECK(putnull(text));
cleanup:
- return (result);
+ return result;
}
static isc_result_t
result = dns_rbtnodechain_first(&chain, ring->keys, &foundname, origin);
if (result == ISC_R_NOTFOUND) {
dns_rbtnodechain_invalidate(&chain);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS && result != DNS_R_NEWORIGIN) {
dns_rbtnodechain_invalidate(&chain);
- return (result);
+ return result;
}
for (;;) {
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_rbtnodechain_invalidate(&chain);
- return (result);
+ return result;
}
isc_result_t
&foundkeys);
RWUNLOCK(&view->statickeys->lock, isc_rwlocktype_read);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
RWLOCK(&view->dynamickeys->lock, isc_rwlocktype_read);
result = list_keynames(view, view->dynamickeys, text,
&foundkeys);
RWUNLOCK(&view->dynamickeys->lock, isc_rwlocktype_read);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
}
cleanup:
- return (result);
+ return result;
}
/*
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (strcasecmp(ptr, NAMED_COMMAND_SIGN) == 0) {
result = zone_from_args(server, lex, NULL, &zone, NULL, text, false);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (zone == NULL) {
- return (ISC_R_UNEXPECTEDEND); /* XXX: or do all zones? */
+ return ISC_R_UNEXPECTEDEND; /* XXX: or do all zones? */
}
type = dns_zone_gettype(zone);
if (type != dns_zone_primary) {
dns_zone_detach(&zone);
- return (DNS_R_NOTPRIMARY);
+ return DNS_R_NOTPRIMARY;
}
keyopts = dns_zone_getkeyopts(zone);
}
dns_zone_detach(&zone);
- return (result);
+ return result;
}
/*
}
}
- return (result);
+ return result;
}
isc_result_t
result = zone_from_args(server, lex, arg, &zone, NULL, text, false);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (zone == NULL) {
"dumping all zones%s: %s",
cleanup ? ", removing journal files" : "",
isc_result_totext(result));
- return (tresult);
+ return tresult;
}
result = isc_task_beginexclusive(server->task);
classstr, sep, vname, cleanup ? ", removing journal file" : "",
isc_result_totext(result));
dns_zone_detach(&zone);
- return (result);
+ return result;
}
/*
result = zone_from_args(server, lex, NULL, &mayberaw, NULL, text, true);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (mayberaw == NULL) {
result = isc_task_beginexclusive(server->task);
"%s all zones: %s",
freeze ? "freezing" : "thawing",
isc_result_totext(tresult));
- return (tresult);
+ return tresult;
}
dns_zone_getraw(mayberaw, &raw);
if (raw != NULL) {
type = dns_zone_gettype(mayberaw);
if (type != dns_zone_primary) {
dns_zone_detach(&mayberaw);
- return (DNS_R_NOTPRIMARY);
+ return DNS_R_NOTPRIMARY;
}
if (freeze && !dns_zone_isdynamic(mayberaw, true)) {
dns_zone_detach(&mayberaw);
- return (DNS_R_NOTDYNAMIC);
+ return DNS_R_NOTDYNAMIC;
}
result = isc_task_beginexclusive(server->task);
freeze ? "freezing" : "thawing", zonename, classstr, sep,
vname, isc_result_totext(result));
dns_zone_detach(&mayberaw);
- return (result);
+ return result;
}
#ifdef HAVE_LIBSCF
named_smf_add_message(isc_buffer_t **text) {
REQUIRE(text != NULL);
- return (putstr(text, "use svcadm(1M) to manage named"));
+ return putstr(text, "use svcadm(1M) to manage named");
}
#endif /* HAVE_LIBSCF */
CHECK(isc_stdio_write(viewname, strlen(viewname), 1, fp, NULL));
CHECK(isc_stdio_write(HEADER2, sizeof(HEADER2) - 1, 1, fp, NULL));
cleanup:
- return (result);
+ return result;
}
static void
}
}
UNLOCK(&view->new_zone_lock);
- return (result);
+ return result;
}
static isc_result_t
result = isc_file_openunique(tmp, &fp);
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
cfg_map_get(config, "zone", &zl);
goto cleanup;
}
CHECK(isc_file_rename(tmp, view->new_zone_file));
- return (result);
+ return result;
cleanup:
if (fp != NULL) {
(void)isc_stdio_close(fp);
}
(void)isc_file_remove(tmp);
- return (result);
+ return result;
}
#else /* HAVE_LMDB */
isc_buffer_free(&text);
}
- return (result);
+ return result;
}
/*
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
"mdb_txn_begin: %s", mdb_strerror(status));
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
status = mdb_dbi_open(txn, NULL, 0, &dbi);
}
mdb_txn_abort(txn);
- return (result);
+ return result;
}
/*
if (txn != NULL) {
mdb_txn_abort(txn);
}
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
int status;
if (view->new_zone_db == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
nzd_env_close(view);
if (env != NULL) {
mdb_env_close(env);
}
- return (result);
+ return result;
}
/*
*txnp = NULL;
}
- return (result);
+ return result;
}
/*
cleanup:
(void)nzd_close(&txn, false);
- return (result);
+ return result;
}
/*
cfg_obj_destroy(named_g_addparser, &nzf_config);
}
- return (result);
+ return result;
}
#endif /* HAVE_LMDB */
*zoneconfp = zoneconf;
*redirectp = redirect;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (zoneconf != NULL) {
dns_view_detach(&view);
}
- return (result);
+ return result;
}
static isc_result_t
cleanup:
UNLOCK(&view->new_zone_lock);
- return (result);
+ return result;
}
static isc_result_t
dns_zone_detach(&zone);
}
- return (result);
+ return result;
}
static isc_result_t
dns_zone_detach(&zone);
}
- return (result);
+ return result;
}
/*
dns_view_detach(&view);
}
- return (result);
+ return result;
}
static bool
}
(void)putstr(text, file);
(void)putnull(text);
- return (false);
+ return false;
}
- return (first);
+ return first;
}
typedef struct {
/* Skip the command name. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/* Find out what we are to do. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (strcmp(ptr, "-clean") == 0 || strcmp(ptr, "-clear") == 0) {
dns_zone_detach(&zone);
}
- return (result);
+ return result;
}
static const cfg_obj_t *
obj = NULL;
}
- return (obj);
+ return obj;
}
static void
(void)putnull(text);
}
- return (result);
+ return result;
}
static void
/* Skip the command name. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/* Find out what we are to do. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (strcasecmp(ptr, "-list") == 0) {
clear = true;
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
strlcpy(keystr, ptr, sizeof(keystr));
} else if (strcasecmp(ptr, "-nsec3param") == 0) {
chain = true;
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (strcasecmp(ptr, "none") == 0) {
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
strlcpy(flagbuf, ptr, sizeof(flagbuf));
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
strlcpy(iterbuf, ptr, sizeof(iterbuf));
n = snprintf(nbuf, sizeof(nbuf), "%s %s %s", hashbuf,
flagbuf, iterbuf);
if (n == sizeof(nbuf)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
n = sscanf(nbuf, "%hu %hu %hu", &hash, &flags, &iter);
if (n != 3U) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
if (hash > 0xffU || flags > 0xffU ||
iter > dns_nsec3_maxiterations())
{
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
} else if (strcasecmp(ptr, "auto") == 0) {
/* Auto-generate a random salt.
* XXXMUKS: This currently uses the
} else if (strcasecmp(ptr, "-serial") == 0) {
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
CHECK(isc_parse_uint32(&serial, ptr, 10));
setserial = true;
dns_zone_detach(&zone);
}
- return (result);
+ return result;
}
static bool
size_t l;
if (cmd == NULL || cmd[0] != '-') {
- return (false);
+ return false;
}
cmd++;
l = strlen(cmd);
if (l > strlen(full) || strncasecmp(cmd, full, l) != 0) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
isc_result_t
/* Skip the command name. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/* Find out what we are to do. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/* Initialize current time and key list. */
dns_zone_detach(&zone);
}
- return (result);
+ return result;
}
static isc_result_t
result = isc_buffer_reserve(b, (unsigned int)len);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putmem(*b, (const unsigned char *)str, (unsigned int)len);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
putstr(isc_buffer_t **b, const char *str) {
- return (putmem(b, str, strlen(str)));
+ return putmem(b, str, strlen(str));
}
static isc_result_t
result = isc_buffer_reserve(b, 1);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint8(*b, val);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
putnull(isc_buffer_t **b) {
- return (putuint8(b, 0));
+ return putuint8(b, 0);
}
isc_result_t
if (result == ISC_R_NOSPACE) {
(void)putstr(text, "\n...");
}
- if ((result == ISC_R_SUCCESS || result == ISC_R_NOSPACE)) {
+ if (result == ISC_R_SUCCESS || result == ISC_R_NOSPACE) {
(void)putnull(text);
}
if (zone != NULL) {
dns_zone_detach(&zone);
}
- return (result);
+ return result;
}
isc_result_t
/* Skip the command name. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
for (;;) {
/* Check for options */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (strcmp(ptr, "--") == 0) {
nametext = next_token(lex, text);
}
if (nametext == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/* Copy nametext as it'll be overwritten by next_token() */
if (ntatable != NULL) {
dns_ntatable_detach(&ntatable);
}
- return (result);
+ return result;
}
isc_result_t
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
CHECK(dns_zone_synckeyzone(view->managed_keys));
cleanup:
- return (result);
+ return result;
}
static isc_result_t
if (exclusive) {
isc_task_endexclusive(server->task);
}
- return (result);
+ return result;
}
static isc_result_t
dns_db_detach(&db);
}
- return (result);
+ return result;
}
static isc_result_t
CHECK(mkey_dumpzone(view, text));
cleanup:
- return (result);
+ return result;
}
isc_result_t
/* Skip rndc command name */
cmd = next_token(lex, text);
if (cmd == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/* Get managed-keys subcommand */
cmd = next_token(lex, text);
if (cmd == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (strcasecmp(cmd, "status") == 0) {
(void)putnull(text);
}
- return (result);
+ return result;
}
isc_result_t
REQUIRE(text != NULL);
if (server->dtenv == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/* Check the command name. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/* "dnstap-reopen" was used in 9.11.0b1 */
} else {
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
}
if (reopen || strcasecmp(ptr, "-reopen") == 0) {
backups = ISC_LOG_ROLLNEVER;
- } else if ((strcasecmp(ptr, "-roll") == 0)) {
+ } else if (strcasecmp(ptr, "-roll") == 0) {
unsigned int n;
ptr = next_token(lex, text);
if (ptr != NULL) {
unsigned int u;
n = sscanf(ptr, "%u", &u);
if (n != 1U || u > INT_MAX) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
backups = u;
} else {
backups = ISC_LOG_ROLLINFINITE;
}
} else {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
result = dns_dt_reopen(server->dtenv, backups);
- return (result);
+ return result;
#else /* ifdef HAVE_DNSTAP */
UNUSED(server);
UNUSED(lex);
UNUSED(text);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
#endif /* ifdef HAVE_DNSTAP */
}
/* Skip the command name. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_nm_gettimeouts(named_g_netmgr, &initial, &idle, &keepalive,
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
CHECK(isc_parse_uint32(&idle, ptr, 10));
idle *= 100;
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
CHECK(isc_parse_uint32(&keepalive, ptr, 10));
keepalive *= 100;
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
CHECK(isc_parse_uint32(&advertised, ptr, 10));
advertised *= 100;
(void)putnull(text);
}
- return (result);
+ return result;
}
isc_result_t
/* Skip the command name. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
ptr = next_token(lex, NULL);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (!strcasecmp(ptr, "on") || !strcasecmp(ptr, "yes") ||
} else if (!strcasecmp(ptr, "check") || !strcasecmp(ptr, "status")) {
wantstatus = true;
} else {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
/* Look for the optional class name. */
(void)putnull(text);
}
- return (result);
+ return result;
}
const struct zt *tp;
if ((dns_zone_getoptions(zone) & DNS_ZONEOPT_AUTOEMPTY) != 0) {
- return ("builtin");
+ return "builtin";
}
view = dns_zone_getview(zone);
if (view != NULL && strcmp(view->name, "_bind") == 0) {
- return ("builtin");
+ return "builtin";
}
ztype = dns_zone_gettype(zone);
for (tp = typemap; tp->string != NULL && tp->type != ztype; tp++) {
/* empty */
}
- return (tp->string);
+ return tp->string;
}
#endif /* ifdef EXTENDED_STATS */
if (category != NULL) {
cat = json_object_new_object();
if (cat == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
json_object_object_add(job, category, cat);
}
#ifdef HAVE_JSON_C
counter = json_object_new_int64(value);
if (counter == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
json_object_object_add(cat, desc[idx], counter);
#endif /* ifdef HAVE_JSON_C */
break;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#ifdef HAVE_LIBXML2
cleanup:
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"failed at dump_counters()");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
#endif /* ifdef HAVE_LIBXML2 */
}
static bool
rdatastatstype_attr(dns_rdatastatstype_t type, unsigned int attr) {
- return ((DNS_RDATASTATSTYPE_ATTR(type) & attr) != 0);
+ return (DNS_RDATASTATSTYPE_ATTR(type) & attr) != 0;
}
static void
statlevel = dns_zone_getstatlevel(zone);
if (statlevel == dns_zonestat_none) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dumparg.type = isc_statsformat_xml;
TRY0(xmlTextWriterEndElement(writer)); /* zone */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"Failed at zone_xmlrender()");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
static isc_result_t
xmlFreeTextWriter(writer);
xmlFreeDoc(doc);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
if (doc != NULL) {
xmlFreeDoc(doc);
}
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
static void
"failed at rendering XML()");
}
- return (result);
+ return result;
}
static isc_result_t
void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_xml(STATS_XML_ALL, arg, retcode, retmsg, mimetype, b,
- freecb, freecb_args));
+ return render_xml(STATS_XML_ALL, arg, retcode, retmsg, mimetype, b,
+ freecb, freecb_args);
}
static isc_result_t
isc_httpdfree_t **freecb, void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_xml(STATS_XML_STATUS, arg, retcode, retmsg, mimetype, b,
- freecb, freecb_args));
+ return render_xml(STATS_XML_STATUS, arg, retcode, retmsg, mimetype, b,
+ freecb, freecb_args);
}
static isc_result_t
isc_httpdfree_t **freecb, void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_xml(STATS_XML_SERVER, arg, retcode, retmsg, mimetype, b,
- freecb, freecb_args));
+ return render_xml(STATS_XML_SERVER, arg, retcode, retmsg, mimetype, b,
+ freecb, freecb_args);
}
static isc_result_t
isc_httpdfree_t **freecb, void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_xml(STATS_XML_ZONES, arg, retcode, retmsg, mimetype, b,
- freecb, freecb_args));
+ return render_xml(STATS_XML_ZONES, arg, retcode, retmsg, mimetype, b,
+ freecb, freecb_args);
}
static isc_result_t
void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_xml(STATS_XML_NET, arg, retcode, retmsg, mimetype, b,
- freecb, freecb_args));
+ return render_xml(STATS_XML_NET, arg, retcode, retmsg, mimetype, b,
+ freecb, freecb_args);
}
static isc_result_t
isc_httpdfree_t **freecb, void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_xml(STATS_XML_TASKS, arg, retcode, retmsg, mimetype, b,
- freecb, freecb_args));
+ return render_xml(STATS_XML_TASKS, arg, retcode, retmsg, mimetype, b,
+ freecb, freecb_args);
}
static isc_result_t
void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_xml(STATS_XML_MEM, arg, retcode, retmsg, mimetype, b,
- freecb, freecb_args));
+ return render_xml(STATS_XML_MEM, arg, retcode, retmsg, mimetype, b,
+ freecb, freecb_args);
}
static isc_result_t
isc_httpdfree_t **freecb, void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_xml(STATS_XML_TRAFFIC, arg, retcode, retmsg, mimetype, b,
- freecb, freecb_args));
+ return render_xml(STATS_XML_TRAFFIC, arg, retcode, retmsg, mimetype, b,
+ freecb, freecb_args);
}
#endif /* HAVE_LIBXML2 */
json_object *node = json_object_new_object();
if (node == NULL) {
- return (NULL);
+ return NULL;
}
json_object_object_add(node, "name", json_object_new_string(name));
json_object_object_add(node, "type",
json_object_new_string(ztype));
}
- return (node);
+ return node;
}
static isc_result_t
statlevel = dns_zone_getstatlevel(zone);
if (statlevel == dns_zonestat_none) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_zone_nameonly(zone, buf, sizeof(buf));
}
if (zoneobj == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
/*
if (zoneobj != NULL) {
json_object_put(zoneobj);
}
- return (result);
+ return result;
}
static isc_result_t
bindstats = json_object_new_object();
if (bindstats == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
/*
json_object_put(bindstats);
}
- return (result);
+ return result;
}
static isc_result_t
"failed at rendering JSON()");
}
- return (result);
+ return result;
}
static isc_result_t
isc_httpdfree_t **freecb, void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_json(STATS_JSON_ALL, arg, retcode, retmsg, mimetype, b,
- freecb, freecb_args));
+ return render_json(STATS_JSON_ALL, arg, retcode, retmsg, mimetype, b,
+ freecb, freecb_args);
}
static isc_result_t
isc_httpdfree_t **freecb, void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_json(STATS_JSON_STATUS, arg, retcode, retmsg, mimetype,
- b, freecb, freecb_args));
+ return render_json(STATS_JSON_STATUS, arg, retcode, retmsg, mimetype, b,
+ freecb, freecb_args);
}
static isc_result_t
isc_httpdfree_t **freecb, void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_json(STATS_JSON_SERVER, arg, retcode, retmsg, mimetype,
- b, freecb, freecb_args));
+ return render_json(STATS_JSON_SERVER, arg, retcode, retmsg, mimetype, b,
+ freecb, freecb_args);
}
static isc_result_t
isc_httpdfree_t **freecb, void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_json(STATS_JSON_ZONES, arg, retcode, retmsg, mimetype, b,
- freecb, freecb_args));
+ return render_json(STATS_JSON_ZONES, arg, retcode, retmsg, mimetype, b,
+ freecb, freecb_args);
}
static isc_result_t
isc_httpdfree_t **freecb, void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_json(STATS_JSON_MEM, arg, retcode, retmsg, mimetype, b,
- freecb, freecb_args));
+ return render_json(STATS_JSON_MEM, arg, retcode, retmsg, mimetype, b,
+ freecb, freecb_args);
}
static isc_result_t
isc_httpdfree_t **freecb, void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_json(STATS_JSON_TASKS, arg, retcode, retmsg, mimetype, b,
- freecb, freecb_args));
+ return render_json(STATS_JSON_TASKS, arg, retcode, retmsg, mimetype, b,
+ freecb, freecb_args);
}
static isc_result_t
isc_httpdfree_t **freecb, void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_json(STATS_JSON_NET, arg, retcode, retmsg, mimetype, b,
- freecb, freecb_args));
+ return render_json(STATS_JSON_NET, arg, retcode, retmsg, mimetype, b,
+ freecb, freecb_args);
}
static isc_result_t
isc_httpdfree_t **freecb, void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_json(STATS_JSON_TRAFFIC, arg, retcode, retmsg, mimetype,
- b, freecb, freecb_args));
+ return render_json(STATS_JSON_TRAFFIC, arg, retcode, retmsg, mimetype,
+ b, freecb, freecb_args);
}
#endif /* HAVE_JSON_C */
isc_buffer_reinit(b, p, strlen(xslmsg));
isc_buffer_add(b, strlen(xslmsg));
end:
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#endif
match > 0)
{
UNLOCK(&listener->lock);
- return (true);
+ return true;
}
UNLOCK(&listener->lock);
NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
"rejected statistics connection from %s", socktext);
- return (false);
+ return false;
}
#endif
UNUSED(aclconfctx);
UNUSED(socktext);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
#else
isc_result_t result;
named_statschannel_t *listener = NULL;
NAMED_LOGMODULE_SERVER, ISC_LOG_NOTICE,
"statistics channel listening on %s", socktext);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (listener->acl != NULL) {
isc_mutex_destroy(&listener->lock);
isc_mem_putanddetach(&listener->mctx, listener, sizeof(*listener));
- return (result);
+ return result;
#endif
}
}
ISC_LIST_APPENDLIST(server->statschannels, new_listeners, link);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
fprintf(fp, "--- Statistics Dump --- (%lu)\n", (unsigned long)now);
- return (ISC_R_SUCCESS); /* this function currently always succeeds */
+ return ISC_R_SUCCESS; /* this function currently always succeeds */
}
result = dns_tkeyctx_create(mctx, &tctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
obj = NULL;
}
*tctxp = tctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
dns_tkeyctx_destroy(&tctx);
- return (result);
+ return result;
}
dns_transport_set_remote_hostname);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
cfg_obj_log(doh, named_g_lctx, ISC_LOG_ERROR,
"configuring DoH '%s': %s", dohid,
isc_result_totext(result));
- return (result);
+ return result;
}
static isc_result_t
dns_transport_set_remote_hostname);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
cfg_obj_log(tls, named_g_lctx, ISC_LOG_ERROR,
"configuring tls '%s': %s", tlsid,
isc_result_totext(result));
- return (result);
+ return result;
}
#define CHECK(f) \
obj = NULL;
}
- return (result);
+ return result;
}
static void
}
*listp = list;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
dns_transport_list_detach(&list);
- return (result);
+ return result;
}
dns_tsigkey_detach(&tsigkey);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
cfg_obj_log(key, named_g_lctx, ISC_LOG_ERROR,
if (secret != NULL) {
isc_mem_put(mctx, secret, secretalloc);
}
- return (ret);
+ return ret;
}
isc_result_t
result = dns_tsigkeyring_create(mctx, &ring);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (i = 0;; i++) {
}
*ringp = ring;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
dns_tsigkeyring_detach(&ring);
- return (result);
+ return result;
}
/* Failing that, see if there's a default ACL already in the view */
if (aclp != NULL && *aclp != NULL) {
(*setzacl)(zone, *aclp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* Check for default ACLs that haven't been parsed yet */
(void)named_config_get(maps, aclname, &aclobj);
if (aclobj == NULL) {
(*clearzacl)(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
parse_acl:
result = cfg_acl_fromconfig(aclobj, config, named_g_lctx, actx,
named_g_mctx, 0, &acl);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
(*setzacl)(zone, acl);
}
dns_acl_detach(&acl);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
if (updatepolicy == NULL) {
dns_zone_setssutable(zone, NULL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (cfg_obj_isstring(updatepolicy) &&
cleanup:
dns_ssutable_detach(&table);
- return (result);
+ return result;
}
/*
cfg_obj_log(zconfig, named_g_lctx, ISC_LOG_ERROR,
"port is not configurable for "
"static stub server-addresses");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
isc_netaddr_fromsockaddr(&na, sa);
if (isc_netaddr_getzone(&na) != 0) {
"scoped address is not allowed "
"for static stub "
"server-addresses");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
switch (na.family) {
if (ISC_LIST_EMPTY(rdatalist_a->rdata) &&
ISC_LIST_EMPTY(rdatalist_aaaa->rdata))
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* Add to the list an apex NS with the ns name being the origin name */
®ion);
ISC_LIST_APPEND(rdatalist_ns->rdata, rdata, link);
- return (result);
+ return result;
}
/*%
"server-name '%s' is not a valid "
"name",
str);
- return (result);
+ return result;
}
if (dns_name_issubdomain(nsname, dns_zone_getorigin(zone))) {
cfg_obj_log(zconfig, named_g_lctx, ISC_LOG_ERROR,
"server-name '%s' must not be a "
"subdomain of zone name '%s'",
str, zname);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
dns_name_toregion(nsname, &sregion);
ISC_LIST_APPEND(rdatalist->rdata, rdata, link);
}
- return (result);
+ return result;
}
/*%
INSIST(dbversion == NULL);
- return (result);
+ return result;
}
/*%
result = cfg_map_get(map, "type", &obj);
INSIST(result == ISC_R_SUCCESS && obj != NULL);
- return (named_config_getzonetype(obj));
+ return named_config_getzonetype(obj);
}
/*%
result = strtoargvsub(mctx, p, argcp, argvp, n + 1);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
(*argvp)[n] = s;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
*/
static isc_result_t
strtoargv(isc_mem_t *mctx, char *s, unsigned int *argcp, char ***argvp) {
- return (strtoargvsub(mctx, s, argcp, argvp, 0));
+ return strtoargvsub(mctx, s, argcp, argvp, 0);
}
static const char *const primary_synonyms[] = { "primary", "master", NULL };
/* interfacemgr can be destroyed only in exclusive mode. */
if (named_g_server->interfacemgr == NULL) {
- return (true);
+ return true;
}
if (!ns_interfacemgr_listeningon(named_g_server->interfacemgr, dstaddr))
{
- return (false);
+ return false;
}
isc_netaddr_fromsockaddr(&netsrc, srcaddr);
break;
}
}
- return (view == myview);
+ return view == myview;
}
/*%
* zone is configured with something else than "notify yes;".
*/
if (ztype != dns_zone_mirror || ntype != dns_notifytype_yes) {
- return (ntype);
+ return ntype;
}
/*
zname);
}
- return (dns_notifytype_explicit);
+ return dns_notifytype_explicit;
}
isc_result_t
if (kasp != NULL) {
dns_kasp_detach(&kasp);
}
- return (result);
+ return result;
}
/*
dns_zone_settype(zone, dns_zone_dlz);
result = dns_sdlz_setdb(dlzdatabase, rdclass, name, &db);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_zone_dlzpostload(zone, db);
dns_db_detach(&db);
- return (result);
+ return result;
}
bool
if (zonetype_fromconfig(zoptions) == dns_zone_staticstub) {
dns_zone_log(zone, ISC_LOG_DEBUG(1),
"not reusable: staticstub");
- return (false);
+ return false;
}
/* If there's a raw zone, use that for filename and type comparison */
if (!inline_signing && has_raw) {
dns_zone_log(zone, ISC_LOG_DEBUG(1),
"not reusable: old zone was inline-signing");
- return (false);
+ return false;
} else if (inline_signing && !has_raw) {
dns_zone_log(zone, ISC_LOG_DEBUG(1),
"not reusable: old zone was not inline-signing");
- return (false);
+ return false;
}
if (zonetype_fromconfig(zoptions) != ztype) {
dns_zone_log(zone, ISC_LOG_DEBUG(1),
"not reusable: type mismatch");
- return (false);
+ return false;
}
obj = NULL;
{
dns_zone_log(zone, ISC_LOG_DEBUG(1),
"not reusable: filename mismatch");
- return (false);
+ return false;
}
- return (true);
+ return true;
}
bool
ISC_R_SUCCESS &&
cfg_obj_asboolean(signing));
- return (inline_signing);
+ return inline_signing;
}
if (zoneclass == dns_rdataclass_none) {
zoneclass = defaultclass;
}
- return (zoneclass);
+ return zoneclass;
}
static bool
zoneclass = rdclass;
}
if (zoneclass != rdclass) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static void
char sc, dc;
if (string == NULL) {
- return (NULL);
+ return NULL;
}
for (; *string != '\0'; string++) {
if (sc == dc) {
*s++ = '\0';
*stringp = s;
- return (string);
+ return string;
}
}
}
- return (string);
+ return string;
}
static void
if (len >= sizeof(buf)) {
error("unknown key type '%.*s'", (int)(len), hmacstr);
- return (false);
+ return false;
}
/* Copy len bytes and NUL terminate. */
result = isc_parse_uint16(&digestbits, &buf[9], 10);
if (result != ISC_R_SUCCESS || digestbits > 128) {
error("digest-bits out of range [0..128]");
- return (false);
+ return false;
}
*digestbitsp = (digestbits + 7) & ~0x7U;
} else if (strcasecmp(buf, "hmac-sha1") == 0) {
result = isc_parse_uint16(&digestbits, &buf[10], 10);
if (result != ISC_R_SUCCESS || digestbits > 160) {
error("digest-bits out of range [0..160]");
- return (false);
+ return false;
}
*digestbitsp = (digestbits + 7) & ~0x7U;
} else if (strcasecmp(buf, "hmac-sha224") == 0) {
result = isc_parse_uint16(&digestbits, &buf[12], 10);
if (result != ISC_R_SUCCESS || digestbits > 224) {
error("digest-bits out of range [0..224]");
- return (false);
+ return false;
}
*digestbitsp = (digestbits + 7) & ~0x7U;
} else if (strcasecmp(buf, "hmac-sha256") == 0) {
result = isc_parse_uint16(&digestbits, &buf[12], 10);
if (result != ISC_R_SUCCESS || digestbits > 256) {
error("digest-bits out of range [0..256]");
- return (false);
+ return false;
}
*digestbitsp = (digestbits + 7) & ~0x7U;
} else if (strcasecmp(buf, "hmac-sha384") == 0) {
result = isc_parse_uint16(&digestbits, &buf[12], 10);
if (result != ISC_R_SUCCESS || digestbits > 384) {
error("digest-bits out of range [0..384]");
- return (false);
+ return false;
}
*digestbitsp = (digestbits + 7) & ~0x7U;
} else if (strcasecmp(buf, "hmac-sha512") == 0) {
result = isc_parse_uint16(&digestbits, &buf[12], 10);
if (result != ISC_R_SUCCESS || digestbits > 512) {
error("digest-bits out of range [0..512]");
- return (false);
+ return false;
}
*digestbitsp = (digestbits + 7) & ~0x7U;
} else {
error("unknown key type '%s'", buf);
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static int
} else if (len > 4 && strcmp(file + len - 4, ".key") == 0) {
len -= 4;
}
- return (len);
+ return len;
}
static void
int len;
if (!isc_file_exists(keyfile)) {
- return (ISC_R_FILENOTFOUND);
+ return ISC_R_FILENOTFOUND;
}
result = cfg_parser_create(mctx, lctx, &pctx);
isc_mem_free(mctx, keystr);
}
- return (result);
+ return result;
}
static void
error("couldn't get address for '%s': %s", host,
isc_result_totext(result));
}
- return (count);
+ return count;
}
static void
word = nsu_strsep(cmdlinep, " \t\r\n");
if (word == NULL || *word == 0) {
fprintf(stderr, "could not read owner name\n");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
result = dns_message_gettempname(msg, namep);
error("invalid owner name: %s", isc_result_totext(result));
isc_buffer_invalidate(&source);
dns_message_puttempname(msg, namep);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
isc_buffer_invalidate(&source);
- return (STATUS_MORE);
+ return STATUS_MORE;
}
static uint16_t
if (cmdline == NULL) {
rdata->flags = DNS_RDATA_UPDATE;
- return (STATUS_MORE);
+ return STATUS_MORE;
}
while (*cmdline != 0 && isspace((unsigned char)*cmdline)) {
fprintf(stderr, "invalid rdata format: %s\n",
isc_result_totext(result));
isc_buffer_free(&buf);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
} else {
rdata->flags = DNS_RDATA_UPDATE;
}
*cmdlinep = cmdline;
- return (STATUS_MORE);
+ return STATUS_MORE;
}
static uint16_t
*/
retval = parse_name(&cmdline, updatemsg, &name);
if (retval != STATUS_MORE) {
- return (retval);
+ return retval;
}
/*
ISC_LIST_INIT(name->list);
ISC_LIST_APPEND(name->list, rdataset, link);
dns_message_addname(updatemsg, name, DNS_SECTION_PREREQUISITE);
- return (STATUS_MORE);
+ return STATUS_MORE;
failure:
if (name != NULL) {
dns_message_puttempname(updatemsg, &name);
}
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
static uint16_t
word = nsu_strsep(&cmdline, " \t\r\n");
if (word == NULL || *word == 0) {
fprintf(stderr, "could not read operation code\n");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
if (strcasecmp(word, "nxdomain") == 0) {
ispositive = false;
isrrset = true;
} else {
fprintf(stderr, "incorrect operation code: %s\n", word);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
- return (make_prereq(cmdline, ispositive, isrrset));
+ return make_prereq(cmdline, ispositive, isrrset);
}
static uint16_t
if (local_only) {
fprintf(stderr, "cannot reset server in localhost-only mode\n");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
word = nsu_strsep(&cmdline, " \t\r\n");
if (word == NULL || *word == 0) {
fprintf(stderr, "could not read server name\n");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
server = word;
port = strtol(word, &endp, 10);
if (*endp != 0) {
fprintf(stderr, "port '%s' is not numeric\n", word);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
} else if (port < 1 || port > 65535) {
fprintf(stderr,
"port '%s' is out of range "
"(1 to 65535)\n",
word);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
}
memset(servers, 0, ns_alloc * sizeof(isc_sockaddr_t));
ns_total = get_addresses(server, (in_port_t)port, servers, ns_alloc);
if (ns_total == 0) {
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
- return (STATUS_MORE);
+ return STATUS_MORE;
}
static uint16_t
word = nsu_strsep(&cmdline, " \t\r\n");
if (word == NULL || *word == 0) {
fprintf(stderr, "could not read server name\n");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
local = word;
port = strtol(word, &endp, 10);
if (*endp != 0) {
fprintf(stderr, "port '%s' is not numeric\n", word);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
} else if (port < 1 || port > 65535) {
fprintf(stderr,
"port '%s' is out of range "
"(1 to 65535)\n",
word);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
}
isc_sockaddr_fromin(localaddr4, &in4, (in_port_t)port);
} else {
fprintf(stderr, "invalid address %s", local);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
- return (STATUS_MORE);
+ return STATUS_MORE;
}
static uint16_t
namestr = nsu_strsep(&cmdline, " \t\r\n");
if (namestr == NULL || *namestr == 0) {
fprintf(stderr, "could not read key name\n");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
mykeyname = dns_fixedname_initname(&fkeyname);
n = strchr(namestr, ':');
if (n != NULL) {
if (!parse_hmac(&hmacname, namestr, n - namestr, &digestbits)) {
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
namestr = n + 1;
} else {
result = dns_name_fromtext(mykeyname, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "could not parse key name\n");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
secretstr = nsu_strsep(&cmdline, "\r\n");
if (secretstr == NULL || *secretstr == 0) {
fprintf(stderr, "could not read key secret\n");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
secretlen = strlen(secretstr) * 3 / 4;
secret = isc_mem_allocate(gmctx, secretlen);
fprintf(stderr, "could not create key from %s: %s\n", secretstr,
isc_result_totext(result));
isc_mem_free(gmctx, secret);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
secretlen = isc_buffer_usedlength(&secretbuf);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "could not create key from %s %s: %s\n",
namestr, secretstr, isc_result_totext(result));
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
dst_key_setbits(tsigkey->key, digestbits);
- return (STATUS_MORE);
+ return STATUS_MORE;
}
static uint16_t
word = nsu_strsep(&cmdline, " \t\r\n");
if (word == NULL || *word == 0) {
fprintf(stderr, "could not read zone name\n");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
userzone = dns_fixedname_initname(&fuserzone);
if (result != ISC_R_SUCCESS) {
userzone = NULL; /* Lest it point to an invalid name */
fprintf(stderr, "could not parse zone name\n");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
- return (STATUS_MORE);
+ return STATUS_MORE;
}
static uint16_t
word = nsu_strsep(&cmdline, " \t\r\n");
if (word == NULL || *word == 0) {
- return (STATUS_MORE);
+ return STATUS_MORE;
}
n = snprintf(buf, sizeof(buf), "@%s", word);
if (n < 0 || (size_t)n >= sizeof(buf)) {
error("realm is too long");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
realm = isc_mem_strdup(gmctx, buf);
- return (STATUS_MORE);
+ return STATUS_MORE;
#else /* HAVE_GSSAPI */
UNUSED(cmdline);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
#endif /* HAVE_GSSAPI */
}
word = nsu_strsep(&cmdline, " \t\r\n");
if (word == NULL || *word == 0) {
fprintf(stderr, "could not read ttl\n");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
if (!strcasecmp(word, "none")) {
default_ttl = 0;
default_ttl_set = false;
- return (STATUS_MORE);
+ return STATUS_MORE;
}
result = isc_parse_uint32(&ttl, word, 10);
if (result != ISC_R_SUCCESS) {
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
if (ttl > TTL_MAX) {
fprintf(stderr, "ttl '%s' is out of range (0 to %u)\n", word,
TTL_MAX);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
default_ttl = ttl;
default_ttl_set = true;
- return (STATUS_MORE);
+ return STATUS_MORE;
}
static uint16_t
word = nsu_strsep(&cmdline, " \t\r\n");
if (word == NULL || *word == 0) {
fprintf(stderr, "could not read class name\n");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
r.base = word;
result = dns_rdataclass_fromtext(&rdclass, &r);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "could not parse class name: %s\n", word);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
switch (rdclass) {
case dns_rdataclass_none:
case dns_rdataclass_any:
case dns_rdataclass_reserved0:
fprintf(stderr, "bad default class: %s\n", word);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
default:
defaultclass = rdclass;
}
- return (STATUS_MORE);
+ return STATUS_MORE;
}
static uint16_t
*/
retval = parse_name(&cmdline, updatemsg, &name);
if (retval != STATUS_MORE) {
- return (retval);
+ return retval;
}
result = dns_message_gettemprdata(updatemsg, &rdata);
ISC_LIST_INIT(name->list);
ISC_LIST_APPEND(name->list, rdataset, link);
dns_message_addname(updatemsg, name, DNS_SECTION_UPDATE);
- return (STATUS_MORE);
+ return STATUS_MORE;
failure:
if (name != NULL) {
dns_message_puttempname(updatemsg, &name);
}
dns_message_puttemprdata(updatemsg, &rdata);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
static uint16_t
word = nsu_strsep(&cmdline, " \t\r\n");
if (word == NULL || *word == 0) {
fprintf(stderr, "could not read operation code\n");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
if (strcasecmp(word, "delete") == 0) {
isdelete = true;
isdelete = false;
} else {
fprintf(stderr, "incorrect operation code: %s\n", word);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
- return (update_addordelete(cmdline, isdelete));
+ return update_addordelete(cmdline, isdelete);
}
static uint16_t
word = nsu_strsep(&cmdline, " \t\r\n");
if (word == NULL || *word == 0) {
fprintf(stderr, "could not read check-names directive\n");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
if (strcasecmp(word, "yes") == 0 || strcasecmp(word, "true") == 0 ||
strcasecmp(word, "on") == 0)
checknames = false;
} else {
fprintf(stderr, "incorrect check-names directive: %s\n", word);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
- return (STATUS_MORE);
+ return STATUS_MORE;
}
static void
word = nsu_strsep(&cmdline, " \t\r\n");
if (word == NULL || *word == 0) {
- return (STATUS_SEND);
+ return STATUS_SEND;
}
if (word[0] == ';') {
- return (STATUS_MORE);
+ return STATUS_MORE;
}
if (strcasecmp(word, "quit") == 0) {
- return (STATUS_QUIT);
+ return STATUS_QUIT;
}
if (strcasecmp(word, "prereq") == 0) {
- return (evaluate_prereq(cmdline));
+ return evaluate_prereq(cmdline);
}
if (strcasecmp(word, "nxdomain") == 0) {
- return (make_prereq(cmdline, false, false));
+ return make_prereq(cmdline, false, false);
}
if (strcasecmp(word, "yxdomain") == 0) {
- return (make_prereq(cmdline, true, false));
+ return make_prereq(cmdline, true, false);
}
if (strcasecmp(word, "nxrrset") == 0) {
- return (make_prereq(cmdline, false, true));
+ return make_prereq(cmdline, false, true);
}
if (strcasecmp(word, "yxrrset") == 0) {
- return (make_prereq(cmdline, true, true));
+ return make_prereq(cmdline, true, true);
}
if (strcasecmp(word, "update") == 0) {
- return (evaluate_update(cmdline));
+ return evaluate_update(cmdline);
}
if (strcasecmp(word, "delete") == 0) {
- return (update_addordelete(cmdline, true));
+ return update_addordelete(cmdline, true);
}
if (strcasecmp(word, "del") == 0) {
- return (update_addordelete(cmdline, true));
+ return update_addordelete(cmdline, true);
}
if (strcasecmp(word, "add") == 0) {
- return (update_addordelete(cmdline, false));
+ return update_addordelete(cmdline, false);
}
if (strcasecmp(word, "server") == 0) {
- return (evaluate_server(cmdline));
+ return evaluate_server(cmdline);
}
if (strcasecmp(word, "local") == 0) {
- return (evaluate_local(cmdline));
+ return evaluate_local(cmdline);
}
if (strcasecmp(word, "zone") == 0) {
- return (evaluate_zone(cmdline));
+ return evaluate_zone(cmdline);
}
if (strcasecmp(word, "class") == 0) {
- return (evaluate_class(cmdline));
+ return evaluate_class(cmdline);
}
if (strcasecmp(word, "send") == 0) {
- return (STATUS_SEND);
+ return STATUS_SEND;
}
if (strcasecmp(word, "debug") == 0) {
if (debugging) {
} else {
debugging = true;
}
- return (STATUS_MORE);
+ return STATUS_MORE;
}
if (strcasecmp(word, "ttl") == 0) {
- return (evaluate_ttl(cmdline));
+ return evaluate_ttl(cmdline);
}
if (strcasecmp(word, "show") == 0) {
show_message(stdout, updatemsg, "Outgoing update query:");
- return (STATUS_MORE);
+ return STATUS_MORE;
}
if (strcasecmp(word, "answer") == 0) {
LOCK(&answer_lock);
show_message(stdout, answer, "Answer:");
}
UNLOCK(&answer_lock);
- return (STATUS_MORE);
+ return STATUS_MORE;
}
if (strcasecmp(word, "key") == 0) {
usegsstsig = false;
- return (evaluate_key(cmdline));
+ return evaluate_key(cmdline);
}
if (strcasecmp(word, "realm") == 0) {
- return (evaluate_realm(cmdline));
+ return evaluate_realm(cmdline);
}
if (strcasecmp(word, "check-names") == 0 ||
strcasecmp(word, "checknames") == 0)
{
- return (evaluate_checknames(cmdline));
+ return evaluate_checknames(cmdline);
}
if (strcasecmp(word, "gsstsig") == 0) {
#if HAVE_GSSAPI
#else /* HAVE_GSSAPI */
fprintf(stderr, "gsstsig not supported\n");
#endif /* HAVE_GSSAPI */
- return (STATUS_MORE);
+ return STATUS_MORE;
}
if (strcasecmp(word, "oldgsstsig") == 0) {
#if HAVE_GSSAPI
#else /* HAVE_GSSAPI */
fprintf(stderr, "gsstsig not supported\n");
#endif /* HAVE_GSSAPI */
- return (STATUS_MORE);
+ return STATUS_MORE;
}
if (strcasecmp(word, "help") == 0) {
fprintf(stdout, "nsupdate " PACKAGE_VERSION ":\n"
"record to the zone)\n"
"[update] del[ete] .... (remove the given "
"record(s) from the zone)\n");
- return (STATUS_MORE);
+ return STATUS_MORE;
}
if (strcasecmp(word, "version") == 0) {
fprintf(stdout, "nsupdate " PACKAGE_VERSION "\n");
- return (STATUS_MORE);
+ return STATUS_MORE;
}
fprintf(stderr, "incorrect section name: %s\n", word);
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
static uint16_t
free(ptr);
}
- return (result);
+ return result;
}
static bool
}
}
if (result == STATUS_SEND) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static void
fprintf(stderr, "; Communication with %s failed: %s\n", addrbuf,
isc_result_totext(eresult));
if (++primary_inuse >= primary_total) {
- return (false);
+ return false;
}
ddebug("%s: trying next server", caller);
- return (true);
+ return true;
}
static void
isc_app_finish();
if (seenerror) {
- return (2);
+ return 2;
}
- return (0);
+ return 0;
}
static isc_result_t
parse_filter_a(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
- return (cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret));
+ return cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret);
}
static void
result = cfg_map_get(param_obj, param_name, &obj);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (cfg_obj_isboolean(obj)) {
result = ISC_R_UNEXPECTED;
}
- return (result);
+ return result;
}
static isc_result_t
cfg_map_get(fmap, "filter-a", &aclobj);
if (aclobj == NULL) {
- return (result);
+ return result;
}
CHECK(cfg_acl_fromconfig(aclobj, (const cfg_obj_t *)cfg, lctx,
dns_acl_detach(&acl);
}
- return (result);
+ return result;
}
static isc_result_t
if (parser != NULL) {
cfg_parser_destroy(&parser);
}
- return (result);
+ return result;
}
/**
plugin_destroy((void **)&inst);
}
- return (result);
+ return result;
}
isc_result_t
if (parser != NULL) {
cfg_parser_destroy(&parser);
}
- return (result);
+ return result;
}
/*
*/
int
plugin_version(void) {
- return (NS_PLUGIN_VERSION);
+ return NS_PLUGIN_VERSION;
}
/**
static bool
is_v4_client(ns_client_t *client) {
if (isc_sockaddr_pf(&client->peeraddr) == AF_INET) {
- return (true);
+ return true;
}
if (isc_sockaddr_pf(&client->peeraddr) == AF_INET6 &&
IN6_IS_ADDR_V4MAPPED(&client->peeraddr.type.sin6.sin6_addr))
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
/*
if (isc_sockaddr_pf(&client->peeraddr) == AF_INET6 &&
!IN6_IS_ADDR_V4MAPPED(&client->peeraddr.type.sin6.sin6_addr))
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static filter_data_t *
sizeof(qctx->client), (void **)&client_state);
UNLOCK(&inst->hlock);
- return (result == ISC_R_SUCCESS ? client_state : NULL);
+ return result == ISC_R_SUCCESS ? client_state : NULL;
}
static void
}
cleanup:
- return (modified);
+ return modified;
}
/*%
client_state_create(qctx, inst);
}
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
/*
*resp = ISC_R_UNSET;
if (client_state == NULL) {
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
if (inst->v4_a != NONE || inst->v6_a != NONE) {
}
}
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
/*
*resp = ISC_R_UNSET;
if (client_state == NULL) {
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
if (client_state->mode != BREAK_DNSSEC &&
(WANTDNSSEC(qctx->client) && qctx->sigrdataset != NULL &&
dns_rdataset_isassociated(qctx->sigrdataset))))
{
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
if (qctx->qtype == dns_rdatatype_a) {
*resp = result;
- return (NS_HOOK_RETURN);
+ return NS_HOOK_RETURN;
}
*resp = result;
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
/*
process_section(&filter_answer);
}
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
/*
}
}
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
/*
*resp = ISC_R_UNSET;
if (!qctx->detach_client) {
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
client_state_destroy(qctx, inst);
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
static isc_result_t
parse_filter_aaaa(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
- return (cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret));
+ return cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret);
}
static void
result = cfg_map_get(param_obj, param_name, &obj);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (cfg_obj_isboolean(obj)) {
result = ISC_R_UNEXPECTED;
}
- return (result);
+ return result;
}
static isc_result_t
cfg_map_get(fmap, "filter-aaaa", &aclobj);
if (aclobj == NULL) {
- return (result);
+ return result;
}
CHECK(cfg_acl_fromconfig(aclobj, (const cfg_obj_t *)cfg, lctx,
dns_acl_detach(&acl);
}
- return (result);
+ return result;
}
static isc_result_t
if (parser != NULL) {
cfg_parser_destroy(&parser);
}
- return (result);
+ return result;
}
/**
plugin_destroy((void **)&inst);
}
- return (result);
+ return result;
}
isc_result_t
if (parser != NULL) {
cfg_parser_destroy(&parser);
}
- return (result);
+ return result;
}
/*
*/
int
plugin_version(void) {
- return (NS_PLUGIN_VERSION);
+ return NS_PLUGIN_VERSION;
}
/**
static bool
is_v4_client(ns_client_t *client) {
if (isc_sockaddr_pf(&client->peeraddr) == AF_INET) {
- return (true);
+ return true;
}
if (isc_sockaddr_pf(&client->peeraddr) == AF_INET6 &&
IN6_IS_ADDR_V4MAPPED(&client->peeraddr.type.sin6.sin6_addr))
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
/*
if (isc_sockaddr_pf(&client->peeraddr) == AF_INET6 &&
!IN6_IS_ADDR_V4MAPPED(&client->peeraddr.type.sin6.sin6_addr))
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static filter_data_t *
sizeof(qctx->client), (void **)&client_state);
UNLOCK(&inst->hlock);
- return (result == ISC_R_SUCCESS ? client_state : NULL);
+ return result == ISC_R_SUCCESS ? client_state : NULL;
}
static void
}
cleanup:
- return (modified);
+ return modified;
}
/*%
client_state_create(qctx, inst);
}
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
/*
*resp = ISC_R_UNSET;
if (client_state == NULL) {
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
if (inst->v4_aaaa != NONE || inst->v6_aaaa != NONE) {
}
}
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
/*
*resp = ISC_R_UNSET;
if (client_state == NULL) {
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
if (client_state->mode != BREAK_DNSSEC &&
(WANTDNSSEC(qctx->client) && qctx->sigrdataset != NULL &&
dns_rdataset_isassociated(qctx->sigrdataset))))
{
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
if (qctx->qtype == dns_rdatatype_aaaa) {
*resp = result;
- return (NS_HOOK_RETURN);
+ return NS_HOOK_RETURN;
}
*resp = result;
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
/*
process_section(&filter_answer);
}
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
/*
}
}
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
/*
*resp = ISC_R_UNSET;
if (!qctx->detach_client) {
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
client_state_destroy(qctx, inst);
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
isc_mem_destroy(&rndc_mctx);
if (failed) {
- return (1);
+ return 1;
}
- return (0);
+ return 0;
}
for (i = 0; single[i]; i++) {
if (strcasecmp(single[i], type) == 0) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
/*
}
if (i == MAX_RECORDS) {
logerr("dlz_example: out of record space");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (strlen(name) >= sizeof(list[i].name) ||
strlen(type) >= sizeof(list[i].type) ||
strlen(data) >= sizeof(list[i].data))
{
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
strncpy(list[i].name, name, sizeof(list[i].name) - 1);
list[i].ttl = ttl;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
}
}
if (i == MAX_RECORDS) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
memset(&list[i], 0, sizeof(struct record));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sizeof(addr_buf));
break;
default:
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (ret == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
snprintf(buffer, size, "%s#%u", addr_buf, port);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
int
dlz_version(unsigned int *flags) {
UNUSED(flags);
- return (DLZ_DLOPEN_VERSION);
+ return DLZ_DLOPEN_VERSION;
}
/*
state = calloc(1, sizeof(struct dlz_example_data));
if (state == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
/* Fill in the helper functions */
if (argc < 2 || argv[1][0] == '\0') {
logerr("dlz_example: please specify a zone name");
dlz_destroy(state);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* Ensure zone name is absolute */
state->zone_name = malloc(strlen(argv[1]) + 2);
if (state->zone_name == NULL) {
free(state);
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (argv[1][strlen(argv[1]) - 1] == '.') {
strcpy(state->zone_name, argv[1]);
loginfo("dlz_example: started for zone %s", state->zone_name);
*dbdata = state;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
free(state);
- return (result);
+ return result;
}
/*
* this; it will move onto the next database after a single query.
*/
if (strcasecmp(name, "test.example.com") == 0) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
/*
if (strcasecmp(name, "test.example.net") == 0 &&
strncmp(addrbuf, "10.53.0.1", 9) == 0)
{
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
/*
* zone origin nodes could fail to return SERVFAIL to the client.
*/
if (strcasecmp(name, "bigcname.domain") == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
* zone name and the qname
*/
if (strcasecmp(state->zone_name, name) == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
snprintf(absolute, sizeof(absolute), "%s.", name);
if (strcasecmp(state->zone_name, absolute) == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
UNUSED(zone);
if (state->putrr == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
if (strcmp(name, "@") == 0) {
if (size < 0 || (size_t)size >= sizeof(full_name) ||
(size_t)size >= sizeof(last))
{
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/*
found = true;
result = state->putrr(lookup, "TXT", 0, buf);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
found = true;
result = state->putrr(lookup, "TXT", 0, buf);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
result = state->putrr(lookup, "A", 0, "100.100.100.2");
found = true;
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
result = state->putrr(lookup, "A", 0, "100.100.100.3");
found = true;
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
state->current[i].ttl,
state->current[i].data);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
}
if (!found) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (result != ISC_R_SUCCESS) {
loginfo("dlz_example: findzonedb returned %s",
isc_result_totext(result));
- return (result);
+ return result;
}
/*
*/
if (strcmp(name, "example.org") == 0) {
loginfo("dlz_example: use view ACL for example.org");
- return (ISC_R_DEFAULT);
+ return ISC_R_DEFAULT;
}
/*
*/
if (strcmp(client, "10.53.0.5") == 0) {
loginfo("dlz_example: disallow transfer to 10.53.0.5");
- return (ISC_R_NOPERM);
+ return ISC_R_NOPERM;
}
loginfo("dlz_example: transfer allowed for %s", name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
UNUSED(zone);
if (state->putnamedrr == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
for (i = 0; i < MAX_RECORDS; i++) {
state->current[i].ttl,
state->current[i].data);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (state->transaction_started) {
loginfo("dlz_example: transaction already started for zone %s",
zone);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
state->transaction_started = true;
*versionp = (void *)&state->transaction_started;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (state->writeable_zone == NULL) {
loginfo("dlz_example: no writeable_zone method available");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
result = state->writeable_zone(view, dlzdb, state->zone_name);
if (result != ISC_R_SUCCESS) {
loginfo("dlz_example: failed to configure zone %s",
state->zone_name);
- return (result);
+ return result;
}
loginfo("dlz_example: configured writeable zone %s", state->zone_name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (strncmp(name, "deny.", 5) == 0) {
loginfo("dlz_example: denying update of name=%s by %s", name,
signer);
- return (false);
+ return false;
}
loginfo("dlz_example: allowing update of name=%s by %s", name, signer);
- return (true);
+ return true;
}
static isc_result_t
buf = strdup(rdatastr);
if (buf == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
result = add_name(state, list, name, type, strtoul(ttlstr, NULL, 10),
data);
free(buf);
- return (result);
+ return result;
error:
free(buf);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
isc_result_t
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (version != (void *)&state->transaction_started) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
loginfo("dlz_example: adding rdataset %s '%s'", name, rdatastr);
- return (modrdataset(state, name, rdatastr, &state->adds[0]));
+ return modrdataset(state, name, rdatastr, &state->adds[0]);
}
isc_result_t
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (version != (void *)&state->transaction_started) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
loginfo("dlz_example: subtracting rdataset %s '%s'", name, rdatastr);
- return (modrdataset(state, name, rdatastr, &state->deletes[0]));
+ return modrdataset(state, name, rdatastr, &state->deletes[0]);
}
isc_result_t
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (version != (void *)&state->transaction_started) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
loginfo("dlz_example: deleting rdataset %s of type %s", name, type);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sample_name_fromnode(dns_dbnode_t *node, dns_name_t *name) {
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
- return (dns_rbt_fullnamefromnode(rbtnode, name));
+ return dns_rbt_fullnamefromnode(rbtnode, name);
}
static void
FATAL_ERROR("current implementation should never call beginload()");
/* Not reached */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
FATAL_ERROR("current implementation should never call endload()");
/* Not reached */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
FATAL_ERROR("current implementation should never call dump()");
/* Not reached */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_newversion(sampledb->rbtdb, versionp));
+ return dns_db_newversion(sampledb->rbtdb, versionp);
}
static void
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_findnode(sampledb->rbtdb, name, create, nodep));
+ return dns_db_findnode(sampledb->rbtdb, name, create, nodep);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_find(sampledb->rbtdb, name, version, type, options, now,
- nodep, foundname, rdataset, sigrdataset));
+ return dns_db_find(sampledb->rbtdb, name, version, type, options, now,
+ nodep, foundname, rdataset, sigrdataset);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_findzonecut(sampledb->rbtdb, name, options, now, nodep,
- foundname, dcname, rdataset, sigrdataset));
+ return dns_db_findzonecut(sampledb->rbtdb, name, options, now, nodep,
+ foundname, dcname, rdataset, sigrdataset);
}
static void
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_expirenode(sampledb->rbtdb, node, now));
+ return dns_db_expirenode(sampledb->rbtdb, node, now);
}
static void
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_createiterator(sampledb->rbtdb, options, iteratorp));
+ return dns_db_createiterator(sampledb->rbtdb, options, iteratorp);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_findrdataset(sampledb->rbtdb, node, version, type,
- covers, now, rdataset, sigrdataset));
+ return dns_db_findrdataset(sampledb->rbtdb, node, version, type, covers,
+ now, rdataset, sigrdataset);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_allrdatasets(sampledb->rbtdb, node, version, options,
- now, iteratorp));
+ return dns_db_allrdatasets(sampledb->rbtdb, node, version, options, now,
+ iteratorp);
}
static isc_result_t
}
cleanup:
- return (result);
+ return result;
}
static isc_result_t
}
cleanup:
- return (result);
+ return result;
}
/*
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_deleterdataset(sampledb->rbtdb, node, version, type,
- covers));
+ return dns_db_deleterdataset(sampledb->rbtdb, node, version, type,
+ covers);
}
static bool
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_issecure(sampledb->rbtdb));
+ return dns_db_issecure(sampledb->rbtdb);
}
static unsigned int
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_nodecount(sampledb->rbtdb, tree));
+ return dns_db_nodecount(sampledb->rbtdb, tree);
}
/*
ispersistent(dns_db_t *db) {
UNUSED(db);
- return (true);
+ return true;
}
static void
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_getoriginnode(sampledb->rbtdb, nodep));
+ return dns_db_getoriginnode(sampledb->rbtdb, nodep);
}
static void
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_getnsec3parameters(sampledb->rbtdb, version, hash, flags,
- iterations, salt, salt_length));
+ return dns_db_getnsec3parameters(sampledb->rbtdb, version, hash, flags,
+ iterations, salt, salt_length);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_findnsec3node(sampledb->rbtdb, name, create, nodep));
+ return dns_db_findnsec3node(sampledb->rbtdb, name, create, nodep);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_setsigningtime(sampledb->rbtdb, rdataset, resign));
+ return dns_db_setsigningtime(sampledb->rbtdb, rdataset, resign);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_getsigningtime(sampledb->rbtdb, rdataset, name));
+ return dns_db_getsigningtime(sampledb->rbtdb, rdataset, name);
}
static void
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_isdnssec(sampledb->rbtdb));
+ return dns_db_isdnssec(sampledb->rbtdb);
}
static dns_stats_t *
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_getrrsetstats(sampledb->rbtdb));
+ return dns_db_getrrsetstats(sampledb->rbtdb);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_findnodeext(sampledb->rbtdb, name, create, methods,
- clientinfo, nodep));
+ return dns_db_findnodeext(sampledb->rbtdb, name, create, methods,
+ clientinfo, nodep);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_findext(sampledb->rbtdb, name, version, type, options,
- now, nodep, foundname, methods, clientinfo,
- rdataset, sigrdataset));
+ return dns_db_findext(sampledb->rbtdb, name, version, type, options,
+ now, nodep, foundname, methods, clientinfo,
+ rdataset, sigrdataset);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_setcachestats(sampledb->rbtdb, stats));
+ return dns_db_setcachestats(sampledb->rbtdb, stats);
}
static size_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_hashsize(sampledb->rbtdb));
+ return dns_db_hashsize(sampledb->rbtdb);
}
/*
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
static isc_result_t
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
static isc_result_t
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
/*
*dbp = (dns_db_t *)sampledb;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (sampledb != NULL) {
sizeof(*sampledb));
}
- return (result);
+ return result;
}
isc_mem_put(mctx, argv, argc * sizeof(*argv));
}
- return (result);
+ return result;
}
/*
dyndb_version(unsigned int *flags) {
UNUSED(flags);
- return (DNS_DYNDB_VERSION);
+ return DNS_DYNDB_VERSION;
}
result = ISC_R_SUCCESS;
cleanup:
- return (result);
+ return result;
}
/*
if (result != ISC_R_SUCCESS) {
destroy_sample_instance(&inst);
}
- return (result);
+ return result;
}
/*
}
cleanup:
- return (result);
+ return result;
}
void
dns_rdata_freestruct(&ipv6);
}
- return (result);
+ return result;
}
/*
isc_event_free((isc_event_t **)&pevent);
}
- return (result);
+ return result;
}
/*
}
cleanup:
- return (result);
+ return result;
}
dns_acl_detach(&acl_any);
*rawp = raw;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_name_format(name, zone_name, DNS_NAME_FORMATSIZE);
dns_acl_detach(&acl_any);
}
- return (result);
+ return result;
}
/*
}
run_exclusive_exit(inst, lock_state);
- return (result);
+ return result;
}
/*
}
cleanup:
- return (result);
+ return result;
}
/*
}
cleanup:
- return (result);
+ return result;
}
main(int argc, char **argv) {
if (argc != 2) {
usage();
- return (1);
+ return 1;
}
if (strcmp(argv[1], "--edns-version") == 0) {
#else /* ifdef DNS_EDNS_VERSION */
printf("0\n");
#endif /* ifdef DNS_EDNS_VERSION */
- return (0);
+ return 0;
}
if (strcmp(argv[1], "--enable-dnsrps") == 0) {
#ifdef USE_DNSRPS
- return (0);
+ return 0;
#else /* ifdef USE_DNSRPS */
- return (1);
+ return 1;
#endif /* ifdef USE_DNSRPS */
}
if (strcmp(argv[1], "--enable-dnstap") == 0) {
#ifdef HAVE_DNSTAP
- return (0);
+ return 0;
#else /* ifdef HAVE_DNSTAP */
- return (1);
+ return 1;
#endif /* ifdef HAVE_DNSTAP */
}
if (strcmp(argv[1], "--enable-querytrace") == 0) {
#ifdef WANT_QUERYTRACE
- return (0);
+ return 0;
#else /* ifdef WANT_QUERYTRACE */
- return (1);
+ return 1;
#endif /* ifdef WANT_QUERYTRACE */
}
n = gethostname(hostname, sizeof(hostname));
if (n == -1) {
perror("gethostname");
- return (1);
+ return 1;
}
fprintf(stdout, "%s\n", hostname);
- return (0);
+ return 0;
}
if (strcmp(argv[1], "--gssapi") == 0) {
#if HAVE_GSSAPI
- return (0);
+ return 0;
#else /* HAVE_GSSAPI */
- return (1);
+ return 1;
#endif /* HAVE_GSSAPI */
}
if (strcmp(argv[1], "--have-geoip2") == 0) {
#ifdef HAVE_GEOIP2
- return (0);
+ return 0;
#else /* ifdef HAVE_GEOIP2 */
- return (1);
+ return 1;
#endif /* ifdef HAVE_GEOIP2 */
}
if (strcmp(argv[1], "--have-json-c") == 0) {
#ifdef HAVE_JSON_C
- return (0);
+ return 0;
#else /* ifdef HAVE_JSON_C */
- return (1);
+ return 1;
#endif /* ifdef HAVE_JSON_C */
}
if (strcmp(argv[1], "--have-libxml2") == 0) {
#ifdef HAVE_LIBXML2
- return (0);
+ return 0;
#else /* ifdef HAVE_LIBXML2 */
- return (1);
+ return 1;
#endif /* ifdef HAVE_LIBXML2 */
}
if (strcmp(argv[1], "--tsan") == 0) {
#if defined(__has_feature)
#if __has_feature(thread_sanitizer)
- return (0);
+ return 0;
#endif
#endif
#if __SANITIZE_THREAD__
- return (0);
+ return 0;
#else
- return (1);
+ return 1;
#endif
}
if (isc_md(ISC_MD_MD5, test, sizeof(test), digest, &size) ==
ISC_R_SUCCESS)
{
- return (0);
+ return 0;
} else {
- return (1);
+ return 1;
}
}
(void *)&v6only, &len);
close(s);
}
- return ((n == 0 && v6only == 0) ? 0 : 1);
+ return (n == 0 && v6only == 0) ? 0 : 1;
#else /* defined(IPPROTO_IPV6) && defined(IPV6_V6ONLY) */
- return (1);
+ return 1;
#endif /* defined(IPPROTO_IPV6) && defined(IPV6_V6ONLY) */
}
if (strcmp(argv[1], "--with-dlz-filesystem") == 0) {
#ifdef DLZ_FILESYSTEM
- return (0);
+ return 0;
#else /* ifdef DLZ_FILESYSTEM */
- return (1);
+ return 1;
#endif /* ifdef DLZ_FILESYSTEM */
}
if (strcmp(argv[1], "--with-libidn2") == 0) {
#ifdef HAVE_LIBIDN2
- return (0);
+ return 0;
#else /* ifdef HAVE_LIBIDN2 */
- return (1);
+ return 1;
#endif /* ifdef HAVE_LIBIDN2 */
}
if (strcmp(argv[1], "--with-lmdb") == 0) {
#ifdef HAVE_LMDB
- return (0);
+ return 0;
#else /* ifdef HAVE_LMDB */
- return (1);
+ return 1;
#endif /* ifdef HAVE_LMDB */
}
if (strcmp(argv[1], "--with-libnghttp2") == 0) {
#ifdef HAVE_LIBNGHTTP2
- return (0);
+ return 0;
#else /* ifdef HAVE_LIBNGHTTP2 */
- return (1);
+ return 1;
#endif /* ifdef HAVE_LIBNGHTTP2 */
}
if (strcmp(argv[1], "--with-zlib") == 0) {
#ifdef HAVE_ZLIB
- return (0);
+ return 0;
#else /* ifdef HAVE_ZLIB */
- return (1);
+ return 1;
#endif /* ifdef HAVE_ZLIB */
}
fprintf(stderr, "unknown arg: %s\n", argv[1]);
usage();
- return (1);
+ return 1;
}
*instp = inst;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
UNUSED(lctx);
UNUSED(actx);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
*/
int
plugin_version(void) {
- return (NS_PLUGIN_VERSION);
+ return NS_PLUGIN_VERSION;
}
static state_t *
sizeof(qctx->client), (void **)&state);
UNLOCK(&inst->hlock);
- return (result == ISC_R_SUCCESS ? state : NULL);
+ return result == ISC_R_SUCCESS ? state : NULL;
}
static void
client_state_create(qctx, inst);
}
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
static void
isc_task_send(task, (isc_event_t **)&rev);
*ctxp = ctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static ns_hookresult_t
if (state->async) {
/* resuming */
state->async = false;
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
/* initial call */
state->hookpoint = NS_QUERY_DONE_BEGIN;
state->origresult = *resp;
ns_query_hookasync(qctx, doasync, state);
- return (NS_HOOK_RETURN);
+ return NS_HOOK_RETURN;
}
static ns_hookresult_t
*resp = ISC_R_UNSET;
if (!qctx->detach_client) {
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
client_state_destroy(qctx, inst);
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
result = dns_name_fromstring(name, origin, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_create(mctx, "rbt", name, dns_dbtype_zone,
dns_rdataclass_in, 0, NULL, db);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_load(*db, filename, dns_masterformat_text, 0);
- return (result);
+ return result;
}
int
if (argc != 5) {
printf("usage: %s origin file1 file2 journal\n", argv[0]);
- return (1);
+ return 1;
}
origin = argv[1];
isc_mem_destroy(&mctx);
}
- return (result != ISC_R_SUCCESS ? 1 : 0);
+ return result != ISC_R_SUCCESS ? 1 : 0;
}
c = scanf("%255s", host);
if (c == EOF) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
onfly++;
task, recvresponse, message, &request);
CHECK("dns_request_create", result);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
isc_app_finish();
- return (0);
+ return 0;
}
goto fail;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
fail:
ctxs_destroy();
- return (result);
+ return result;
}
static char *algname = NULL;
if (!dns_rdataset_isassociated(rdataset)) {
printf("[WARN: empty]\n");
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_buffer_init(&target, t, sizeof(t));
result = dns_rdataset_totext(rdataset, owner, false, false, &target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_usedregion(&target, &r);
printf("%.*s", (int)r.length, (char *)r.base);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
noreturn static void
ctxs_destroy();
dst_lib_destroy();
- return (0);
+ return 0;
}
continue;
}
if (buf[i] != chars[*start]) {
- return (0);
+ return 0;
}
}
- return (1);
+ return 1;
}
int
close(fd);
}
- return (ret);
+ return ret;
}
case 'a':
if (!link_dnsrps(&emsg)) {
printf("I:%s\n", emsg.c);
- return (1);
+ return 1;
}
- return (0);
+ return 0;
case 'p':
if (!link_dnsrps(&emsg)) {
fprintf(stderr, "## %s\n", emsg.c);
- return (1);
+ return 1;
}
#ifdef USE_DNSRPS
printf("%s\n", librpz->dnsrpzd_path);
#else /* ifdef USE_DNSRPS */
UNREACHABLE();
#endif /* ifdef USE_DNSRPS */
- return (0);
+ return 0;
case 'n':
if (!link_dnsrps(&emsg)) {
fprintf(stderr, "## %s\n", emsg.c);
- return (1);
+ return 1;
}
#ifdef USE_DNSRPS
/*
NULL, NULL);
if (clist == NULL) {
fprintf(stderr, "## %s: %s\n", optarg, emsg.c);
- return (1);
+ return 1;
}
snprintf(cstr, sizeof(cstr),
"zone %s; dnsrpzd \"\";"
true);
if (client == NULL) {
fprintf(stderr, "## %s\n", emsg.c);
- return (1);
+ return 1;
}
rsp = NULL;
{
fprintf(stderr, "## %s\n", emsg.c);
librpz->client_detach(&client);
- return (1);
+ return 1;
}
if (!librpz->soa_serial(&emsg, &serial, optarg, rsp)) {
fprintf(stderr, "## %s\n", emsg.c);
librpz->client_detach(&client);
- return (1);
+ return 1;
}
librpz->rsp_detach(&rsp);
librpz->client_detach(&client);
#else /* ifdef USE_DNSRPS */
UNREACHABLE();
#endif /* ifdef USE_DNSRPS */
- return (0);
+ return 0;
case 'w':
seconds = strtod(optarg, &p);
if (seconds <= 0 || *p != '\0') {
fprintf(stderr, USAGE);
- return (1);
+ return 1;
}
usleep((int)(seconds * 1000.0 * 1000.0));
- return (0);
+ return 0;
default:
fprintf(stderr, USAGE);
- return (1);
+ return 1;
}
}
fprintf(stderr, USAGE);
- return (1);
+ return 1;
}
static bool
#ifdef USE_DNSRPS
librpz = librpz_lib_open(emsg, NULL, DNSRPS_LIBRPZ_PATH);
if (librpz == NULL) {
- return (false);
+ return false;
}
- return (true);
+ return true;
#else /* ifdef USE_DNSRPS */
snprintf(emsg->c, sizeof(emsg->c), "DNSRPS not configured");
- return (false);
+ return false;
#endif /* ifdef USE_DNSRPS */
}
dns_log_setcontext(NULL);
dst_lib_destroy();
isc_mem_destroy(&mctx);
- return (0);
+ return 0;
}
/*! \file */
isc_app_finish();
- return (0);
+ return 0;
}
isc_app_finish();
- return (0);
+ return 0;
}
long val = strtol(input, &endptr, 10);
if ((*endptr != '\0') || (val <= 0) || (val >= 65536)) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
port = input;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
for (size_t i = 0; i < ARRAY_SIZE(protocols); i++) {
if (!strcasecmp(input, protocols[i])) {
protocol = i;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
static isc_result_t
if (inet_pton(AF_INET6, input, &in6) == 1) {
family = AF_INET6;
address = input;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (inet_pton(AF_INET, input, &in) == 1) {
family = AF_INET;
address = input;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_BADADDRESSFORM);
+ return ISC_R_BADADDRESSFORM;
}
static int
long val = strtol(input, &endptr, 10);
if ((*endptr != '\0') || (val <= 0) || (val >= 128)) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
workers = val;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
long val = strtol(input, &endptr, 10);
if ((*endptr != '\0') || (val <= 0) || (val >= 120)) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
timeout = (in_port_t)val * 1000;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
close(in);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
}
RUNTIME_CHECK(out >= 0);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
teardown();
- return (EXIT_SUCCESS);
+ return EXIT_SUCCESS;
}
long val = strtol(input, &endptr, 10);
if ((*endptr != '\0') || (val <= 0) || (val >= 65536)) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
port = (in_port_t)val;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
for (size_t i = 0; i < ARRAY_SIZE(protocols); i++) {
if (!strcasecmp(input, protocols[i])) {
protocol = i;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
static isc_result_t
if (inet_pton(AF_INET6, input, &in6) == 1) {
isc_netaddr_fromin6(&netaddr, &in6);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (inet_pton(AF_INET, input, &in) == 1) {
isc_netaddr_fromin(&netaddr, &in);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_BADADDRESSFORM);
+ return ISC_R_BADADDRESSFORM;
}
static int
long val = strtol(input, &endptr, 10);
if ((*endptr != '\0') || (val <= 0) || (val >= 128)) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
workers = val;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
REQUIRE(eresult == ISC_R_SUCCESS);
UNUSED(cbarg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
teardown();
- return (EXIT_SUCCESS);
+ return EXIT_SUCCESS;
}
static int
fromhex(char c) {
if (c >= '0' && c <= '9') {
- return (c - '0');
+ return c - '0';
} else if (c >= 'a' && c <= 'f') {
- return (c - 'a' + 10);
+ return c - 'a' + 10;
} else if (c >= 'A' && c <= 'F') {
- return (c - 'A' + 10);
+ return c - 'A' + 10;
}
fprintf(stderr, "bad input format: %02x\n", c);
isc_mem_put(mctx, buf, len);
}
- return (result);
+ return result;
}
int
}
isc_mem_destroy(&mctx);
- return (0);
+ return 0;
}
static void
argv++;
continue;
}
- return (1);
+ return 1;
}
fflush(stdout);
- return (ferror(stdout));
+ return ferror(stdout);
}
} else {
totext.consttext = rcodetext[rcode];
}
- return (totext.deconsttext);
+ return totext.deconsttext;
}
/* receive response event handler */
query->udpretries, task, recvresponse, message, &request);
CHECK("dns_request_create", result);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
if (result != ISC_R_SUCCESS) {
printf("invalid %s '%s': %s\n", desc, value,
isc_result_totext(result));
- return (result);
+ return result;
}
*uip = n;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
parse_uint(uint32_t *uip, const char *value, uint32_t max, const char *desc) {
- return (parse_uint_helper(uip, value, max, desc, 10));
+ return parse_uint_helper(uip, value, max, desc, 10);
}
static isc_result_t
parse_xint(uint32_t *uip, const char *value, uint32_t max, const char *desc) {
- return (parse_uint_helper(uip, value, max, desc, 0));
+ return parse_uint_helper(uip, value, max, desc, 0);
}
static void
sa->length = netmask;
*sap = sa;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
static isc_result_t
append(const char *text, int len, char **p, char *end) {
if (len > end - *p) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(*p, text, len);
*p += len;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
} else {
len = strlen(in);
}
- return (append(in, len, p, end));
+ return append(in, len, p, end);
}
static void
} else {
fatal("can't find IPv4 networking");
UNREACHABLE();
- return (false);
+ return false;
}
break;
case '6':
} else {
fatal("can't find IPv6 networking");
UNREACHABLE();
- return (false);
+ return false;
}
break;
case 'h':
if (strlen(option) > 1U) {
option = &option[1];
} else {
- return (false);
+ return false;
}
}
opt = option[0];
*hash = '#';
}
have_src = true;
- return (value_from_next);
+ return value_from_next;
case 'c':
tr.base = value;
tr.length = strlen(value);
(isc_textregion_t *)&tr);
CHECK("dns_rdataclass_fromtext", result);
query->rdclass = rdclass;
- return (value_from_next);
+ return value_from_next;
case 'f':
batchname = value;
- return (value_from_next);
+ return value_from_next;
case 'p':
GLOBAL();
result = parse_uint(&num, value, MAXPORT, "port number");
CHECK("parse_uint(port)", result);
port = num;
- return (value_from_next);
+ return value_from_next;
case 't':
tr.base = value;
tr.length = strlen(value);
(isc_textregion_t *)&tr);
CHECK("dns_rdatatype_fromtext", result);
query->rdtype = rdtype;
- return (value_from_next);
+ return value_from_next;
case 'x':
get_reverse(textname, sizeof(textname), value);
strlcpy(query->textname, textname, sizeof(query->textname));
query->rdtype = dns_rdatatype_ptr;
query->rdclass = dns_rdataclass_in;
*setname = true;
- return (value_from_next);
+ return value_from_next;
global_option:
fprintf(stderr, "Ignored late global option: -%s\n", option);
usage();
usage();
}
UNREACHABLE();
- return (false);
+ return false;
}
static struct query *
query->timeout = tcp_mode ? TCPTIMEOUT : UDPTIMEOUT;
}
- return (query);
+ return query;
}
/*%
isc_app_finish();
- return (0);
+ return 0;
}
ISC_R_SUCCESS);
*logp = log;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
int
}
isc_log_destroy(&lctx);
isc_mem_detach(&mctx);
- return (result != ISC_R_SUCCESS ? 1 : 0);
+ return result != ISC_R_SUCCESS ? 1 : 0;
}
mdb_txn_abort(txn);
mdb_env_close(env);
- return (0);
+ return 0;
}
}
cleanup();
- return (0);
+ return 0;
}
nsec3hash(nsec3hash_print, argv[1], NULL, argv[2], argv[0],
argv[3]);
}
- return (0);
+ return 0;
}
for (i = 0; single[i]; i++) {
if (strcasecmp(single[i], type) == 0) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
/*
state->log(ISC_LOG_ERROR, "dlz_example: out of record "
"space");
}
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (strlen(name) >= sizeof(list[i].name) ||
strlen(type) >= sizeof(list[i].type) ||
strlen(data) >= sizeof(list[i].data))
{
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
strncpy(list[i].name, name, sizeof(list[i].name));
list[i].ttl = ttl;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
}
}
if (i == MAX_RECORDS) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
memset(&list[i], 0, sizeof(struct record));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sizeof(addr_buf));
break;
default:
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (ret == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
snprintf(buffer, size, "%s#%u", addr_buf, port);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
int
dlz_version(unsigned int *flags) {
UNUSED(flags);
- return (DLZ_DLOPEN_VERSION);
+ return DLZ_DLOPEN_VERSION;
}
/*
state = calloc(1, sizeof(struct dlz_example_data));
if (state == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
/* Fill in the helper functions */
"a zone name");
}
dlz_destroy(state);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* Ensure zone name is absolute */
state->zone_name = malloc(strlen(argv[1]) + 2);
if (state->zone_name == NULL) {
free(state);
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (argv[1][strlen(argv[1]) - 1] == '.') {
strcpy(state->zone_name, argv[1]);
}
*dbdata = state;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
free(state);
- return (result);
+ return result;
}
/*
* this; it will move onto the next database after a single query.
*/
if (strcasecmp(name, "test.example.com") == 0) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
/*
if (strcasecmp(name, "test.example.net") == 0 &&
strncmp(addrbuf, "10.53.0.1", 9) == 0)
{
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
if (strcasecmp(state->zone_name, name) == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
snprintf(absolute, sizeof(absolute), "%s.", name);
if (strcasecmp(state->zone_name, absolute) == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
UNUSED(zone);
if (state->putrr == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
if (strcmp(name, "@") == 0) {
snprintf(buf, sizeof(buf), "%s.redirect.example.", ecsbuf);
result = state->putrr(lookup, "CNAME", 0, buf); */
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
found = true;
result = state->putrr(lookup, "TXT", 0, buf);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
state->current[i].ttl,
state->current[i].data);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
}
if (!found) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
UNUSED(client);
/* Just say yes for all our zones */
- return (dlz_findzonedb(dbdata, name, NULL, NULL));
+ return dlz_findzonedb(dbdata, name, NULL, NULL);
}
/*
UNUSED(zone);
if (state->putnamedrr == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
for (i = 0; i < MAX_RECORDS; i++) {
state->current[i].ttl,
state->current[i].data);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
"started for zone %s",
zone);
}
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
state->transaction_started = true;
*versionp = (void *)&state->transaction_started;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
"writeable_zone method "
"available");
}
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
result = state->writeable_zone(view, dlzdb, state->zone_name);
"configure zone %s",
state->zone_name);
}
- return (result);
+ return result;
}
if (state->log != NULL) {
"zone %s",
state->zone_name);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
"of name=%s by %s",
name, signer);
}
- return (false);
+ return false;
}
if (state->log != NULL) {
state->log(ISC_LOG_INFO,
"name=%s by %s",
name, signer);
}
- return (true);
+ return true;
}
static isc_result_t
buf = strdup(rdatastr);
if (buf == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
result = add_name(state, list, name, type, strtoul(ttlstr, NULL, 10),
data);
free(buf);
- return (result);
+ return result;
error:
free(buf);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
isc_result_t
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (version != (void *)&state->transaction_started) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (state->log != NULL) {
name, rdatastr);
}
- return (modrdataset(state, name, rdatastr, &state->adds[0]));
+ return modrdataset(state, name, rdatastr, &state->adds[0]);
}
isc_result_t
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (version != (void *)&state->transaction_started) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (state->log != NULL) {
name, rdatastr);
}
- return (modrdataset(state, name, rdatastr, &state->deletes[0]));
+ return modrdataset(state, name, rdatastr, &state->deletes[0]);
}
isc_result_t
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
if (version != (void *)&state->transaction_started) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (state->log != NULL) {
name, type);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
char *p1, *p2;
if (!str || !*str) {
- return (str);
+ return str;
}
for (p1 = str, p2 = str + strlen(str) - 1; p2 > p1; ++p1, --p2) {
*p1 ^= *p2;
*p2 ^= *p1;
*p1 ^= *p2;
}
- return (str);
+ return str;
}
/*%
tmp = strchr(tmp, ' ');
/* verify we found a space */
if (tmp == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* make sure it is safe to increment pointer */
if (++tmp > lastchar) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* save pointer to host */
tmp = strchr(tmp, ' ');
/* verify we found a space */
if (tmp == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* change the space to a null (string terminator) */
tmp[0] = '\0';
/* make sure it is safe to increment pointer */
if (++tmp > lastchar) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* save pointer to ttl string */
tmp = strchr(tmp, ' ');
/* verify we found a space */
if (tmp == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* change the space to a null (string terminator) */
tmp[0] = '\0';
/* make sure it is safe to increment pointer */
if (++tmp > lastchar) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* save pointer to dns type */
tmp = strchr(tmp, ' ');
/* verify we found a space */
if (tmp == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* change the space to a null (string terminator) */
tmp[0] = '\0';
/* make sure it is safe to increment pointer */
if (++tmp > lastchar) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* save pointer to remainder of DNS data */
if (*endp != '\0' || pd->ttl < 0) {
log(ISC_LOG_ERROR, "bdbhpt_dynamic: "
"ttl must be a positive number");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* if we get this far everything should have worked. */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
result = dlz_findzonedb(dbdata, name);
#endif /* if DLZ_DLOPEN_VERSION >= 3 */
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
memset(&key, 0, sizeof(DBT));
free(data.data);
}
- return (result);
+ return result;
}
/*%
xfr_key.data = tmp_zone = strdup(zone);
if (xfr_key.data == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
xfr_key.size = strlen(xfr_key.data);
dns_cursor->c_close(dns_cursor);
}
- return (result);
+ return result;
}
/*%
key.data = strdup(name);
if (key.data == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
/*
free(data.data);
}
- return (result);
+ return result;
}
/*
key.data = keyStr = malloc((key.size + 1) * sizeof(char));
if (keyStr == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
strcpy(keyStr, zone);
free(tmp);
}
- return (result);
+ return result;
}
/*%
"bdbhpt_dynamic: could not initialize %s database. "
"BerkeleyDB error: %s",
db_name, db_strerror(result));
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* set database flags. */
"bdbhpt_dynamic: could not set flags for %s database. "
"BerkeleyDB error: %s",
db_name, db_strerror(result));
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* open the database. */
"bdbhpt_dynamic: could not open %s database in %s. "
"BerkeleyDB error: %s",
db_name, db_file, db_strerror(result));
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
/* Allocate memory for our db structures and helper functions */
db = calloc(1, sizeof(struct bdbhpt_instance));
if (db == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
/* Fill in the helper functions */
"bdbhpt_dynamic: please supply 3 command line args. "
"You supplied: %s",
argc);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
switch ((char)*argv[1]) {
"operating mode must be set to P or C or T. "
"You specified '%s'",
argv[1]);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
db->log(ISC_LOG_INFO, "bdbhpt_dynamic: version %s, started",
dlz_bdbhpt_dynamic_version);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
init_cleanup:
bdbhpt_cleanup(db);
- return (result);
+ return result;
}
/*
int
dlz_version(unsigned int *flags) {
UNUSED(flags);
- return (DLZ_DLOPEN_VERSION);
+ return DLZ_DLOPEN_VERSION;
}
/*
if (query_str == NULL || strlen(query_str) < 1) {
if ((flags & REQUIRE_QUERY) == 0) {
/* we don't need it were ok. */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
/* we did need it, PROBLEM!!! */
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
tql = calloc(1, sizeof(query_list_t));
/* couldn't allocate memory. Problem!! */
if (tql == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
/* initialize the query segment list */
*querylist = (query_list_t *)tql;
/* return success */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
/* get rid of temp_str */
flag_fail:
/* get rid of what was build of the query list */
destroy_querylist(&tql);
- return (result);
+ return result;
}
/*%
qs = malloc(length + 1);
if (qs == NULL) {
- return (NULL);
+ return NULL;
}
*qs = '\0';
tseg = DLZ_LIST_NEXT(tseg, link);
}
- return (qs);
+ return qs;
}
/*% constructs a dbinstance (DBI) */
log(ISC_LOG_ERROR, "Could not allocate memory for "
"database instance object.");
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
memset(db, 0, sizeof(dbinstance_t));
db->dbconn = NULL;
*dbi = (dbinstance_t *)db;
/* return success */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
/* destroy whatever was build of the db instance */
destroy_dbinstance(db);
/* return failure */
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
void
int i;
if (key == NULL || input == NULL || *input == '\0') {
- return (NULL);
+ return NULL;
}
keylen = strlen(key);
if (keylen < 1) {
- return (NULL);
+ return NULL;
}
keystart = strstr(input, key);
if (keystart == NULL) {
- return (NULL);
+ return NULL;
}
for (i = 0; i < 255; i++) {
}
}
- return (strdup(value));
+ return strdup(value);
}
isc_result_t result = ISC_R_SUCCESS;
if (strlen(dirname) + 3 > sizeof(dir->dirname)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
strcpy(dir->dirname, dirname);
}
}
- return (result);
+ return result;
}
/*!
entry = readdir(dir->handle);
if (entry == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
if (sizeof(dir->entry.name) <= strlen(entry->d_name)) {
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
strcpy(dir->entry.name, entry->d_name);
dir->entry.length = strlen(entry->d_name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*!
dir_reset(dir_t *dir) {
rewinddir(dir->handle);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (input[i] == '.') {
/* '.' is not allowed as first char */
if (i == 0) {
- return (false);
+ return false;
}
/* '..', two dots together is not allowed. */
if (input[i - 1] == '.') {
- return (false);
+ return false;
}
/* '.' is not allowed as last char */
if (i == len - 1) {
- return (false);
+ return false;
}
/* only 1 dot in ok location, continue at next char */
continue;
* if we reach this point we have encountered a
* disallowed char!
*/
- return (false);
+ return false;
}
/* everything ok. */
- return (true);
+ return true;
}
static isc_result_t
tmpString = strdup(in);
if (tmpString == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
/*
}
free(tmpString);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
/* if the requested zone is "unsafe", return error */
if (!isroot && !is_safe(zone)) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* if host was passed, verify that it is safe */
if (host != NULL && !is_safe(host)) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* if client was passed, verify that it is safe */
if (client != NULL && !is_safe(client)) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* Determine how much memory the split up string will require */
free(tmpPath);
}
- return (result);
+ return result;
}
static isc_result_t
if (dir_list != NULL) {
direntry = malloc(sizeof(dir_entry_t));
if (direntry == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
strcpy(direntry->dirpath, tmp);
DLZ_LINK_INIT(direntry, link);
"Filesystem driver: "
"%s could not be parsed properly",
tmp);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* replace separator char with NULL to split string */
"Filesystem driver: "
"%s could not be parsed properly",
tmp);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* replace separator char with NULL to split string */
/* if error, return error right away */
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
} /* end of while loop */
- return (result);
+ return result;
}
/*
cd = (config_data_t *)dbdata;
if (create_path(name, NULL, client, cd, &path) != ISC_R_SUCCESS) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (stat(path, &sb) != 0) {
complete_AXFR:
free(path);
- return (result);
+ return result;
}
isc_result_t
free(basepath);
}
- return (result);
+ return result;
}
#if DLZ_DLOPEN_VERSION < 3
#endif /* if DLZ_DLOPEN_VERSION >= 3 */
if (create_path(name, NULL, NULL, cd, &path) != ISC_R_SUCCESS) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
cd->log(ISC_LOG_DEBUG(1),
complete_FZ:
free(path);
- return (result);
+ return result;
}
#if DLZ_DLOPEN_VERSION == 1
}
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/* remove path separator at end of path so stat works properly */
complete_lkup:
free(path);
- return (result);
+ return result;
}
isc_result_t
*dbdata = cd;
/* return success */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
/* handle no memory error */
no_mem:
}
/* return error */
- return (result);
+ return result;
}
void
int
dlz_version(unsigned int *flags) {
UNUSED(flags);
- return (DLZ_DLOPEN_VERSION);
+ return DLZ_DLOPEN_VERSION;
}
/*
ldap_free_urldesc(ldap_url);
}
- return (result);
+ return result;
}
/*% Connects / reconnects to LDAP server */
/* initialize. */
dbc->dbconn = ldap_init(dbi->hosts, LDAP_PORT);
if (dbc->dbconn == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
/* set protocol version. */
goto cleanup;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dbc->dbconn = NULL;
}
- return (result);
+ return result;
}
/*%
while (count < dbc_search_limit) {
/* try to lock on the mutex */
if (dlz_mutex_trylock(&dbi->lock) == 0) {
- return (dbi); /* success, return the DBI for use. */
+ return dbi; /* success, return the DBI for use. */
}
/* not successful, keep trying */
dbi = DLZ_LIST_NEXT(dbi, link);
"LDAP driver unable to find available connection "
"after searching %d times",
count);
- return (NULL);
+ return NULL;
}
static isc_result_t
entry = ldap_first_entry(dbc, msg);
if (entry == NULL) {
db->log(ISC_LOG_INFO, "LDAP no entries to process.");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* loop through all entries returned */
free(data);
}
- return (result);
+ return result;
}
/*%
/* if DBI is null, can't do anything else */
if (dbi == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* set fields */
}
/* return result */
- return (result);
+ return result;
}
/*
result = dlz_findzonedb(dbdata, name, NULL, NULL);
#endif /* if DLZ_DLOPEN_VERSION < 3 */
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/* get all the zone data */
result = dlz_ldap_get_results(name, NULL, client, ALLOWXFR, dbdata,
NULL);
- return (result);
+ return result;
}
isc_result_t
dlz_allnodes(const char *zone, void *dbdata, dns_sdlzallnodes_t *allnodes) {
- return (dlz_ldap_get_results(zone, NULL, NULL, ALLNODES, dbdata,
- allnodes));
+ return dlz_ldap_get_results(zone, NULL, NULL, ALLNODES, dbdata,
+ allnodes);
}
isc_result_t
dlz_authority(const char *zone, void *dbdata, dns_sdlzlookup_t *lookup) {
- return (dlz_ldap_get_results(zone, NULL, NULL, AUTHORITY, dbdata,
- lookup));
+ return dlz_ldap_get_results(zone, NULL, NULL, AUTHORITY, dbdata,
+ lookup);
}
#if DLZ_DLOPEN_VERSION < 3
UNUSED(methods);
UNUSED(clientinfo);
#endif /* if DLZ_DLOPEN_VERSION >= 3 */
- return (dlz_ldap_get_results(name, NULL, NULL, FINDZONE, dbdata, NULL));
+ return dlz_ldap_get_results(name, NULL, NULL, FINDZONE, dbdata, NULL);
}
#if DLZ_DLOPEN_VERSION == 1
result = dlz_ldap_get_results(zone, name, NULL, LOOKUP, dbdata,
lookup);
}
- return (result);
+ return result;
}
isc_result_t
/* allocate memory for LDAP instance */
ldap = calloc(1, sizeof(ldap_instance_t));
if (ldap == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
memset(ldap, 0, sizeof(ldap_instance_t));
/* set dbdata to the ldap_instance we created. */
*dbdata = ldap;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dlz_destroy(ldap);
- return (result);
+ return result;
}
void
int
dlz_version(unsigned int *flags) {
*flags |= DNS_SDLZFLAG_RELATIVERDATA | DNS_SDLZFLAG_THREADSAFE;
- return (DLZ_DLOPEN_VERSION);
+ return DLZ_DLOPEN_VERSION;
}
/*
while (count < dbc_search_limit) {
/* try to lock on the mutex */
if (dlz_mutex_trylock(&dbi->lock) == 0) {
- return (dbi); /* success, return the DBI for use. */
+ return dbi; /* success, return the DBI for use. */
}
/* not successful, keep trying */
dbi = DLZ_LIST_NEXT(dbi, link);
"MySQL module unable to find available connection "
"after searching %d times",
count);
- return (NULL);
+ return NULL;
}
/*%
unsigned int len;
if (instr == NULL) {
- return (NULL);
+ return NULL;
}
len = strlen(instr);
outstr = malloc((2 * len * sizeof(char)) + 1);
if (outstr == NULL) {
- return (NULL);
+ return NULL;
}
mysql_real_escape_string(mysql, outstr, instr, len);
- return (outstr);
+ return outstr;
}
/*%
dbi = mysql_find_avail_conn(db);
if (dbi == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* what type of query are we going to run? */
free(querystring);
}
- return (result);
+ return result;
}
/*%
db->log(ISC_LOG_ERROR, "MySQL module ttl must "
"be "
"a positive number");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
result = db->putrr(lookup, safeGet(row[1]), ttl,
"memory for temporary "
"string");
mysql_free_result(rs);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
strcpy(tmpString, safeGet(row[2]));
"be "
"a positive number");
free(tmpString);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
result = db->putrr(lookup, safeGet(row[1]), ttl,
mysql_free_result(rs);
db->log(ISC_LOG_ERROR, "putrr returned error: %d",
result);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
row = mysql_fetch_row(rs);
}
mysql_free_result(rs);
- return (result);
+ return result;
}
/*
db->log(ISC_LOG_ERROR, "MySQL module unable to return "
"result set for findzone query");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
mysql_free_result(rs);
if (rows > 0) {
mysql_get_resultset(name, NULL, NULL, COUNTZONE, dbdata, NULL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*% Determine if the client is allowed to perform a zone transfer */
/* first check if the zone is supported by the database. */
result = dlz_findzonedb(dbdata, name, NULL, NULL);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
*/
result = mysql_get_resultset(name, NULL, client, ALLOWXFR, dbdata, &rs);
if (result == ISC_R_NOTIMPLEMENTED) {
- return (result);
+ return result;
}
if (result != ISC_R_SUCCESS || rs == NULL) {
}
db->log(ISC_LOG_ERROR, "MySQL module unable to return "
"result set for allow xfr query");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
rows = mysql_num_rows(rs);
mysql_free_result(rs);
if (rows > 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_NOPERM);
+ return ISC_R_NOPERM;
}
/*%
result = mysql_get_resultset(zone, NULL, NULL, ALLNODES, dbdata, &rs);
if (result == ISC_R_NOTIMPLEMENTED) {
- return (result);
+ return result;
}
/* if we didn't get a result set, log an err msg. */
mysql_free_result(rs);
}
- return (result);
+ return result;
}
/*%
result = mysql_get_resultset(zone, NULL, NULL, AUTHORITY, dbdata, &rs);
if (result == ISC_R_NOTIMPLEMENTED) {
- return (result);
+ return result;
}
if (result != ISC_R_SUCCESS) {
}
db->log(ISC_LOG_ERROR, "MySQL module unable to return "
"result set for authority query");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
* lookup and authority result sets are processed in the same
* manner: mysql_process_rs does the job for both functions.
*/
- return (mysql_process_rs(db, lookup, rs));
+ return mysql_process_rs(db, lookup, rs);
}
/*% If zone is supported, lookup up a (or multiple) record(s) in it */
}
db->log(ISC_LOG_ERROR, "MySQL module unable to return "
"result set for lookup query");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
* lookup and authority result sets are processed in the same
* manner: mysql_process_rs does the job for both functions.
*/
- return (mysql_process_rs(db, lookup, rs));
+ return mysql_process_rs(db, lookup, rs);
}
/*%
/* allocate memory for MySQL instance */
mysql = calloc(1, sizeof(mysql_instance_t));
if (mysql == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
memset(mysql, 0, sizeof(mysql_instance_t));
if (argc < 4) {
mysql->log(ISC_LOG_ERROR, "MySQL module requires "
"at least 4 command line args.");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* no more than 8 arg's should be passed to the module */
if (argc > 8) {
mysql->log(ISC_LOG_ERROR, "MySQL module cannot accept "
"more than 7 command line args.");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* get db name - required */
*dbdata = mysql;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dlz_destroy(mysql);
- return (result);
+ return result;
}
/*%
dlz_version(unsigned int *flags) {
*flags |= (DNS_SDLZFLAG_RELATIVEOWNER | DNS_SDLZFLAG_RELATIVERDATA |
DNS_SDLZFLAG_THREADSAFE);
- return (DLZ_DLOPEN_VERSION);
+ return DLZ_DLOPEN_VERSION;
}
/*
mysql_thread_init();
if (dbi->connected) {
- return (true);
+ return true;
}
if (state->log != NULL) {
}
dlz_mutex_unlock(&dbi->mutex);
- return (false);
+ return false;
}
dbi->connected = 1;
- return (true);
+ return true;
}
static mysql_instance_t *
state->log(ISC_LOG_ERROR,
"%s: No available connections", modname);
}
- return (NULL);
+ return NULL;
}
- return (&state->db[i]);
+ return &state->db[i];
}
/*
char *s;
if (original == NULL) {
- return (NULL);
+ return NULL;
}
s = (char *)malloc((strlen(original) * 2) + 1);
strlen(original));
}
- return (s);
+ return s;
}
/*
item = malloc(sizeof(*item));
if (item == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
DLZ_LINK_INIT(item, link);
DLZ_LIST_APPEND(*arglist, item, link);
*s = NULL;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (dbi == NULL) {
dbi = get_dbi(state);
if (dbi == NULL) {
- return (NULL);
+ return NULL;
}
localdbi = true;
}
dlz_mutex_unlock(&dbi->mutex);
}
- return (query);
+ return query;
}
/* Does this name end in a dot? */
static bool
isrelative(const char *s) {
if (s == NULL || s[strlen(s) - 1] == '.') {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
/* Return a dot if 's' doesn't already end with one */
static const char *
dot(const char *s) {
- return (isrelative(s) ? "." : "");
+ return isrelative(s) ? "." : "";
}
/*
new = (char *)malloc(strlen(name) + 1);
if (new == NULL) {
- return (NULL);
+ return NULL;
}
nlen = strlen(name);
if (nlen < zlen) {
strcpy(new, name);
- return (new);
+ return new;
} else if (nlen == zlen || strcasecmp(name, zone) == 0) {
strcpy(new, "@");
- return (new);
+ return new;
}
p = name + nlen - zlen;
(zone[zlen - 1] != '.' || strncasecmp(p, zone, zlen - 1) != 0))
{
strcpy(new, name);
- return (new);
+ return new;
}
strncpy(new, name, nlen - zlen);
new[nlen - zlen - 1] = '\0';
- return (new);
+ return new;
}
static isc_result_t
state->log(ISC_LOG_ERROR, "%s: invalid txn %x", modname, txn);
}
- return (result);
+ return result;
}
static isc_result_t
/* Make sure this instance is connected. */
if (!db_connect(state, dbi)) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
ret = mysql_real_query(dbi->sock, query, strlen(query));
state->log(ISC_LOG_ERROR, "%s: query '%s' failed: %s",
modname, query, mysql_error(dbi->sock));
}
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (state->debug && state->log != NULL) {
query);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static MYSQL_RES *
MYSQL_RES *res = NULL;
if (query == NULL) {
- return (NULL);
+ return NULL;
}
/* Get a DB instance if needed */
if (dbi == NULL) {
dbi = get_dbi(state);
if (dbi == NULL) {
- return (NULL);
+ return NULL;
}
localdbi = true;
}
if (dbi != NULL && localdbi) {
dlz_mutex_unlock(&dbi->mutex);
}
- return (res);
+ return res;
}
/*
unsigned char *packet = (unsigned char *)malloc(strlen(zone) + 18);
if (packet == NULL) {
- return (NULL);
+ return NULL;
}
*packetlen = strlen(zone) + 18;
packet[j + 3] = htons(i) & 0xff;
packet[j + 4] = htons(i) >> 8;
- return (packet);
+ return packet;
}
static void
"%s: makerecord - unable to malloc",
modname);
}
- return (NULL);
+ return NULL;
}
buf = strdup(rdatastr);
modname);
}
free(new_record);
- return (NULL);
+ return NULL;
}
/*
sprintf(new_record->ttl, "%d", ttlvalue);
free(buf);
- return (new_record);
+ return new_record;
error:
free(buf);
free(new_record);
- return (NULL);
+ return NULL;
}
/*
dlz_version(unsigned int *flags) {
UNUSED(flags);
*flags |= DNS_SDLZFLAG_THREADSAFE;
- return (DLZ_DLOPEN_VERSION);
+ return DLZ_DLOPEN_VERSION;
}
/*
state = calloc(1, sizeof(mysql_data_t));
if (state == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
dlz_mutex_init(&state->tx_mutex, NULL);
modname);
}
dlz_destroy(state);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
state->db_name = strdup(argv[1]);
*dbdata = state;
dlz_mutex_unlock(&state->tx_mutex);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
free(state->db_name);
free(state->db_pass);
dlz_mutex_destroy(&state->tx_mutex);
free(state);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
query = build_query(state, NULL, Q_FINDZONE, name);
if (query == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
res = db_query(state, NULL, query);
if (res == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (mysql_num_rows(res) == 0) {
}
mysql_free_result(res);
- return (result);
+ return result;
}
/*
state->log(ISC_LOG_ERROR, "%s: dlz_lookup - no putrr",
modname);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
/* Are we okay to try to find the txn version? */
if (strcmp(name, "@") == 0) {
real_name = (char *)malloc(strlen(zone) + 1);
if (real_name == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
strcpy(real_name, zone);
} else {
real_name = (char *)malloc(strlen(name) + 1);
if (real_name == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
strcpy(real_name, name);
}
query = build_query(state, dbi, Q_GETSOA, zone);
if (query == NULL) {
free(real_name);
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
res = db_query(state, dbi, query);
if (res == NULL) {
free(real_name);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
while ((row = mysql_fetch_row(res)) != NULL) {
if (result != ISC_R_SUCCESS) {
free(real_name);
mysql_free_result(res);
- return (result);
+ return result;
}
}
if (res == NULL) {
free(real_name);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
while ((row = mysql_fetch_row(res)) != NULL) {
if (result != ISC_R_SUCCESS) {
free(real_name);
mysql_free_result(res);
- return (result);
+ return result;
}
found = true;
free(real_name);
if (!found) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
}
/* Just say yes for all our zones */
- return (dlz_findzonedb(dbdata, name, NULL, NULL));
+ return dlz_findzonedb(dbdata, name, NULL, NULL);
}
/*
}
if (state->putnamedrr == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
/*
*/
query = build_query(state, NULL, Q_GETALL, zone);
if (query == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
res = db_query(state, NULL, query);
free(query);
if (res == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
while ((row = mysql_fetch_row(res)) != NULL) {
}
mysql_free_result(res);
- return (result);
+ return result;
}
/*
*/
query = build_query(state, NULL, Q_WRITEABLE, zone);
if (query == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
res = db_query(state, NULL, query);
free(query);
if (res == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if ((row = mysql_fetch_row(res)) == NULL) {
mysql_free_result(res);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
strcpy(zone_id, row[0]);
modname, zone);
}
dlz_mutex_unlock(&state->tx_mutex);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
}
}
- return (result);
+ return result;
}
/*
"%s: no writeable_zone method available",
modname);
}
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
*/
res = db_query(state, NULL, Q_GETZONES);
if (res == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
count = 0;
modname, row[0]);
}
mysql_free_result(res);
- return (result);
+ return result;
}
count++;
}
state->log(ISC_LOG_INFO, "%s: configured %d zones", modname,
count);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
state->log(ISC_LOG_INFO, "%s: allowing update of %s by key %s",
modname, name, signer);
}
- return (true);
+ return true;
}
isc_result_t
isc_result_t result;
if (txn == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
new_name = relname(name, txn->zone);
if (new_name == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (state->debug && (state->log != NULL)) {
record = makerecord(state, new_name, rdatastr);
free(new_name);
if (record == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* Write out data to database */
cleanup:
free(record);
- return (result);
+ return result;
}
isc_result_t
isc_result_t result;
if (txn == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
new_name = relname(name, txn->zone);
if (new_name == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (state->debug && (state->log != NULL)) {
record = makerecord(state, new_name, rdatastr);
free(new_name);
if (record == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
* If 'type' isn't 'SOA', delete the records
cleanup:
free(record);
- return (result);
+ return result;
}
isc_result_t
isc_result_t result;
if (txn == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
new_name = relname(name, txn->zone);
if (new_name == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (state->debug && (state->log != NULL)) {
cleanup:
free(new_name);
- return (result);
+ return result;
}
int
dlz_version(unsigned int *flags) {
UNUSED(flags);
- return (DLZ_DLOPEN_VERSION);
+ return DLZ_DLOPEN_VERSION;
}
isc_result_t
carp("DLZ Perl: Returning from allnodes, r = %i, retval = %i", r,
retval);
- return (retval);
+ return retval;
}
isc_result_t
PUTBACK;
FREETMPS;
LEAVE;
- return (retval);
+ return retval;
}
#if DLZ_DLOPEN_VERSION < 3
PUTBACK;
FREETMPS;
LEAVE;
- return (retval);
+ return retval;
}
#if DLZ_DLOPEN_VERSION == 1
carp("DLZ Perl: Returning from lookup, r = %i, retval = %i", r, retval);
- return (retval);
+ return retval;
}
static const char *
methods[i]);
if (get_cv(full_name, 0) == NULL) {
- return (methods[i]);
+ return methods[i];
}
i++;
}
- return (NULL);
+ return NULL;
}
isc_result_t
cd = malloc(sizeof(config_data_t));
if (cd == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
memset(cd, 0, sizeof(config_data_t));
cd->log(ISC_LOG_ERROR,
"DLZ Perl '%s': Missing script argument.", dlzname);
free(cd);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (argc < 3) {
cd->log(ISC_LOG_ERROR,
"DLZ Perl '%s': Missing class name argument.", dlzname);
free(cd);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
perl_class_name = argv[2];
cd->perl = perl_alloc();
if (cd->perl == NULL) {
free(cd);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
#ifdef MULTIPLICITY
my_perl = cd->perl;
cd->perl_source = strdup(argv[1]);
if (cd->perl_source == NULL) {
free(cd);
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
perlrun[1] = cd->perl_source;
#ifndef MULTIPLICITY
global_perl = cd->perl;
#endif /* ifndef MULTIPLICITY */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
CLEAN_UP_PERL_AND_FAIL:
PL_perl_destruct_level = 1;
perl_free(cd->perl);
free(cd->perl_source);
free(cd);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
void
while (count < dbc_search_limit) {
/* try to lock on the mutex */
if (dlz_mutex_trylock(&dbi->lock) == 0) {
- return (dbi); /* success, return the DBI for use. */
+ return dbi; /* success, return the DBI for use. */
}
/* not successful, keep trying */
dbi = DLZ_LIST_NEXT(dbi, link);
"SQLite3 module: unable to find available connection "
"after searching %d times",
count);
- return (NULL);
+ return NULL;
}
/*%
unsigned int i;
if (instr == NULL) {
- return (NULL);
+ return NULL;
}
len = strlen(instr);
atlen = (2 * len * sizeof(char)) + 1;
outstr = malloc(atlen);
if (outstr == NULL) {
- return (NULL);
+ return NULL;
}
ptr = outstr;
}
*ptr = '\0';
- return (outstr);
+ return outstr;
}
/*%
dbi = sqlite3_find_avail(db);
if (dbi == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* what type of query are we going to run? */
free(querystring);
}
- return (result);
+ return result;
}
/*%
rs->curRow++;
}
}
- return (retval);
+ return retval;
}
static unsigned int
if (rs != NULL) {
retval = rs->pnColumn;
}
- return (retval);
+ return retval;
}
static unsigned int
if (rs != NULL) {
retval = rs->pnRow;
}
- return (retval);
+ return retval;
}
static void
db->log(ISC_LOG_ERROR, "SQLite3 module: TTL "
"must be "
"a positive number");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
result = db->putrr(lookup, safeGet(row[1]), ttl,
"memory for temporary "
"string");
dlz_sqlite3_free_result(rs);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
strcpy(tmpString, safeGet(row[2]));
"must be "
"a positive number");
free(tmpString);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
result = db->putrr(lookup, safeGet(row[1]), ttl,
dlz_sqlite3_free_result(rs);
db->log(ISC_LOG_ERROR, "putrr returned error: %d",
result);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
row = dlz_sqlite3_fetch_row(rs);
}
dlz_sqlite3_free_result(rs);
- return (result);
+ return result;
}
/*
db->log(ISC_LOG_ERROR, "SQLite3 module: unable to return "
"result set for FINDZONE query");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
if (rows > 0) {
sqlite3_get_resultset(name, NULL, NULL, COUNTZONE, dbdata,
NULL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*% Determine if the client is allowed to perform a zone transfer */
/* first check if the zone is supported by the database. */
result = dlz_findzonedb(dbdata, name, NULL, NULL);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
result = sqlite3_get_resultset(name, NULL, client, ALLOWXFR, dbdata,
&rs);
if (result == ISC_R_NOTIMPLEMENTED) {
- return (result);
+ return result;
}
if (result != ISC_R_SUCCESS || rs == NULL) {
}
db->log(ISC_LOG_ERROR, "SQLite3 module: unable to return "
"result set for ALLOWXFR query");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
rows = dlz_sqlite3_num_rows(rs);
dlz_sqlite3_free_result(rs);
if (rows > 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_NOPERM);
+ return ISC_R_NOPERM;
}
/*%
result = sqlite3_get_resultset(zone, NULL, NULL, ALLNODES, dbdata, &rs);
if (result == ISC_R_NOTIMPLEMENTED) {
- return (result);
+ return result;
}
/* if we didn't get a result set, log an err msg. */
dlz_sqlite3_free_result(rs);
}
- return (result);
+ return result;
}
/*%
result = sqlite3_get_resultset(zone, NULL, NULL, AUTHORITY, dbdata,
&rs);
if (result == ISC_R_NOTIMPLEMENTED) {
- return (result);
+ return result;
}
if (result != ISC_R_SUCCESS) {
}
db->log(ISC_LOG_ERROR, "SQLite3 module: unable to return "
"result set for AUTHORITY query");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
* lookup and authority result sets are processed in the same
* manner: dlz_sqlite3_process_rs does the job for both functions.
*/
- return (dlz_sqlite3_process_rs(db, lookup, rs));
+ return dlz_sqlite3_process_rs(db, lookup, rs);
}
/*% If zone is supported, lookup up a (or multiple) record(s) in it */
}
db->log(ISC_LOG_ERROR, "SQLite3 module: unable to return "
"result set for LOOKUP query");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
* lookup and authority result sets are processed in the same
* manner: dlz_sqlite3_process_rs does the job for both functions.
*/
- return (dlz_sqlite3_process_rs(db, lookup, rs));
+ return dlz_sqlite3_process_rs(db, lookup, rs);
}
/*%
/* allocate memory for SQLite3 instance */
s3 = calloc(1, sizeof(sqlite3_instance_t));
if (s3 == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
memset(s3, 0, sizeof(sqlite3_instance_t));
if (argc < 4) {
s3->log(ISC_LOG_ERROR, "SQLite3 module requires "
"at least 4 command line args.");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* no more than 8 arg's should be passed to the module */
if (argc > 8) {
s3->log(ISC_LOG_ERROR, "SQLite3 module cannot accept "
"more than 8 command line args.");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* get db name - required */
}
*dbdata = s3;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dlz_destroy(s3);
- return (result);
+ return result;
}
/*%
dlz_version(unsigned int *flags) {
*flags |= (DNS_SDLZFLAG_RELATIVEOWNER | DNS_SDLZFLAG_RELATIVERDATA |
DNS_SDLZFLAG_THREADSAFE);
- return (DLZ_DLOPEN_VERSION);
+ return DLZ_DLOPEN_VERSION;
}
/*
free(querystring);
}
- return (result);
+ return result;
}
isc_result_t
"dlz_wildcard allowzonexfr called for client '%s'", client);
if (fnmatch(cd->axfr_pattern, client, FNM_CASEFOLD) == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
p = shortest_match(cd->zone_pattern, name);
if (p == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/* Write info message to log */
cd->log(ISC_LOG_DEBUG(1), "dlz_wildcard findzonedb matched '%s'", p);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#if DLZ_DLOPEN_VERSION == 1
p = shortest_match(cd->zone_pattern, zone);
if (p == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
DE_CONST(name, cd->record);
size_t len = p - zone;
namebuf = malloc(len);
if (namebuf == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
strncpy(namebuf, zone, len - 1);
namebuf[len - 1] = '\0';
free(querystring);
}
- return (result);
+ return result;
}
isc_result_t
p = shortest_match(cd->zone_pattern, zone);
if (p == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
DE_CONST(p, cd->zone);
free(querystring);
}
- return (result);
+ return result;
}
static void
va_list ap;
if (argc < 8 || argc % 4 != 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
cd = calloc(1, sizeof(config_data_t));
if (cd == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
memset(cd, 0, sizeof(config_data_t));
*dbdata = cd;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
full_cleanup:
destroy_rrlist(cd);
}
free(cd);
- return (result);
+ return result;
}
void
dlz_version(unsigned int *flags) {
UNUSED(flags);
/* XXX: ok to set DNS_SDLZFLAG_THREADSAFE here? */
- return (DLZ_DLOPEN_VERSION);
+ return DLZ_DLOPEN_VERSION;
}
/*
shortest_match(const char *pattern, const char *string) {
const char *p = string;
if (pattern == NULL || p == NULL || *p == '\0') {
- return (NULL);
+ return NULL;
}
p += strlen(p);
while (p-- > string) {
if (*p == '.') {
if (fnmatch(pattern, p + 1, FNM_CASEFOLD) == 0) {
- return (p + 1);
+ return p + 1;
}
}
}
if (fnmatch(pattern, string, FNM_CASEFOLD) == 0) {
- return (string);
+ return string;
}
- return (NULL);
+ return NULL;
}
/*
switch (c = *pattern++) {
case EOS:
if ((flags & FNM_LEADING_DIR) && *string == '/') {
- return (0);
+ return 0;
}
- return (*string == EOS ? 0 : FNM_NOMATCH);
+ return *string == EOS ? 0 : FNM_NOMATCH;
case '?':
if (*string == EOS) {
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
}
if (*string == '/' && (flags & FNM_PATHNAME)) {
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
}
if (*string == '.' && (flags & FNM_PERIOD) &&
(string == stringstart ||
((flags & FNM_PATHNAME) && *(string - 1) == '/')))
{
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
}
++string;
break;
(string == stringstart ||
((flags & FNM_PATHNAME) && *(string - 1) == '/')))
{
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
}
/* Optimize for pattern with * at end or before /. */
if (c == EOS) {
if (flags & FNM_PATHNAME) {
- return ((flags & FNM_LEADING_DIR) ||
- index(string,
- '/') ==
- NULL
- ? 0
- : FNM_NOMATCH);
+ return (flags & FNM_LEADING_DIR) ||
+ index(string,
+ '/') ==
+ NULL
+ ? 0
+ : FNM_NOMATCH;
} else {
- return (0);
+ return 0;
}
} else if (c == '/' && flags & FNM_PATHNAME) {
if ((string = index(string, '/')) == NULL) {
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
}
break;
}
if (!fnmatch(pattern, string,
flags & ~FNM_PERIOD))
{
- return (0);
+ return 0;
}
if (test == '/' && flags & FNM_PATHNAME) {
break;
}
++string;
}
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
case '[':
if (*string == EOS) {
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
}
if (*string == '/' && (flags & FNM_PATHNAME)) {
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
}
if (*string == '.' && (flags & FNM_PERIOD) &&
(string == stringstart ||
((flags & FNM_PATHNAME) && *(string - 1) == '/')))
{
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
}
switch (rangematch(pattern, *string, flags, &newp)) {
pattern = newp;
break;
case RANGE_NOMATCH:
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
}
++string;
break;
tolower((unsigned char)*string)))
{
} else {
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
}
string++;
break;
c = *pattern++;
}
if (c == EOS) {
- return (RANGE_ERROR);
+ return RANGE_ERROR;
}
if (c == '/' && (flags & FNM_PATHNAME)) {
- return (RANGE_NOMATCH);
+ return RANGE_NOMATCH;
}
if (flags & FNM_CASEFOLD) {
c2 = *pattern++;
}
if (c2 == EOS) {
- return (RANGE_ERROR);
+ return RANGE_ERROR;
}
if (flags & FNM_CASEFOLD) {
} while ((c = *pattern++) != ']');
*newp = (char *)(uintptr_t)pattern;
- return (ok == negate ? RANGE_NOMATCH : RANGE_MATCH);
+ return ok == negate ? RANGE_NOMATCH : RANGE_MATCH;
}
fflush(stdout);
if (ferror(stdout)) {
fprintf(stderr, "write error\n");
- return (1);
+ return 1;
}
- return (0);
+ return 0;
}
LLVMFuzzerInitialize(int *argc, char ***argv) {
UNUSED(argc);
UNUSED(argv);
- return (0);
+ return 0;
}
int
end:
dns_db_detach(&db);
isc_mem_destroy(&mctx);
- return (0);
+ return 0;
}
wd = mkdtemp(template);
if (wd == NULL) {
fprintf(stderr, "mkdtemp failed\n");
- return (1);
+ return 1;
}
snprintf(pathbuf, sizeof(pathbuf), "%s/%s", wd, f1);
fd = fopen(pathbuf, "w");
if (fd == NULL) {
fprintf(stderr, "fopen(%s) failed\n", pathbuf);
- return (1);
+ return 1;
}
fputs(c1, fd);
fclose(fd);
fd = fopen(pathbuf, "w");
if (fd == NULL) {
fprintf(stderr, "fopen(%s) failed\n", pathbuf);
- return (1);
+ return 1;
}
fputs(c2, fd);
fclose(fd);
fd = fopen(pathbuf, "w");
if (fd == NULL) {
fprintf(stderr, "fopen(%s) failed\n", pathbuf);
- return (1);
+ return 1;
}
fputs(c3, fd);
fclose(fd);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dst_lib_init failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
destroy_dst = true;
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_view_create failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
result = dns_tsigkeyring_create(mctx, &ring);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_tsigkeyring_create failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
result = dns_tsigkeyring_create(mctx, &emptyring);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_tsigkeyring_create failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
result = dns_name_fromstring(name, "tsig-key", 0, NULL);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_name_fromstring failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
result = dns_tsigkey_create(name, dns_tsig_hmacsha256_name, secret,
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_tsigkey_create failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
result = dns_name_fromstring(name, "sig0key", 0, NULL);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_name_fromstring failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
result = dns_zone_create(&zone, mctx);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_zone_create failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
result = dns_zone_setorigin(zone, name);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_zone_setorigin failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
dns_zone_setclass(zone, view->rdclass);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_zone_setkeydirectory failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
result = dns_zone_setfile(zone, pathbuf, dns_masterformat_text,
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_zone_setfile failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
result = dns_zone_load(zone, false);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_zone_load failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
result = dns_view_addzone(view, zone);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_view_addzone failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
dns_view_freeze(view);
dns_zone_detach(&zone);
- return (0);
+ return 0;
}
static isc_result_t
}
*messagep = message;
}
- return (result);
+ return result;
}
int
* opcode.
*/
if (size > 65535 || size < 2) {
- return (0);
+ return 0;
}
addasig = (*data & 0x80) != 0;
result = create_message(&message, data, size, addasig, addtsig);
if (result != ISC_R_SUCCESS) {
- return (0);
+ return 0;
}
/*
dns_message_detach(&message);
}
- return (0);
+ return 0;
}
isc_mem_create(&mctx);
output = isc_mem_get(mctx, output_len);
- return (0);
+ return 0;
}
static isc_result_t
dns_message_detach(&message);
}
- return (result);
+ return result;
}
static isc_result_t
output);
}
- return (result);
+ return result;
}
#define CHECKRESULT(r, f) \
result = dns_compress_init(&cctx, -1, mctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
CHECKRESULT(result, dns_message_renderbegin(message, &cctx, &buffer));
result = parse_message(&buffer, messagep);
- return (result);
+ return result;
cleanup:
dns_compress_invalidate(&cctx);
- return (result);
+ return result;
}
int
dns_message_t *message = NULL;
if (size > 65535) {
- return (0);
+ return 0;
}
isc_buffer_constinit(&buffer, data, size);
dns_message_detach(&message);
}
- return (0);
+ return 0;
}
int
LLVMFuzzerInitialize(int *argc __attribute__((unused)),
char ***argv __attribute__((unused))) {
- return (0);
+ return 0;
}
int
fprintf(stderr, "dns_name_fromtext: %s\n",
isc_result_totext(result));
}
- return (0);
+ return 0;
}
LLVMFuzzerInitialize(int *argc, char ***argv) {
UNUSED(argc);
UNUSED(argv);
- return (0);
+ return 0;
}
/* following code was copied from named-rrchecker */
isc_lex_close(lex);
isc_lex_destroy(&lex);
isc_mem_destroy(&mctx);
- return (0);
+ return 0;
}
isc_lex_setspecials(lex, specials);
isc_lex_setcomments(lex, ISC_LEXCOMMENT_DNSMASTERFILE);
- return (0);
+ return 0;
}
static void
* dns_rdata_fromwire() only accepts input up to 2^16-1 octets.
*/
if (size < 2 || size > 0xffff + 2) {
- return (0);
+ return 0;
}
/*
assert(target.used == size);
assert(!memcmp(target.base, data, size));
- return (0);
+ return 0;
}
result = isc_lex_create(mctx, 1024, &lex);
REQUIRE(result == ISC_R_SUCCESS);
- return (0);
+ return 0;
}
int
bool eol;
if (size < sizeof(expect) + sizeof(eol)) {
- return (0);
+ return 0;
}
(void)memmove(&expect, data, sizeof(expect));
result = isc_lex_getmastertoken(lex, &token, expect, eol);
} while (result == ISC_R_SUCCESS && token.type != isc_tokentype_eof);
- return (0);
+ return 0;
}
result = isc_lex_create(mctx, 1024, &lex);
REQUIRE(result == ISC_R_SUCCESS);
- return (0);
+ return 0;
}
int
result = isc_lex_gettoken(lex, 0, &token);
} while (result == ISC_R_SUCCESS);
- return (0);
+ return 0;
}
argc--;
}
POST(argc);
- return (0);
+ return 0;
}
target = (target != NULL) ? target + 1 : argv[0];
test_all_from(corpusdir);
- return (0);
+ return 0;
}
#elif __AFL_COMPILER
#endif /* ifdef __AFL_LOOP */
ret = fread(buf, 1, sizeof(buf), stdin);
if (ret < 0) {
- return (0);
+ return 0;
}
LLVMFuzzerTestOneInput(buf, ret);
}
- return (0);
+ return 0;
}
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
result = ISC_R_FAILURE;
}
}
- return (result);
+ return result;
}
static isc_result_t
const cfg_obj_t *obj = NULL;
if (cfg_map_get(options, "rrset-order", &obj) != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (element = cfg_list_first(obj); element != NULL;
result = tresult;
}
}
- return (result);
+ return result;
}
static isc_result_t
(void)cfg_map_get(options, "dual-stack-servers", &alternates);
if (alternates == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
obj = cfg_tuple_get(alternates, "port");
}
}
}
- return (result);
+ return result;
}
static isc_result_t
"forwarders declared in root zone and "
"in general configuration: %s:%u",
file, line);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (forward != NULL && forwarders == NULL) {
cfg_obj_log(forward, logctx, ISC_LOG_ERROR,
"no matching 'forwarders' statement");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
result = tresult;
}
}
- return (result);
+ return result;
}
static isc_result_t
result = tresult;
}
}
- return (result);
+ return result;
}
static isc_result_t
} else if (result != ISC_R_SUCCESS) {
isc_mem_free(mctx, key);
}
- return (result);
+ return result;
}
static isc_result_t
"exists previous definition: %s:%u",
logctx, mctx);
}
- return (result);
+ return result;
}
static isc_result_t
}
}
if (aclobj == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = cfg_acl_fromconfig(aclobj, config, logctx, actx, mctx, 0,
&acl);
}
}
}
- return (result);
+ return result;
}
static isc_result_t
result = tresult;
}
}
- return (result);
+ return result;
}
static void
}
}
if (dns64 == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
for (element = cfg_list_first(dns64); element != NULL;
}
}
- return (result);
+ return result;
}
#define CHECK_RRL(cond, pat, val1, val2) \
}
}
if (map == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
min_entries = 500;
}
}
- return (result);
+ return result;
}
/*
}
}
- return (result);
+ return result;
}
typedef struct {
dns_fixedname_t fixed;
dns_fixedname_init(&fixed);
- return (dns_name_fromstring(dns_fixedname_name(&fixed), str, 0, NULL));
+ return dns_name_fromstring(dns_fixedname_name(&fixed), str, 0, NULL);
}
static bool
cfg_tuple_get(cfg_listelt_value(element), "name"));
if (strcmp("none", name) == 0) {
- return (false);
+ return false;
}
if (strcmp("default", name) == 0) {
- return (false);
+ return false;
}
if (strcmp("insecure", name) == 0) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static const cfg_obj_t *
result = cfg_map_get(config, listname, &maplist);
if (result != ISC_R_SUCCESS) {
- return (NULL);
+ return NULL;
}
for (elt = cfg_list_first(maplist); elt != NULL;
if (strcasecmp(cfg_obj_asstring(cfg_map_getname(map)), name) ==
0)
{
- return (map);
+ return map;
}
}
- return (NULL);
+ return NULL;
}
static isc_result_t
dns_acl_detach(&acl);
}
- return (result);
+ return result;
}
static isc_result_t
}
}
- return (result);
+ return result;
}
static isc_result_t
result = cfg_map_get(options, type, &portobj);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (cfg_obj_asuint32(portobj) >= UINT16_MAX) {
cfg_obj_log(portobj, logctx, ISC_LOG_ERROR,
"port '%u' out of range",
cfg_obj_asuint32(portobj));
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
if (portp != NULL) {
*portp = (in_port_t)cfg_obj_asuint32(portobj);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
cfg_aclconfctx_detach(&actx);
}
- return (result);
+ return result;
}
/*
result = cfg_map_get(cctx, list, &obj);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
elt = cfg_list_first(obj);
elt = cfg_list_next(elt);
}
- return (result);
+ return result;
}
/*
result = isc_symtab_create(mctx, 100, freekey, mctx, false, &symtab);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
tresult = bind9_check_remoteserverlist(cctx, "primaries", logctx,
symtab, mctx);
result = tresult;
}
isc_symtab_destroy(&symtab);
- return (result);
+ return result;
}
/*
result = isc_symtab_create(mctx, 100, freekey, mctx, false, &symtab);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
tresult = bind9_check_remoteserverlist(cctx, "parental-agents", logctx,
symtab, mctx);
result = tresult;
}
isc_symtab_destroy(&symtab);
- return (result);
+ return result;
}
#if HAVE_LIBNGHTTP2
}
}
- return (result);
+ return result;
}
static isc_result_t
result = isc_symtab_create(mctx, 100, NULL, NULL, false, &symtab);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = cfg_map_get(config, "http", &obj);
done:
isc_symtab_destroy(&symtab);
- return (result);
+ return result;
}
#endif /* HAVE_LIBNGHTTP2 */
}
}
- return (result);
+ return result;
}
static isc_result_t
result = cfg_map_get(config, "tls", &obj);
if (result != ISC_R_SUCCESS) {
result = ISC_R_SUCCESS;
- return (result);
+ return result;
}
result = isc_symtab_create(mctx, 100, NULL, NULL, false, &symtab);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (elt = cfg_list_first(obj); elt != NULL; elt = cfg_list_next(elt)) {
isc_symtab_destroy(&symtab);
- return (result);
+ return result;
}
static isc_result_t
result = cfg_map_get(cctx, list, &obj);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
elt = cfg_list_first(obj);
if (strcasecmp(listname, name) == 0) {
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
elt = cfg_list_next(elt);
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
static isc_result_t
} else if (strcmp(list, "parental-agents") == 0) {
result = get_remotes(cctx, "parental-agents", name, ret);
}
- return (result);
+ return result;
}
static isc_result_t
result = isc_symtab_create(mctx, 100, NULL, NULL, false, &symtab);
if (result != ISC_R_SUCCESS) {
*countp = count;
- return (result);
+ return result;
}
newlist:
}
isc_symtab_destroy(&symtab);
*countp = count;
- return (result);
+ return result;
}
static isc_result_t
if (cfg_obj_isstring(policy) &&
strcmp("local", cfg_obj_asstring(policy)) == 0)
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* Now check the grant policy */
}
}
}
- return (result);
+ return result;
}
typedef struct {
result = ISC_R_FAILURE;
}
}
- return (result);
+ return result;
}
/*%
/*
* "notify" not set at zone level. This is fine.
*/
- return (true);
+ return true;
}
if (cfg_obj_isboolean(obj)) {
znamestr);
}
- return (notify_configuration_ok);
+ return notify_configuration_ok;
}
/*%
dns_acl_detach(&acl);
}
- return (retval);
+ return retval;
}
static isc_result_t
if (obj == NULL) {
cfg_obj_log(zconfig, logctx, ISC_LOG_ERROR,
"zone '%s': type not present", znamestr);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
typestr = cfg_obj_asstring(obj);
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"zone '%s': invalid type %s", znamestr,
typestr);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (ztype == CFG_ZONE_REDIRECT && strcmp(znamestr, ".") != 0) {
cfg_obj_log(zconfig, logctx, ISC_LOG_ERROR,
"redirect zones must be called \".\"");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"zone '%s': invalid class %s", znamestr,
r.base);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (zclass != defclass) {
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"zone '%s': class '%s' does not "
"match view/default class",
znamestr, r.base);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
} else {
zclass = defclass;
result = ISC_R_FAILURE;
}
}
- return (result);
+ return result;
}
/*
tresult = cfg_map_get(zoptions, "file", &fileobj);
obj = NULL;
res1 = cfg_map_get(zoptions, "inline-signing", &obj);
- if ((tresult != ISC_R_SUCCESS &&
- (ztype == CFG_ZONE_PRIMARY || ztype == CFG_ZONE_HINT ||
- (ztype == CFG_ZONE_SECONDARY && res1 == ISC_R_SUCCESS &&
- cfg_obj_asboolean(obj)))))
+ if (tresult != ISC_R_SUCCESS &&
+ (ztype == CFG_ZONE_PRIMARY || ztype == CFG_ZONE_HINT ||
+ (ztype == CFG_ZONE_SECONDARY && res1 == ISC_R_SUCCESS &&
+ cfg_obj_asboolean(obj))))
{
cfg_obj_log(zconfig, logctx, ISC_LOG_ERROR,
"zone '%s': missing 'file' entry",
}
}
- return (result);
+ return result;
}
typedef struct keyalgorithms {
"key '%s' must have both 'secret' and "
"'algorithm' defined",
keyname);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
isc_buffer_init(&buf, secretbuf, sizeof(secretbuf));
if (result != ISC_R_SUCCESS) {
cfg_obj_log(secretobj, logctx, ISC_LOG_ERROR, "bad secret '%s'",
isc_result_totext(result));
- return (result);
+ return result;
}
algorithm = cfg_obj_asstring(algobj);
if (algorithms[i].name == NULL) {
cfg_obj_log(algobj, logctx, ISC_LOG_ERROR,
"unknown algorithm '%s'", algorithm);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (algorithm[len] == '-') {
uint16_t digestbits;
"[%u..%u]",
keyname, algorithms[i].size / 2,
algorithms[i].size);
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
if ((digestbits % 8) != 0) {
cfg_obj_log(algobj, logctx, ISC_LOG_ERROR,
"key '%s' digest-bits not multiple"
" of 8",
keyname);
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
/*
* Recommended minima for hmac algorithms.
*/
- if ((digestbits < (algorithms[i].size / 2U) ||
- (digestbits < 80U)))
+ if (digestbits < (algorithms[i].size / 2U) ||
+ (digestbits < 80U))
{
cfg_obj_log(algobj, logctx, ISC_LOG_WARNING,
"key '%s' digest-bits too small "
cfg_obj_log(algobj, logctx, ISC_LOG_ERROR,
"key '%s': unable to parse digest-bits",
keyname);
- return (result);
+ return result;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
"writeable file '%s': already in use: "
"%s:%u",
cfg_obj_asstring(obj), file, line);
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
result = isc_symtab_lookup(symtab, cfg_obj_asstring(obj), 2,
&symvalue);
"writeable file '%s': already in use: "
"%s:%u",
cfg_obj_asstring(obj), file, line);
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
symvalue.as_cpointer = obj;
result = isc_symtab_define(symtab, cfg_obj_asstring(obj),
writeable ? 2 : 1, symvalue,
isc_symexists_reject);
- return (result);
+ return result;
}
static isc_result_t
char *symkey;
if (kaspnamestr == NULL || strcmp(kaspnamestr, "none") == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = isc_symtab_lookup(symtab, keydir, 0, &symvalue);
strcmp(cfg_obj_asstring(kasp), "none") == 0 ||
strcmp(cfg_obj_asstring(kasp), kaspnamestr) == 0)
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
cfg_obj_log(zcfg, logctx, ISC_LOG_ERROR,
keydir,
cfg_obj_asstring(cfg_tuple_get(exist, "name")),
cfg_obj_asstring(kasp), file, line);
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
/*
symvalue.as_cpointer = zcfg;
result = isc_symtab_define(symtab, symkey, 2, symvalue,
isc_symexists_reject);
- return (result);
+ return result;
}
/*
}
tresult = bind9_check_key(key, logctx);
if (tresult != ISC_R_SUCCESS) {
- return (tresult);
+ return tresult;
}
dns_name_format(name, namebuf, sizeof(namebuf));
result = tresult;
} else if (tresult != ISC_R_SUCCESS) {
isc_mem_free(mctx, keyname);
- return (tresult);
+ return tresult;
}
}
- return (result);
+ return result;
}
/*
const char *str;
if (keylist == NULL) {
- return (false);
+ return false;
}
for (element = cfg_list_first(keylist); element != NULL;
obj = cfg_listelt_value(element);
str = cfg_obj_asstring(cfg_map_getname(obj));
if (!strcasecmp(str, keyname)) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static struct {
(void)cfg_map_get(config, "server", &servers);
}
if (servers == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
for (e1 = cfg_list_first(servers); e1 != NULL; e1 = cfg_list_next(e1)) {
}
dns_peer_detach(&peer);
}
- return (result);
+ return result;
}
#define ROOT_KSK_STATIC 0x01
}
cleanup:
- return (result);
+ return result;
}
static isc_result_t
}
}
- return (ret);
+ return ret;
}
static isc_result_t
}
}
- return (ret);
+ return ret;
}
static isc_result_t
}
}
- return (ret);
+ return ret;
}
/*
if (dstab != NULL) {
isc_symtab_destroy(&dstab);
}
- return (result);
+ return result;
}
typedef enum { special_zonetype_rpz, special_zonetype_catz } special_zonetype_t;
"more than 64 response policy "
"zones in view '%s'",
viewname);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
}
}
}
- return (result);
+ return result;
}
static isc_result_t
result = isc_symtab_create(mctx, 100, freekey, mctx, false, &symtab);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
obj = cfg_tuple_get(catz_obj, "zone list");
isc_symtab_destroy(&symtab);
}
- return (result);
+ return result;
}
/*%
"%s: plugin check failed: "
"unable to get full plugin path: %s",
plugin_path, isc_result_totext(result));
- return (result);
+ return result;
}
result = ns_plugin_check(full_path, parameters, config,
*data->check_result = result;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"'dnstap-output' must be set if 'dnstap' "
"is set");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#else /* ifdef HAVE_DNSTAP */
UNUSED(voptions);
UNUSED(config);
UNUSED(logctx);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#endif /* ifdef HAVE_DNSTAP */
}
*/
tresult = isc_symtab_create(mctx, 1000, freekey, mctx, false, &symtab);
if (tresult != ISC_R_SUCCESS) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
cfg_aclconfctx_create(mctx, &actx);
cfg_aclconfctx_detach(&actx);
}
- return (result);
+ return result;
}
static const char *default_channels[] = { "default_syslog", "default_stderr",
(void)cfg_map_get(config, "logging", &logobj);
if (logobj == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = isc_symtab_create(mctx, 100, NULL, NULL, false, &symtab);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
symvalue.as_cpointer = NULL;
}
}
isc_symtab_destroy(&symtab);
- return (result);
+ return result;
}
static isc_result_t
control_keylist = cfg_tuple_get(control, "keys");
if (cfg_obj_isvoid(control_keylist)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
for (element = cfg_list_first(control_keylist); element != NULL;
result = ISC_R_NOTFOUND;
}
}
- return (result);
+ return result;
}
static isc_result_t
(void)cfg_map_get(config, "controls", &controlslist);
if (controlslist == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
(void)cfg_map_get(config, "key", &keylist);
}
}
cfg_aclconfctx_detach(&actx);
- return (result);
+ return result;
}
isc_result_t
isc_symtab_destroy(&keydirs);
}
- return (result);
+ return result;
}
isc_sockaddr_v6fromin(&addrs[0], &in4, port);
}
*addrcount = 1;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (strlen(hostname) <= 127U) {
char tmpbuf[128], *d;
uint32_t zone = 0;
isc_netaddr_t na;
if (!have_ipv6) {
- return (ISC_R_FAMILYNOSUPPORT);
+ return ISC_R_FAMILYNOSUPPORT;
}
if (d != NULL) {
&in6, &zone);
if (iresult != ISC_R_SUCCESS) {
- return (iresult);
+ return iresult;
}
}
&addrs[0], (const isc_netaddr_t *)&na, port);
*addrcount = 1;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
memset(&hints, 0, sizeof(hints));
#if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME)
case EAI_NODATA:
#endif /* if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME) */
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
#ifdef AI_ADDRCONFIG
case EAI_BADFLAGS:
if ((hints.ai_flags & AI_ADDRCONFIG) != 0) {
#endif /* ifdef AI_ADDRCONFIG */
FALLTHROUGH;
default:
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
for (tmpai = ai, i = 0; tmpai != NULL && i < addrsize;
tmpai = tmpai->ai_next)
freeaddrinfo(ai);
*addrcount = i;
if (*addrcount == 0) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
result = dns_iptable_create(mctx, &acl->iptable);
if (result != ISC_R_SUCCESS) {
isc_mem_put(mctx, acl, sizeof(*acl));
- return (result);
+ return result;
}
acl->elements = NULL;
acl->port_proto_entries = 0;
*target = acl;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
result = dns_acl_create(mctx, 0, &acl);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_iptable_addprefix(acl->iptable, NULL, 0, !neg);
if (result != ISC_R_SUCCESS) {
dns_acl_detach(&acl);
- return (result);
+ return result;
}
*target = acl;
- return (result);
+ return result;
}
/*
*/
isc_result_t
dns_acl_any(isc_mem_t *mctx, dns_acl_t **target) {
- return (dns_acl_anyornone(mctx, false, target));
+ return dns_acl_anyornone(mctx, false, target);
}
/*
*/
isc_result_t
dns_acl_none(isc_mem_t *mctx, dns_acl_t **target) {
- return (dns_acl_anyornone(mctx, true, target));
+ return dns_acl_anyornone(mctx, true, target);
}
/*
acl->iptable->radix == NULL || acl->iptable->radix->head == NULL ||
acl->iptable->radix->head->prefix == NULL)
{
- return (false);
+ return false;
}
if (acl->length != 0 || dns_acl_node_count(acl) != 1) {
- return (false);
+ return false;
}
if (acl->iptable->radix->head->prefix->bitlen == 0 &&
acl->iptable->radix->head->data[1] &&
*(bool *)(acl->iptable->radix->head->data[0]) == pos)
{
- return (true);
+ return true;
}
- return (false); /* All others */
+ return false; /* All others */
}
/*
*/
bool
dns_acl_isany(dns_acl_t *acl) {
- return (dns_acl_isanyornone(acl, true));
+ return dns_acl_isanyornone(acl, true);
}
/*
*/
bool
dns_acl_isnone(dns_acl_t *acl) {
- return (dns_acl_isanyornone(acl, false));
+ return dns_acl_isanyornone(acl, false);
}
/*
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return (dns_acl_match(reqaddr, reqsigner, acl, env, match, matchelt));
+ return dns_acl_match(reqaddr, reqsigner, acl, env, match, matchelt);
}
/*
nodes = max_node + dns_acl_node_count(dest);
result = dns_iptable_merge(dest->iptable, source->iptable, pos);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (nodes > dns_acl_node_count(dest)) {
dns_acl_node_count(dest) = nodes;
*/
dns_acl_merge_ports_transports(dest, source, pos);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (matchelt != NULL) {
*matchelt = e;
}
- return (true);
+ return true;
} else {
- return (false);
+ return false;
}
case dns_aclelementtype_nestedacl:
case dns_aclelementtype_localhost:
if (env == NULL) {
- return (false);
+ return false;
}
RWLOCK(&env->rwlock, isc_rwlocktype_read);
if (env->localhost == NULL) {
RWUNLOCK(&env->rwlock, isc_rwlocktype_read);
- return (false);
+ return false;
}
dns_acl_attach(env->localhost, &inner);
RWUNLOCK(&env->rwlock, isc_rwlocktype_read);
case dns_aclelementtype_localnets:
if (env == NULL) {
- return (false);
+ return false;
}
RWLOCK(&env->rwlock, isc_rwlocktype_read);
if (env->localnets == NULL) {
RWUNLOCK(&env->rwlock, isc_rwlocktype_read);
- return (false);
+ return false;
}
dns_acl_attach(env->localnets, &inner);
RWUNLOCK(&env->rwlock, isc_rwlocktype_read);
#if defined(HAVE_GEOIP2)
case dns_aclelementtype_geoip:
if (env == NULL || env->geoip == NULL) {
- return (false);
+ return false;
}
- return (dns_geoip_match(reqaddr, env->geoip, &e->geoip_elem));
+ return dns_geoip_match(reqaddr, env->geoip, &e->geoip_elem);
#endif /* if defined(HAVE_GEOIP2) */
default:
UNREACHABLE();
if (matchelt != NULL) {
*matchelt = e;
}
- return (true);
+ return true;
}
/*
*matchelt = NULL;
}
- return (false);
+ return false;
}
void
insecure = insecure_prefix_found;
UNLOCK(&insecure_prefix_lock);
if (insecure) {
- return (true);
+ return true;
}
/* Now check non-radix elements */
case dns_aclelementtype_nestedacl:
if (dns_acl_isinsecure(e->nestedacl)) {
- return (true);
+ return true;
}
continue;
case dns_aclelementtype_geoip:
#endif /* if defined(HAVE_GEOIP2) */
case dns_aclelementtype_localnets:
- return (true);
+ return true;
default:
UNREACHABLE();
}
/* No insecure elements were found. */
- return (false);
+ return false;
}
/*%
isc_result_t result;
if (acl == NULL) {
- return (true);
+ return true;
}
result = dns_acl_match(addr, signer, acl, aclenv, &match, NULL);
if (result == ISC_R_SUCCESS && match > 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
/*
*envp = env;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_localhost:
dns_acl_detach(&env->localhost);
cleanup_rwlock:
isc_rwlock_destroy(&env->rwlock);
isc_mem_putanddetach(&env->mctx, env, sizeof(*env));
- return (result);
+ return result;
}
void
ttl = ADB_CACHE_MAXIMUM;
}
- return (ttl);
+ return ttl;
}
/*
* Lie a little here. This is more or less so code that cares
* can find out if any new information was added or not.
*/
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
/*
if (result) {
result = dec_adb_irefcnt(adb);
}
- return (result);
+ return result;
}
/*
name->flags |= NAME_IS_DEAD;
}
}
- return (result);
+ return result;
}
/*
clean_target(adb, &name->target);
name->expire_target = INT_MAX;
}
- return (result4 || result6);
+ return result4 || result6;
}
/*
if (adb->name_sd[bucket] && adb->name_refcnt[bucket] == 0) {
result = true;
}
- return (result);
+ return result;
}
/*
if (adb->entry_sd[bucket] && adb->entry_refcnt[bucket] == 0) {
result = true;
}
- return (result);
+ return result;
}
static void
UNLOCK(&adb->namelocks[bucket]);
}
- return (result);
+ return result;
}
/*
UNLOCK(&adb->entrylocks[bucket]);
}
- return (result);
+ return result;
}
/*
if (addr_bucket != DNS_ADB_INVALIDBUCKET) {
UNLOCK(&adb->entrylocks[addr_bucket]);
}
- return (result);
+ return result;
}
static void
*/
result = dns_rdataset_first(rdataset);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_current(rdataset, &rdata);
result = dns_rdata_tostruct(&rdata, &cname, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_name_dup(&cname.cname, adb->mctx, target);
dns_rdata_freestruct(&cname);
*/
result = dns_rdataset_first(rdataset);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_current(rdataset, &rdata);
result = dns_rdata_tostruct(&rdata, &dname, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
* Construct the new target name.
NULL);
dns_rdata_freestruct(&dname);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_name_dup(new_target, adb->mctx, target);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
result = true;
}
UNLOCK(&adb->reflock);
- return (result);
+ return result;
}
static void
}
if (!destroy_entry) {
- return (result);
+ return result;
}
entry->lock_bucket = DNS_ADB_INVALIDBUCKET;
result = dec_adb_irefcnt(adb);
}
- return (result);
+ return result;
}
static dns_adbname_t *
}
UNLOCK(&adb->namescntlock);
- return (name);
+ return name;
}
static void
nh->entry = entry;
ISC_LINK_INIT(nh, plink);
- return (nh);
+ return nh;
}
static void
li->qtype = qtype;
ISC_LINK_INIT(li, plink);
- return (li);
+ return li;
}
static void
}
UNLOCK(&adb->entriescntlock);
- return (e);
+ return e;
}
static void
inc_adb_irefcnt(adb);
h->magic = DNS_ADBFIND_MAGIC;
- return (h);
+ return h;
}
static dns_adbfetch_t *
f->magic = DNS_ADBFETCH_MAGIC;
- return (f);
+ return f;
}
static void
isc_refcount_decrement(&adb->ahrefcnt);
isc_mem_put(adb->mctx, find, sizeof(*find));
- return (dec_adb_irefcnt(adb));
+ return dec_adb_irefcnt(adb);
}
/*
ai->entry = entry;
ISC_LINK_INIT(ai, publink);
- return (ai);
+ return ai;
}
static void
STARTATZONE_MATCHES(adbname, options) &&
STATICSTUB_MATCHES(adbname, options))
{
- return (adbname);
+ return adbname;
}
}
adbname = ISC_LIST_NEXT(adbname, plink);
}
- return (NULL);
+ return NULL;
}
/*
{
ISC_LIST_UNLINK(adb->entries[bucket], entry, plink);
ISC_LIST_PREPEND(adb->entries[bucket], entry, plink);
- return (entry);
+ return entry;
}
}
- return (NULL);
+ return NULL;
}
/*
li = ISC_LIST_HEAD(entry->lameinfo);
if (li == NULL) {
- return (false);
+ return false;
}
while (li != NULL) {
next_li = ISC_LIST_NEXT(li, plink);
li = next_li;
}
- return (is_bad);
+ return is_bad;
}
static void
name = *namep;
if (NAME_HAS_V4(name) || NAME_HAS_V6(name)) {
- return (result);
+ return result;
}
if (NAME_FETCH(name)) {
- return (result);
+ return result;
}
if (!EXPIRE_OK(name->expire_v4, now)) {
- return (result);
+ return result;
}
if (!EXPIRE_OK(name->expire_v6, now)) {
- return (result);
+ return result;
}
if (!EXPIRE_OK(name->expire_target, now)) {
- return (result);
+ return result;
}
/*
* Our caller, or one of its callers, will be calling check_exit() at
* some point, so we don't need to do it here.
*/
- return (result);
+ return result;
}
/*%
entry = *entryp;
if (entry->refcnt != 0) {
- return (result);
+ return result;
}
if (entry->expires == 0 || entry->expires > now) {
- return (result);
+ return result;
}
/*
if (result) {
dec_adb_irefcnt(adb);
}
- return (result);
+ return result;
}
/*
LOCK(&adb->namelocks[bucket]);
if (adb->name_sd[bucket]) {
UNLOCK(&adb->namelocks[bucket]);
- return (result);
+ return result;
}
name = ISC_LIST_HEAD(adb->names[bucket]);
name = next_name;
}
UNLOCK(&adb->namelocks[bucket]);
- return (result);
+ return result;
}
/*
entry = next_entry;
}
UNLOCK(&adb->entrylocks[bucket]);
- return (result);
+ return result;
}
static void
*/
adb->magic = DNS_ADB_MAGIC;
*newadb = adb;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
fail2:
if (adb->task != NULL) {
}
isc_mem_putanddetach(&adb->mctx, adb, sizeof(dns_adb_t));
- return (result);
+ return result;
}
void
DP(DEF_LEVEL, "dns_adb_createfind: returning "
"ISC_R_SHUTTINGDOWN");
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
if (now == 0) {
}
UNLOCK(&adb->namelocks[bucket]);
- return (result);
+ return result;
}
void
dns_rdataset_disassociate(&rdataset);
}
- return (result);
+ return result;
}
static void
dns_rdataset_disassociate(&rdataset);
}
- return (result);
+ return result;
}
/*
unlock:
UNLOCK(&adb->entrylocks[bucket]);
- return (result);
+ return result;
}
void
size = addr->entry->udpsize;
UNLOCK(&adb->entrylocks[bucket]);
- return (size);
+ return size;
}
void
}
UNLOCK(&adb->entrylocks[bucket]);
- return (len);
+ return len;
}
isc_result_t
unlock:
UNLOCK(&adb->entrylocks[bucket]);
- return (result);
+ return result;
}
void
uint_fast32_t quota = atomic_load_relaxed(&entry->quota);
uint_fast32_t active = atomic_load_acquire(&entry->active);
- return (quota != 0 && active >= quota);
+ return quota != 0 && active >= quota;
}
void
bc->magic = BADCACHE_MAGIC;
*bcp = bc;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
}
RWUNLOCK(&bc->lock, isc_rwlocktype_read);
- return (answer);
+ return answer;
}
void
remaining = sizeof(textname) - (cp - textname);
strlcpy(cp, "ip6.arpa.", remaining);
} else {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
len = (unsigned int)strlen(textname);
isc_buffer_init(&buffer, textname, len);
isc_buffer_add(&buffer, len);
- return (dns_name_fromtext(name, &buffer, dns_rootname, 0, NULL));
+ return dns_name_fromtext(name, &buffer, dns_rootname, 0, NULL);
}
struct dns_byaddr {
dns_rdataset_current(rdataset, &rdata);
result = dns_rdata_tostruct(&rdata, &ptr, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
name = isc_mem_get(byaddr->mctx, sizeof(*name));
dns_name_init(name, NULL);
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
static void
*byaddrp = byaddr;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_lock:
isc_mutex_destroy(&byaddr->lock);
isc_mem_putanddetach(&mctx, byaddr, sizeof(*byaddr));
- return (result);
+ return result;
}
void
*dbp = db;
*tmctxp = tmctx;
*hmctxp = hmctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = isc_task_create(cache->taskmgr, 1, &dbtask);
*tmctxp = tmctx;
*hmctxp = hmctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_dbtask:
isc_task_detach(&dbtask);
isc_mem_detach(&tmctx);
isc_mem_detach(&hmctx);
- return (result);
+ return result;
}
static void
}
*cachep = cache;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
cache_free(cache);
- return (result);
+ return result;
}
void
dns_cache_getname(dns_cache_t *cache) {
REQUIRE(VALID_CACHE(cache));
- return (cache->name);
+ return cache->name;
}
/*
overmem_cleaning_action, cleaner, sizeof(isc_event_t));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (cleaner->overmem_event != NULL) {
}
isc_mutex_destroy(&cleaner->lock);
- return (result);
+ return result;
}
static void
result = dns_db_createiterator(cache->db, 0, &iterator);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_dbiterator_first(iterator);
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
static void
size = cache->size;
UNLOCK(&cache->lock);
- return (size);
+ return size;
}
void
* to confirm the value that the db is really using.
*/
result = dns_db_getservestalettl(cache->db, &ttl);
- return (result == ISC_R_SUCCESS ? ttl : 0);
+ return result == ISC_R_SUCCESS ? ttl : 0;
}
void
REQUIRE(VALID_CACHE(cache));
result = dns_db_getservestalerefresh(cache->db, &interval);
- return (result == ISC_R_SUCCESS ? interval : 0);
+ return result == ISC_R_SUCCESS ? interval : 0;
}
/*
result = cache_create_db(cache, &db, &tmctx, &hmctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_createiterator(db, false, &dbiterator);
dns_db_detach(&db);
isc_mem_detach(&tmctx);
isc_mem_detach(&hmctx);
- return (result);
+ return result;
}
LOCK(&cache->lock);
isc_mem_detach(&oldhmctx);
isc_mem_detach(&oldtmctx);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
result = dns_db_allrdatasets(db, node, NULL, DNS_DB_STALEOK,
(isc_stdtime_t)0, &iter);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (result = dns_rdatasetiter_first(iter); result == ISC_R_SUCCESS;
}
dns_rdatasetiter_destroy(&iter);
- return (result);
+ return result;
}
static isc_result_t
dns_db_detachnode(db, &top);
}
- return (answer);
+ return answer;
}
isc_result_t
dns_cache_flushname(dns_cache_t *cache, const dns_name_t *name) {
- return (dns_cache_flushnode(cache, name, false));
+ return dns_cache_flushnode(cache, name, false);
}
isc_result_t
dns_db_t *db = NULL;
if (tree && dns_name_equal(name, dns_rootname)) {
- return (dns_cache_flush(cache));
+ return dns_cache_flush(cache);
}
LOCK(&cache->lock);
}
UNLOCK(&cache->lock);
if (db == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (tree) {
cleanup_db:
dns_db_detach(&db);
- return (result);
+ return result;
}
isc_stats_t *
dns_cache_getstats(dns_cache_t *cache) {
REQUIRE(VALID_CACHE(cache));
- return (cache->stats);
+ return cache->stats;
}
void
TRY0(xmlTextWriterEndElement(writer)); /* counter */
error:
- return (xmlrc);
+ return xmlrc;
}
int
TRY0(renderstat("HeapMemInUse", isc_mem_inuse(cache->hmctx), writer));
TRY0(renderstat("HeapMemMax", isc_mem_maxinuse(cache->hmctx), writer));
error:
- return (xmlrc);
+ return xmlrc;
}
#endif /* ifdef HAVE_LIBXML2 */
result = ISC_R_SUCCESS;
error:
- return (result);
+ return result;
}
#endif /* ifdef HAVE_JSON_C */
dns_name_t *
dns_catz_entry_getname(dns_catz_entry_t *entry) {
REQUIRE(DNS_CATZ_ENTRY_VALID(entry));
- return (&entry->name);
+ return &entry->name;
}
void
REQUIRE(DNS_CATZ_ENTRY_VALID(entry));
UNUSED(entry);
- return (true);
+ return true;
}
bool
REQUIRE(DNS_CATZ_ENTRY_VALID(eb));
if (ea == eb) {
- return (true);
+ return true;
}
if (ea->opts.masters.count != eb->opts.masters.count) {
- return (false);
+ return false;
}
if (memcmp(ea->opts.masters.addrs, eb->opts.masters.addrs,
ea->opts.masters.count * sizeof(isc_sockaddr_t)))
{
- return (false);
+ return false;
}
for (size_t i = 0; i < eb->opts.masters.count; i++) {
if ((ea->opts.masters.keys[i] == NULL) !=
(eb->opts.masters.keys[i] == NULL))
{
- return (false);
+ return false;
}
if (ea->opts.masters.keys[i] == NULL) {
continue;
if (!dns_name_equal(ea->opts.masters.keys[i],
eb->opts.masters.keys[i]))
{
- return (false);
+ return false;
}
}
if ((ea->opts.masters.tlss[i] == NULL) !=
(eb->opts.masters.tlss[i] == NULL))
{
- return (false);
+ return false;
}
if (ea->opts.masters.tlss[i] == NULL) {
continue;
if (!dns_name_equal(ea->opts.masters.tlss[i],
eb->opts.masters.tlss[i]))
{
- return (false);
+ return false;
}
}
/* If one is NULL and the other isn't, the entries don't match */
if ((ea->opts.allow_query == NULL) != (eb->opts.allow_query == NULL)) {
- return (false);
+ return false;
}
/* If one is non-NULL, then they both are */
isc_buffer_usedregion(ea->opts.allow_query, &ra);
isc_buffer_usedregion(eb->opts.allow_query, &rb);
if (isc_region_compare(&ra, &rb)) {
- return (false);
+ return false;
}
}
if ((ea->opts.allow_transfer == NULL) !=
(eb->opts.allow_transfer == NULL))
{
- return (false);
+ return false;
}
if (ea->opts.allow_transfer != NULL) {
isc_buffer_usedregion(ea->opts.allow_transfer, &ra);
isc_buffer_usedregion(eb->opts.allow_transfer, &rb);
if (isc_region_compare(&ra, &rb)) {
- return (false);
+ return false;
}
}
- return (true);
+ return true;
}
dns_name_t *
dns_catz_zone_getname(dns_catz_zone_t *catz) {
REQUIRE(DNS_CATZ_ZONE_VALID(catz));
- return (&catz->name);
+ return &catz->name;
}
dns_catz_options_t *
dns_catz_zone_getdefoptions(dns_catz_zone_t *catz) {
REQUIRE(DNS_CATZ_ZONE_VALID(catz));
- return (&catz->defoptions);
+ return &catz->defoptions;
}
void
UNLOCK(&catz->lock);
- return (result);
+ return result;
}
isc_result_t
*catzsp = catzs;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_task:
isc_mem_put(mctx, catzs, sizeof(*catzs));
- return (result);
+ return result;
}
void *
dns_catz_zones_get_udata(dns_catz_zones_t *catzs) {
REQUIRE(DNS_CATZ_ZONES_VALID(catzs));
- return (catzs->zmm->udata);
+ return catzs->zmm->udata;
}
void
*catzp = catz;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_timer:
isc_mem_put(catzs->mctx, catz, sizeof(*catz));
- return (result);
+ return result;
}
isc_result_t
cleanup:
UNLOCK(&catzs->lock);
- return (result);
+ return result;
}
dns_catz_zone_t *
LOCK(&catzs->lock);
if (catzs->zones == NULL) {
UNLOCK(&catzs->lock);
- return (NULL);
+ return NULL;
}
result = isc_ht_find(catzs->zones, name->ndata, name->length,
(void **)&found);
UNLOCK(&catzs->lock);
if (result != ISC_R_SUCCESS) {
- return (NULL);
+ return NULL;
}
- return (found);
+ return found;
}
static void
if (option->length - 1 == len &&
memcmp(opt, option->base + 1, len) == 0)
{
- return (true);
+ return true;
} else {
- return (false);
+ return false;
}
}
static catz_opt_t
catz_get_option(const dns_label_t *option) {
if (catz_opt_cmp(option, "ext")) {
- return (CATZ_OPT_EXT);
+ return CATZ_OPT_EXT;
} else if (catz_opt_cmp(option, "zones")) {
- return (CATZ_OPT_ZONES);
+ return CATZ_OPT_ZONES;
} else if (catz_opt_cmp(option, "masters") ||
catz_opt_cmp(option, "primaries"))
{
- return (CATZ_OPT_PRIMARIES);
+ return CATZ_OPT_PRIMARIES;
} else if (catz_opt_cmp(option, "allow-query")) {
- return (CATZ_OPT_ALLOW_QUERY);
+ return CATZ_OPT_ALLOW_QUERY;
} else if (catz_opt_cmp(option, "allow-transfer")) {
- return (CATZ_OPT_ALLOW_TRANSFER);
+ return CATZ_OPT_ALLOW_TRANSFER;
} else if (catz_opt_cmp(option, "coo")) {
- return (CATZ_OPT_COO);
+ return CATZ_OPT_COO;
} else if (catz_opt_cmp(option, "version")) {
- return (CATZ_OPT_VERSION);
+ return CATZ_OPT_VERSION;
} else {
- return (CATZ_OPT_NONE);
+ return CATZ_OPT_NONE;
}
}
REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC));
if (name->labels == 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
dns_name_getlabel(name, name->labels - 1, &mhash);
if (name->labels == 1) {
- return (catz_process_zones_entry(catz, value, &mhash));
+ return catz_process_zones_entry(catz, value, &mhash);
} else {
dns_name_init(&opt, NULL);
dns_name_split(name, 1, &opt, NULL);
- return (catz_process_zones_suboption(catz, value, &mhash,
- &opt));
+ return catz_process_zones_suboption(catz, value, &mhash, &opt);
}
}
/* Change of Ownership was introduced in version "2" of the schema. */
if (catz->version < 2) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (value->type != dns_rdatatype_ptr) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (dns_rdataset_count(value) != 1) {
"catz: 'coo' property PTR RRset contains "
"more than one record, which is invalid");
catz->broken = true;
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
result = dns_rdataset_first(value);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdata_init(&rdata);
result = dns_rdata_tostruct(&rdata, &ptr, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (dns_name_countlabels(&ptr.ptr) == 0) {
cleanup:
dns_rdata_freestruct(&ptr);
- return (result);
+ return result;
}
static isc_result_t
dns_catz_entry_t *entry = NULL;
if (value->type != dns_rdatatype_ptr) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (dns_rdataset_count(value) != 1) {
"catz: member zone PTR RRset contains "
"more than one record, which is invalid");
catz->broken = true;
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
result = dns_rdataset_first(value);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdata_init(&rdata);
result = dns_rdata_tostruct(&rdata, &ptr, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = isc_ht_find(catz->entries, mhash->base, mhash->length,
if (dns_name_countlabels(&entry->name) != 0) {
/* We have a duplicate. */
dns_rdata_freestruct(&ptr);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
} else {
dns_name_dup(&ptr.ptr, catz->catzs->mctx, &entry->name);
}
if (result != ISC_R_SUCCESS) {
dns_rdata_freestruct(&ptr);
dns_catz_entry_detach(catz, &entry);
- return (result);
+ return result;
}
}
dns_rdata_freestruct(&ptr);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(DNS_RDATASET_VALID(value));
if (value->type != dns_rdatatype_txt) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (dns_rdataset_count(value) != 1) {
"catz: 'version' property TXT RRset contains "
"more than one record, which is invalid");
catz->broken = true;
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
result = dns_rdataset_first(value);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdata_init(&rdata);
result = dns_rdata_tostruct(&rdata, &rdatatxt, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_rdata_txt_first(&rdatatxt);
"zone version property");
catz->broken = true;
}
- return (result);
+ return result;
}
static isc_result_t
result = dns_rdata_txt_first(&rdata_txt);
if (result != ISC_R_SUCCESS) {
dns_rdata_freestruct(&rdata_txt);
- return (result);
+ return result;
}
result = dns_rdata_txt_current(&rdata_txt, &rdatastr);
if (result != ISC_R_SUCCESS) {
dns_rdata_freestruct(&rdata_txt);
- return (result);
+ return result;
}
result = dns_rdata_txt_next(&rdata_txt);
if (result != ISC_R_NOMORE) {
dns_rdata_freestruct(&rdata_txt);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* rdatastr.length < DNS_NAME_MAXTEXT */
if (result != ISC_R_SUCCESS) {
dns_name_free(keyname, mctx);
isc_mem_put(mctx, keyname, sizeof(*keyname));
- return (result);
+ return result;
}
break;
default:
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
} else {
result = dns_ipkeylist_resize(mctx, ipkl, i + 1);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
ipkl->labels[i] = isc_mem_get(mctx,
}
ipkl->count++;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* else - 'simple' case - without labels */
if (value->type != dns_rdatatype_a && value->type != dns_rdatatype_aaaa)
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
rcount = dns_rdataset_count(value) + ipkl->count;
result = dns_ipkeylist_resize(mctx, ipkl, rcount);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (result = dns_rdataset_first(value); result == ISC_R_SUCCESS;
ipkl->labels[ipkl->count] = NULL;
ipkl->count++;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(dns_rdataset_isassociated(value));
if (value->type != dns_rdatatype_apl) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (dns_rdataset_count(value) > 1) {
dns_rdataset_current(value, &rdata);
result = dns_rdata_tostruct(&rdata, &rdata_apl, catz->catzs->mctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_allocate(catz->catzs->mctx, &aclb, 16);
isc_buffer_setautorealloc(aclb, true);
isc_buffer_free(&aclb);
}
dns_rdata_freestruct(&rdata_apl);
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC));
if (name->labels < 1) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
dns_name_getlabel(name, name->labels - 1, &option);
opt = catz_get_option(&option);
*/
if (catz->version >= 2 && opt >= CATZ_OPT_CUSTOM_START) {
if (opt != CATZ_OPT_EXT || name->labels < 2) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
suffix_labels++;
dns_name_getlabel(name, name->labels - 2, &option);
entry);
if (result != ISC_R_SUCCESS) {
dns_catz_entry_detach(catz, &entry);
- return (result);
+ return result;
}
}
dns_name_split(name, suffix_labels, &prefix, NULL);
switch (opt) {
case CATZ_OPT_COO:
- return (catz_process_coo(catz, mhash, value));
+ return catz_process_coo(catz, mhash, value);
case CATZ_OPT_PRIMARIES:
- return (catz_process_primaries(catz, &entry->opts.masters,
- value, &prefix));
+ return catz_process_primaries(catz, &entry->opts.masters, value,
+ &prefix);
case CATZ_OPT_ALLOW_QUERY:
if (prefix.labels != 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (catz_process_apl(catz, &entry->opts.allow_query,
- value));
+ return catz_process_apl(catz, &entry->opts.allow_query, value);
case CATZ_OPT_ALLOW_TRANSFER:
if (prefix.labels != 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (catz_process_apl(catz, &entry->opts.allow_transfer,
- value));
+ return catz_process_apl(catz, &entry->opts.allow_transfer,
+ value);
default:
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
static void
REQUIRE(DNS_RDATASET_VALID(rdataset));
if (name->labels < 1) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
dns_name_getlabel(name, name->labels - 1, &option);
opt = catz_get_option(&option);
*/
if (catz->version >= 2 && opt >= CATZ_OPT_CUSTOM_START) {
if (opt != CATZ_OPT_EXT || name->labels < 2) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
suffix_labels++;
dns_name_getlabel(name, name->labels - 2, &option);
switch (opt) {
case CATZ_OPT_ZONES:
- return (catz_process_zones(catz, rdataset, &prefix));
+ return catz_process_zones(catz, rdataset, &prefix);
case CATZ_OPT_PRIMARIES:
- return (catz_process_primaries(catz, &catz->zoneoptions.masters,
- rdataset, &prefix));
+ return catz_process_primaries(catz, &catz->zoneoptions.masters,
+ rdataset, &prefix);
case CATZ_OPT_ALLOW_QUERY:
if (prefix.labels != 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (catz_process_apl(catz, &catz->zoneoptions.allow_query,
- rdataset));
+ return catz_process_apl(catz, &catz->zoneoptions.allow_query,
+ rdataset);
case CATZ_OPT_ALLOW_TRANSFER:
if (prefix.labels != 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (catz_process_apl(
- catz, &catz->zoneoptions.allow_transfer, rdataset));
+ return catz_process_apl(catz, &catz->zoneoptions.allow_transfer,
+ rdataset);
case CATZ_OPT_VERSION:
if (prefix.labels != 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (catz_process_version(catz, rdataset));
+ return catz_process_version(catz, rdataset);
default:
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
"catz: RR found which has a non-IN class");
catz->broken = true;
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
nrres = dns_name_fullcompare(src_name, &catz->name, &order, &nlabels);
if (rdataset->type == dns_rdatatype_soa) {
result = dns_rdataset_first(rdataset);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_current(rdataset, &rdata);
* xxxwpk TODO do we want to save something from SOA?
*/
dns_rdata_freestruct(&soa);
- return (result);
+ return result;
} else if (rdataset->type == dns_rdatatype_ns) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
} else if (nrres != dns_namereln_subdomain) {
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
dns_name_init(&prefix, NULL);
dns_name_split(src_name, catz->name.labels, &prefix, NULL);
result = catz_process_value(catz, &prefix, rdataset);
- return (result);
+ return result;
}
static isc_result_t
size_t left = hashlen - i * 2;
int ret = snprintf(hash + i * 2, left, "%02x", digest[i]);
if (ret < 0 || (size_t)ret >= left) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
cleanup:
isc_buffer_free(&tbuf);
- return (result);
+ return result;
}
/*
isc_buffer_putstr(buffer, "};");
*buf = buffer;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
isc_buffer_free(&buffer);
- return (result);
+ return result;
}
static void
REQUIRE(DNS_CATZ_ZONES_VALID(catzs));
if (atomic_load(&catzs->shuttingdown)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
dns_name_toregion(&db->origin, &r);
cleanup:
UNLOCK(&catzs->lock);
- return (result);
+ return result;
}
void
static bool
catz_rdatatype_is_processable(const dns_rdatatype_t type) {
- return (!dns_rdatatype_isdnssec(type) && type != dns_rdatatype_cds &&
- type != dns_rdatatype_cdnskey && type != dns_rdatatype_zonemd);
+ return !dns_rdatatype_isdnssec(type) && type != dns_rdatatype_cds &&
+ type != dns_rdatatype_cdnskey && type != dns_rdatatype_zonemd;
}
/*
isc_portset_destroy(mctx, &v6portset);
}
- return (result);
+ return result;
}
static isc_result_t
*dispp = disp;
}
- return (result);
+ return result;
}
static isc_result_t
result = dns_view_create(mctx, rdclass, DNS_CLIENTVIEW_NAME, &view);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/* Initialize view security roots */
result = dns_view_initsecroots(view, mctx);
if (result != ISC_R_SUCCESS) {
dns_view_detach(&view);
- return (result);
+ return result;
}
result = dns_view_createresolver(view, taskmgr, ntasks, 1, nm, timermgr,
dispatchv6);
if (result != ISC_R_SUCCESS) {
dns_view_detach(&view);
- return (result);
+ return result;
}
result = dns_db_create(mctx, "rbt", dns_rootname, dns_dbtype_cache,
rdclass, 0, NULL, &view->cachedb);
if (result != ISC_R_SUCCESS) {
dns_view_detach(&view);
- return (result);
+ return result;
}
*viewp = view;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
*clientp = client;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_references:
isc_refcount_decrementz(&client->references);
isc_mutex_destroy(&client->lock);
isc_mem_put(mctx, client, sizeof(*client));
- return (result);
+ return result;
}
static void
rdclass, &view);
if (result != ISC_R_SUCCESS) {
UNLOCK(&client->lock);
- return (result);
+ return result;
}
UNLOCK(&client->lock);
dns_view_detach(&view);
- return (result);
+ return result;
}
isc_result_t
rdclass, &view);
if (result != ISC_R_SUCCESS) {
UNLOCK(&client->lock);
- return (result);
+ return result;
}
UNLOCK(&client->lock);
dns_view_detach(&view);
- return (result);
+ return result;
}
void
*rdatasetp = rdataset;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
rctx->task, fetch_done, rctx, rctx->rdataset, rctx->sigrdataset,
&rctx->fetch);
- return (result);
+ return result;
}
static isc_result_t
nodep, foundname, rctx->rdataset,
rctx->sigrdataset);
- return (result);
+ return result;
}
static void
if (result != ISC_R_SUCCESS) {
isc_mutex_destroy(&resarg->lock);
isc_mem_put(client->mctx, resarg, sizeof(*resarg));
- return (result);
+ return result;
}
/*
isc_mem_put(client->mctx, resarg, sizeof(*resarg));
}
- return (result);
+ return result;
}
isc_result_t
rdclass, &view);
UNLOCK(&client->lock);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
mctx = client->mctx;
*transp = (dns_clientrestrans_t *)rctx;
client_resfind(rctx, NULL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (rdataset != NULL) {
isc_task_detach(&tclone);
dns_view_detach(&view);
- return (result);
+ return result;
}
/*%<
if (secroots != NULL) {
dns_keytable_detach(&secroots);
}
- return (result);
+ return result;
}
cctx->magic = CCTX_MAGIC;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
unsigned int
dns_compress_getmethods(dns_compress_t *cctx) {
REQUIRE(VALID_CCTX(cctx));
- return (cctx->allowed & DNS_COMPRESS_ALL);
+ return cctx->allowed & DNS_COMPRESS_ALL;
}
void
dns_compress_getsensitive(dns_compress_t *cctx) {
REQUIRE(VALID_CCTX(cctx));
- return (cctx->allowed & DNS_COMPRESS_CASESENSITIVE);
+ return cctx->allowed & DNS_COMPRESS_CASESENSITIVE;
}
int
dns_compress_getedns(dns_compress_t *cctx) {
REQUIRE(VALID_CCTX(cctx));
- return (cctx->edns);
+ return cctx->edns;
}
/*
REQUIRE(offset != NULL);
if ((cctx->allowed & DNS_COMPRESS_ENABLED) == 0) {
- return (false);
+ return false;
}
if (cctx->count == 0) {
- return (false);
+ return false;
}
labels = dns_name_countlabels(name);
* If node == NULL, we found no match at all.
*/
if (node == NULL) {
- return (false);
+ return false;
}
if (n == 0) {
}
*offset = (node->offset & 0x7fff);
- return (true);
+ return true;
}
static unsigned int
name_length(const dns_name_t *name) {
isc_region_t r;
dns_name_toregion(name, &r);
- return (r.length);
+ return r.length;
}
void
dns_decompress_getmethods(dns_decompress_t *dctx) {
REQUIRE(VALID_DCTX(dctx));
- return (dctx->allowed);
+ return dctx->allowed;
}
int
dns_decompress_edns(dns_decompress_t *dctx) {
REQUIRE(VALID_DCTX(dctx));
- return (dctx->edns);
+ return dctx->edns;
}
dns_decompresstype_t
dns_decompress_type(dns_decompress_t *dctx) {
REQUIRE(VALID_DCTX(dctx));
- return (dctx->type);
+ return dctx->type;
}
imp = ISC_LIST_NEXT(imp, link))
{
if (strcasecmp(name, imp->name) == 0) {
- return (imp);
+ return imp;
}
}
- return (NULL);
+ return NULL;
}
/***
result = ((impinfo->create)(mctx, origin, type, rdclass, argc,
argv, impinfo->driverarg, dbp));
RWUNLOCK(&implock, isc_rwlocktype_read);
- return (result);
+ return result;
}
RWUNLOCK(&implock, isc_rwlocktype_read);
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DB,
ISC_LOG_ERROR, "unsupported database type '%s'", db_type);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
void
REQUIRE(DNS_DB_VALID(db));
if ((db->attributes & DNS_DBATTR_CACHE) != 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
REQUIRE(DNS_DB_VALID(db));
if ((db->attributes & (DNS_DBATTR_CACHE | DNS_DBATTR_STUB)) == 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
REQUIRE(DNS_DB_VALID(db));
if ((db->attributes & DNS_DBATTR_STUB) != 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
if (db->methods->isdnssec != NULL) {
- return ((db->methods->isdnssec)(db));
+ return (db->methods->isdnssec)(db);
}
- return ((db->methods->issecure)(db));
+ return (db->methods->issecure)(db);
}
bool
REQUIRE(DNS_DB_VALID(db));
REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
- return ((db->methods->issecure)(db));
+ return (db->methods->issecure)(db);
}
bool
REQUIRE(DNS_DB_VALID(db));
- return ((db->methods->ispersistent)(db));
+ return (db->methods->ispersistent)(db);
}
dns_name_t *
REQUIRE(DNS_DB_VALID(db));
- return (&db->origin);
+ return &db->origin;
}
dns_rdataclass_t
REQUIRE(DNS_DB_VALID(db));
- return (db->rdclass);
+ return db->rdclass;
}
isc_result_t
REQUIRE(DNS_DB_VALID(db));
REQUIRE(DNS_CALLBACK_VALID(callbacks));
- return ((db->methods->beginload)(db, callbacks));
+ return (db->methods->beginload)(db, callbacks);
}
isc_result_t
listener->onupdate(db, listener->onupdate_arg);
}
- return ((db->methods->endload)(db, callbacks));
+ return (db->methods->endload)(db, callbacks);
}
isc_result_t
dns_rdatacallbacks_init(&callbacks);
result = dns_db_beginload(db, &callbacks);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_master_loadfile(filename, &db->origin, &db->origin,
db->rdclass, options, 0, &callbacks, NULL,
result = eresult;
}
- return (result);
+ return result;
}
isc_result_t
dns_db_dump(dns_db_t *db, dns_dbversion_t *version, const char *filename) {
- return ((db->methods->dump)(db, version, filename,
- dns_masterformat_text));
+ return (db->methods->dump)(db, version, filename,
+ dns_masterformat_text);
}
/***
REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
REQUIRE(versionp != NULL && *versionp == NULL);
- return ((db->methods->newversion)(db, versionp));
+ return (db->methods->newversion)(db, versionp);
}
void
REQUIRE(nodep != NULL && *nodep == NULL);
if (db->methods->findnode != NULL) {
- return ((db->methods->findnode)(db, name, create, nodep));
+ return (db->methods->findnode)(db, name, create, nodep);
} else {
- return ((db->methods->findnodeext)(db, name, create, NULL, NULL,
- nodep));
+ return (db->methods->findnodeext)(db, name, create, NULL, NULL,
+ nodep);
}
}
REQUIRE(nodep != NULL && *nodep == NULL);
if (db->methods->findnodeext != NULL) {
- return ((db->methods->findnodeext)(db, name, create, methods,
- clientinfo, nodep));
+ return (db->methods->findnodeext)(db, name, create, methods,
+ clientinfo, nodep);
} else {
- return ((db->methods->findnode)(db, name, create, nodep));
+ return (db->methods->findnode)(db, name, create, nodep);
}
}
REQUIRE(DNS_DB_VALID(db));
REQUIRE(nodep != NULL && *nodep == NULL);
- return ((db->methods->findnsec3node)(db, name, create, nodep));
+ return (db->methods->findnsec3node)(db, name, create, nodep);
}
isc_result_t
!dns_rdataset_isassociated(sigrdataset)));
if (db->methods->find != NULL) {
- return ((db->methods->find)(db, name, version, type, options,
- now, nodep, foundname, rdataset,
- sigrdataset));
+ return (db->methods->find)(db, name, version, type, options,
+ now, nodep, foundname, rdataset,
+ sigrdataset);
} else {
- return ((db->methods->findext)(db, name, version, type, options,
- now, nodep, foundname, NULL,
- NULL, rdataset, sigrdataset));
+ return (db->methods->findext)(db, name, version, type, options,
+ now, nodep, foundname, NULL, NULL,
+ rdataset, sigrdataset);
}
}
!dns_rdataset_isassociated(sigrdataset)));
if (db->methods->findext != NULL) {
- return ((db->methods->findext)(
+ return (db->methods->findext)(
db, name, version, type, options, now, nodep, foundname,
- methods, clientinfo, rdataset, sigrdataset));
+ methods, clientinfo, rdataset, sigrdataset);
} else {
- return ((db->methods->find)(db, name, version, type, options,
- now, nodep, foundname, rdataset,
- sigrdataset));
+ return (db->methods->find)(db, name, version, type, options,
+ now, nodep, foundname, rdataset,
+ sigrdataset);
}
}
(DNS_RDATASET_VALID(sigrdataset) &&
!dns_rdataset_isassociated(sigrdataset)));
- return ((db->methods->findzonecut)(db, name, options, now, nodep,
- foundname, dcname, rdataset,
- sigrdataset));
+ return (db->methods->findzonecut)(db, name, options, now, nodep,
+ foundname, dcname, rdataset,
+ sigrdataset);
}
void
REQUIRE((db->attributes & DNS_DBATTR_CACHE) != 0);
REQUIRE(node != NULL);
- return ((db->methods->expirenode)(db, node, now));
+ return (db->methods->expirenode)(db, node, now);
}
void
REQUIRE((flags & (DNS_DB_NSEC3ONLY | DNS_DB_NONSEC3)) !=
(DNS_DB_NSEC3ONLY | DNS_DB_NONSEC3));
- return (db->methods->createiterator(db, flags, iteratorp));
+ return db->methods->createiterator(db, flags, iteratorp);
}
/***
(DNS_RDATASET_VALID(sigrdataset) &&
!dns_rdataset_isassociated(sigrdataset)));
- return ((db->methods->findrdataset)(db, node, version, type, covers,
- now, rdataset, sigrdataset));
+ return (db->methods->findrdataset)(db, node, version, type, covers, now,
+ rdataset, sigrdataset);
}
isc_result_t
REQUIRE(DNS_DB_VALID(db));
REQUIRE(iteratorp != NULL && *iteratorp == NULL);
- return ((db->methods->allrdatasets)(db, node, version, options, now,
- iteratorp));
+ return (db->methods->allrdatasets)(db, node, version, options, now,
+ iteratorp);
}
isc_result_t
(DNS_RDATASET_VALID(addedrdataset) &&
!dns_rdataset_isassociated(addedrdataset)));
- return ((db->methods->addrdataset)(db, node, version, now, rdataset,
- options, addedrdataset));
+ return (db->methods->addrdataset)(db, node, version, now, rdataset,
+ options, addedrdataset);
}
isc_result_t
(DNS_RDATASET_VALID(newrdataset) &&
!dns_rdataset_isassociated(newrdataset)));
- return ((db->methods->subtractrdataset)(db, node, version, rdataset,
- options, newrdataset));
+ return (db->methods->subtractrdataset)(db, node, version, rdataset,
+ options, newrdataset);
}
isc_result_t
REQUIRE(((db->attributes & DNS_DBATTR_CACHE) == 0 && version != NULL) ||
((db->attributes & DNS_DBATTR_CACHE) != 0 && version == NULL));
- return ((db->methods->deleterdataset)(db, node, version, type, covers));
+ return (db->methods->deleterdataset)(db, node, version, type, covers);
}
void
result = dns_db_findnode(db, dns_db_origin(db), false, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_init(&rdataset);
freenode:
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
unsigned int
dns_db_nodecount(dns_db_t *db, dns_dbtree_t tree) {
REQUIRE(DNS_DB_VALID(db));
- return ((db->methods->nodecount)(db, tree));
+ return (db->methods->nodecount)(db, tree);
}
size_t
REQUIRE(DNS_DB_VALID(db));
if (db->methods->hashsize == NULL) {
- return (0);
+ return 0;
}
- return ((db->methods->hashsize)(db));
+ return (db->methods->hashsize)(db);
}
void
imp = impfind(name);
if (imp != NULL) {
RWUNLOCK(&implock, isc_rwlocktype_write);
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
imp = isc_mem_get(mctx, sizeof(dns_dbimplementation_t));
*dbimp = imp;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
REQUIRE(nodep != NULL && *nodep == NULL);
if (db->methods->getoriginnode != NULL) {
- return ((db->methods->getoriginnode)(db, nodep));
+ return (db->methods->getoriginnode)(db, nodep);
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
dns_stats_t *
REQUIRE(DNS_DB_VALID(db));
if (db->methods->getrrsetstats != NULL) {
- return ((db->methods->getrrsetstats)(db));
+ return (db->methods->getrrsetstats)(db);
}
- return (NULL);
+ return NULL;
}
isc_result_t
REQUIRE(DNS_DB_VALID(db));
if (db->methods->setcachestats != NULL) {
- return ((db->methods->setcachestats)(db, stats));
+ return (db->methods->setcachestats)(db, stats);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
REQUIRE(dns_db_iszone(db));
if (db->methods->getnsec3parameters != NULL) {
- return ((db->methods->getnsec3parameters)(db, version, hash,
- flags, iterations,
- salt, salt_length));
+ return (db->methods->getnsec3parameters)(db, version, hash,
+ flags, iterations,
+ salt, salt_length);
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
isc_result_t
REQUIRE(dns_db_iszone(db));
if (db->methods->getsize != NULL) {
- return ((db->methods->getsize)(db, version, records, bytes));
+ return (db->methods->getsize)(db, version, records, bytes);
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
isc_result_t
dns_db_setsigningtime(dns_db_t *db, dns_rdataset_t *rdataset,
isc_stdtime_t resign) {
if (db->methods->setsigningtime != NULL) {
- return ((db->methods->setsigningtime)(db, rdataset, resign));
+ return (db->methods->setsigningtime)(db, rdataset, resign);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
dns_db_getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset,
dns_name_t *name) {
if (db->methods->getsigningtime != NULL) {
- return ((db->methods->getsigningtime)(db, rdataset, name));
+ return (db->methods->getsigningtime)(db, rdataset, name);
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
void
isc_result_t
dns_db_rpz_ready(dns_db_t *db) {
if (db->methods->rpz_ready == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return ((db->methods->rpz_ready)(db));
+ return (db->methods->rpz_ready)(db);
}
/*
if ((listener->onupdate == fn) &&
(listener->onupdate_arg == fn_arg))
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
ISC_LINK_INIT(listener, link);
ISC_LIST_APPEND(db->update_listeners, listener, link);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
ISC_LIST_UNLINK(db->update_listeners, listener, link);
isc_mem_put(db->mctx, listener,
sizeof(dns_dbonupdatelistener_t));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
isc_result_t
REQUIRE(name != NULL);
if (db->methods->nodefullname == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
- return ((db->methods->nodefullname)(db, node, name));
+ return (db->methods->nodefullname)(db, node, name);
}
isc_result_t
REQUIRE((db->attributes & DNS_DBATTR_CACHE) != 0);
if (db->methods->setservestalettl != NULL) {
- return ((db->methods->setservestalettl)(db, ttl));
+ return (db->methods->setservestalettl)(db, ttl);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
REQUIRE((db->attributes & DNS_DBATTR_CACHE) != 0);
if (db->methods->getservestalettl != NULL) {
- return ((db->methods->getservestalettl)(db, ttl));
+ return (db->methods->getservestalettl)(db, ttl);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
REQUIRE((db->attributes & DNS_DBATTR_CACHE) != 0);
if (db->methods->setservestalerefresh != NULL) {
- return ((db->methods->setservestalerefresh)(db, interval));
+ return (db->methods->setservestalerefresh)(db, interval);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
REQUIRE((db->attributes & DNS_DBATTR_CACHE) != 0);
if (db->methods->getservestalerefresh != NULL) {
- return ((db->methods->getservestalerefresh)(db, interval));
+ return (db->methods->getservestalerefresh)(db, interval);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
REQUIRE(stats != NULL);
if (db->methods->setgluecachestats != NULL) {
- return ((db->methods->setgluecachestats)(db, stats));
+ return (db->methods->setgluecachestats)(db, stats);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
void
REQUIRE(DNS_DBITERATOR_VALID(iterator));
- return (iterator->methods->first(iterator));
+ return iterator->methods->first(iterator);
}
isc_result_t
REQUIRE(DNS_DBITERATOR_VALID(iterator));
- return (iterator->methods->last(iterator));
+ return iterator->methods->last(iterator);
}
isc_result_t
REQUIRE(DNS_DBITERATOR_VALID(iterator));
- return (iterator->methods->seek(iterator, name));
+ return iterator->methods->seek(iterator, name);
}
isc_result_t
REQUIRE(DNS_DBITERATOR_VALID(iterator));
- return (iterator->methods->prev(iterator));
+ return iterator->methods->prev(iterator);
}
isc_result_t
REQUIRE(DNS_DBITERATOR_VALID(iterator));
- return (iterator->methods->next(iterator));
+ return iterator->methods->next(iterator);
}
isc_result_t
REQUIRE(nodep != NULL && *nodep == NULL);
REQUIRE(name == NULL || dns_name_hasbuffer(name));
- return (iterator->methods->current(iterator, nodep, name));
+ return iterator->methods->current(iterator, nodep, name);
}
isc_result_t
REQUIRE(DNS_DBITERATOR_VALID(iterator));
- return (iterator->methods->pause(iterator));
+ return iterator->methods->pause(iterator);
}
isc_result_t
REQUIRE(iterator->relative_names);
REQUIRE(dns_name_hasbuffer(name));
- return (iterator->methods->origin(iterator, name));
+ return iterator->methods->origin(iterator, name);
}
void
static dns_rdatatype_t
rdata_covers(dns_rdata_t *rdata) {
- return (rdata->type == dns_rdatatype_rrsig ? dns_rdata_covers(rdata)
- : 0);
+ return rdata->type == dns_rdatatype_rrsig ? dns_rdata_covers(rdata) : 0;
}
isc_result_t
INSIST(datap == (unsigned char *)t + size);
*tp = t;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_result_t
dns_difftuple_copy(dns_difftuple_t *orig, dns_difftuple_t **copyp) {
- return (dns_difftuple_create(orig->mctx, orig->op, &orig->name,
- orig->ttl, &orig->rdata, copyp));
+ return dns_difftuple_create(orig->mctx, orig->op, &orig->name,
+ orig->ttl, &orig->rdata, copyp);
}
void
result = dns_rdataset_next(modified);
}
INSIST(result == ISC_R_NOMORE);
- return ((isc_stdtime_t)when);
+ return (isc_stdtime_t)when;
}
static void
optotext(dns_diffop_t op) {
switch (op) {
case DNS_DIFFOP_ADD:
- return ("add");
+ return "add";
case DNS_DIFFOP_ADDRESIGN:
- return ("add-resign");
+ return "add-resign";
case DNS_DIFFOP_DEL:
- return ("del");
+ return "del";
case DNS_DIFFOP_DELRESIGN:
- return ("del-resign");
+ return "del-resign";
default:
- return ("unknown");
+ return "unknown";
}
}
}
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
isc_result_t
dns_diff_apply(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver) {
- return (diff_apply(diff, db, ver, true));
+ return diff_apply(diff, db, ver, true);
}
isc_result_t
dns_diff_applysilently(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver) {
- return (diff_apply(diff, db, ver, false));
+ return diff_apply(diff, db, ver, false);
}
/* XXX this duplicates lots of code in diff_apply(). */
}
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
/*
length++;
}
if (length == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
v = isc_mem_get(diff->mctx, length * sizeof(dns_difftuple_t *));
for (i = 0; i < length; i++) {
ISC_LIST_APPEND(diff->tuples, v[i], link);
}
isc_mem_put(diff->mctx, v, length * sizeof(dns_difftuple_t *));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
ISC_LINK_INIT(rdata, link);
dns_rdata_clone(&t->rdata, rdata);
ISC_LIST_APPEND(rdl->rdata, rdata, link);
- return (dns_rdatalist_tordataset(rdl, rds));
+ return dns_rdatalist_tordataset(rdl, rds);
}
isc_result_t
if (mem != NULL) {
isc_mem_put(diff->mctx, mem, size);
}
- return (result);
+ return result;
}
switch (disp->socktype) {
case isc_socktype_udp:
- return ("UDP");
+ return "UDP";
case isc_socktype_tcp:
- return ("TCP");
+ return "TCP";
default:
- return ("<unexpected>");
+ return "<unexpected>";
}
}
state2str(dns_dispatchstate_t state) {
switch (state) {
case DNS_DISPATCHSTATE_NONE:
- return ("none");
+ return "none";
case DNS_DISPATCHSTATE_CONNECTING:
- return ("connecting");
+ return "connecting";
case DNS_DISPATCHSTATE_CONNECTED:
- return ("connected");
+ return "connected";
case DNS_DISPATCHSTATE_CANCELED:
- return ("canceled");
+ return "canceled";
default:
- return ("<unexpected>");
+ return "<unexpected>";
}
}
INSIST(ret < qid->qid_nbuckets);
- return (ret);
+ return ret;
}
/*%
in_port_t port = *portp;
if (resp->retries++ > 5) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (isc_sockaddr_pf(&disp->local) == AF_INET) {
ports = mgr->v6ports;
}
if (nports == 0) {
- return (ISC_R_ADDRNOTAVAIL);
+ return ISC_R_ADDRNOTAVAIL;
}
resp->local = disp->local;
}
resp->port = port;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (res->id == id && isc_sockaddr_equal(dest, &res->peer) &&
res->port == port)
{
- return (res);
+ return res;
}
res = ISC_LIST_NEXT(res, link);
}
- return (NULL);
+ return NULL;
}
static void
static unsigned int
dispentry_runtime(dns_dispentry_t *resp, const isc_time_t *now) {
if (isc_time_isepoch(&resp->start)) {
- return (0);
+ return 0;
}
- return (isc_time_microdiff(now, &resp->start) / 1000);
+ return isc_time_microdiff(now, &resp->start) / 1000;
}
/*
disp->timedout++;
*respp = resp;
- return (ISC_R_TIMEDOUT);
+ return ISC_R_TIMEDOUT;
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
static isc_result_t
result = dns_message_peekheader(&source, &id, &flags);
if (result != ISC_R_SUCCESS) {
dispatch_log(disp, LVL(10), "got garbage packet");
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
dispatch_log(disp, LVL(92),
*/
if ((flags & DNS_MESSAGEFLAG_QR) == 0) {
dispatch_log(disp, LVL(10), "got DNS query instead of answer");
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
/*
bucket, isc_result_totext(result));
UNLOCK(&qid->lock);
- return (result);
+ return result;
}
static void
mgr->v6ports = v6ports;
mgr->nv6ports = nv6ports;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
mgr->magic = DNS_DISPATCHMGR_MAGIC;
*mgrp = mgr;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#if DNS_DISPATCH_TRACE
dns_acl_t *
dns_dispatchmgr_getblackhole(dns_dispatchmgr_t *mgr) {
REQUIRE(VALID_DISPATCHMGR(mgr));
- return (mgr->blackhole);
+ return mgr->blackhole;
}
isc_result_t
dns_dispatchmgr_setavailports(dns_dispatchmgr_t *mgr, isc_portset_t *v4portset,
isc_portset_t *v6portset) {
REQUIRE(VALID_DISPATCHMGR(mgr));
- return (setavailports(mgr, v4portset, v6portset));
+ return setavailports(mgr, v4portset, v6portset);
}
static void
}
*dispp = disp;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
UNLOCK(&mgr->lock);
- return (result);
+ return result;
}
isc_result_t
}
UNLOCK(&mgr->lock);
- return (result);
+ return result;
}
static isc_result_t
if (!isc_sockaddr_eqaddr(&sa_any, localaddr)) {
result = isc_nm_checkaddr(localaddr, isc_socktype_udp);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
*dispp = disp;
- return (result);
+ return result;
}
static void
if (disp->state == DNS_DISPATCHSTATE_CANCELED) {
UNLOCK(&disp->lock);
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
qid = disp->mgr->qid;
isc_mem_put(disp->mgr->mctx, resp, sizeof(*resp));
UNLOCK(&disp->lock);
inc_stats(disp->mgr, dns_resstatscounter_dispsockfail);
- return (result);
+ return result;
}
}
if (!ok) {
isc_mem_put(disp->mgr->mctx, resp, sizeof(*resp));
UNLOCK(&disp->lock);
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
dns_dispatch_attach(disp, &resp->disp); /* DISPATCH001 */
*idp = id;
*respp = resp;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
TIME_NOW(&now);
timeout = resp->timeout - dispentry_runtime(resp, &now);
if (timeout <= 0) {
- return (ISC_R_TIMEDOUT);
+ return ISC_R_TIMEDOUT;
}
LOCK(&disp->lock);
}
UNLOCK(&disp->lock);
- return (result);
+ return result;
}
static void
UNREACHABLE();
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
switch (disp->socktype) {
case isc_socktype_tcp:
- return (tcp_dispatch_connect(disp, resp));
+ return tcp_dispatch_connect(disp, resp);
case isc_socktype_udp:
udp_dispatch_connect(disp, resp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
default:
UNREACHABLE();
if (disp->socktype == isc_socktype_udp) {
*addrp = disp->local;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
switch (disp->socktype) {
case isc_socktype_tcp:
*addrp = disp->local;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
case isc_socktype_udp:
*addrp = isc_nmhandle_localaddr(resp->handle);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
default:
UNREACHABLE();
}
/* check that dispatch set is configured */
if (dset == NULL || dset->ndisp == 0) {
- return (NULL);
+ return NULL;
}
LOCK(&dset->lock);
}
UNLOCK(&dset->lock);
- return (disp);
+ return disp;
}
isc_result_t
UNLOCK(&mgr->lock);
*dsetp = dset;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
fail:
UNLOCK(&mgr->lock);
isc_mutex_destroy(&dset->lock);
isc_mem_put(mctx, dset, sizeof(dns_dispatchset_t));
- return (result);
+ return result;
}
void
imp = ISC_LIST_NEXT(imp, link))
{
if (strcasecmp(name, imp->name) == 0) {
- return (imp);
+ return imp;
}
}
- return (NULL);
+ return NULL;
}
/***
case ISC_R_SUCCESS:
case ISC_R_NOPERM:
case ISC_R_DEFAULT:
- return (result);
+ return result;
default:
break;
}
result = ISC_R_NOTFOUND;
}
- return (result);
+ return result;
}
isc_result_t
" %s not loaded.",
drivername, dlzname);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/* Allocate memory to hold the DLZ database driver */
DNS_LOGMODULE_DLZ, ISC_LOG_DEBUG(2),
"DLZ driver loaded successfully.");
*dbp = db;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_DLZ, ISC_LOG_ERROR,
RWUNLOCK(&dlz_implock, isc_rwlocktype_read);
isc_mem_free(mctx, db->dlzname);
isc_mem_put(mctx, db, sizeof(dns_dlzdb_t));
- return (result);
+ return result;
}
void
DNS_LOGMODULE_DLZ, ISC_LOG_DEBUG(2),
"DLZ Driver '%s' already registered", drivername);
RWUNLOCK(&dlz_implock, isc_rwlocktype_write);
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
/*
/* Pass back the dlz_implementation that we created. */
*dlzimp = dlz_imp;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
*/
isc_result_t
dns_dlzstrtoargv(isc_mem_t *mctx, char *s, unsigned int *argcp, char ***argvp) {
- return (isc_commandline_strtoargv(mctx, s, argcp, argvp, 0));
+ return isc_commandline_strtoargv(mctx, s, argcp, argvp, 0);
}
/*%
dns_zone_detach(&zone);
}
- return (result);
+ return result;
}
/*%
impl = dlzdb->implementation;
if (impl->methods->configure == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dlzdb->configure_callback = callback;
result = impl->methods->configure(impl->driverarg, dlzdb->dbdata, view,
dlzdb);
- return (result);
+ return result;
}
bool
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_DLZ, ISC_LOG_INFO,
"No ssumatch method for DLZ database");
- return (false);
+ return false;
}
r = impl->methods->ssumatch(signer, name, tcpaddr, type, key,
impl->driverarg, dlzdatabase->dbdata);
- return (r);
+ return r;
}
dns64->mctx = NULL;
isc_mem_attach(mctx, &dns64->mctx);
*dns64p = dns64;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
if ((dns64->flags & DNS_DNS64_RECURSIVE_ONLY) != 0 &&
(flags & DNS_DNS64_RECURSIVE) == 0)
{
- return (DNS_R_DISALLOWED);
+ return DNS_R_DISALLOWED;
}
if ((dns64->flags & DNS_DNS64_BREAK_DNSSEC) == 0 &&
(flags & DNS_DNS64_DNSSEC) != 0)
{
- return (DNS_R_DISALLOWED);
+ return DNS_R_DISALLOWED;
}
if (dns64->clients != NULL) {
result = dns_acl_match(reqaddr, reqsigner, dns64->clients, env,
&match, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (match <= 0) {
- return (DNS_R_DISALLOWED);
+ return DNS_R_DISALLOWED;
}
}
result = dns_acl_match(&netaddr, NULL, dns64->mapped, env,
&match, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (match <= 0) {
- return (DNS_R_DISALLOWED);
+ return DNS_R_DISALLOWED;
}
}
}
/* Copy suffix. */
memmove(aaaa + nbytes, dns64->bits + nbytes, 16 - nbytes);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_dns64_t *
dns_dns64_next(dns_dns64_t *dns64) {
dns64 = ISC_LIST_NEXT(dns64, link);
- return (dns64);
+ return dns64;
}
void
aaaaok[i] = true;
}
}
- return (found ? answer : true);
+ return found ? answer : true;
}
/*
/* Does the prefix match? */
while ((j * 8U) < plen) {
if (rd1->data[j] != rd2->data[j]) {
- return (0);
+ return 0;
}
j++;
}
}
}
if (j == 16U) {
- return (prefixes[i].plen);
+ return prefixes[i].plen;
}
if (rd2 != NULL) {
- return (0);
+ return 0;
}
}
- return (0);
+ return 0;
}
isc_result_t
}
}
if (count == 0U) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (count > *len) {
*len = count;
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*len = count;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
* "dnsrps-enable yes" (including the default view).
*/
if (librpz == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_mutex_init(&dnsrps_mutex);
isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
DNS_LOGMODULE_RBTDB, DNS_RPZ_ERROR_LEVEL,
"dnsrps: %s", emsg.c);
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
DNS_LOGMODULE_RBTDB, DNS_RPZ_ERROR_LEVEL,
"librpz->client_create(): %s", emsg.c);
new->p.dnsrps_enabled = false;
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
new->p.dnsrps_enabled = true;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
librpz_emsg_t emsg;
if (rpzs == NULL || !rpzs->p.dnsrps_enabled) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
DNS_LOGMODULE_RBTDB, DNS_RPZ_ERROR_LEVEL,
"librpz->connect(): %s", librpz_lib_open_emsg.c);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (!librpz->connect(&emsg, rpzs->rps_client, true)) {
isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
DNS_LOGMODULE_RBTDB, DNS_RPZ_ERROR_LEVEL,
"librpz->connect(): %s", emsg.c);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
DNS_RPZ_INFO_LEVEL, "dnsrps: librpz version %s",
librpz->version);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
have_rd, false))
{
isc_mem_put(mctx, rpsdb, sizeof(*rpsdb));
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
if (rpsdb->rsp == NULL) {
isc_mem_put(mctx, rpsdb, sizeof(*rpsdb));
- return (DNS_R_DISALLOWED);
+ return DNS_R_DISALLOWED;
}
rpsdb->common.magic = DNS_DB_MAGIC;
rpsdb->qname = qname;
st->rpsdb = &rpsdb->common;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
dns_dnsrps_2policy(librpz_policy_t rps_policy) {
switch (rps_policy) {
case LIBRPZ_POLICY_UNDEFINED:
- return (DNS_RPZ_POLICY_MISS);
+ return DNS_RPZ_POLICY_MISS;
case LIBRPZ_POLICY_PASSTHRU:
- return (DNS_RPZ_POLICY_PASSTHRU);
+ return DNS_RPZ_POLICY_PASSTHRU;
case LIBRPZ_POLICY_DROP:
- return (DNS_RPZ_POLICY_DROP);
+ return DNS_RPZ_POLICY_DROP;
case LIBRPZ_POLICY_TCP_ONLY:
- return (DNS_RPZ_POLICY_TCP_ONLY);
+ return DNS_RPZ_POLICY_TCP_ONLY;
case LIBRPZ_POLICY_NXDOMAIN:
- return (DNS_RPZ_POLICY_NXDOMAIN);
+ return DNS_RPZ_POLICY_NXDOMAIN;
case LIBRPZ_POLICY_NODATA:
- return (DNS_RPZ_POLICY_NODATA);
+ return DNS_RPZ_POLICY_NODATA;
case LIBRPZ_POLICY_RECORD:
case LIBRPZ_POLICY_CNAME:
- return (DNS_RPZ_POLICY_RECORD);
+ return DNS_RPZ_POLICY_RECORD;
case LIBRPZ_POLICY_DELETED:
case LIBRPZ_POLICY_GIVEN:
switch (trig) {
case LIBRPZ_TRIG_BAD:
default:
- return (DNS_RPZ_TYPE_BAD);
+ return DNS_RPZ_TYPE_BAD;
case LIBRPZ_TRIG_CLIENT_IP:
- return (DNS_RPZ_TYPE_CLIENT_IP);
+ return DNS_RPZ_TYPE_CLIENT_IP;
case LIBRPZ_TRIG_QNAME:
- return (DNS_RPZ_TYPE_QNAME);
+ return DNS_RPZ_TYPE_QNAME;
case LIBRPZ_TRIG_IP:
- return (DNS_RPZ_TYPE_IP);
+ return DNS_RPZ_TYPE_IP;
case LIBRPZ_TRIG_NSDNAME:
- return (DNS_RPZ_TYPE_NSDNAME);
+ return DNS_RPZ_TYPE_NSDNAME;
case LIBRPZ_TRIG_NSIP:
- return (DNS_RPZ_TYPE_NSIP);
+ return DNS_RPZ_TYPE_NSIP;
}
}
switch (type) {
case DNS_RPZ_TYPE_BAD:
default:
- return (LIBRPZ_TRIG_BAD);
+ return LIBRPZ_TRIG_BAD;
case DNS_RPZ_TYPE_CLIENT_IP:
- return (LIBRPZ_TRIG_CLIENT_IP);
+ return LIBRPZ_TRIG_CLIENT_IP;
case DNS_RPZ_TYPE_QNAME:
- return (LIBRPZ_TRIG_QNAME);
+ return LIBRPZ_TRIG_QNAME;
case DNS_RPZ_TYPE_IP:
- return (LIBRPZ_TRIG_IP);
+ return LIBRPZ_TRIG_IP;
case DNS_RPZ_TYPE_NSDNAME:
- return (LIBRPZ_TRIG_NSDNAME);
+ return LIBRPZ_TRIG_NSDNAME;
case DNS_RPZ_TYPE_NSIP:
- return (LIBRPZ_TRIG_NSIP);
+ return LIBRPZ_TRIG_NSIP;
}
}
dbp = NULL;
rpsdb_attach(db, &dbp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
rpsdb->rsp))
{
librpz->log(LIBRPZ_LOG_ERROR, NULL, "%s", emsg.c);
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
rpsdb_bind_rdataset(rdataset, 1, LIBRPZ_IDX_BAD, dns_rdatatype_soa,
dns_rdataclass_in, ttl, rpsdb);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (node == &rpsdb->origin_node) {
if (type == dns_rdatatype_any) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (type == dns_rdatatype_soa) {
- return (rpsdb_bind_soa(rdataset, rpsdb));
+ return rpsdb_bind_soa(rdataset, rpsdb);
}
- return (DNS_R_NXRRSET);
+ return DNS_R_NXRRSET;
}
REQUIRE(node == &rpsdb->data_node);
librpz->log(LIBRPZ_LOG_ERROR, NULL,
"impossible dnsrps policy %d at %s:%d",
rpsdb->result.policy, __FILE__, __LINE__);
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
case LIBRPZ_POLICY_NXDOMAIN:
- return (DNS_R_NXDOMAIN);
+ return DNS_R_NXDOMAIN;
case LIBRPZ_POLICY_NODATA:
- return (DNS_R_NXRRSET);
+ return DNS_R_NXRRSET;
case LIBRPZ_POLICY_RECORD:
case LIBRPZ_POLICY_CNAME:
}
if (type == dns_rdatatype_soa) {
- return (rpsdb_bind_soa(rdataset, rpsdb));
+ return rpsdb_bind_soa(rdataset, rpsdb);
}
/*
* There is little to do for an ANY query.
*/
if (type == dns_rdatatype_any) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
*/
if (!librpz->rsp_result(&emsg, &rpsdb->result, true, rpsdb->rsp)) {
librpz->log(LIBRPZ_LOG_ERROR, NULL, "%s", emsg.c);
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
if (!librpz->rsp_rr(&emsg, &foundtype, &class, &ttl, NULL,
&rpsdb->result, rpsdb->qname->ndata,
rpsdb->qname->length, rpsdb->rsp))
{
librpz->log(LIBRPZ_LOG_ERROR, NULL, "%s", emsg.c);
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
REQUIRE(foundtype != dns_rdatatype_none);
rpsdb->qname->length, rpsdb->rsp))
{
librpz->log(LIBRPZ_LOG_ERROR, NULL, "%s", emsg.c);
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
} while (foundtype != dns_rdatatype_none);
if (count == 0) {
- return (DNS_R_NXRRSET);
+ return DNS_R_NXRRSET;
}
rpsdb_bind_rdataset(rdataset, count, rpsdb->result.next_rr, type, class,
ttl, rpsdb);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
}
rpsdb_findnode(db, name, false, nodep);
dns_name_copy(name, foundname);
- return (rpsdb_findrdataset(db, *nodep, NULL, type, 0, 0, rdataset,
- sigrdataset));
+ return rpsdb_findrdataset(db, *nodep, NULL, type, 0, 0, rdataset,
+ sigrdataset);
}
static isc_result_t
*iteratorp = &rpsdb_iter->common;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
rpsdb_issecure(dns_db_t *db) {
UNUSED(db);
- return (false);
+ return false;
}
static isc_result_t
REQUIRE(nodep != NULL && *nodep == NULL);
rpsdb_attachnode(db, &rpsdb->origin_node, nodep);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
*/
if (rdataset->type == dns_rdatatype_soa) {
if (RD_NEXT_RR(rdataset) == LIBRPZ_IDX_NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
RD_NEXT_RR(rdataset) = LIBRPZ_IDX_NULL;
if (!librpz->rsp_soa(&emsg, NULL, &rr, NULL, &rpsdb->result,
rpsdb->rsp))
{
librpz->log(LIBRPZ_LOG_ERROR, NULL, "%s", emsg.c);
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
RD_CUR_RR(rdataset) = rr;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
rpsdb->result.next_rr = RD_NEXT_RR(rdataset);
rpsdb->qname->length, rpsdb->rsp))
{
librpz->log(LIBRPZ_LOG_ERROR, NULL, "%s", emsg.c);
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
if (rdataset->type == type && rdataset->rdclass == class) {
RD_CUR_RR(rdataset) = rr;
RD_NEXT_RR(rdataset) = rpsdb->result.next_rr;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (type == dns_rdatatype_none) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
free(rr);
}
if (!librpz->rsp_result(&emsg, &rpsdb->result, true, rpsdb->rsp)) {
librpz->log(LIBRPZ_LOG_ERROR, NULL, "%s", emsg.c);
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
if (rdataset->type == dns_rdatatype_soa) {
RD_NEXT_RR(rdataset) = LIBRPZ_IDX_BAD;
RD_NEXT_RR(rdataset) = rpsdb->result.next_rr;
}
- return (rpsdb_rdataset_next(rdataset));
+ return rpsdb_rdataset_next(rdataset);
}
static void
rpsdb = RD_DB(rdataset);
REQUIRE(VALID_RPSDB(rpsdb));
- return (RD_COUNT(rdataset));
+ return RD_COUNT(rdataset);
}
static void
*/
if (!librpz->rsp_result(&emsg, &rpsdb->result, true, rpsdb->rsp)) {
librpz->log(LIBRPZ_LOG_ERROR, NULL, "%s", emsg.c);
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
/*
* Find the next class and type after the current class and type
rpsdb->qname->length, rpsdb->rsp))
{
librpz->log(LIBRPZ_LOG_ERROR, NULL, "%s", emsg.c);
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
if (type == dns_rdatatype_none) {
if (next_type == dns_rdatatype_none) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
rpsdb_iter->type = next_type;
rpsdb_iter->class = next_class;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
* Skip RRs with the current class and type or before.
rpsdb_iter->type = dns_rdatatype_none;
rpsdb_iter->class = dns_rdataclass_reserved0;
- return (rpsdb_rdatasetiter_next(iterator));
+ return rpsdb_rdatasetiter_next(iterator);
}
static void
digest_callback(void *arg, isc_region_t *data) {
dst_context_t *ctx = arg;
- return (dst_context_adddata(ctx, data));
+ return dst_context_adddata(ctx, data);
}
static void
*/
static int
rdata_compare_wrapper(const void *rdata1, const void *rdata2) {
- return (dns_rdata_compare((const dns_rdata_t *)rdata1,
- (const dns_rdata_t *)rdata2));
+ return dns_rdata_compare((const dns_rdata_t *)rdata1,
+ (const dns_rdata_t *)rdata2);
}
/*
if (ret != ISC_R_SUCCESS) {
dns_rdataset_disassociate(&rdataset);
isc_mem_put(mctx, data, n * sizeof(dns_rdata_t));
- return (ret);
+ return ret;
}
/*
*rdata = data;
*nrdata = n;
dns_rdataset_disassociate(&rdataset);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
dns_rdata_toregion(rdata, &r);
isc_buffer_init(&b, r.base, r.length);
isc_buffer_add(&b, r.length);
- return (dst_key_fromdns(name, rdata->rdclass, &b, mctx, key));
+ return dst_key_fromdns(name, rdata->rdclass, &b, mctx, key);
}
static isc_result_t
r.length = 18;
ret = dst_context_adddata(ctx, &r);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
if (downcase) {
dns_fixedname_init(&fname);
dns_name_toregion(&rrsig->signer, &r);
}
- return (dst_context_adddata(ctx, &r));
+ return dst_context_adddata(ctx, &r);
}
isc_result_t
REQUIRE(sigrdata != NULL);
if (*inception >= *expire) {
- return (DNS_R_INVALIDTIME);
+ return DNS_R_INVALIDTIME;
}
/*
*/
flags = dst_key_flags(key);
if ((flags & DNS_KEYTYPE_NOAUTH) != 0) {
- return (DNS_R_KEYUNAUTHORIZED);
+ return DNS_R_KEYUNAUTHORIZED;
}
if ((flags & DNS_KEYFLAG_OWNERMASK) != DNS_KEYOWNER_ZONE) {
- return (DNS_R_KEYUNAUTHORIZED);
+ return DNS_R_KEYUNAUTHORIZED;
}
sig.mctx = mctx;
sig.keyid = dst_key_id(key);
ret = dst_key_sigsize(key, &sigsize);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
sig.siglen = sigsize;
/*
isc_buffer_free(&databuf);
isc_mem_put(mctx, sig.signature, sig.siglen);
- return (ret);
+ return ret;
}
isc_result_t
ret = dns_rdata_tostruct(sigrdata, &sig, NULL);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
if (set->type != sig.covered) {
- return (DNS_R_SIGINVALID);
+ return DNS_R_SIGINVALID;
}
if (isc_serial_lt(sig.timeexpire, sig.timesigned)) {
inc_stat(dns_dnssecstats_fail);
- return (DNS_R_SIGINVALID);
+ return DNS_R_SIGINVALID;
}
if (!ignoretime) {
*/
if (isc_serial_lt((uint32_t)now, sig.timesigned)) {
inc_stat(dns_dnssecstats_fail);
- return (DNS_R_SIGFUTURE);
+ return DNS_R_SIGFUTURE;
} else if (isc_serial_lt(sig.timeexpire, (uint32_t)now)) {
inc_stat(dns_dnssecstats_fail);
- return (DNS_R_SIGEXPIRED);
+ return DNS_R_SIGEXPIRED;
}
}
case dns_rdatatype_dnskey:
if (!dns_name_equal(name, &sig.signer)) {
inc_stat(dns_dnssecstats_fail);
- return (DNS_R_SIGINVALID);
+ return DNS_R_SIGINVALID;
}
break;
case dns_rdatatype_ds:
if (dns_name_equal(name, &sig.signer)) {
inc_stat(dns_dnssecstats_fail);
- return (DNS_R_SIGINVALID);
+ return DNS_R_SIGINVALID;
}
FALLTHROUGH;
default:
if (!dns_name_issubdomain(name, &sig.signer)) {
inc_stat(dns_dnssecstats_fail);
- return (DNS_R_SIGINVALID);
+ return DNS_R_SIGINVALID;
}
break;
}
flags = dst_key_flags(key);
if ((flags & DNS_KEYTYPE_NOAUTH) != 0) {
inc_stat(dns_dnssecstats_fail);
- return (DNS_R_KEYUNAUTHORIZED);
+ return DNS_R_KEYUNAUTHORIZED;
}
if ((flags & DNS_KEYFLAG_OWNERMASK) != DNS_KEYOWNER_ZONE) {
inc_stat(dns_dnssecstats_fail);
- return (DNS_R_KEYUNAUTHORIZED);
+ return DNS_R_KEYUNAUTHORIZED;
}
again:
inc_stat(dns_dnssecstats_wildcard);
ret = DNS_R_FROMWILDCARD;
}
- return (ret);
+ return ret;
}
bool
* keys are assumed active.
*/
if (major == 1 && minor <= 2) {
- return (true);
+ return true;
}
hint_publish = dst_key_is_published(key, now, &publish);
hint_remove = dst_key_is_removed(key, now, &remove);
if (hint_remove) {
- return (false);
+ return false;
}
if (hint_publish && hint_revoke) {
- return (true);
+ return true;
}
if (hint_zsign && zsk) {
- return (true);
+ return true;
}
if (hint_ksign && ksk) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
/*%<
* Smart signing started with key format 1.3
*/
if (major == 1 && minor <= 2) {
- return (false);
+ return false;
}
/* Check kasp state first. */
result = dst_key_getstate(key, DST_KEY_DS, &state);
if (result == ISC_R_SUCCESS) {
- return (state == DST_KEY_STATE_RUMOURED ||
- state == DST_KEY_STATE_OMNIPRESENT);
+ return state == DST_KEY_STATE_RUMOURED ||
+ state == DST_KEY_STATE_OMNIPRESENT;
}
/* If no kasp state, check timings. */
if (result == ISC_R_SUCCESS && when < now) {
publish = false;
}
- return (publish);
+ return publish;
}
/*%<
* Smart signing started with key format 1.3.
*/
if (major == 1 && minor <= 2) {
- return (false);
+ return false;
}
/* Check kasp state first. */
result = dst_key_getstate(key, DST_KEY_DS, &state);
if (result == ISC_R_SUCCESS) {
- return (state == DST_KEY_STATE_UNRETENTIVE ||
- state == DST_KEY_STATE_HIDDEN);
+ return state == DST_KEY_STATE_UNRETENTIVE ||
+ state == DST_KEY_STATE_HIDDEN;
}
/* If no kasp state, check timings. */
result = dst_key_gettime(key, DST_TIME_SYNCDELETE, &when);
if (result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
if (when <= now) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
#define is_zone_key(key) \
}
}
*nkeys = count;
- return (result);
+ return result;
}
isc_result_t
ISC_R_SUCCESS);
msg->sig0 = dataset;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
if (dynbuf != NULL) {
dst_context_destroy(&ctx);
}
- return (result);
+ return result;
}
isc_result_t
if (is_response(msg)) {
if (msg->query.base == NULL) {
- return (DNS_R_UNEXPECTEDTSIG);
+ return DNS_R_UNEXPECTEDTSIG;
}
}
dst_context_destroy(&ctx);
dns_rdata_freestruct(&sig);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
if (signeedsfree) {
dst_context_destroy(&ctx);
}
- return (result);
+ return result;
}
/*%
INSIST(sigrdataset->covers == dns_rdatatype_dnskey);
}
- return (dns_dnssec_signs(rdata, name, rdataset, sigrdataset, ignoretime,
- mctx));
+ return dns_dnssec_signs(rdata, name, rdataset, sigrdataset, ignoretime,
+ mctx);
}
bool
INSIST(sigrdataset->type == dns_rdatatype_rrsig);
if (sigrdataset->covers != rdataset->type) {
- return (false);
+ return false;
}
result = dns_dnssec_keyfromrdata(name, rdata, mctx, &dstkey);
if (result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
result = dns_rdata_tostruct(rdata, &key, NULL);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
&sigrdata, NULL);
if (result == ISC_R_SUCCESS) {
dst_key_free(&dstkey);
- return (true);
+ return true;
}
}
}
dst_key_free(&dstkey);
- return (false);
+ return false;
}
isc_result_t
ISC_LINK_INIT(dk, link);
*dkp = dk;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
if (dstkey != NULL) {
dst_key_free(&dstkey);
}
- return (result);
+ return result;
}
/*%
}
key->source = dns_keysource_zoneapex;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = dns_dnsseckey_create(mctx, newkey, &key);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (key->legacy || savekeys) {
key->force_publish = true;
key->source = dns_keysource_zoneapex;
ISC_LIST_APPEND(*keylist, key, link);
*newkey = NULL;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
if (dns_rdataset_isassociated(&sigs)) {
dns_rdataset_disassociate(&sigs);
}
- return (result);
+ return result;
}
/*%
if (privkey != NULL) {
dst_key_free(&privkey);
}
- return (result);
+ return result;
}
isc_result_t
isc_buffer_init(&b, buf, bufsize);
result = dst_key_todns(key, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdata_reset(target);
isc_buffer_usedregion(&b, &r);
dns_rdata_fromregion(target, dst_key_class(key), dns_rdatatype_dnskey,
&r);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_diff_appendminimal(diff, &tuple);
failure:
- return (result);
+ return result;
}
static isc_result_t
dns_diff_appendminimal(diff, &tuple);
failure:
- return (result);
+ return result;
}
static isc_result_t
result = addrdata(&dnskey, diff, origin, ttl, mctx);
failure:
- return (result);
+ return result;
}
static isc_result_t
result = delrdata(&dnskey, diff, origin, ttl, mctx);
failure:
- return (result);
+ return result;
}
static bool
dns_rdataset_current(&trdataset, ¤t);
if (dns_rdata_compare(rdata, ¤t) == 0) {
dns_rdataset_disassociate(&trdataset);
- return (true);
+ return true;
}
}
dns_rdataset_disassociate(&trdataset);
- return (false);
+ return false;
}
isc_result_t
if (!dns_rdataset_isassociated(cds) &&
!dns_rdataset_isassociated(cdnskey))
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
isc_result_t
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
/*
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
isc_result_t
result = ISC_R_NOTFOUND;
}
- return (result);
+ return result;
}
isc_mem_putanddetach(&env->mctx, env, sizeof(dns_dtenv_t));
}
- return (result);
+ return result;
}
isc_result_t
if (max_size == 0 && rolls == ISC_LOG_ROLLINFINITE &&
suffix == isc_log_rollsuffix_increment)
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_INVALIDFILE);
+ return ISC_R_INVALIDFILE;
}
}
env->rolls = rolls;
env->suffix = suffix;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
isc_task_endexclusive(env->reopen_task);
- return (result);
+ return result;
}
static isc_result_t
r->length = strlen((char *)p);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
dns_dt_setidentity(dns_dtenv_t *env, const char *identity) {
REQUIRE(VALID_DTENV(env));
- return (toregion(env, &env->identity, identity));
+ return toregion(env, &env->identity, identity);
}
isc_result_t
dns_dt_setversion(dns_dtenv_t *env, const char *version) {
REQUIRE(VALID_DTENV(env));
- return (toregion(env, &env->version, version));
+ return toregion(env, &env->version, version);
}
static void
unsigned int generation;
if (env->iothr == NULL) {
- return (NULL);
+ return NULL;
}
generation = atomic_load_acquire(&global_generation);
set_dt_ioq(generation, ioq);
}
- return (dt_ioq.ioq);
+ return dt_ioq.ioq;
}
void
REQUIRE(statsp != NULL && *statsp == NULL);
if (env->stats == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
isc_stats_attach(env->stats, statsp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
/* Need to use malloc() here because protobuf uses free() */
sbuf.data = malloc(sbuf.alloced);
if (sbuf.data == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
sbuf.must_free_data = 1;
*sz = dnstap__dnstap__pack_to_buffer(d, (ProtobufCBuffer *)&sbuf);
if (sbuf.data == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
*buf = sbuf.data;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
dnstap_type(dns_dtmsgtype_t msgtype) {
switch (msgtype) {
case DNS_DTTYPE_SQ:
- return (DNSTAP__MESSAGE__TYPE__STUB_QUERY);
+ return DNSTAP__MESSAGE__TYPE__STUB_QUERY;
case DNS_DTTYPE_SR:
- return (DNSTAP__MESSAGE__TYPE__STUB_RESPONSE);
+ return DNSTAP__MESSAGE__TYPE__STUB_RESPONSE;
case DNS_DTTYPE_CQ:
- return (DNSTAP__MESSAGE__TYPE__CLIENT_QUERY);
+ return DNSTAP__MESSAGE__TYPE__CLIENT_QUERY;
case DNS_DTTYPE_CR:
- return (DNSTAP__MESSAGE__TYPE__CLIENT_RESPONSE);
+ return DNSTAP__MESSAGE__TYPE__CLIENT_RESPONSE;
case DNS_DTTYPE_AQ:
- return (DNSTAP__MESSAGE__TYPE__AUTH_QUERY);
+ return DNSTAP__MESSAGE__TYPE__AUTH_QUERY;
case DNS_DTTYPE_AR:
- return (DNSTAP__MESSAGE__TYPE__AUTH_RESPONSE);
+ return DNSTAP__MESSAGE__TYPE__AUTH_RESPONSE;
case DNS_DTTYPE_RQ:
- return (DNSTAP__MESSAGE__TYPE__RESOLVER_QUERY);
+ return DNSTAP__MESSAGE__TYPE__RESOLVER_QUERY;
case DNS_DTTYPE_RR:
- return (DNSTAP__MESSAGE__TYPE__RESOLVER_RESPONSE);
+ return DNSTAP__MESSAGE__TYPE__RESOLVER_RESPONSE;
case DNS_DTTYPE_FQ:
- return (DNSTAP__MESSAGE__TYPE__FORWARDER_QUERY);
+ return DNSTAP__MESSAGE__TYPE__FORWARDER_QUERY;
case DNS_DTTYPE_FR:
- return (DNSTAP__MESSAGE__TYPE__FORWARDER_RESPONSE);
+ return DNSTAP__MESSAGE__TYPE__FORWARDER_RESPONSE;
case DNS_DTTYPE_TQ:
- return (DNSTAP__MESSAGE__TYPE__TOOL_QUERY);
+ return DNSTAP__MESSAGE__TYPE__TOOL_QUERY;
case DNS_DTTYPE_TR:
- return (DNSTAP__MESSAGE__TYPE__TOOL_RESPONSE);
+ return DNSTAP__MESSAGE__TYPE__TOOL_RESPONSE;
case DNS_DTTYPE_UQ:
- return (DNSTAP__MESSAGE__TYPE__UPDATE_QUERY);
+ return DNSTAP__MESSAGE__TYPE__UPDATE_QUERY;
case DNS_DTTYPE_UR:
- return (DNSTAP__MESSAGE__TYPE__UPDATE_RESPONSE);
+ return DNSTAP__MESSAGE__TYPE__UPDATE_RESPONSE;
default:
UNREACHABLE();
}
result = isc_buffer_reserve(b, strlen(str));
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putstr(*b, str);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
if (ip->length == 4) {
if (!inet_ntop(AF_INET, ip->base, buf, sizeof(buf))) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
} else if (ip->length == 16) {
if (!inet_ntop(AF_INET6, ip->base, buf, sizeof(buf))) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
} else {
- return (ISC_R_BADADDRESSFORM);
+ return ISC_R_BADADDRESSFORM;
}
- return (putstr(b, buf));
+ return putstr(b, buf);
}
static bool
res = fstrm_reader_get_control(r, FSTRM_CONTROL_START, &control);
if (res != fstrm_res_success) {
- return (false);
+ return false;
}
res = fstrm_control_get_num_field_content_type(control, &n);
if (res != fstrm_res_success) {
- return (false);
+ return false;
}
if (n > 0) {
res = fstrm_control_get_field_content_type(control, 0, &rtype,
&rlen);
if (res != fstrm_res_success) {
- return (false);
+ return false;
}
if (rlen != dlen) {
- return (false);
+ return false;
}
if (memcmp(DNSTAP_CONTENT_TYPE, rtype, dlen) == 0) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
isc_result_t
if (handle != NULL) {
isc_mem_put(mctx, handle, sizeof(*handle));
}
- return (result);
+ return result;
}
isc_result_t
switch (res) {
case fstrm_res_success:
if (data == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
DE_CONST(data, *bufp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
case fstrm_res_stop:
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
default:
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
dns_dtdata_free(&d);
}
- return (result);
+ return result;
}
isc_result_t
CHECK(putstr(dest, "UR "));
break;
default:
- return (DNS_R_BADDNSTAP);
+ return DNS_R_BADDNSTAP;
}
/* Query and response addresses */
isc_buffer_putuint8(*dest, 0);
cleanup:
- return (result);
+ return result;
}
void
key->type == dns_rdatatype_cdnskey);
if (!dst_ds_digest_supported(digest_type)) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
switch (digest_type) {
md = isc_md_new();
if (md == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
result = isc_md_init(md, md_type);
end:
isc_md_free(md);
- return (result);
+ return result;
}
isc_result_t
result = dns_ds_fromkeyrdata(owner, key, digest_type, digest, &ds);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
memset(buffer, 0, DNS_DS_BUFFERSIZE);
isc_buffer_init(&b, buffer, DNS_DS_BUFFERSIZE);
result = dns_rdata_fromstruct(rdata, key->rdclass, dns_rdatatype_ds,
&ds, &b);
- return (result);
+ return result;
}
#endif /* HAVE_GSSAPI */
dst_initialized = true;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
out:
/* avoid immediate crash! */
dst_initialized = true;
dst_lib_destroy();
- return (result);
+ return result;
}
void
REQUIRE(dst_initialized);
if (alg >= DST_MAX_ALGS || dst_t_func[alg] == NULL) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
bool
dst_ds_digest_supported(unsigned int digest_type) {
- return (digest_type == DNS_DSDIGEST_SHA1 ||
- digest_type == DNS_DSDIGEST_SHA256 ||
- digest_type == DNS_DSDIGEST_SHA384);
+ return digest_type == DNS_DSDIGEST_SHA1 ||
+ digest_type == DNS_DSDIGEST_SHA256 ||
+ digest_type == DNS_DSDIGEST_SHA384;
}
isc_result_t
REQUIRE(dctxp != NULL && *dctxp == NULL);
if (key->func->createctx == NULL && key->func->createctx2 == NULL) {
- return (DST_R_UNSUPPORTEDALG);
+ return DST_R_UNSUPPORTEDALG;
}
if (key->keydata.generic == NULL) {
- return (DST_R_NULLKEY);
+ return DST_R_NULLKEY;
}
dctx = isc_mem_get(mctx, sizeof(dst_context_t));
dst_key_free(&dctx->key);
}
isc_mem_putanddetach(&dctx->mctx, dctx, sizeof(dst_context_t));
- return (result);
+ return result;
}
dctx->magic = CTX_MAGIC;
*dctxp = dctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
REQUIRE(data != NULL);
INSIST(dctx->key->func->adddata != NULL);
- return (dctx->key->func->adddata(dctx, data));
+ return dctx->key->func->adddata(dctx, data);
}
isc_result_t
key = dctx->key;
CHECKALG(key->key_alg);
if (key->keydata.generic == NULL) {
- return (DST_R_NULLKEY);
+ return DST_R_NULLKEY;
}
if (key->func->sign == NULL) {
- return (DST_R_NOTPRIVATEKEY);
+ return DST_R_NOTPRIVATEKEY;
}
if (key->func->isprivate == NULL || !key->func->isprivate(key)) {
- return (DST_R_NOTPRIVATEKEY);
+ return DST_R_NOTPRIVATEKEY;
}
- return (key->func->sign(dctx, sig));
+ return key->func->sign(dctx, sig);
}
isc_result_t
CHECKALG(dctx->key->key_alg);
if (dctx->key->keydata.generic == NULL) {
- return (DST_R_NULLKEY);
+ return DST_R_NULLKEY;
}
if (dctx->key->func->verify == NULL) {
- return (DST_R_NOTPUBLICKEY);
+ return DST_R_NOTPUBLICKEY;
}
- return (dctx->key->func->verify(dctx, sig));
+ return dctx->key->func->verify(dctx, sig);
}
isc_result_t
CHECKALG(dctx->key->key_alg);
if (dctx->key->keydata.generic == NULL) {
- return (DST_R_NULLKEY);
+ return DST_R_NULLKEY;
}
if (dctx->key->func->verify == NULL && dctx->key->func->verify2 == NULL)
{
- return (DST_R_NOTPUBLICKEY);
+ return DST_R_NOTPUBLICKEY;
}
- return (dctx->key->func->verify2 != NULL
- ? dctx->key->func->verify2(dctx, maxbits, sig)
- : dctx->key->func->verify(dctx, sig));
+ return dctx->key->func->verify2 != NULL
+ ? dctx->key->func->verify2(dctx, maxbits, sig)
+ : dctx->key->func->verify(dctx, sig);
}
isc_result_t
CHECKALG(priv->key_alg);
if (pub->keydata.generic == NULL || priv->keydata.generic == NULL) {
- return (DST_R_NULLKEY);
+ return DST_R_NULLKEY;
}
if (pub->key_alg != priv->key_alg || pub->func->computesecret == NULL ||
priv->func->computesecret == NULL)
{
- return (DST_R_KEYCANNOTCOMPUTESECRET);
+ return DST_R_KEYCANNOTCOMPUTESECRET;
}
if (!dst_key_isprivate(priv)) {
- return (DST_R_NOTPRIVATEKEY);
+ return DST_R_NOTPRIVATEKEY;
}
- return (pub->func->computesecret(pub, priv, secret));
+ return pub->func->computesecret(pub, priv, secret);
}
isc_result_t
CHECKALG(key->key_alg);
if (key->func->tofile == NULL) {
- return (DST_R_UNSUPPORTEDALG);
+ return DST_R_UNSUPPORTEDALG;
}
if ((type & DST_TYPE_PUBLIC) != 0) {
ret = write_public_key(key, type, directory);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
}
if ((type & DST_TYPE_STATE) != 0) {
ret = write_key_state(key, type, directory);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
}
if (((type & DST_TYPE_PRIVATE) != 0) &&
(key->key_flags & DNS_KEYFLAG_TYPEMASK) != DNS_KEYTYPE_NOKEY)
{
- return (key->func->tofile(key, directory));
+ return key->func->tofile(key, directory);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
dst_key_isexternal(dst_key_t *key) {
REQUIRE(VALID_KEY(key));
- return (key->external);
+ return key->external;
}
void
modified = key->modified;
isc_mutex_unlock(&(((dst_key_t *)key)->mdlock));
- return (modified);
+ return modified;
}
isc_result_t
}
}
- return (result);
+ return result;
}
isc_result_t
dst_key_free(&key);
}
- return (result);
+ return result;
}
isc_result_t
if (key != NULL) {
dst_key_free(&key);
}
- return (result);
+ return result;
}
isc_result_t
CHECKALG(key->key_alg);
if (key->func->todns == NULL) {
- return (DST_R_UNSUPPORTEDALG);
+ return DST_R_UNSUPPORTEDALG;
}
if (isc_buffer_availablelength(target) < 4) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint16(target, (uint16_t)(key->key_flags & 0xffff));
isc_buffer_putuint8(target, (uint8_t)key->key_proto);
if ((key->key_flags & DNS_KEYFLAG_EXTENDED) != 0) {
if (isc_buffer_availablelength(target) < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint16(
target, (uint16_t)((key->key_flags >> 16) & 0xffff));
}
if (key->keydata.generic == NULL) { /*%< NULL KEY */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (key->func->todns(key, target));
+ return key->func->todns(key, target);
}
isc_result_t
dst_key_fromdns(const dns_name_t *name, dns_rdataclass_t rdclass,
isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp) {
- return (dst_key_fromdns_ex(name, rdclass, source, mctx, false, keyp));
+ return dst_key_fromdns_ex(name, rdclass, source, mctx, false, keyp);
}
isc_result_t
isc_buffer_remainingregion(source, &r);
if (isc_buffer_remaininglength(source) < 4) {
- return (DST_R_INVALIDPUBLICKEY);
+ return DST_R_INVALIDPUBLICKEY;
}
flags = isc_buffer_getuint16(source);
proto = isc_buffer_getuint8(source);
if ((flags & DNS_KEYFLAG_EXTENDED) != 0) {
if (isc_buffer_remaininglength(source) < 2) {
- return (DST_R_INVALIDPUBLICKEY);
+ return DST_R_INVALIDPUBLICKEY;
}
extflags = isc_buffer_getuint16(source);
flags |= (extflags << 16);
result = frombuffer(name, alg, flags, proto, rdclass, source, mctx,
no_rdata, &key);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
key->key_id = id;
key->key_rid = rid;
*keyp = key;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
result = frombuffer(name, alg, flags, protocol, rdclass, source, mctx,
false, &key);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = computeid(key);
if (result != ISC_R_SUCCESS) {
dst_key_free(&key);
- return (result);
+ return result;
}
*keyp = key;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
CHECKALG(key->key_alg);
if (key->func->todns == NULL) {
- return (DST_R_UNSUPPORTEDALG);
+ return DST_R_UNSUPPORTEDALG;
}
- return (key->func->todns(key, target));
+ return key->func->todns(key, target);
}
isc_result_t
if (lex != NULL) {
isc_lex_destroy(&lex);
}
- return (result);
+ return result;
}
dns_gss_ctx_id_t
dst_key_getgssctx(const dst_key_t *key) {
REQUIRE(key != NULL);
- return (key->keydata.gssctx);
+ return key->keydata.gssctx;
}
isc_result_t
key = get_key_struct(name, DST_ALG_GSSAPI, 0, DNS_KEYPROTO_DNSSEC, 0,
dns_rdataclass_in, 0, mctx);
if (key == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (intoken != NULL) {
if (result != ISC_R_SUCCESS) {
dst_key_free(&key);
}
- return (result);
+ return result;
}
FILE *
/* Create public key file. */
int fd = mkstemp(tmpname);
if (fd == -1) {
- return (NULL);
+ return NULL;
}
if (fchmod(fd, mode & ~isc_os_umask()) != 0) {
goto error;
}
- return (fp);
+ return fp;
error:
(void)close(fd);
(void)unlink(tmpname);
- return (NULL);
+ return NULL;
}
isc_result_t
dst_key_close(char *tmpname, FILE *fp, char *filename) {
if ((fflush(fp) != 0) || (ferror(fp) != 0)) {
- return (dst_key_cleanup(tmpname, fp));
+ return dst_key_cleanup(tmpname, fp);
}
if (rename(tmpname, filename) != 0) {
- return (dst_key_cleanup(tmpname, fp));
+ return dst_key_cleanup(tmpname, fp);
}
if (fclose(fp) != 0) {
*/
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
(void)unlink(tmpname);
(void)fclose(fp);
- return (DST_R_WRITEERROR);
+ return DST_R_WRITEERROR;
}
isc_result_t
key = get_key_struct(name, alg, flags, protocol, bits, rdclass, 0,
mctx);
if (key == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
key->keydata.generic = data;
result = computeid(key);
if (result != ISC_R_SUCCESS) {
dst_key_free(&key);
- return (result);
+ return result;
}
*keyp = key;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
key = get_key_struct(name, alg, flags, protocol, 0, rdclass, 0, mctx);
if (key == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (key->func->fromlabel == NULL) {
dst_key_free(&key);
- return (DST_R_UNSUPPORTEDALG);
+ return DST_R_UNSUPPORTEDALG;
}
result = key->func->fromlabel(key, engine, label, pin);
if (result != ISC_R_SUCCESS) {
dst_key_free(&key);
- return (result);
+ return result;
}
result = computeid(key);
if (result != ISC_R_SUCCESS) {
dst_key_free(&key);
- return (result);
+ return result;
}
*keyp = key;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
key = get_key_struct(name, alg, flags, protocol, bits, rdclass, 0,
mctx);
if (key == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (bits == 0) { /*%< NULL KEY */
key->key_flags |= DNS_KEYTYPE_NOKEY;
*keyp = key;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (key->func->generate == NULL) {
dst_key_free(&key);
- return (DST_R_UNSUPPORTEDALG);
+ return DST_R_UNSUPPORTEDALG;
}
ret = key->func->generate(key, param, callback);
if (ret != ISC_R_SUCCESS) {
dst_key_free(&key);
- return (ret);
+ return ret;
}
ret = computeid(key);
if (ret != ISC_R_SUCCESS) {
dst_key_free(&key);
- return (ret);
+ return ret;
}
*keyp = key;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
isc_mutex_lock(&(((dst_key_t *)key)->mdlock));
if (!key->boolset[type]) {
isc_mutex_unlock(&(((dst_key_t *)key)->mdlock));
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
*valuep = key->bools[type];
isc_mutex_unlock(&(((dst_key_t *)key)->mdlock));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_mutex_lock(&(((dst_key_t *)key)->mdlock));
if (!key->numset[type]) {
isc_mutex_unlock(&(((dst_key_t *)key)->mdlock));
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
*valuep = key->nums[type];
isc_mutex_unlock(&(((dst_key_t *)key)->mdlock));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_mutex_lock(&(((dst_key_t *)key)->mdlock));
if (!key->timeset[type]) {
isc_mutex_unlock(&(((dst_key_t *)key)->mdlock));
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
*timep = key->times[type];
isc_mutex_unlock(&(((dst_key_t *)key)->mdlock));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_mutex_lock(&(((dst_key_t *)key)->mdlock));
if (!key->keystateset[type]) {
isc_mutex_unlock(&(((dst_key_t *)key)->mdlock));
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
*statep = key->keystates[type];
isc_mutex_unlock(&(((dst_key_t *)key)->mdlock));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
REQUIRE(minorp != NULL);
*majorp = key->fmt_major;
*minorp = key->fmt_minor;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
REQUIRE(VALID_KEY(key2));
if (key1 == key2) {
- return (true);
+ return true;
}
if (key1->key_alg != key2->key_alg) {
- return (false);
+ return false;
}
if (key1->key_id != key2->key_id) {
if (!match_revoked_key) {
- return (false);
+ return false;
}
if ((key1->key_flags & DNS_KEYFLAG_REVOKE) ==
(key2->key_flags & DNS_KEYFLAG_REVOKE))
{
- return (false);
+ return false;
}
if (key1->key_id != key2->key_rid &&
key1->key_rid != key2->key_id)
{
- return (false);
+ return false;
}
}
if (compare != NULL) {
- return (compare(key1, key2));
+ return compare(key1, key2);
} else {
- return (false);
+ return false;
}
}
isc_buffer_init(&b1, buf1, sizeof(buf1));
result = dst_key_todns(key1, &b1);
if (result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
/* Zero out flags. */
buf1[0] = buf1[1] = 0;
isc_buffer_init(&b2, buf2, sizeof(buf2));
result = dst_key_todns(key2, &b2);
if (result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
/* Zero out flags. */
buf2[0] = buf2[1] = 0;
memmove(&buf2[4], &buf2[6], r2.length - 6);
r2.length -= 2;
}
- return (isc_region_compare(&r1, &r2) == 0);
+ return isc_region_compare(&r1, &r2) == 0;
}
bool
dst_key_compare(const dst_key_t *key1, const dst_key_t *key2) {
- return (comparekeys(key1, key2, false, key1->func->compare));
+ return comparekeys(key1, key2, false, key1->func->compare);
}
bool
dst_key_pubcompare(const dst_key_t *key1, const dst_key_t *key2,
bool match_revoked_key) {
- return (comparekeys(key1, key2, match_revoked_key, pub_compare));
+ return comparekeys(key1, key2, match_revoked_key, pub_compare);
}
bool
REQUIRE(VALID_KEY(key2));
if (key1 == key2) {
- return (true);
+ return true;
}
if (key1->key_alg == key2->key_alg &&
key1->func->paramcompare != NULL &&
key1->func->paramcompare(key1, key2))
{
- return (true);
+ return true;
} else {
- return (false);
+ return false;
}
}
dst_key_isprivate(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
INSIST(key->func->isprivate != NULL);
- return (key->func->isprivate(key));
+ return key->func->isprivate(key);
}
isc_result_t
type == DST_TYPE_STATE || type == DST_TYPE_TEMPLATE ||
type == 0);
- return (buildfilename(key->key_name, key->key_id, key->key_alg, type,
- directory, out));
+ return buildfilename(key->key_name, key->key_id, key->key_alg, type,
+ directory, out);
}
isc_result_t
break;
case DST_ALG_DH:
default:
- return (DST_R_UNSUPPORTEDALG);
+ return DST_R_UNSUPPORTEDALG;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (key->key_alg == DST_ALG_DH) {
*n = (key->key_size + 7) / 8;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (DST_R_UNSUPPORTEDALG);
+ return DST_R_UNSUPPORTEDALG;
}
/*%
dst_key_setflags(dst_key_t *key, uint32_t flags) {
REQUIRE(VALID_KEY(key));
key->key_flags = flags;
- return (computeid(key));
+ return computeid(key);
}
void
REQUIRE(VALID_KEY(key));
if (key->func->dump == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
- return (key->func->dump(key, mctx, buffer, length));
+ return key->func->dump(key, mctx, buffer, length);
}
isc_result_t
REQUIRE(keyp != NULL && *keyp == NULL);
if (alg >= DST_MAX_ALGS || dst_t_func[alg] == NULL) {
- return (DST_R_UNSUPPORTEDALG);
+ return DST_R_UNSUPPORTEDALG;
}
if (dst_t_func[alg]->restore == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
key = get_key_struct(name, alg, flags, protocol, 0, rdclass, 0, mctx);
if (key == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
result = (dst_t_func[alg]->restore)(key, keystr);
dst_key_free(&key);
}
- return (result);
+ return result;
}
/***
isc_mutex_init(&key->mdlock);
key->inactive = false;
key->magic = KEY_MAGIC;
- return (key);
+ return key;
}
bool
dst_key_inactive(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
- return (key->inactive);
+ return key->inactive;
}
void
if (lex != NULL) {
isc_lex_destroy(&lex);
}
- return (ret);
+ return ret;
}
static int
find_metadata(const char *s, const char *tags[], int ntags) {
for (int i = 0; i < ntags; i++) {
if (tags[i] != NULL && strcasecmp(s, tags[i]) == 0) {
- return (i);
+ return i;
}
}
- return (-1);
+ return -1;
}
static int
find_numericdata(const char *s) {
- return (find_metadata(s, numerictags, NUMERIC_NTAGS));
+ return find_metadata(s, numerictags, NUMERIC_NTAGS);
}
static int
find_booleandata(const char *s) {
- return (find_metadata(s, booleantags, BOOLEAN_NTAGS));
+ return find_metadata(s, booleantags, BOOLEAN_NTAGS);
}
static int
find_timingdata(const char *s) {
- return (find_metadata(s, timingtags, TIMING_NTAGS));
+ return find_metadata(s, timingtags, TIMING_NTAGS);
}
static int
find_keystatedata(const char *s) {
- return (find_metadata(s, keystatestags, KEYSTATES_NTAGS));
+ return find_metadata(s, keystatestags, KEYSTATES_NTAGS);
}
static isc_result_t
for (int i = 0; i < KEYSTATES_NVALUES; i++) {
if (keystates[i] != NULL && strcasecmp(s, keystates[i]) == 0) {
*state = (dst_key_state_t)i;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*%
if (lex != NULL) {
isc_lex_destroy(&lex);
}
- return (ret);
+ return ret;
}
static bool
case DST_ALG_ECDSA384:
case DST_ALG_ED25519:
case DST_ALG_ED448:
- return (false);
+ return false;
case DST_ALG_HMACMD5:
case DST_ALG_HMACSHA1:
case DST_ALG_HMACSHA224:
case DST_ALG_HMACSHA384:
case DST_ALG_HMACSHA512:
case DST_ALG_GSSAPI:
- return (true);
+ return true;
default:
- return (false);
+ return false;
}
}
isc_buffer_init(&fileb, filename, sizeof(filename));
result = dst_key_buildfilename(key, DST_TYPE_STATE, directory, &fileb);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_init(&tmpb, tmpname, sizeof(tmpname));
result = dst_key_buildfilename(key, DST_TYPE_TEMPLATE, directory,
&tmpb);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
mode_t mode = issymmetric(key) ? S_IRUSR | S_IWUSR
/* Create temporary public key file. */
fp = dst_key_open(tmpname, mode);
if (fp == NULL) {
- return (DST_R_WRITEERROR);
+ return DST_R_WRITEERROR;
}
/* Write key state */
fprintf(fp, "; This is the state of key %d, for ", key->key_id);
result = dns_name_print(key->key_name, fp);
if (result != ISC_R_SUCCESS) {
- return (dst_key_cleanup(tmpname, fp));
+ return dst_key_cleanup(tmpname, fp);
}
fputc('\n', fp);
printstate(key, DST_KEY_GOAL, "GoalState", fp);
}
- return (dst_key_close(tmpname, fp, filename));
+ return dst_key_close(tmpname, fp, filename);
}
/*%
result = dst_key_todns(key, &keyb);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_usedregion(&keyb, &r);
result = dns_rdata_totext(&rdata, (dns_name_t *)NULL, &textb);
if (result != ISC_R_SUCCESS) {
- return (DST_R_INVALIDPUBLICKEY);
+ return DST_R_INVALIDPUBLICKEY;
}
result = dns_rdataclass_totext(key->key_class, &classb);
if (result != ISC_R_SUCCESS) {
- return (DST_R_INVALIDPUBLICKEY);
+ return DST_R_INVALIDPUBLICKEY;
}
/*
isc_buffer_init(&fileb, filename, sizeof(filename));
result = dst_key_buildfilename(key, DST_TYPE_PUBLIC, directory, &fileb);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_init(&tmpb, tmpname, sizeof(tmpname));
result = dst_key_buildfilename(key, DST_TYPE_TEMPLATE, directory,
&tmpb);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/* Create temporary public key file. */
fp = dst_key_open(tmpname, mode);
if (fp == NULL) {
- return (DST_R_WRITEERROR);
+ return DST_R_WRITEERROR;
}
/* Write key information in comments */
key->key_id);
result = dns_name_print(key->key_name, fp);
if (result != ISC_R_SUCCESS) {
- return (dst_key_cleanup(tmpname, fp));
+ return dst_key_cleanup(tmpname, fp);
}
fputc('\n', fp);
/* Now print the actual key */
result = dns_name_print(key->key_name, fp);
if (result != ISC_R_SUCCESS) {
- return (dst_key_cleanup(tmpname, fp));
+ return dst_key_cleanup(tmpname, fp);
}
fprintf(fp, " ");
isc_buffer_usedregion(&classb, &r);
if ((unsigned)fwrite(r.base, 1, r.length, fp) != r.length) {
- return (dst_key_cleanup(tmpname, fp));
+ return dst_key_cleanup(tmpname, fp);
}
if ((type & DST_TYPE_KEY) != 0) {
isc_buffer_usedregion(&textb, &r);
if ((unsigned)fwrite(r.base, 1, r.length, fp) != r.length) {
- return (dst_key_cleanup(tmpname, fp));
+ return dst_key_cleanup(tmpname, fp);
}
fputc('\n', fp);
- return (dst_key_close(tmpname, fp, filename));
+ return dst_key_close(tmpname, fp, filename);
}
static isc_result_t
if (directory != NULL) {
if (isc_buffer_availablelength(out) < strlen(directory)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putstr(out, directory);
if (strlen(directory) > 0U &&
}
}
if (isc_buffer_availablelength(out) < 1) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putstr(out, "K");
result = dns_name_tofilenametext(name, false, out);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return (isc_buffer_printf(out, "+%03d+%05d%s", alg, id, suffix));
+ return isc_buffer_printf(out, "+%03d+%05d%s", alg, id, suffix);
}
static isc_result_t
isc_buffer_init(&dnsbuf, dns_array, sizeof(dns_array));
ret = dst_key_todns(key, &dnsbuf);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
isc_buffer_usedregion(&dnsbuf, &r);
key->key_id = dst_region_computeid(&r);
key->key_rid = dst_region_computerid(&r);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
key = get_key_struct(name, alg, flags, protocol, 0, rdclass, 0, mctx);
if (key == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (isc_buffer_remaininglength(source) > 0) {
ret = algorithm_status(alg);
if (ret != ISC_R_SUCCESS) {
dst_key_free(&key);
- return (ret);
+ return ret;
}
if (key->func->fromdns == NULL) {
dst_key_free(&key);
- return (DST_R_UNSUPPORTEDALG);
+ return DST_R_UNSUPPORTEDALG;
}
if (!no_rdata) {
ret = key->func->fromdns(key, source);
if (ret != ISC_R_SUCCESS) {
dst_key_free(&key);
- return (ret);
+ return ret;
}
}
}
*keyp = key;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(dst_initialized);
if (dst_algorithm_supported(alg)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (DST_R_UNSUPPORTEDALG);
+ return DST_R_UNSUPPORTEDALG;
}
static isc_result_t
ofilename, suffix);
}
if (n < 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (n >= len) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_buffer_t *
dst_key_tkeytoken(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
- return (key->key_tkeytoken);
+ return key->key_tkeytoken;
}
/*
* This key is used.
*/
if (!state_type_set) {
- return (false);
+ return false;
}
/*
* If the state is not HIDDEN, the key is in use.
st = DST_KEY_STATE_NA;
}
if (st != DST_KEY_STATE_HIDDEN) {
- return (false);
+ return false;
}
}
/* This key is unused. */
- return (true);
+ return true;
}
isc_result_t
ret = result;
}
}
- return (ret);
+ return ret;
}
/* Hints on key whether it can be published and/or used for signing. */
time_ok = true;
}
- return (state_ok && time_ok);
+ return state_ok && time_ok;
}
bool
inactive = false;
}
}
- return (ds_ok && zrrsig_ok && time_ok && !inactive);
+ return ds_ok && zrrsig_ok && time_ok && !inactive;
}
bool
inactive = false;
}
}
- return (krrsig_ok && zrrsig_ok && time_ok && !inactive);
+ return krrsig_ok && zrrsig_ok && time_ok && !inactive;
}
bool
time_ok = (when <= now);
}
- return (time_ok);
+ return time_ok;
}
bool
if (dst_key_is_unused(key)) {
/* This key was never used. */
- return (false);
+ return false;
}
result = dst_key_gettime(key, DST_TIME_DELETE, &when);
time_ok = true;
}
- return (state_ok && time_ok);
+ return state_ok && time_ok;
}
dst_key_state_t
result = dst_key_getstate(key, DST_KEY_GOAL, &state);
if (result == ISC_R_SUCCESS) {
- return (state);
+ return state;
}
- return (DST_KEY_STATE_HIDDEN);
+ return DST_KEY_STATE_HIDDEN;
}
bool
dst_key_haskasp(dst_key_t *key) {
REQUIRE(VALID_KEY(key));
- return (key->kasp);
+ return key->kasp;
}
void
dst_hmac_algorithm_totext(dst_algorithm_t alg) {
switch (alg) {
case DST_ALG_HMACMD5:
- return ("hmac-md5");
+ return "hmac-md5";
case DST_ALG_HMACSHA1:
- return ("hmac-sha1");
+ return "hmac-sha1";
case DST_ALG_HMACSHA224:
- return ("hmac-sha224");
+ return "hmac-sha224";
case DST_ALG_HMACSHA256:
- return ("hmac-sha256");
+ return "hmac-sha256";
case DST_ALG_HMACSHA384:
- return ("hmac-sha384");
+ return "hmac-sha384";
case DST_ALG_HMACSHA512:
- return ("hmac-sha512");
+ return "hmac-sha512";
default:
- return ("unknown");
+ return "unknown";
}
}
if (strcasecmp(s, map[i].tag) == 0 &&
(TAG_ALG(map[i].value) == alg))
{
- return (map[i].value);
+ return map[i].value;
}
}
- return (-1);
+ return -1;
}
static const char *
for (i = 0;; i++) {
if (map[i].tag == NULL) {
- return (NULL);
+ return NULL;
} else if (value == map[i].value) {
- return (map[i].tag);
+ return map[i].tag;
}
}
}
for (i = 0; i < ntags; i++) {
if (tags[i] != NULL && strcasecmp(s, tags[i]) == 0) {
- return (i);
+ return i;
}
}
- return (-1);
+ return -1;
}
static int
find_timedata(const char *s) {
- return (find_metadata(s, timetags, TIMING_NTAGS));
+ return find_metadata(s, timetags, TIMING_NTAGS);
}
static int
find_numericdata(const char *s) {
- return (find_metadata(s, numerictags, NUMERIC_NTAGS));
+ return find_metadata(s, numerictags, NUMERIC_NTAGS);
}
static int
unsigned int mask;
if (external) {
- return ((priv->nelements == 0) ? 0 : -1);
+ return (priv->nelements == 0) ? 0 : -1;
}
for (i = 0; i < RSA_NTAGS; i++) {
}
}
if (i == RSA_NTAGS) {
- return (-1);
+ return -1;
}
have[i] = true;
}
have[TAG_RSA_EXPONENT2 & mask] &&
have[TAG_RSA_COEFFICIENT & mask];
}
- return (ok ? 0 : -1);
+ return ok ? 0 : -1;
}
static int
check_dh(const dst_private_t *priv) {
int i, j;
if (priv->nelements != DH_NTAGS) {
- return (-1);
+ return -1;
}
for (i = 0; i < DH_NTAGS; i++) {
for (j = 0; j < priv->nelements; j++) {
}
}
if (j == priv->nelements) {
- return (-1);
+ return -1;
}
}
- return (0);
+ return 0;
}
static int
unsigned int mask;
if (external) {
- return ((priv->nelements == 0) ? 0 : -1);
+ return (priv->nelements == 0) ? 0 : -1;
}
for (i = 0; i < ECDSA_NTAGS; i++) {
}
}
if (i == ECDSA_NTAGS) {
- return (-1);
+ return -1;
}
have[i] = true;
}
} else {
ok = have[TAG_ECDSA_PRIVATEKEY & mask];
}
- return (ok ? 0 : -1);
+ return ok ? 0 : -1;
}
static int
unsigned int mask;
if (external) {
- return ((priv->nelements == 0) ? 0 : -1);
+ return (priv->nelements == 0) ? 0 : -1;
}
for (i = 0; i < EDDSA_NTAGS; i++) {
}
}
if (i == EDDSA_NTAGS) {
- return (-1);
+ return -1;
}
have[i] = true;
}
} else {
ok = have[TAG_EDDSA_PRIVATEKEY & mask];
}
- return (ok ? 0 : -1);
+ return ok ? 0 : -1;
}
static int
if (old && priv->nelements == OLD_HMACMD5_NTAGS &&
priv->elements[0].tag == TAG_HMACMD5_KEY)
{
- return (0);
+ return 0;
}
- return (-1);
+ return -1;
}
/*
* We must be new format at this point.
}
}
if (j == priv->nelements) {
- return (-1);
+ return -1;
}
}
- return (0);
+ return 0;
}
static int
unsigned int alg) {
unsigned int i, j;
if (priv->nelements != ntags) {
- return (-1);
+ return -1;
}
for (i = 0; i < ntags; i++) {
for (j = 0; j < priv->nelements; j++) {
}
}
if (j == priv->nelements) {
- return (-1);
+ return -1;
}
}
- return (0);
+ return 0;
}
static int
case DST_ALG_NSEC3RSASHA1:
case DST_ALG_RSASHA256:
case DST_ALG_RSASHA512:
- return (check_rsa(priv, external));
+ return check_rsa(priv, external);
case DST_ALG_DH:
- return (check_dh(priv));
+ return check_dh(priv);
case DST_ALG_ECDSA256:
case DST_ALG_ECDSA384:
- return (check_ecdsa(priv, external));
+ return check_ecdsa(priv, external);
case DST_ALG_ED25519:
case DST_ALG_ED448:
- return (check_eddsa(priv, external));
+ return check_eddsa(priv, external);
case DST_ALG_HMACMD5:
- return (check_hmac_md5(priv, old));
+ return check_hmac_md5(priv, old);
case DST_ALG_HMACSHA1:
- return (check_hmac_sha(priv, HMACSHA1_NTAGS, alg));
+ return check_hmac_sha(priv, HMACSHA1_NTAGS, alg);
case DST_ALG_HMACSHA224:
- return (check_hmac_sha(priv, HMACSHA224_NTAGS, alg));
+ return check_hmac_sha(priv, HMACSHA224_NTAGS, alg);
case DST_ALG_HMACSHA256:
- return (check_hmac_sha(priv, HMACSHA256_NTAGS, alg));
+ return check_hmac_sha(priv, HMACSHA256_NTAGS, alg);
case DST_ALG_HMACSHA384:
- return (check_hmac_sha(priv, HMACSHA384_NTAGS, alg));
+ return check_hmac_sha(priv, HMACSHA384_NTAGS, alg);
case DST_ALG_HMACSHA512:
- return (check_hmac_sha(priv, HMACSHA512_NTAGS, alg));
+ return check_hmac_sha(priv, HMACSHA512_NTAGS, alg);
default:
- return (DST_R_UNSUPPORTEDALG);
+ return DST_R_UNSUPPORTEDALG;
}
}
key->external = external;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
fail:
dst__privstruct_free(priv, mctx);
isc_mem_put(mctx, data, MAXFIELDSIZE);
}
- return (ret);
+ return ret;
}
isc_result_t
ret = check_data(priv, dst_key_alg(key), false, key->external);
if (ret < 0) {
- return (DST_R_INVALIDPRIVATEKEY);
+ return DST_R_INVALIDPRIVATEKEY;
} else if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
isc_buffer_init(&fileb, filename, sizeof(filename));
result = dst_key_buildfilename(key, DST_TYPE_PRIVATE, directory,
&fileb);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = isc_file_mode(filename, &mode);
result = dst_key_buildfilename(key, DST_TYPE_TEMPLATE, directory,
&tmpb);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
fp = dst_key_open(tmpname, S_IRUSR | S_IWUSR);
if (fp == NULL) {
- return (DST_R_WRITEERROR);
+ return DST_R_WRITEERROR;
}
dst_key_getprivateformat(key, &major, &minor);
isc_buffer_init(&b, buffer, sizeof(buffer));
result = isc_base64_totext(&r, sizeof(buffer), "", &b);
if (result != ISC_R_SUCCESS) {
- return (dst_key_cleanup(tmpname, fp));
+ return dst_key_cleanup(tmpname, fp);
}
isc_buffer_usedregion(&b, &r);
isc_buffer_init(&b, buffer, sizeof(buffer));
result = dns_time32_totext(when, &b);
if (result != ISC_R_SUCCESS) {
- return (dst_key_cleanup(tmpname, fp));
+ return dst_key_cleanup(tmpname, fp);
}
isc_buffer_usedregion(&b, &r);
}
result = dst_key_close(tmpname, fp, filename);
- return (result);
+ return result;
}
/*! \file */
imp = ISC_LIST_NEXT(imp, link))
{
if (strcasecmp(name, imp->name) == 0) {
- return (imp);
+ return imp;
}
}
- return (NULL);
+ return NULL;
}
static isc_result_t
"failed to lookup symbol %s in "
"DynDB module '%s': %s",
symbol_name, filename, errmsg);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
*symbolp = symbol;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
*impp = imp;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
unload_library(&imp);
- return (result);
+ return result;
}
static void
}
UNLOCK(&dyndb_lock);
- return (result);
+ return result;
}
void
*dctxp = dctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
if (ecs1->source != ecs2->source ||
ecs1->addr.family != ecs2->addr.family)
{
- return (false);
+ return false;
}
alen = (ecs1->source + 7) / 8;
if (alen == 0) {
- return (true);
+ return true;
}
switch (ecs1->addr.family) {
* prefix.
*/
if (alen > 1 && memcmp(addr1, addr2, alen - 1) != 0) {
- return (false);
+ return false;
}
/*
}
if ((addr1[alen - 1] & mask) != (addr2[alen - 1] & mask)) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
void
dns_name_t *
dns_fixedname_name(dns_fixedname_t *fixed) {
- return (&fixed->name);
+ return &fixed->name;
}
dns_name_t *
dns_fixedname_initname(dns_fixedname_t *fixed) {
dns_fixedname_init(fixed);
- return (dns_fixedname_name(fixed));
+ return dns_fixedname_name(fixed);
}
fwdtable->magic = FWDTABLEMAGIC;
*fwdtablep = fwdtable;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_fwdtable:
isc_mem_put(mctx, fwdtable, sizeof(*fwdtable));
- return (result);
+ return result;
}
isc_result_t
goto cleanup;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
while (!ISC_LIST_EMPTY(forwarders->fwdrs)) {
isc_mem_put(fwdtable->mctx, fwd, sizeof(*fwd));
}
isc_mem_put(fwdtable->mctx, forwarders, sizeof(*forwarders));
- return (result);
+ return result;
}
isc_result_t
goto cleanup;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
while (!ISC_LIST_EMPTY(forwarders->fwdrs)) {
isc_mem_put(fwdtable->mctx, fwd, sizeof(*fwd));
}
isc_mem_put(fwdtable->mctx, forwarders, sizeof(*forwarders));
- return (result);
+ return result;
}
isc_result_t
result = dns_rbt_deletename(fwdtable->table, name, false);
RWUNLOCK(&fwdtable->rwlock, isc_rwlocktype_write);
- return (result);
+ return result;
}
isc_result_t
(void **)forwardersp);
RWUNLOCK(&fwdtable->rwlock, isc_rwlocktype_read);
- return (result);
+ return result;
}
void
dir->handle = opendir(path);
if (dir->handle != NULL) {
- return (true);
+ return true;
} else {
- return (false);
+ return false;
}
}
}
if (dir->filename != NULL) {
- return (true);
+ return true;
} else {
- return (false);
+ return false;
}
}
*b++ = islower(c) ? toupper(c) : c;
}
*b = '\0';
- return (buf[buf_to_use]);
+ return buf[buf_to_use];
}
static char *
*b++ = (c == '-') ? '_' : c;
}
*b = '\0';
- return (buf);
+ return buf;
}
static void
for (i = 0; i < TYPENAMES; i++) {
if (typenames[i].typebuf[0] != 0 && typenames[i].type == type) {
- return (&typenames[i]);
+ return &typenames[i];
}
}
- return (NULL);
+ return NULL;
}
static void
a = tolower((unsigned char)string[0]);
b = tolower((unsigned char)string[n - 1]);
- return (((a + n) * b) % 256);
+ return ((a + n) * b) % 256;
}
int
exit(EXIT_FAILURE);
}
- return (0);
+ return 0;
}
if (db == geoip_state.db && isc_netaddr_equal(addr, &geoip_state.addr))
{
- return (&geoip_state);
+ return &geoip_state;
}
isc_sockaddr_fromnetaddr(&sa, addr, 0);
match = MMDB_lookup_sockaddr(db, &sa.type.sa, &err);
if (err != MMDB_SUCCESS || !match.found_entry) {
- return (NULL);
+ return NULL;
}
set_state(db, addr, match, match.entry);
- return (&geoip_state);
+ return &geoip_state;
}
static dns_geoip_subtype_t
break;
}
- return (ret);
+ return ret;
}
static MMDB_s *
case dns_geoip_country_name:
case dns_geoip_country_continentcode:
case dns_geoip_country_continent:
- return (geoip->country);
+ return geoip->country;
case dns_geoip_city_countrycode:
case dns_geoip_city_countryname:
case dns_geoip_city_timezonecode:
case dns_geoip_city_metrocode:
case dns_geoip_city_areacode:
- return (geoip->city);
+ return geoip->city;
case dns_geoip_isp_name:
- return (geoip->isp);
+ return geoip->isp;
case dns_geoip_as_asnum:
case dns_geoip_org_name:
- return (geoip->as);
+ return geoip->as;
case dns_geoip_domain_name:
- return (geoip->domain);
+ return geoip->domain;
default:
/*
* All other subtypes are unavailable in GeoIP2.
*/
- return (NULL);
+ return NULL;
}
}
value->type != MMDB_DATA_TYPE_UTF8_STRING ||
value->utf8_string == NULL)
{
- return (false);
+ return false;
}
- return (strncasecmp(value->utf8_string, str, value->data_size) == 0);
+ return strncasecmp(value->utf8_string, str, value->data_size) == 0;
}
static bool
(value->type != MMDB_DATA_TYPE_UINT32 &&
value->type != MMDB_DATA_TYPE_UINT16))
{
- return (false);
+ return false;
}
- return (value->uint32 == ui32);
+ return value->uint32 == ui32;
}
bool
subtype = fix_subtype(geoip, elt->subtype);
db = geoip2_database(geoip, subtype);
if (db == NULL) {
- return (false);
+ return false;
}
state = get_entry_for(db, reqaddr);
if (state == NULL) {
- return (false);
+ return false;
}
switch (subtype) {
ret = MMDB_get_value(&state->entry, &value, "country",
"iso_code", (char *)0);
if (ret == MMDB_SUCCESS) {
- return (match_string(&value, elt->as_string));
+ return match_string(&value, elt->as_string);
}
break;
ret = MMDB_get_value(&state->entry, &value, "country", "names",
"en", (char *)0);
if (ret == MMDB_SUCCESS) {
- return (match_string(&value, elt->as_string));
+ return match_string(&value, elt->as_string);
}
break;
ret = MMDB_get_value(&state->entry, &value, "continent", "code",
(char *)0);
if (ret == MMDB_SUCCESS) {
- return (match_string(&value, elt->as_string));
+ return match_string(&value, elt->as_string);
}
break;
ret = MMDB_get_value(&state->entry, &value, "continent",
"names", "en", (char *)0);
if (ret == MMDB_SUCCESS) {
- return (match_string(&value, elt->as_string));
+ return match_string(&value, elt->as_string);
}
break;
ret = MMDB_get_value(&state->entry, &value, "subdivisions", "0",
"iso_code", (char *)0);
if (ret == MMDB_SUCCESS) {
- return (match_string(&value, elt->as_string));
+ return match_string(&value, elt->as_string);
}
break;
ret = MMDB_get_value(&state->entry, &value, "subdivisions", "0",
"names", "en", (char *)0);
if (ret == MMDB_SUCCESS) {
- return (match_string(&value, elt->as_string));
+ return match_string(&value, elt->as_string);
}
break;
ret = MMDB_get_value(&state->entry, &value, "city", "names",
"en", (char *)0);
if (ret == MMDB_SUCCESS) {
- return (match_string(&value, elt->as_string));
+ return match_string(&value, elt->as_string);
}
break;
ret = MMDB_get_value(&state->entry, &value, "postal", "code",
(char *)0);
if (ret == MMDB_SUCCESS) {
- return (match_string(&value, elt->as_string));
+ return match_string(&value, elt->as_string);
}
break;
ret = MMDB_get_value(&state->entry, &value, "location",
"time_zone", (char *)0);
if (ret == MMDB_SUCCESS) {
- return (match_string(&value, elt->as_string));
+ return match_string(&value, elt->as_string);
}
break;
ret = MMDB_get_value(&state->entry, &value, "location",
"metro_code", (char *)0);
if (ret == MMDB_SUCCESS) {
- return (match_string(&value, elt->as_string));
+ return match_string(&value, elt->as_string);
}
break;
case dns_geoip_isp_name:
ret = MMDB_get_value(&state->entry, &value, "isp", (char *)0);
if (ret == MMDB_SUCCESS) {
- return (match_string(&value, elt->as_string));
+ return match_string(&value, elt->as_string);
}
break;
s += 2;
}
i = strtol(s, NULL, 10);
- return (match_int(&value, i));
+ return match_int(&value, i);
}
break;
"autonomous_system_organization",
(char *)0);
if (ret == MMDB_SUCCESS) {
- return (match_string(&value, elt->as_string));
+ return match_string(&value, elt->as_string);
}
break;
ret = MMDB_get_value(&state->entry, &value, "domain",
(char *)0);
if (ret == MMDB_SUCCESS) {
- return (match_string(&value, elt->as_string));
+ return match_string(&value, elt->as_string);
}
break;
* For any other subtype, we assume the database was
* unavailable and return false.
*/
- return (false);
+ return false;
}
/*
* No database matched: return false.
*/
- return (false);
+ return false;
}
dctx->ctxdata.gssctx = ctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
result = isc_buffer_copyregion(ctx->buffer, data);
if (result == ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
length = isc_buffer_length(ctx->buffer) + data->length + BUFFER_EXTRA;
isc_buffer_free(&ctx->buffer);
ctx->buffer = newbuffer;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
if (gret != GSS_S_COMPLETE) {
gss_log(3, "GSS sign error: %s",
gss_error_tostring(gret, minor, buf, sizeof(buf)));
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
*/
if (gsig.length > isc_buffer_availablelength(sig)) {
gss_release_buffer(&minor, &gsig);
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/*
gss_release_buffer(&minor, &gsig);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
gret == GSS_S_CONTEXT_EXPIRED || gret == GSS_S_NO_CONTEXT ||
gret == GSS_S_FAILURE)
{
- return (DST_R_VERIFYFAILURE);
+ return DST_R_VERIFYFAILURE;
} else {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
gss_ctx_id_t gsskey2 = key2->keydata.gssctx;
/* No idea */
- return (gsskey1 == gsskey2);
+ return gsskey1 == gsskey2;
}
static isc_result_t
UNUSED(callback);
/* No idea */
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
static bool
gssapi_isprivate(const dst_key_t *key) {
UNUSED(key);
- return (true);
+ return true;
}
static void
len = strlen(keystr);
if ((len % 4) != 0U) {
- return (ISC_R_BADBASE64);
+ return ISC_R_BADBASE64;
}
len = (len / 4) * 3;
result = isc_base64_decodestring(keystr, b);
if (result != ISC_R_SUCCESS) {
isc_buffer_free(&b);
- return (result);
+ return result;
}
isc_buffer_remainingregion(b, &r);
(gss_ctx_id_t *)&key->keydata.gssctx);
if (major != GSS_S_COMPLETE) {
isc_buffer_free(&b);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
isc_buffer_free(&b);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
if (major != GSS_S_COMPLETE) {
fprintf(stderr, "gss_export_sec_context -> %u, %u\n", major,
minor);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (gssbuffer.length == 0U) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
len = ((gssbuffer.length + 2) / 3) * 4;
buf = isc_mem_get(mctx, len);
gss_release_buffer(&minor, &gssbuffer);
*buffer = buf;
*length = (int)len;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static dst_func_t gssapi_functions = {
if (*funcp == NULL) {
*funcp = &gssapi_functions;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
gret = gss_create_empty_oid_set(minor, mech_oid_set);
if (gret != GSS_S_COMPLETE) {
- return (gret);
+ return gret;
}
gret = gss_add_oid_set_member(minor, GSS_KRB5_MECHANISM, mech_oid_set);
release:
REQUIRE(gss_release_oid_set(minor, mech_oid_set) == GSS_S_COMPLETE);
- return (gret);
+ return gret;
}
static void
gss_log(3, "failed gss_import_name: %s",
gss_error_tostring(gret, minor, buf,
sizeof(buf)));
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
} else {
gname = NULL;
if (gret != GSS_S_COMPLETE) {
gss_log(3, "failed to create OID_set: %s",
gss_error_tostring(gret, minor, buf, sizeof(buf)));
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
gret = gss_acquire_cred(&minor, gname, GSS_C_INDEFINITE, mech_oid_set,
}
}
- return (result);
+ return result;
}
bool
*/
rname = strchr(sbuf, '@');
if (rname == NULL) {
- return (false);
+ return false;
}
*rname = '\0';
rname++;
if (strcmp(rname, rbuf) != 0) {
- return (false);
+ return false;
}
/*
*/
sname = strchr(sbuf, '/');
if (sname == NULL) {
- return (false);
+ return false;
}
*sname = '\0';
sname++;
if (strcmp(sbuf, "host") != 0) {
- return (false);
+ return false;
}
/*
machine = dns_fixedname_initname(&fixed);
result = dns_name_fromstring(machine, sname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
if (subdomain) {
- return (dns_name_issubdomain(name, machine));
+ return dns_name_issubdomain(name, machine);
}
- return (dns_name_equal(name, machine));
+ return dns_name_equal(name, machine);
}
- return (true);
+ return true;
}
bool
*/
rname = strchr(sbuf, '@');
if (rname == NULL) {
- return (false);
+ return false;
}
sname = strchr(sbuf, '$');
if (sname == NULL) {
- return (false);
+ return false;
}
/*
* Verify that the $ and @ follow one another.
*/
if (rname - sname != 1) {
- return (false);
+ return false;
}
/*
*sname = '\0';
if (strcmp(rname, rbuf) != 0) {
- return (false);
+ return false;
}
/*
machine = dns_fixedname_initname(&fixed);
result = dns_name_fromstring2(machine, sbuf, realm, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
if (subdomain) {
- return (dns_name_issubdomain(name, machine));
+ return dns_name_issubdomain(name, machine);
}
- return (dns_name_equal(name, machine));
+ return dns_name_equal(name, machine);
}
- return (true);
+ return true;
}
isc_result_t
}
*cred = NULL;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
(void)gss_release_buffer(&minor, &gouttoken);
}
(void)gss_release_name(&minor, &gname);
- return (result);
+ return result;
}
isc_result_t
"gsskrb5_register_acceptor_identity(%s): %s",
gssapi_keytab,
gss_error_tostring(gret, 0, buf, sizeof(buf)));
- return (DNS_R_INVALIDTKEY);
+ return DNS_R_INVALIDTKEY;
}
#else
/*
size = strlen(gssapi_keytab) + 13;
kt = malloc(size);
if (kt == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
snprintf(kt, size, "KRB5_KTNAME=%s", gssapi_keytab);
if (putenv(kt) != 0) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
}
#endif
if (gouttoken.length > 0U) {
(void)gss_release_buffer(&minor, &gouttoken);
}
- return (result);
+ return result;
}
if (gouttoken.length > 0U) {
}
}
- return (result);
+ return result;
}
isc_result_t
gss_log(3, "Failure deleting security context %s",
gss_error_tostring(gret, minor, buf, sizeof(buf)));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
char *
if (msg_minor.length != 0U) {
(void)gss_release_buffer(&minor_stat, &msg_minor);
}
- return (buf);
+ return buf;
}
#else
UNUSED(initiate);
UNUSED(cred);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
bool
UNUSED(realm);
UNUSED(subdomain);
- return (false);
+ return false;
}
bool
UNUSED(realm);
UNUSED(subdomain);
- return (false);
+ return false;
}
isc_result_t
dst_gssapi_releasecred(dns_gss_cred_id_t *cred) {
UNUSED(cred);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
UNUSED(mctx);
UNUSED(err_message);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
UNUSED(principal);
UNUSED(mctx);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
dst_gssapi_deletectx(isc_mem_t *mctx, dns_gss_ctx_id_t *gssctx) {
UNUSED(mctx);
UNUSED(gssctx);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
char *
snprintf(buf, buflen, "GSSAPI error: Major = %u, Minor = %u.", major,
minor);
- return (buf);
+ return buf;
}
#endif
uint16_t *bits = (uint16_t *)element->data;
if (element->length != 2) {
- return (DST_R_INVALIDPRIVATEKEY);
+ return DST_R_INVALIDPRIVATEKEY;
}
key->key_bits = ntohs(*bits);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
type);
if (result != ISC_R_SUCCESS) {
isc_hmac_free(ctx);
- return (DST_R_UNSUPPORTEDALG);
+ return DST_R_UNSUPPORTEDALG;
}
dctx->ctxdata.hmac_ctx = ctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
result = isc_hmac_update(ctx, data->base, data->length);
if (result != ISC_R_SUCCESS) {
- return (DST_R_OPENSSLFAILURE);
+ return DST_R_OPENSSLFAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
unsigned int digestlen = sizeof(digest);
if (isc_hmac_final(ctx, digest, &digestlen) != ISC_R_SUCCESS) {
- return (DST_R_OPENSSLFAILURE);
+ return DST_R_OPENSSLFAILURE;
}
if (isc_hmac_reset(ctx) != ISC_R_SUCCESS) {
- return (DST_R_OPENSSLFAILURE);
+ return DST_R_OPENSSLFAILURE;
}
if (isc_buffer_availablelength(sig) < digestlen) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putmem(sig, digest, digestlen);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(ctx != NULL);
if (isc_hmac_final(ctx, digest, &digestlen) != ISC_R_SUCCESS) {
- return (DST_R_OPENSSLFAILURE);
+ return DST_R_OPENSSLFAILURE;
}
if (isc_hmac_reset(ctx) != ISC_R_SUCCESS) {
- return (DST_R_OPENSSLFAILURE);
+ return DST_R_OPENSSLFAILURE;
}
if (sig->length > digestlen) {
- return (DST_R_VERIFYFAILURE);
+ return DST_R_VERIFYFAILURE;
}
- return (isc_safe_memequal(digest, sig->base, sig->length)
- ? ISC_R_SUCCESS
- : DST_R_VERIFYFAILURE);
+ return isc_safe_memequal(digest, sig->base, sig->length)
+ ? ISC_R_SUCCESS
+ : DST_R_VERIFYFAILURE;
}
static bool
hkey2 = key2->keydata.hmac_key;
if (hkey1 == NULL && hkey2 == NULL) {
- return (true);
+ return true;
} else if (hkey1 == NULL || hkey2 == NULL) {
- return (false);
+ return false;
}
- return (isc_safe_memequal(hkey1->key, hkey2->key,
- isc_md_type_get_block_size(type)));
+ return isc_safe_memequal(hkey1->key, hkey2->key,
+ isc_md_type_get_block_size(type));
}
static isc_result_t
isc_safe_memwipe(data, sizeof(data));
- return (ret);
+ return ret;
}
static bool
hmac_isprivate(const dst_key_t *key) {
UNUSED(key);
- return (true);
+ return true;
}
static void
bytes = (key->key_size + 7) / 8;
if (isc_buffer_availablelength(data) < bytes) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putmem(data, hkey->key, bytes);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_remainingregion(data, &r);
if (r.length == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
hkey = isc_mem_get(key->mctx, sizeof(dst_hmac_key_t));
ISC_R_SUCCESS)
{
isc_mem_put(key->mctx, hkey, sizeof(dst_hmac_key_t));
- return (DST_R_OPENSSLFAILURE);
+ return DST_R_OPENSSLFAILURE;
}
} else {
memmove(hkey->key, r.base, r.length);
isc_buffer_forward(data, r.length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static int
hmac__get_tag_key(const isc_md_type_t *type) {
if (type == ISC_MD_MD5) {
- return (TAG_HMACMD5_KEY);
+ return TAG_HMACMD5_KEY;
} else if (type == ISC_MD_SHA1) {
- return (TAG_HMACSHA1_KEY);
+ return TAG_HMACSHA1_KEY;
} else if (type == ISC_MD_SHA224) {
- return (TAG_HMACSHA224_KEY);
+ return TAG_HMACSHA224_KEY;
} else if (type == ISC_MD_SHA256) {
- return (TAG_HMACSHA256_KEY);
+ return TAG_HMACSHA256_KEY;
} else if (type == ISC_MD_SHA384) {
- return (TAG_HMACSHA384_KEY);
+ return TAG_HMACSHA384_KEY;
} else if (type == ISC_MD_SHA512) {
- return (TAG_HMACSHA512_KEY);
+ return TAG_HMACSHA512_KEY;
} else {
UNREACHABLE();
}
static int
hmac__get_tag_bits(const isc_md_type_t *type) {
if (type == ISC_MD_MD5) {
- return (TAG_HMACMD5_BITS);
+ return TAG_HMACMD5_BITS;
} else if (type == ISC_MD_SHA1) {
- return (TAG_HMACSHA1_BITS);
+ return TAG_HMACSHA1_BITS;
} else if (type == ISC_MD_SHA224) {
- return (TAG_HMACSHA224_BITS);
+ return TAG_HMACSHA224_BITS;
} else if (type == ISC_MD_SHA256) {
- return (TAG_HMACSHA256_BITS);
+ return TAG_HMACSHA256_BITS;
} else if (type == ISC_MD_SHA384) {
- return (TAG_HMACSHA384_BITS);
+ return TAG_HMACSHA384_BITS;
} else if (type == ISC_MD_SHA512) {
- return (TAG_HMACSHA512_BITS);
+ return TAG_HMACSHA512_BITS;
} else {
UNREACHABLE();
}
uint16_t bits;
if (key->keydata.hmac_key == NULL) {
- return (DST_R_NULLKEY);
+ return DST_R_NULLKEY;
}
if (key->external) {
- return (DST_R_EXTERNALKEY);
+ return DST_R_EXTERNALKEY;
}
hkey = key->keydata.hmac_key;
priv.nelements = 2;
- return (dst__privstruct_writefile(key, &priv, directory));
+ return dst__privstruct_writefile(key, &priv, directory);
}
static int
hmac__to_dst_alg(const isc_md_type_t *type) {
if (type == ISC_MD_MD5) {
- return (DST_ALG_HMACMD5);
+ return DST_ALG_HMACMD5;
} else if (type == ISC_MD_SHA1) {
- return (DST_ALG_HMACSHA1);
+ return DST_ALG_HMACSHA1;
} else if (type == ISC_MD_SHA224) {
- return (DST_ALG_HMACSHA224);
+ return DST_ALG_HMACSHA224;
} else if (type == ISC_MD_SHA256) {
- return (DST_ALG_HMACSHA256);
+ return DST_ALG_HMACSHA256;
} else if (type == ISC_MD_SHA384) {
- return (DST_ALG_HMACSHA384);
+ return DST_ALG_HMACSHA384;
} else if (type == ISC_MD_SHA512) {
- return (DST_ALG_HMACSHA512);
+ return DST_ALG_HMACSHA512;
} else {
UNREACHABLE();
}
result = dst__privstruct_parse(key, hmac__to_dst_alg(type), lexer, mctx,
&priv);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (key->external) {
}
dst__privstruct_free(&priv, mctx);
isc_safe_memwipe(&priv, sizeof(priv));
- return (result);
+ return result;
}
hmac_register_algorithm(md5);
if (dlclose(*dl_handle) != 0) {
snprintf(emsg->c, sizeof(librpz_emsg_t),
"dlopen(NULL): %s", dlerror());
- return (NULL);
+ return NULL;
}
*dl_handle = NULL;
}
if (dl_handle != NULL) {
*dl_handle = handle;
}
- return (new_librpz);
+ return new_librpz;
}
if (dlclose(handle) != 0) {
snprintf(emsg->c, sizeof(librpz_emsg_t),
"dlsym(NULL, " LIBRPZ_DEF_STR "): %s",
dlerror());
- return (NULL);
+ return NULL;
}
}
if (path == NULL || path[0] == '\0') {
snprintf(emsg->c, sizeof(librpz_emsg_t),
"librpz not linked and no dlopen() path provided");
- return (NULL);
+ return NULL;
}
handle = dlopen(path, RTLD_NOW | RTLD_LOCAL);
if (handle == NULL) {
snprintf(emsg->c, sizeof(librpz_emsg_t), "dlopen(%s): %s", path,
dlerror());
- return (NULL);
+ return NULL;
}
new_librpz = dlsym(handle, LIBRPZ_DEF_STR);
if (new_librpz != NULL) {
if (dl_handle != NULL) {
*dl_handle = handle;
}
- return (new_librpz);
+ return new_librpz;
}
snprintf(emsg->c, sizeof(librpz_emsg_t),
"dlsym(%s, " LIBRPZ_DEF_STR "): %s", path, dlerror());
dlclose(handle);
- return (NULL);
+ return NULL;
}
#elif defined(LIBRPZ_LIB_OPEN)
/*
#if LIBRPZ_LIB_OPEN == 1
emsg->c[0] = '\0';
- return (&LIBRPZ_DEF);
+ return &LIBRPZ_DEF;
#else /* if LIBRPZ_LIB_OPEN == 1 */
snprintf(emsg->c, sizeof(librpz_emsg_t),
"librpz not available via ./configure");
- return (NULL);
+ return NULL;
#endif /* LIBRPZ_LIB_OPEN */
}
#endif /* LIBRPZ_LIB_OPEN */
REQUIRE(dst->count == 0);
if (src->count == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = dns_ipkeylist_resize(mctx, dst, src->count);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
memmove(dst->addrs, src->addrs, src->count * sizeof(isc_sockaddr_t));
}
}
dst->count = src->count;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(n > ipkl->count);
if (n <= ipkl->allocated) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
addrs = isc_mem_get(mctx, n * sizeof(isc_sockaddr_t));
(n - ipkl->allocated) * sizeof(dns_name_t *));
ipkl->allocated = n;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
isc_mem_put(mctx, addrs, n * sizeof(isc_sockaddr_t));
isc_mem_put(mctx, tlss, n * sizeof(dns_name_t *));
isc_mem_put(mctx, keys, n * sizeof(dns_name_t *));
isc_mem_put(mctx, labels, n * sizeof(dns_name_t *));
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
}
*target = tab;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_iptable_detach(&tab);
- return (result);
+ return result;
}
static bool dns_iptable_neg = false;
result = isc_radix_insert(tab->radix, &node, NULL, &pfx);
if (result != ISC_R_SUCCESS) {
isc_refcount_destroy(&pfx.refcount);
- return (result);
+ return result;
}
/* If a node already contains data, don't overwrite it */
}
isc_refcount_destroy(&pfx.refcount);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
result = isc_radix_insert(tab->radix, &new_node, node, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
RADIX_WALK_END;
tab->radix->num_added_node += max_node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
static uint32_t
decode_uint32(unsigned char *p) {
- return (((uint32_t)p[0] << 24) + ((uint32_t)p[1] << 16) +
- ((uint32_t)p[2] << 8) + ((uint32_t)p[3] << 0));
+ return ((uint32_t)p[0] << 24) + ((uint32_t)p[1] << 16) +
+ ((uint32_t)p[2] << 8) + ((uint32_t)p[3] << 0);
}
static void
dns_rdataset_disassociate(&rdataset);
dns_db_detachnode(db, &node);
- return (result);
+ return result;
freenode:
dns_db_detachnode(db, &node);
nonode:
UNEXPECTED_ERROR("missing SOA");
- return (result);
+ return result;
}
/* Journaling */
isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
"%s: seek: %s", j->filename,
isc_result_totext(result));
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
j->offset = offset;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
result = isc_stdio_read(mem, 1, nbytes, j->fp, NULL);
if (result != ISC_R_SUCCESS) {
if (result == ISC_R_EOF) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
"%s: read: %s", j->filename,
isc_result_totext(result));
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
j->offset += (isc_offset_t)nbytes;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
"%s: write: %s", j->filename,
isc_result_totext(result));
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
j->offset += (isc_offset_t)nbytes;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
"%s: flush: %s", j->filename,
isc_result_totext(result));
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
result = isc_stdio_sync(j->fp);
if (result != ISC_R_SUCCESS) {
isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
"%s: fsync: %s", j->filename,
isc_result_totext(result));
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
journal_rawxhdr_ver1_t raw;
result = journal_read(j, &raw, sizeof(raw));
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
xhdr->size = decode_uint32(raw.size);
xhdr->count = 0;
xhdr->serial0 = decode_uint32(raw.serial0);
xhdr->serial1 = decode_uint32(raw.serial1);
j->curxhdr = *xhdr;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
case XHDR_VERSION2: {
journal_rawxhdr_t raw;
result = journal_read(j, &raw, sizeof(raw));
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
xhdr->size = decode_uint32(raw.size);
xhdr->count = decode_uint32(raw.count);
xhdr->serial0 = decode_uint32(raw.serial0);
xhdr->serial1 = decode_uint32(raw.serial1);
j->curxhdr = *xhdr;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
default:
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
}
encode_uint32(size, raw.size);
encode_uint32(serial0, raw.serial0);
encode_uint32(serial1, raw.serial1);
- return (journal_write(j, &raw, sizeof(raw)));
+ return journal_write(j, &raw, sizeof(raw));
} else {
journal_rawxhdr_t raw;
encode_uint32(size, raw.size);
encode_uint32(count, raw.count);
encode_uint32(serial0, raw.serial0);
encode_uint32(serial1, raw.serial1);
- return (journal_write(j, &raw, sizeof(raw)));
+ return journal_write(j, &raw, sizeof(raw));
}
}
result = journal_read(j, &raw, sizeof(raw));
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
rrhdr->size = decode_uint32(raw.size);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
"%s: create: %s", filename,
isc_result_totext(result));
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
if (downgrade) {
(void)isc_stdio_close(fp);
(void)isc_file_remove(filename);
isc_mem_put(mctx, mem, size);
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
isc_mem_put(mctx, mem, size);
"%s: close: %s", filename,
isc_result_totext(result));
(void)isc_file_remove(filename);
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
j->state = writable ? JOURNAL_STATE_WRITE : JOURNAL_STATE_READ;
*journalp = j;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
j->magic = 0;
(void)isc_stdio_close(j->fp);
}
isc_mem_putanddetach(&j->mctx, j, sizeof(*j));
- return (result);
+ return result;
}
isc_result_t
result = snprintf(backup, sizeof(backup), "%.*s.jbk",
(int)namelen, filename);
if (result >= sizeof(backup)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
result = journal_open(mctx, backup, writable, writable, false,
journalp);
}
- return (result);
+ return result;
}
/*
r = bop - aop;
if (r != 0) {
- return (r);
+ return r;
}
r = (b->rdata.type == dns_rdatatype_soa) -
(a->rdata.type == dns_rdatatype_soa);
if (r != 0) {
- return (r);
+ return r;
}
r = (a->rdata.type - b->rdata.type);
- return (r);
+ return r;
}
static isc_result_t
* Handle mixture of version 1 and version 2
* transaction headers in a version 1 journal.
*/
- if ((xhdr->serial0 != serial ||
- isc_serial_le(xhdr->serial1, xhdr->serial0)))
+ if (xhdr->serial0 != serial ||
+ isc_serial_le(xhdr->serial1, xhdr->serial0))
{
if (j->xhdr_version == XHDR_VERSION1 && xhdr->serial1 == serial)
{
}
failure:
- return (result);
+ return result;
}
/*
result = journal_seek(j, pos->offset);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (pos->serial == j->header.end.serial) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
/*
*/
result = journal_read_xhdr(j, &xhdr);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (j->header_ver1) {
"%s: journal file corrupt: "
"expected serial %u, got %u",
j->filename, pos->serial, xhdr.serial0);
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
/*
if ((isc_offset_t)(pos->offset + hdrsize + xhdr.size) < pos->offset) {
isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
"%s: offset too large", j->filename);
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
pos->offset += hdrsize + xhdr.size;
pos->serial = xhdr.serial1;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
/*
REQUIRE(DNS_JOURNAL_VALID(j));
if (DNS_SERIAL_GT(j->header.begin.serial, serial)) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
if (DNS_SERIAL_GT(serial, j->header.end.serial)) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
if (serial == j->header.end.serial) {
*pos = j->header.end;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
current_pos = j->header.begin;
while (current_pos.serial != serial) {
if (DNS_SERIAL_GT(current_pos.serial, serial)) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
result = journal_next(j, ¤t_pos);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
*pos = current_pos;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
j->state = JOURNAL_STATE_TRANSACTION;
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
isc_result_t
"dns_journal_writediff: %s: journal entry "
"too big to be stored: %" PRIu64 " bytes",
j->filename, size);
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
mem = isc_mem_get(j->mctx, size);
if (mem != NULL) {
isc_mem_put(j->mctx, mem, size);
}
- return (result);
+ return result;
}
isc_result_t
CHECK(journal_write(j, &rawheader, sizeof(rawheader)));
CHECK(journal_fsync(j));
j->state = JOURNAL_STATE_WRITE;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
"%s: malformed transaction: %d SOAs", j->filename,
j->x.n_soa);
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
if (!DNS_SERIAL_GT(j->x.pos[1].serial, j->x.pos[0].serial)) {
isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
"%s: malformed transaction: serial number "
"did not increase",
j->filename);
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
if (!JOURNAL_EMPTY(&j->header)) {
if (j->x.pos[0].serial != j->header.end.serial) {
"transaction first serial %u",
j->filename, j->header.end.serial,
j->x.pos[0].serial);
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
}
"transaction too big to be stored in journal: "
"%" PRIu64 "b (max is %" PRIu64 "b)",
total, (uint64_t)DNS_JOURNAL_SIZE_MAX);
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
/*
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
isc_result_t
CHECK(dns_journal_commit(j));
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
void
INSIST(ver == NULL);
- return (result);
+ return result;
}
isc_result_t
result = dns_journal_open(mctx, filename, DNS_JOURNAL_READ, &j);
if (result == ISC_R_NOTFOUND) {
isc_log_write(JOURNAL_DEBUG_LOGARGS(3), "no journal file");
- return (DNS_R_NOJOURNAL);
+ return DNS_R_NOJOURNAL;
} else if (result != ISC_R_SUCCESS) {
isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
"journal open failure: %s: %s",
isc_result_totext(result), filename);
- return (result);
+ return result;
}
if (printxhdr) {
dns_diff_clear(&diff);
dns_journal_destroy(&j);
- return (result);
+ return result;
}
/**************************************************************************/
*/
bool
dns_journal_empty(dns_journal_t *j) {
- return (JOURNAL_EMPTY(&j->header));
+ return JOURNAL_EMPTY(&j->header);
}
bool
dns_journal_recovered(dns_journal_t *j) {
- return (j->recovered);
+ return j->recovered;
}
uint32_t
dns_journal_first_serial(dns_journal_t *j) {
- return (j->header.begin.serial);
+ return j->header.begin.serial;
}
uint32_t
dns_journal_last_serial(dns_journal_t *j) {
- return (j->header.end.serial);
+ return j->header.end.serial;
}
void
REQUIRE(sourceserial != NULL);
if (!j->header.serialset) {
- return (false);
+ return false;
}
*sourceserial = j->header.sourceserial;
- return (true);
+ return true;
}
/**************************************************************************/
if (b->length < size) {
void *mem = isc_mem_get(mctx, size);
if (mem == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (b->base != NULL) {
isc_mem_put(mctx, b->base, b->length);
b->length = size;
}
isc_buffer_clear(b);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
result = ISC_R_SUCCESS;
failure:
j->it.result = result;
- return (j->it.result);
+ return j->it.result;
}
isc_result_t
j->it.xsize = 0; /* We have no transaction data yet... */
j->it.xpos = 0; /* ...and haven't used any of it. */
- return (read_one_rr(j));
+ return read_one_rr(j);
failure:
- return (result);
+ return result;
}
static isc_result_t
isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
"%s: journal corrupt: possible integer overflow",
j->filename);
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
if (j->offset == j->it.epos.offset) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
if (j->it.xpos == j->it.xsize) {
/*
failure:
j->it.result = result;
- return (result);
+ return result;
}
isc_result_t
dns_journal_next_rr(dns_journal_t *j) {
j->it.result = read_one_rr(j);
- return (j->it.result);
+ return j->it.result;
}
void
result = dns_dbiterator_current(dbit, &node, name);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_allrdatasets(db, node, ver, 0, now, &rdsiter);
cleanup_node:
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
/*
int r;
r = (b->rdata.type - a->rdata.type);
if (r != 0) {
- return (r);
+ return r;
}
r = dns_rdata_compare(&a->rdata, &b->rdata);
- return (r);
+ return r;
}
static isc_result_t
ISC_LIST_APPENDLIST(r->tuples, add, link);
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
static isc_result_t
result = dns_db_createiterator(db[0], options, &dbit[0]);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_createiterator(db[1], options, &dbit[1]);
if (result != ISC_R_SUCCESS) {
dns_dbiterator_destroy(&dbit[0]);
dns_diff_clear(&diff[0]);
dns_diff_clear(&diff[1]);
- return (result);
+ return result;
}
/*
dns_diff_clear(&diff);
- return (result);
+ return result;
}
isc_result_t
result = dns_journal_open(diff->mctx, filename,
DNS_JOURNAL_CREATE, &journal);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
if (journal != NULL) {
dns_journal_destroy(&journal);
}
- return (result);
+ return result;
}
static uint32_t
count++;
}
- return (count);
+ return count;
}
static bool
isc_buffer_add(&b, size);
while (isc_buffer_remaininglength(&b) > 0) {
if (isc_buffer_remaininglength(&b) < 4) {
- return (false);
+ return false;
}
rrsize = isc_buffer_getuint32(&b);
/* "." + type + class + ttl + rdlen => 11U */
if (rrsize < 11U || isc_buffer_remaininglength(&b) < rrsize) {
- return (false);
+ return false;
}
isc_buffer_forward(&b, rrsize);
}
- return (true);
+ return true;
}
isc_result_t
result = journal_open(mctx, backup, false, false, false, &j1);
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
serial = dns_journal_first_serial(j1);
} else if (JOURNAL_EMPTY(&j1->header)) {
dns_journal_destroy(&j1);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (DNS_SERIAL_GT(j1->header.begin.serial, serial) ||
DNS_SERIAL_GT(serial, j1->header.end.serial))
{
dns_journal_destroy(&j1);
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
/*
*/
if (!rewrite && (uint32_t)j1->header.end.offset < target_size) {
dns_journal_destroy(&j1);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
CHECK(journal_open(mctx, newname, true, true, downgrade, &j2));
if (j2 != NULL) {
dns_journal_destroy(&j2);
}
- return (result);
+ return result;
}
static isc_result_t
CHECK(journal_write(j, j->rawindex, rawbytes));
}
failure:
- return (result);
+ return result;
}
ISC_LIST_INIT(kasp->keys);
*kaspp = kasp;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
dns_kasp_getname(dns_kasp_t *kasp) {
REQUIRE(DNS_KASP_VALID(kasp));
- return (kasp->name);
+ return kasp->name;
}
void
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(kasp->frozen);
- return (kasp->signatures_validity - kasp->signatures_refresh);
+ return kasp->signatures_validity - kasp->signatures_refresh;
}
uint32_t
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(kasp->frozen);
- return (kasp->signatures_jitter);
+ return kasp->signatures_jitter;
}
void
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(kasp->frozen);
- return (kasp->signatures_refresh);
+ return kasp->signatures_refresh;
}
void
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(kasp->frozen);
- return (kasp->signatures_validity);
+ return kasp->signatures_validity;
}
void
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(kasp->frozen);
- return (kasp->signatures_validity_dnskey);
+ return kasp->signatures_validity_dnskey;
}
void
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(kasp->frozen);
- return (kasp->dnskey_ttl);
+ return kasp->dnskey_ttl;
}
void
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(kasp->frozen);
- return (kasp->purge_keys);
+ return kasp->purge_keys;
}
void
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(kasp->frozen);
- return (kasp->publish_safety);
+ return kasp->publish_safety;
}
void
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(kasp->frozen);
- return (kasp->retire_safety);
+ return kasp->retire_safety;
}
void
REQUIRE(kasp->frozen);
if (kasp->zone_max_ttl == 0 && fallback) {
- return (DEFAULT_TTLSIG);
+ return DEFAULT_TTLSIG;
}
- return (kasp->zone_max_ttl);
+ return kasp->zone_max_ttl;
}
void
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(kasp->frozen);
- return (kasp->zone_propagation_delay);
+ return kasp->zone_propagation_delay;
}
void
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(kasp->frozen);
- return (kasp->parent_ds_ttl);
+ return kasp->parent_ds_ttl;
}
void
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(kasp->frozen);
- return (kasp->parent_propagation_delay);
+ return kasp->parent_propagation_delay;
}
void
REQUIRE(kaspp != NULL && *kaspp == NULL);
if (list == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
for (kasp = ISC_LIST_HEAD(*list); kasp != NULL;
}
if (kasp == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
dns_kasp_attach(kasp, kaspp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_kasp_keylist_t
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(kasp->frozen);
- return (kasp->keys);
+ return kasp->keys;
}
bool
dns_kasp_keylist_empty(dns_kasp_t *kasp) {
REQUIRE(DNS_KASP_VALID(kasp));
- return (ISC_LIST_EMPTY(kasp->keys));
+ return ISC_LIST_EMPTY(kasp->keys);
}
void
key->length = -1;
key->role = 0;
*keyp = key;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
dns_kasp_key_algorithm(dns_kasp_key_t *key) {
REQUIRE(key != NULL);
- return (key->algorithm);
+ return key->algorithm;
}
unsigned int
/* unsupported */
break;
}
- return (size);
+ return size;
}
uint32_t
dns_kasp_key_lifetime(dns_kasp_key_t *key) {
REQUIRE(key != NULL);
- return (key->lifetime);
+ return key->lifetime;
}
bool
dns_kasp_key_ksk(dns_kasp_key_t *key) {
REQUIRE(key != NULL);
- return (key->role & DNS_KASP_KEY_ROLE_KSK);
+ return key->role & DNS_KASP_KEY_ROLE_KSK;
}
bool
dns_kasp_key_zsk(dns_kasp_key_t *key) {
REQUIRE(key != NULL);
- return (key->role & DNS_KASP_KEY_ROLE_ZSK);
+ return key->role & DNS_KASP_KEY_ROLE_ZSK;
}
uint8_t
REQUIRE(kasp->frozen);
REQUIRE(kasp->nsec3);
- return (kasp->nsec3param.iterations);
+ return kasp->nsec3param.iterations;
}
uint8_t
REQUIRE(kasp->nsec3);
if (kasp->nsec3param.optout) {
- return (0x01);
+ return 0x01;
}
- return (0x00);
+ return 0x00;
}
uint8_t
REQUIRE(kasp->frozen);
REQUIRE(kasp->nsec3);
- return (kasp->nsec3param.saltlen);
+ return kasp->nsec3param.saltlen;
}
bool
}
ac += (ac >> 16) & 0xffff;
- return ((uint16_t)(ac & 0xffff));
+ return (uint16_t)(ac & 0xffff);
}
uint16_t
}
ac += (ac >> 16) & 0xffff;
- return ((uint16_t)(ac & 0xffff));
+ return (uint16_t)(ac & 0xffff);
}
dns_name_t *
dst_key_name(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
- return (key->key_name);
+ return key->key_name;
}
unsigned int
dst_key_size(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
- return (key->key_size);
+ return key->key_size;
}
unsigned int
dst_key_proto(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
- return (key->key_proto);
+ return key->key_proto;
}
unsigned int
dst_key_alg(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
- return (key->key_alg);
+ return key->key_alg;
}
uint32_t
dst_key_flags(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
- return (key->key_flags);
+ return key->key_flags;
}
dns_keytag_t
dst_key_id(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
- return (key->key_id);
+ return key->key_id;
}
dns_keytag_t
dst_key_rid(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
- return (key->key_rid);
+ return key->key_rid;
}
dns_rdataclass_t
dst_key_class(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
- return (key->key_class);
+ return key->key_class;
}
bool
REQUIRE(VALID_KEY(key));
if ((key->key_flags & DNS_KEYTYPE_NOAUTH) != 0) {
- return (false);
+ return false;
}
if ((key->key_flags & DNS_KEYFLAG_OWNERMASK) != DNS_KEYOWNER_ZONE) {
- return (false);
+ return false;
}
if (key->key_proto != DNS_KEYPROTO_DNSSEC &&
key->key_proto != DNS_KEYPROTO_ANY)
{
- return (false);
+ return false;
}
- return (true);
+ return true;
}
bool
REQUIRE(VALID_KEY(key));
if ((key->key_flags & DNS_KEYFLAG_TYPEMASK) != DNS_KEYTYPE_NOKEY) {
- return (false);
+ return false;
}
if ((key->key_flags & DNS_KEYFLAG_OWNERMASK) != DNS_KEYOWNER_ZONE) {
- return (false);
+ return false;
}
if (key->key_proto != DNS_KEYPROTO_DNSSEC &&
key->key_proto != DNS_KEYPROTO_ANY)
{
- return (false);
+ return false;
}
- return (true);
+ return true;
}
void
uint16_t
dst_key_getbits(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
- return (key->key_bits);
+ return key->key_bits;
}
void
dns_ttl_t
dst_key_getttl(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
- return (key->key_ttl);
+ return key->key_ttl;
}
/*! \file */
memmove(dnskey->data, keydata->data, dnskey->datalen);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
memmove(keydata->data, dnskey->data, keydata->datalen);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t ret;
ret = dst_key_getbool(key, DST_BOOL_KSK, &ksk);
if (ret != ISC_R_SUCCESS) {
- return ("UNKNOWN");
+ return "UNKNOWN";
}
ret = dst_key_getbool(key, DST_BOOL_ZSK, &zsk);
if (ret != ISC_R_SUCCESS) {
- return ("UNKNOWN");
+ return "UNKNOWN";
}
if (ksk && zsk) {
- return ("CSK");
+ return "CSK";
} else if (ksk) {
- return ("KSK");
+ return "KSK";
} else if (zsk) {
- return ("ZSK");
+ return "ZSK";
}
- return ("NOSIGN");
+ return "NOSIGN";
}
/*
* No inactive time and no lifetime,
* so no need to start a rollover.
*/
- return (0);
+ return 0;
}
retire = active + klifetime;
*/
if (prepub > retire) {
/* We should have already prepublished the new key. */
- return (now);
+ return now;
}
- return (retire - prepub);
+ return retire - prepub;
}
static void
/* Matching algorithms? */
if (dst_key_alg(key) != dns_kasp_key_algorithm(kkey)) {
- return (false);
+ return false;
}
/* Matching length? */
if (dst_key_size(key) != dns_kasp_key_size(kkey)) {
- return (false);
+ return false;
}
/* Matching role? */
ret = dst_key_getbool(key, DST_BOOL_KSK, &role);
if (ret != ISC_R_SUCCESS || role != dns_kasp_key_ksk(kkey)) {
- return (false);
+ return false;
}
ret = dst_key_getbool(key, DST_BOOL_ZSK, &role);
if (ret != ISC_R_SUCCESS || role != dns_kasp_key_zsk(kkey)) {
- return (false);
+ return false;
}
/* Found a match. */
- return (true);
+ return true;
}
/* Update lifetime and retire and remove time accordingly. */
dst_key_id(dkey->key) == rid ||
dst_key_rid(dkey->key) == rid)
{
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
/*
dst_key_setbool(newkey, DST_BOOL_KSK, dns_kasp_key_ksk(kkey));
dst_key_setbool(newkey, DST_BOOL_ZSK, dns_kasp_key_zsk(kkey));
*dst_key = newkey;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
/*
if (dst_key_getstate(key->key, DST_KEY_GOAL, &goal) != ISC_R_SUCCESS) {
/* No goal? No movement. */
- return (state);
+ return state;
}
if (goal == HIDDEN) {
switch (state) {
case RUMOURED:
case OMNIPRESENT:
- return (UNRETENTIVE);
+ return UNRETENTIVE;
case HIDDEN:
case UNRETENTIVE:
- return (HIDDEN);
+ return HIDDEN;
default:
- return (state);
+ return state;
}
} else if (goal == OMNIPRESENT) {
switch (state) {
case RUMOURED:
case OMNIPRESENT:
- return (OMNIPRESENT);
+ return OMNIPRESENT;
case HIDDEN:
case UNRETENTIVE:
- return (RUMOURED);
+ return RUMOURED;
default:
- return (state);
+ return state;
}
}
/* Unknown goal. */
- return (state);
+ return state;
}
/*
} else if (dst_key_getstate(key, i, &state) != ISC_R_SUCCESS) {
/* This is fine only if expected state is HIDDEN. */
if (states[i] != HIDDEN) {
- return (false);
+ return false;
}
continue;
}
if (state != states[i]) {
- return (false);
+ return false;
}
}
/* Match. */
- return (true);
+ return true;
}
/*
uint32_t s, p;
if (dst_key_getnum(d, DST_NUM_SUCCESSOR, &s) != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
if (dst_key_getnum(k, DST_NUM_PREDECESSOR, &p) != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
- return (dst_key_id(d) == p && dst_key_id(k) == s);
+ return dst_key_id(d) == p && dst_key_id(k) == s;
}
/*
if (dep != NULL) {
*dep = dst_key_id(d->key);
}
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
/*
* nothing depending on x.
*/
if (keymgr_dep(x, keyring, &dep_x)) {
- return (false);
+ return false;
}
/*
* If there is no keys relying on key z, then z is not a successor.
*/
if (!keymgr_dep(z, keyring, &dep_z)) {
- return (false);
+ return false;
}
/*
* x depends on z, thus key z is a direct successor of key x.
*/
if (dst_key_id(x) == dep_z) {
- return (true);
+ return true;
}
/*
* If y is a successor of x, then z is also a
* successor of x.
*/
- return (keymgr_key_is_successor(x, y->key, key, type,
- next_state, keyring));
+ return keymgr_key_is_successor(x, y->key, key, type,
+ next_state, keyring);
}
}
- return (false);
+ return false;
}
/*
/* Found a match. */
if (!check_successor) {
- return (true);
+ return true;
}
/*
key->key, type, next_state,
keyring))
{
- return (true);
+ return true;
}
}
}
/* No match. */
- return (false);
+ return false;
}
/*
successor != NULL; successor = ISC_LIST_NEXT(successor, link))
{
if (keymgr_direct_dep(predecessor->key, successor->key)) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
/*
}
if (must_be_hidden) {
- return (false);
+ return false;
}
/*
na, false, match_algorithms))
{
/* There is no chain of trust. */
- return (false);
+ return false;
}
}
/* All good. */
- return (true);
+ return true;
}
/*
false, match_algorithms))
{
/* There is no chain of trust. */
- return (false);
+ return false;
}
}
/* All good. */
- return (true);
+ return true;
}
/*
* Equation (3a):
* There is a key with the DS in either RUMOURD or OMNIPRESENT state.
*/
- return (keymgr_key_exists_with_state(keyring, key, type, next_state,
- states[0], na, false, false) ||
- keymgr_key_exists_with_state(keyring, key, type, next_state,
- states[1], na, false, false) ||
- (secure_to_insecure &&
- keymgr_key_exists_with_state(keyring, key, type, next_state,
- na, na, false, false)));
+ return keymgr_key_exists_with_state(keyring, key, type, next_state,
+ states[0], na, false, false) ||
+ keymgr_key_exists_with_state(keyring, key, type, next_state,
+ states[1], na, false, false) ||
+ (secure_to_insecure &&
+ keymgr_key_exists_with_state(keyring, key, type, next_state, na,
+ na, false, false));
}
/*
/* successor n/a */
dst_key_state_t na[NUM_KEYSTATES] = { NA, NA, NA, NA };
- return (
+ return
/*
* Equation (3b):
* There is a key with the same algorithm with its DNSKEY,
* chain of trust for those validators.
*/
keymgr_ds_hidden_or_chained(keyring, key, type, next_state,
- true, false));
+ true, false);
}
/*
/* successor n/a */
dst_key_state_t na[NUM_KEYSTATES] = { NA, NA, NA, NA };
- return (
+ return
/*
* If all DS records are hidden than this rule can be ignored.
*/
* must be a path that can be validated from there.
*/
keymgr_dnskey_hidden_or_chained(keyring, key, type, next_state,
- true));
+ true);
}
/*
* Local policy only adds an extra barrier on transitions to
* the RUMOURED state.
*/
- return (true);
+ return true;
}
switch (type) {
case DST_KEY_DNSKEY:
/* No restrictions. */
- return (true);
+ return true;
case DST_KEY_ZRRSIG:
/* Make sure the DNSKEY record is OMNIPRESENT. */
(void)dst_key_getstate(key->key, DST_KEY_DNSKEY, &dnskeystate);
if (dnskeystate == OMNIPRESENT) {
- return (true);
+ return true;
}
/*
* Or are we introducing a new key for this algorithm? Because
* in that case allow publishing the RRSIG records before the
* DNSKEY.
*/
- return (!(keymgr_key_exists_with_state(keyring, key, type, next,
- ksk_present, na, false,
- true) ||
- keymgr_key_exists_with_state(keyring, key, type, next,
- ds_retired, ds_rumoured,
- true, true) ||
- keymgr_key_exists_with_state(
- keyring, key, type, next, ksk_retired,
- ksk_rumoured, true, true)));
+ return !(keymgr_key_exists_with_state(keyring, key, type, next,
+ ksk_present, na, false,
+ true) ||
+ keymgr_key_exists_with_state(keyring, key, type, next,
+ ds_retired, ds_rumoured,
+ true, true) ||
+ keymgr_key_exists_with_state(keyring, key, type, next,
+ ksk_retired, ksk_rumoured,
+ true, true));
case DST_KEY_KRRSIG:
/* Only introduce if the DNSKEY is also introduced. */
(void)dst_key_getstate(key->key, DST_KEY_DNSKEY, &dnskeystate);
- return (dnskeystate != HIDDEN);
+ return dnskeystate != HIDDEN;
case DST_KEY_DS:
/* Make sure the DNSKEY record is OMNIPRESENT. */
(void)dst_key_getstate(key->key, DST_KEY_DNSKEY, &dnskeystate);
- return (dnskeystate == OMNIPRESENT);
+ return dnskeystate == OMNIPRESENT;
default:
- return (false);
+ return false;
}
}
rule3a ? "true" : "false", rule3b ? "true" : "false");
}
- return (
+ return
/*
* Rule 1: There must be a DS at all times.
* First check the current situation: if the rule check fails,
* state.
*/
(!keymgr_have_rrsig(keyring, key, type, NA) ||
- keymgr_have_rrsig(keyring, key, type, next_state)));
+ keymgr_have_rrsig(keyring, key, type, next_state));
}
/*
goto transition;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (*nexttime == 0 || prepub < *nexttime) {
*nexttime = prepub;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (keymgr_key_has_successor(active_key, keyring)) {
keystr, keymgr_keyrole(active_key->key),
dns_kasp_getname(kasp));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(1))) {
"policy %s, cannot start rollover",
keystr, keymgr_keyrole(active_key->key),
dns_kasp_getname(kasp));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
} else if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(1))) {
char namestr[DNS_NAME_FORMATSIZE];
mctx, keyring, newkeys,
&dst_key);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dst_key_setttl(dst_key, dns_kasp_dnskeyttl(kasp));
dst_key_settime(dst_key, DST_TIME_CREATED, now);
result = dns_dnsseckey_create(mctx, &dst_key, &new_key);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
keymgr_key_init(new_key, kasp, now, csk);
} else {
keystr, keymgr_keyrole(new_key->key),
(candidate != NULL) ? "selected" : "created",
dns_kasp_getname(kasp));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
/* If 'purge-keys' is disabled, always retain keys. */
if (after == 0) {
- return (false);
+ return false;
}
/* Don't purge keys with goal OMNIPRESENT */
if (dst_key_goal(key) == OMNIPRESENT) {
- return (false);
+ return false;
}
/* Don't purge unused keys. */
if (dst_key_is_unused(key)) {
- return (false);
+ return false;
}
/* If this key is completely HIDDEN it may be purged. */
hidden[DST_KEY_ZRRSIG] = HIDDEN;
}
if (!keymgr_key_match_state(key, key, 0, NA, hidden)) {
- return (false);
+ return false;
}
/*
}
}
- return ((lastchange + after) < now);
+ return (lastchange + after) < now;
}
static void
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(3),
"keymgr: %s done", namebuf);
}
- return (result);
+ return result;
}
static isc_result_t
/*
* Only checkds for one key at a time.
*/
- return (DNS_R_TOOMANYKEYS);
+ return DNS_R_TOOMANYKEYS;
}
ksk_key = dkey;
}
if (ksk_key == NULL) {
- return (DNS_R_NOKEYMATCH);
+ return DNS_R_NOKEYMATCH;
}
if (dspublish) {
}
result = isc_dir_open(&dir, directory);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_dnssec_get_hints(ksk_key, now);
}
isc_dir_close(&dir);
- return (result);
+ return result;
}
isc_result_t
dns_keymgr_checkds(dns_kasp_t *kasp, dns_dnsseckeylist_t *keyring,
const char *directory, isc_stdtime_t now, isc_stdtime_t when,
bool dspublish) {
- return (keymgr_checkds(kasp, keyring, directory, now, when, dspublish,
- 0, 0, false));
+ return keymgr_checkds(kasp, keyring, directory, now, when, dspublish, 0,
+ 0, false);
}
isc_result_t
const char *directory, isc_stdtime_t now,
isc_stdtime_t when, bool dspublish, dns_keytag_t id,
unsigned int alg) {
- return (keymgr_checkds(kasp, keyring, directory, now, when, dspublish,
- id, alg, true));
+ return keymgr_checkds(kasp, keyring, directory, now, when, dspublish,
+ id, alg, true);
}
static void
/*
* Only rollover for one key at a time.
*/
- return (DNS_R_TOOMANYKEYS);
+ return DNS_R_TOOMANYKEYS;
}
key = dkey;
}
if (key == NULL) {
- return (DNS_R_NOKEYMATCH);
+ return DNS_R_NOKEYMATCH;
}
result = dst_key_gettime(key->key, DST_TIME_ACTIVATE, &active);
if (result != ISC_R_SUCCESS || active > now) {
- return (DNS_R_KEYNOTACTIVE);
+ return DNS_R_KEYNOTACTIVE;
}
result = dst_key_gettime(key->key, DST_TIME_INACTIVE, &retire);
}
result = isc_dir_open(&dir, directory);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_dnssec_get_hints(key, now);
}
isc_dir_close(&dir);
- return (result);
+ return result;
}
keytable->magic = KEYTABLE_MAGIC;
*keytablep = keytable;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_keytable:
isc_mem_putanddetach(&mctx, keytable, sizeof(*keytable));
- return (result);
+ return result;
}
void
RWLOCK(&knode->rwlock, isc_rwlocktype_read);
if (knode->dslist == NULL) {
RWUNLOCK(&knode->rwlock, isc_rwlocktype_read);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_buffer_init(&b, data, DNS_DS_BUFFERSIZE);
dns_rdatatype_ds, ds, &b);
if (result != ISC_R_SUCCESS) {
RWUNLOCK(&knode->rwlock, isc_rwlocktype_write);
- return (result);
+ return result;
}
for (rdata = ISC_LIST_HEAD(knode->dslist->rdata); rdata != NULL;
* The keyname must have matched or we wouldn't be here,
* so we use DNS_R_PARTIALMATCH instead of ISC_R_NOTFOUND.
*/
- return (DNS_R_PARTIALMATCH);
+ return DNS_R_PARTIALMATCH;
}
/*
keynode_detach(keytable->mctx, &knode);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
knode->managed = managed;
knode->initial = initial;
- return (knode);
+ return knode;
}
/*%
RWUNLOCK(&keytable->rwlock, isc_rwlocktype_write);
- return (result);
+ return result;
}
isc_result_t
REQUIRE(ds != NULL);
REQUIRE(!initial || managed);
- return (insert(keytable, managed, initial, name, ds, callback,
- callback_arg));
+ return insert(keytable, managed, initial, name, ds, callback,
+ callback_arg);
}
isc_result_t
dns_keytable_marksecure(dns_keytable_t *keytable, const dns_name_t *name) {
- return (insert(keytable, true, false, name, NULL, NULL, NULL));
+ return insert(keytable, true, false, name, NULL, NULL, NULL);
}
isc_result_t
}
RWUNLOCK(&keytable->rwlock, isc_rwlocktype_write);
- return (result);
+ return result;
}
isc_result_t
finish:
RWUNLOCK(&keytable->rwlock, isc_rwlocktype_write);
- return (result);
+ return result;
}
isc_result_t
}
RWUNLOCK(&keytable->rwlock, isc_rwlocktype_read);
- return (result);
+ return result;
}
isc_result_t
RWUNLOCK(&keytable->rwlock, isc_rwlocktype_read);
- return (result);
+ return result;
}
void
RWUNLOCK(&keytable->rwlock, isc_rwlocktype_read);
- return (result);
+ return result;
}
static isc_result_t
result = isc_buffer_reserve(b, strlen(str));
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_putstr(*b, str);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
(char *)isc_buffer_base(text));
isc_buffer_free(&text);
- return (result);
+ return result;
}
static isc_result_t
dns_rdataset_init(&dsset);
if (!dns_keynode_dsset(keynode, &dsset)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
for (result = dns_rdataset_first(&dsset); result == ISC_R_SUCCESS;
result = putstr(text, obuf);
if (result != ISC_R_SUCCESS) {
dns_rdataset_disassociate(&dsset);
- return (result);
+ return result;
}
}
dns_rdataset_disassociate(&dsset);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
cleanup:
dns_rbtnodechain_invalidate(&chain);
RWUNLOCK(&keytable->rwlock, isc_rwlocktype_read);
- return (result);
+ return result;
}
isc_result_t
cleanup:
dns_rbtnodechain_invalidate(&chain);
RWUNLOCK(&keytable->rwlock, isc_rwlocktype_read);
- return (result);
+ return result;
}
bool
result = false;
}
RWUNLOCK(&keynode->rwlock, isc_rwlocktype_read);
- return (result);
+ return result;
}
bool
managed = keynode->managed;
RWUNLOCK(&keynode->rwlock, isc_rwlocktype_read);
- return (managed);
+ return managed;
}
bool
initial = keynode->initial;
RWUNLOCK(&keynode->rwlock, isc_rwlocktype_read);
- return (initial);
+ return initial;
}
void
RWUNLOCK(&keynode->rwlock, isc_rwlocktype_read);
if (rdataset->private2 == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
rdata = rdataset->private2;
if (rdata == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
keynode = rdataset->private1;
RWUNLOCK(&keynode->rwlock, isc_rwlocktype_read);
if (rdataset->private2 == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
lookup->task, fetch_done, lookup, &lookup->rdataset,
&lookup->sigrdataset, &lookup->fetch);
- return (result);
+ return result;
}
static void
&lookup->event->db, &lookup->event->node,
foundname, &lookup->rdataset,
&lookup->sigrdataset);
- return (result);
+ return result;
}
static void
lookup_find(lookup, NULL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
static bool
dns_master_isprimary(dns_loadctx_t *lctx) {
- return ((lctx->options & DNS_MASTER_ZONE) != 0 &&
- (lctx->options & DNS_MASTER_SECONDARY) == 0 &&
- (lctx->options & DNS_MASTER_KEY) == 0);
+ return (lctx->options & DNS_MASTER_ZONE) != 0 &&
+ (lctx->options & DNS_MASTER_SECONDARY) == 0 &&
+ (lctx->options & DNS_MASTER_KEY) == 0;
}
static isc_result_t
if (result != ISC_R_SUCCESS) {
switch (result) {
case ISC_R_NOMEMORY:
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
default:
(*callbacks->error)(callbacks,
"dns_master_load: %s:%lu:"
isc_lex_getsourcename(lex),
isc_lex_getsourceline(lex),
isc_result_totext(result));
- return (result);
+ return result;
}
/*NOTREACHED*/
}
"dns_master_load: %s:%lu: "
"unexpected end of %s",
file, line, what);
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
ictx->origin_changed = true;
*ictxp = ictx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
lctx->magic = DNS_LCTX_MAGIC;
*lctxp = lctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_inc:
incctx_destroy(mctx, lctx->inc);
cleanup_ctx:
isc_mem_put(mctx, lctx, sizeof(*lctx));
- return (result);
+ return result;
}
static const char *hex = "0123456789abcdef0123456789ABCDEF";
count++;
}
} while (value != 0 || width > 0);
- return (count);
+ return count;
}
static isc_result_t
name++;
if (*name == '$') {
if (r.length == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
r.base[0] = *name++;
isc_textregion_consume(&r, 1);
&delta, comma1, &width, comma2, mode,
brace);
if (n < 2 || n > 6) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
if (comma1[0] == '}') {
/* %{delta} */
n = snprintf(fmt, sizeof(fmt),
"%%0%u%c", width, mode[0]);
} else {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
if (n >= sizeof(fmt)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/* Skip past closing brace. */
while (*name != '\0' && *name++ != '}') {
* 'it' is >= 0 so we don't need to check for
* underflow.
*/
- if ((it > 0 && delta > INT_MAX - it)) {
- return (ISC_R_RANGE);
+ if (it > 0 && delta > INT_MAX - it) {
+ return ISC_R_RANGE;
}
if (nibblemode) {
n = nibbles(numbuf, sizeof(numbuf), width,
it + delta);
}
if (n >= sizeof(numbuf)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
cp = numbuf;
while (*cp != '\0') {
if (r.length == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
r.base[0] = *cp++;
isc_textregion_consume(&r, 1);
}
} else if (*name == '\\') {
if (r.length == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
r.base[0] = *name++;
isc_textregion_consume(&r, 1);
continue;
}
if (r.length == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
r.base[0] = *name++;
isc_textregion_consume(&r, 1);
} else {
if (r.length == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
r.base[0] = *name++;
isc_textregion_consume(&r, 1);
}
}
if (r.length == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
r.base[0] = '\0';
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
if (rhsbuf != NULL) {
isc_mem_put(lctx->mctx, rhsbuf, DNS_MASTER_RHS);
}
- return (result);
+ return result;
}
static void
if (tmp != NULL) {
isc_mem_free(lctx->mctx, tmp);
}
- return (result);
+ return result;
}
static void
static isc_result_t
openfile_text(dns_loadctx_t *lctx, const char *master_file) {
- return (isc_lex_openfile(lctx->lex, master_file));
+ return isc_lex_openfile(lctx->lex, master_file);
}
static int
}
}
INSIST(!incctx->in_use[i]);
- return (i);
+ return i;
}
static isc_result_t
if (rhs != NULL) {
isc_mem_free(mctx, rhs);
}
- return (result);
+ return result;
}
static isc_result_t
result = incctx_create(lctx->mctx, origin, &newctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
if (lctx->include_cb != NULL) {
lctx->include_cb(master_file, lctx->include_arg);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
incctx_destroy(lctx->mctx, newctx);
- return (result);
+ return result;
}
/*
result = isc_stdio_read(isc_buffer_used(buffer), 1, len, f,
NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_add(buffer, (unsigned int)len);
if (*totallen < len) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
*totallen -= (uint32_t)len;
} else if (isc_buffer_remaininglength(buffer) < len) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(DNS_LCTX_VALID(lctx));
if (lctx->format != dns_masterformat_raw) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
callbacks = lctx->callbacks;
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR("isc_stdio_read failed: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
isc_buffer_add(&target, (unsigned int)commonlen);
(*callbacks->error)(callbacks,
"dns_master_load: "
"file format mismatch (not raw)");
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
header.version = isc_buffer_getuint32(&target);
(*callbacks->error)(callbacks, "dns_master_load: "
"unsupported file format "
"version");
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
result = isc_stdio_read(data + commonlen, 1, remainder, lctx->f, NULL);
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR("isc_stdio_read failed: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
isc_buffer_add(&target, (unsigned int)remainder);
lctx->first = false;
lctx->header = header;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_result_totext(result));
}
- return (result);
+ return result;
}
static isc_result_t
if (lctx->first) {
result = load_header(lctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
isc_result_totext(result));
}
- return (result);
+ return result;
}
isc_result_t
origin, callbacks, NULL, NULL, NULL, include_cb,
include_arg, NULL, &lctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
lctx->maxttl = maxttl;
cleanup:
dns_loadctx_detach(&lctx);
- return (result);
+ return result;
}
isc_result_t
origin, callbacks, task, done, done_arg,
include_cb, include_arg, NULL, &lctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
lctx->maxttl = maxttl;
result = task_send(lctx);
if (result == ISC_R_SUCCESS) {
dns_loadctx_attach(lctx, lctxp);
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
cleanup:
dns_loadctx_detach(&lctx);
- return (result);
+ return result;
}
isc_result_t
if (lctx != NULL) {
dns_loadctx_detach(&lctx);
}
- return (result);
+ return result;
}
isc_result_t
result = task_send(lctx);
if (result == ISC_R_SUCCESS) {
dns_loadctx_attach(lctx, lctxp);
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
cleanup:
if (lctx != NULL) {
dns_loadctx_detach(&lctx);
}
- return (result);
+ return result;
}
isc_result_t
zclass, origin, callbacks, NULL, NULL, NULL,
NULL, NULL, NULL, &lctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = isc_lex_openbuffer(lctx->lex, buffer);
cleanup:
dns_loadctx_detach(&lctx);
- return (result);
+ return result;
}
isc_result_t
zclass, origin, callbacks, task, done, done_arg,
NULL, NULL, NULL, &lctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = isc_lex_openbuffer(lctx->lex, buffer);
result = task_send(lctx);
if (result == ISC_R_SUCCESS) {
dns_loadctx_attach(lctx, lctxp);
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
cleanup:
dns_loadctx_detach(&lctx);
- return (result);
+ return result;
}
isc_result_t
zclass, origin, callbacks, NULL, NULL, NULL,
NULL, NULL, lex, &lctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = (lctx->load)(lctx);
INSIST(result != DNS_R_CONTINUE);
dns_loadctx_detach(&lctx);
- return (result);
+ return result;
}
isc_result_t
zclass, origin, callbacks, task, done, done_arg,
NULL, NULL, lex, &lctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = task_send(lctx);
if (result == ISC_R_SUCCESS) {
dns_loadctx_attach(lctx, lctxp);
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
dns_loadctx_detach(&lctx);
- return (result);
+ return result;
}
/*
newlist = isc_mem_get(mctx, new_len * sizeof(*newlist));
if (newlist == NULL) {
- return (NULL);
+ return NULL;
}
ISC_LIST_INIT(save);
if (oldlist != NULL) {
isc_mem_put(mctx, oldlist, old_len * sizeof(*oldlist));
}
- return (newlist);
+ return newlist;
}
/*
newlist = isc_mem_get(mctx, new_len * sizeof(*newlist));
if (newlist == NULL) {
- return (NULL);
+ return NULL;
}
memset(newlist, 0, new_len * sizeof(*newlist));
if (oldlist != NULL) {
isc_mem_put(mctx, oldlist, old_len * sizeof(*oldlist));
}
- return (newlist);
+ return newlist;
}
static uint32_t
}
rdata = ISC_LIST_NEXT(rdata, link);
}
- return (when);
+ return when;
}
/*
error = callbacks->error;
if (this == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
do {
dns_rdataset_init(&dataset);
if (MANYERRS(lctx, result)) {
SETRESULT(lctx, result);
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
ISC_LIST_UNLINK(*head, this, link);
this = ISC_LIST_HEAD(*head);
} while (this != NULL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
this = ISC_LIST_NEXT(this, link);
}
if (this == NULL) {
- return (false);
+ return false;
}
rdata = ISC_LIST_HEAD(this->rdata);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
if (dns_name_equal(&name, owner)) {
- return (true);
+ return true;
}
rdata = ISC_LIST_NEXT(rdata, link);
}
- return (false);
+ return false;
}
static void
event = isc_event_allocate(lctx->mctx, NULL, DNS_EVENT_MASTERQUANTUM,
load_quantum, lctx, sizeof(*event));
isc_task_send(lctx->task, &event);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
if (ntabs > 0) {
isc_buffer_availableregion(target, &r);
if (r.length < (unsigned)ntabs) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
p = r.base;
isc_buffer_availableregion(target, &r);
if (r.length < (unsigned)nspaces) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
p = r.base;
isc_buffer_add(target, nspaces);
*current = to;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_availableregion(&buf, &r);
if (r.length < 1) {
- return (DNS_R_TEXTTOOLONG);
+ return DNS_R_TEXTTOOLONG;
}
r.base[0] = '\n';
isc_buffer_add(&buf, 1);
unsigned int i, len = strlen(indentctx->string);
for (i = 0; i < indentctx->count; i++) {
if (isc_buffer_availablelength(&buf) < len) {
- return (DNS_R_TEXTTOOLONG);
+ return DNS_R_TEXTTOOLONG;
}
isc_buffer_putstr(&buf, indentctx->string);
}
if ((ctx->style.flags & DNS_STYLEFLAG_COMMENTDATA) != 0) {
isc_buffer_availableregion(&buf, &r);
if (r.length < 1) {
- return (DNS_R_TEXTTOOLONG);
+ return DNS_R_TEXTTOOLONG;
}
r.base[0] = ';';
isc_buffer_add(&buf, 1);
* so it won't help. Use DNS_R_TEXTTOOLONG as a substitute.
*/
if (result == ISC_R_NOSPACE) {
- return (DNS_R_TEXTTOOLONG);
+ return DNS_R_TEXTTOOLONG;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_availableregion(&buf, &r);
if (r.length < 1) {
- return (DNS_R_TEXTTOOLONG);
+ return DNS_R_TEXTTOOLONG;
}
r.base[0] = '\0';
isc_buffer_add(&buf, 1);
ctx->serve_stale_ttl = 0;
ctx->indent = *indentctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#define INDENT_TO(col) \
l = strlen(source);
if (l > region.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, source, l);
isc_buffer_add(target, l);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_availableregion(target, &r);
if (r.length < 1) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/* NUL terminate buffer for string operations below */
isc_buffer_availableregion(target, &r);
/* Space to shift by 1 with trailing NUL? */
if (r.length < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tmp + 1, tmp,
(char *)isc_buffer_used(target) - tmp + 1);
s = tmp + 2;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdataset_disassociate(&rds);
}
- return (result);
+ return result;
}
/*
result = dns_ttl_totext(rdataset->ttl, false,
false, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
column += target->used - length;
} else {
INSIST(length <= sizeof(ttlbuf));
isc_buffer_availableregion(target, &r);
if (r.length < length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(r.base, ttlbuf, length);
isc_buffer_add(target, length);
rdataset->rdclass, target);
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
column += (target->used - class_start);
}
if (isc_buffer_availablelength(target) <
(sizeof(KEYDATA) - 1))
{
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putstr(target, KEYDATA);
break;
result = dns_rdatatype_totext(type, target);
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
column += (target->used - type_start);
}
if (result != ISC_R_NOMORE) {
- return (result);
+ return result;
}
/*
ctx->current_ttl = current_ttl;
ctx->current_ttl_valid = current_ttl_valid;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
target);
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
column += (target->used - class_start);
}
result = dns_rdatatype_totext(rdataset->type, target);
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
column += (target->used - type_start);
}
}
RETERR(str_totext("\n", target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
result = totext_ctx_init(&dns_master_style_debug, NULL, &ctx);
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR("could not set master file style");
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
/*
}
if (question) {
- return (question_totext(rdataset, owner_name, &ctx,
- omit_final_dot, target));
+ return question_totext(rdataset, owner_name, &ctx,
+ omit_final_dot, target);
} else {
- return (rdataset_totext(rdataset, owner_name, &ctx,
- omit_final_dot, target));
+ return rdataset_totext(rdataset, owner_name, &ctx,
+ omit_final_dot, target);
}
}
result = totext_ctx_init(style, indent, &ctx);
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR("could not set master file style");
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
- return (rdataset_totext(rdataset, owner_name, &ctx, false, target));
+ return rdataset_totext(rdataset, owner_name, &ctx, false, target);
}
isc_result_t
result = totext_ctx_init(style, NULL, &ctx);
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR("could not set master file style");
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
- return (question_totext(rdataset, owner_name, &ctx, false, target));
+ return question_totext(rdataset, owner_name, &ctx, false, target);
}
/*
isc_buffer_init(buffer, newmem, newlength);
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR("master file write failed: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
t += 2;
break;
}
- return ((t << 1) + sig);
+ return (t << 1) + sig;
}
static int
dump_order_compare(const void *a, const void *b) {
- return (dump_order(*((const dns_rdataset_t *const *)a)) -
- dump_order(*((const dns_rdataset_t *const *)b)));
+ return dump_order(*((const dns_rdataset_t *const *)a)) -
+ dump_order(*((const dns_rdataset_t *const *)b));
}
/*
}
if (dumpresult != ISC_R_SUCCESS) {
- return (dumpresult);
+ return dumpresult;
}
/*
itresult = ISC_R_SUCCESS;
}
- return (itresult);
+ return itresult;
}
/*
} while (result == ISC_R_SUCCESS);
if (result != ISC_R_NOMORE) {
- return (result);
+ return result;
}
/*
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR("raw master file write failed: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
- return (result);
+ return result;
}
static isc_result_t
}
dns_rdataset_disassociate(&rdataset);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
/*
dns_dbversion_t *
dns_dumpctx_version(dns_dumpctx_t *dctx) {
REQUIRE(DNS_DCTX_VALID(dctx));
- return (dctx->version);
+ return dctx->version;
}
dns_db_t *
dns_dumpctx_db(dns_dumpctx_t *dctx) {
REQUIRE(DNS_DCTX_VALID(dctx));
- return (dctx->db);
+ return dctx->db;
}
void
isc_result_totext(result));
}
}
- return (result);
+ return result;
}
static isc_result_t
"dumping master file: rename: %s: %s", file,
isc_result_totext(result));
}
- return (result);
+ return result;
}
/*
event = isc_event_allocate(dctx->mctx, NULL, DNS_EVENT_DUMPQUANTUM,
setup_dump, dctx, sizeof(*event));
isc_task_send(dctx->task, &event);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_refcount_init(&dctx->references, 1);
dctx->magic = DNS_DCTX_MAGIC;
*dctxp = dctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (dctx->dbiter != NULL) {
dns_db_detach(&dctx->db);
}
isc_mem_put(mctx, dctx, sizeof(*dctx));
- return (result);
+ return result;
}
static isc_result_t
}
isc_mem_put(dctx->mctx, buffer.base, buffer.length);
- return (result);
+ return result;
}
static isc_result_t
cleanup:
RUNTIME_CHECK(dns_dbiterator_pause(dctx->dbiter) == ISC_R_SUCCESS);
isc_mem_put(dctx->mctx, buffer.base, buffer.length);
- return (result);
+ return result;
}
isc_result_t
result = dumpctx_create(mctx, db, version, style, f, &dctx,
dns_masterformat_text, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_task_attach(task, &dctx->task);
dctx->done = done;
result = task_send(dctx);
if (result == ISC_R_SUCCESS) {
dns_dumpctx_attach(dctx, dctxp);
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
dns_dumpctx_detach(&dctx);
- return (result);
+ return result;
}
isc_result_t
result = dumpctx_create(mctx, db, version, style, f, &dctx, format,
header);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dumptostream(dctx);
dns_dumpctx_detach(&dctx);
result = flushandsync(f, result, NULL);
- return (result);
+ return result;
}
static isc_result_t
*tempp = tempname;
*fp = f;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
isc_mem_free(mctx, tempname);
- return (result);
+ return result;
}
isc_result_t
result = task_send(dctx);
if (result == ISC_R_SUCCESS) {
dns_dumpctx_attach(dctx, dctxp);
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
cleanup:
if (tempname != NULL) {
isc_mem_free(mctx, tempname);
}
- return (result);
+ return result;
}
isc_result_t
result = opentmp(mctx, format, filename, &tempname, &f);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dumpctx_create(mctx, db, version, style, f, &dctx, format,
cleanup:
isc_mem_free(mctx, tempname);
- return (result);
+ return result;
}
/*
result = totext_ctx_init(style, NULL, &ctx);
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR("could not set master file style");
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
isc_stdtime_get(&now);
failure:
isc_mem_put(mctx, buffer.base, buffer.length);
- return (result);
+ return result;
}
isc_result_t
DNS_LOGMODULE_MASTERDUMP, ISC_LOG_ERROR,
"dumping node to file: %s: open: %s", filename,
isc_result_totext(result));
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
result = dns_master_dumpnodetostream(mctx, db, version, node, name,
"dumping master file: %s: dump: %s", filename,
isc_result_totext(result));
(void)isc_stdio_close(f);
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
result = isc_stdio_close(f);
DNS_LOGMODULE_MASTERDUMP, ISC_LOG_ERROR,
"dumping master file: %s: close: %s", filename,
isc_result_totext(result));
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
- return (result);
+ return result;
}
dns_masterstyle_flags_t
dns_master_styleflags(const dns_master_style_t *style) {
REQUIRE(style != NULL);
- return (style->flags);
+ return style->flags;
}
isc_result_t
style->tab_width = tab_width;
style->split_width = split_width;
*stylep = style;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
ISC_LINK_INIT(block, link);
- return (block);
+ return block;
}
/*
void *ptr;
if (block == NULL || block->remaining == 0) {
- return (NULL);
+ return NULL;
}
block->remaining--;
ptr = (((unsigned char *)block) + sizeof(dns_msgblock_t) +
(sizeof_type * block->remaining));
- return (ptr);
+ return ptr;
}
static void
isc_buffer_allocate(msg->mctx, &dynbuf, size);
ISC_LIST_APPEND(msg->scratchpad, dynbuf, link);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_buffer_t *
dynbuf = ISC_LIST_TAIL(msg->scratchpad);
INSIST(dynbuf != NULL);
- return (dynbuf);
+ return dynbuf;
}
static void
rdata = ISC_LIST_HEAD(msg->freerdata);
if (rdata != NULL) {
ISC_LIST_UNLINK(msg->freerdata, rdata, link);
- return (rdata);
+ return rdata;
}
msgblock = ISC_LIST_TAIL(msg->rdatas);
}
dns_rdata_init(rdata);
- return (rdata);
+ return rdata;
}
static void
}
out:
dns_rdatalist_init(rdatalist);
- return (rdatalist);
+ return rdatalist;
}
static dns_offsets_t *
offsets = msgblock_get(msgblock, dns_offsets_t);
}
- return (offsets);
+ return offsets;
}
static void
x = 0;
}
}
- return (26 + r1.length + r2.length + x + otherlen);
+ return 26 + r1.length + r2.length + x + otherlen;
}
void
isc_result_t result = isc_ht_find(ht, name->ndata, name->length,
(void **)foundp);
if (result == ISC_R_SUCCESS) {
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
result = isc_ht_add(ht, name->ndata, name->length, (void *)name);
INSIST(result == ISC_R_SUCCESS);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
if (foundname != NULL) {
*foundname = curr;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
typedef struct __attribute__((__packed__)) rds_key {
isc_result_t result = isc_ht_find(ht, (const unsigned char *)&key,
sizeof(key), (void **)foundp);
if (result == ISC_R_SUCCESS) {
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
result = isc_ht_add(ht, (const unsigned char *)&key, sizeof(key),
(void *)rds);
INSIST(result == ISC_R_SUCCESS);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (rdataset != NULL) {
*rdataset = curr;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
result = newbuffer(msg, SCRATCHPAD_SIZE);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
scratch = currentbuffer(msg);
dns_name_reset(name);
} else {
- return (result);
+ return result;
}
}
} else {
INSIST(trysize != 0);
if (trysize >= 65535) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/* XXX DNS_R_RRTOOLONG? */
trysize *= 2;
tries++;
result = newbuffer(msg, trysize);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
scratch = currentbuffer(msg);
} else {
- return (result);
+ return result;
}
}
}
isc_ht_destroy(&name_map);
}
- return (result);
+ return result;
}
static bool
update(dns_section_t section, dns_rdataclass_t rdclass) {
if (section == DNS_SECTION_PREREQUISITE) {
- return (rdclass == dns_rdataclass_any ||
- rdclass == dns_rdataclass_none);
+ return rdclass == dns_rdataclass_any ||
+ rdclass == dns_rdataclass_none;
}
if (section == DNS_SECTION_UPDATE) {
- return (rdclass == dns_rdataclass_any);
+ return rdclass == dns_rdataclass_any;
}
- return (false);
+ return false;
}
/*
}
if (auth_dnssec != auth_rrsig) {
- return (false);
+ return false;
}
}
- return (true);
+ return true;
}
static isc_result_t
isc_ht_destroy(&name_map);
}
- return (result);
+ return result;
}
isc_result_t
isc_buffer_remainingregion(source, &r);
if (r.length < DNS_MESSAGE_HEADERLEN) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
msg->id = isc_buffer_getuint16(source);
ret = ISC_R_SUCCESS;
}
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
msg->question_ok = 1;
ret = ISC_R_SUCCESS;
}
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
ret = getsection(source, msg, &dctx, DNS_SECTION_AUTHORITY, options);
ret = ISC_R_SUCCESS;
}
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
ret = getsection(source, msg, &dctx, DNS_SECTION_ADDITIONAL, options);
ret = ISC_R_SUCCESS;
}
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
isc_buffer_remainingregion(source, &r);
truncated:
if (ret == ISC_R_UNEXPECTEDEND && ignore_tc) {
- return (DNS_R_RECOVERABLE);
+ return DNS_R_RECOVERABLE;
}
if (seen_problem) {
- return (DNS_R_RECOVERABLE);
+ return DNS_R_RECOVERABLE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
*/
isc_buffer_availableregion(buffer, &r);
if (r.length < DNS_MESSAGE_HEADERLEN) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
if (r.length - DNS_MESSAGE_HEADERLEN < msg->reserved) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/*
msg->buffer = buffer;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
msg->buffer = buffer;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
if (msg->buffer != NULL) {
isc_buffer_availableregion(msg->buffer, &r);
if (r.length < (space + msg->reserved)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
}
msg->reserved += space;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
* If we are not rendering class IN, this ordering is bogus.
*/
if (rds->rdclass != dns_rdataclass_in) {
- return (false);
+ return false;
}
switch (rds->type) {
}
if (pass_needed >= pass) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static isc_result_t
* Shrink the space in the buffer by the reserved amount.
*/
if (target->length - target->used < reserved) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
target->length -= reserved;
options, countp);
target->length += reserved;
- return (result);
+ return result;
}
static void
* Shrink the space in the buffer by the reserved amount.
*/
if (msg->buffer->length - msg->buffer->used < msg->reserved) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
msg->buffer->length -= msg->reserved;
msg->flags |= DNS_MESSAGEFLAG_TC;
msg->buffer->length += msg->reserved;
msg->counts[sectionid] += total;
- return (result);
+ return result;
}
if (result == ISC_R_NOSPACE) {
msg->flags |= DNS_MESSAGEFLAG_TC;
*(msg->buffer) = st; /* rollback */
msg->buffer->length += msg->reserved;
msg->counts[sectionid] += total;
- return (result);
+ return result;
}
update_min_section_ttl(msg, sectionid, rdataset);
if (name == NULL) {
msg->buffer->length += msg->reserved;
msg->counts[sectionid] += total;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
while (name != NULL) {
if (partial && result == ISC_R_NOSPACE) {
msg->buffer->length += msg->reserved;
msg->counts[sectionid] += total;
- return (result);
+ return result;
}
if (result != ISC_R_SUCCESS) {
INSIST(st.used < 65536);
msg->buffer->length += msg->reserved;
msg->counts[sectionid] += total;
maybe_clear_ad(msg, sectionid);
- return (result);
+ return result;
}
/*
msg->buffer->length += msg->reserved;
msg->counts[sectionid] += total;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
/*
* We have an extended rcode but are not using EDNS.
*/
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
/*
result = dns_message_rendersection(msg, DNS_SECTION_QUESTION,
0);
if (result != ISC_R_SUCCESS && result != ISC_R_NOSPACE) {
- return (result);
+ return result;
}
}
msg->buffer, msg->reserved, 0, &count);
msg->counts[DNS_SECTION_ADDITIONAL] += count;
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
if ((cp[-4] != 0) || (cp[-3] != DNS_OPT_PAD) || (cp[-2] != 0) ||
(cp[-1] != 0))
{
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
/*
msg->sig_reserved = 0;
result = dns_tsig_sign(msg);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
count = 0;
result = renderset(msg->tsig, msg->tsigname, msg->cctx,
msg->buffer, msg->reserved, 0, &count);
msg->counts[DNS_SECTION_ADDITIONAL] += count;
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
msg->sig_reserved = 0;
result = dns_dnssec_signmessage(msg, msg->sig0key);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
count = 0;
/*
msg->buffer, msg->reserved, 0, &count);
msg->counts[DNS_SECTION_ADDITIONAL] += count;
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
msg->buffer = NULL; /* forget about this buffer only on success XXX */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
msg->cursors[section] = ISC_LIST_HEAD(msg->sections[section]);
if (msg->cursors[section] == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
msg->cursors[section] = ISC_LIST_NEXT(msg->cursors[section], link);
if (msg->cursors[section] == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
result = findname(&foundname, target, &msg->sections[section]);
if (result == ISC_R_NOTFOUND) {
- return (DNS_R_NXDOMAIN);
+ return DNS_R_NXDOMAIN;
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (name != NULL) {
* And now look for the type.
*/
if (type == dns_rdatatype_any) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = dns_message_findtype(foundname, type, covers, rdataset);
if (result == ISC_R_NOTFOUND) {
- return (DNS_R_NXRRSET);
+ return DNS_R_NXRRSET;
}
- return (result);
+ return result;
}
void
fn = isc_mempool_get(msg->namepool);
*item = dns_fixedname_initname(fn);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(item != NULL && *item == NULL);
*item = newrdata(msg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
*item = isc_mempool_get(msg->rdspool);
dns_rdataset_init(*item);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(item != NULL && *item == NULL);
*item = newrdatalist(msg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_buffer_remainingregion(&buffer, &r);
if (r.length < DNS_MESSAGE_HEADERLEN) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
id = isc_buffer_getuint16(&buffer);
*idp = id;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE((msg->flags & DNS_MESSAGEFLAG_QR) == 0);
if (!msg->header_ok) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
if (msg->opcode != dns_opcode_query && msg->opcode != dns_opcode_notify)
{
clear_from = DNS_SECTION_PREREQUISITE;
} else if (want_question_section) {
if (!msg->question_ok) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
clear_from = DNS_SECTION_ANSWER;
} else {
result = dns_message_renderreserve(msg, msg->sig_reserved);
if (result != ISC_R_SUCCESS) {
msg->sig_reserved = 0;
- return (result);
+ return result;
}
}
if (msg->saved.base != NULL) {
msg->free_saved = 0;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_rdataset_t *
REQUIRE(DNS_MESSAGE_VALID(msg));
- return (msg->opt);
+ return msg->opt;
}
isc_result_t
msg->opt = opt;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_rdataset_disassociate(opt);
dns_message_puttemprdataset(msg, &opt);
- return (result);
+ return result;
}
dns_rdataset_t *
if (owner != NULL) {
*owner = msg->tsigname;
}
- return (msg->tsig);
+ return msg->tsig;
}
isc_result_t
if (result != ISC_R_SUCCESS) {
dns_tsigkey_detach(&msg->tsigkey);
msg->sig_reserved = 0;
- return (result);
+ return result;
}
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_tsigkey_t *
REQUIRE(DNS_MESSAGE_VALID(msg));
- return (msg->tsigkey);
+ return msg->tsigkey;
}
isc_result_t
REQUIRE(msg->querytsig == NULL);
if (querytsig == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = dns_message_gettemprdata(msg, &rdata);
msg->querytsig = set;
- return (result);
+ return result;
cleanup:
if (rdata != NULL) {
if (set != NULL) {
dns_message_puttemprdataset(msg, &set);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
isc_result_t
REQUIRE(querytsig != NULL && *querytsig == NULL);
if (msg->tsig == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = dns_rdataset_first(msg->tsig);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_current(msg->tsig, &rdata);
dns_rdata_toregion(&rdata, &r);
isc_buffer_allocate(mctx, querytsig, r.length);
isc_buffer_putmem(*querytsig, r.base, r.length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_rdataset_t *
*owner = msg->sig0name;
}
}
- return (msg->sig0);
+ return msg->sig0;
}
isc_result_t
result = dst_key_sigsize(key, &x);
if (result != ISC_R_SUCCESS) {
msg->sig_reserved = 0;
- return (result);
+ return result;
}
msg->sig_reserved = 27 + r.length + x;
result = dns_message_renderreserve(msg, msg->sig_reserved);
if (result != ISC_R_SUCCESS) {
msg->sig_reserved = 0;
- return (result);
+ return result;
}
msg->sig0key = key;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dst_key_t *
REQUIRE(DNS_MESSAGE_VALID(msg));
- return (msg->sig0key);
+ return msg->sig0key;
}
void
REQUIRE(msg->from_to_wire == DNS_MESSAGE_INTENTPARSE);
if (msg->tsig == NULL && msg->sig0 == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (msg->verify_attempted == 0) {
- return (DNS_R_NOTVERIFIEDYET);
+ return DNS_R_NOTVERIFIEDYET;
}
if (!dns_name_hasbuffer(signer)) {
result = dns_rdata_tostruct(&rdata, &sig, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (msg->verified_sig && msg->sig0status == dns_rcode_noerror) {
}
}
- return (result);
+ return result;
}
void
isc_result_t
dns_message_rechecksig(dns_message_t *msg, dns_view_t *view) {
dns_message_resetsig(msg);
- return (dns_message_checksig(msg, view));
+ return dns_message_checksig(msg, view);
}
#ifdef SKAN_MSG_DEBUG
REQUIRE(DNS_MESSAGE_VALID(msg));
if (msg->tsigkey == NULL && msg->tsig == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
INSIST(msg->saved.base != NULL);
dns_message_dumpsig(msg, "dns_message_checksig#1");
#endif /* ifdef SKAN_MSG_DEBUG */
if (view != NULL) {
- return (dns_view_checksig(view, &msgb, msg));
+ return dns_view_checksig(view, &msgb, msg);
} else {
- return (dns_tsig_verify(&msgb, msg, NULL, NULL));
+ return dns_tsig_verify(&msgb, msg, NULL, NULL);
}
}
cleanup:
msg->indent.count = saved_count;
- return (result);
+ return result;
}
static isc_result_t
*/
if (isc_buffer_remaininglength(ecsbuf) < 4) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
family = isc_buffer_getuint16(ecsbuf);
addrlen = isc_buffer_getuint8(ecsbuf);
addrbytes = (addrlen + 7) / 8;
if (isc_buffer_remaininglength(ecsbuf) < addrbytes) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
if (addrbytes > sizeof(addr)) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
memset(addr, 0, sizeof(addr));
switch (family) {
case 0:
if (addrlen != 0U || scopelen != 0U) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
strlcpy(addr_text, "0", sizeof(addr_text));
break;
case 1:
if (addrlen > 32 || scopelen > 32) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
inet_ntop(AF_INET, addr, addr_text, sizeof(addr_text));
break;
case 2:
if (addrlen > 128 || scopelen > 128) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
inet_ntop(AF_INET6, addr, addr_text, sizeof(addr_text));
break;
default:
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
ADD_STRING(target, " ");
result = ISC_R_SUCCESS;
cleanup:
- return (result);
+ return result;
}
static isc_result_t
snprintf(buf, sizeof(buf), "%u", u);
ADD_STRING(target, buf);
cleanup:
- return (result);
+ return result;
}
static isc_result_t
cleanup:
msg->indent.count = saved_count;
- return (result);
+ return result;
}
isc_result_t
REQUIRE(VALID_PSEUDOSECTION(section));
if ((dns_master_styleflags(style) & DNS_STYLEFLAG_YAML) != 0) {
- return (dns_message_pseudosectiontoyaml(msg, section, style,
- flags, target));
+ return dns_message_pseudosectiontoyaml(msg, section, style,
+ flags, target);
}
switch (section) {
case DNS_PSEUDOSECTION_OPT:
ps = dns_message_getopt(msg);
if (ps == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if ((flags & DNS_MESSAGETEXTFLAG_NOCOMMENTS) == 0) {
INDENT(style);
result = dns_rdataset_first(ps);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (optlen == 18U) {
result = render_llq(&optbuf, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
ADD_STRING(target, "\n");
continue;
isc_buffer_add(&ecsbuf, optlen);
result = render_ecs(&ecsbuf, target);
if (result == ISC_R_NOSPACE) {
- return (result);
+ return result;
}
if (result == ISC_R_SUCCESS) {
isc_buffer_forward(&optbuf, optlen);
result = dns_ttl_totext(secs, true,
true, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
ADD_STRING(target, ")\n");
continue;
}
if (isc_buffer_availablelength(target) < optlen)
{
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
for (i = 0; i < optlen; i++) {
if (isprint(optdata[i]) ||
}
ADD_STRING(target, "\n");
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
case DNS_PSEUDOSECTION_TSIG:
ps = dns_message_gettsig(msg, &name);
if (ps == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
INDENT(style);
if ((flags & DNS_MESSAGETEXTFLAG_NOCOMMENTS) == 0) {
{
ADD_STRING(target, "\n");
}
- return (result);
+ return result;
case DNS_PSEUDOSECTION_SIG0:
ps = dns_message_getsig0(msg, &name);
if (ps == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
INDENT(style);
if ((flags & DNS_MESSAGETEXTFLAG_NOCOMMENTS) == 0) {
{
ADD_STRING(target, "\n");
}
- return (result);
+ return result;
}
result = ISC_R_UNEXPECTED;
cleanup:
- return (result);
+ return result;
}
isc_result_t
REQUIRE(target != NULL);
if ((flags & DNS_MESSAGETEXTFLAG_NOHEADERS) != 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (dns_master_styleflags(style) & DNS_STYLEFLAG_YAML) {
ADD_STRING(target, "status: ");
result = dns_rcode_totext(msg->rcode, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
ADD_STRING(target, "\n");
INDENT(style);
ADD_STRING(target, ", status: ");
result = dns_rcode_totext(msg->rcode, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
ADD_STRING(target, ", id: ");
snprintf(buf, sizeof(buf), "%6u", msg->id);
}
cleanup:
- return (result);
+ return result;
}
isc_result_t
result = dns_message_headertotext(msg, style, flags, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_message_pseudosectiontotext(msg, DNS_PSEUDOSECTION_OPT,
style, flags, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_message_sectiontotext(msg, DNS_SECTION_QUESTION, style,
flags, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_message_sectiontotext(msg, DNS_SECTION_ANSWER, style,
flags, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_message_sectiontotext(msg, DNS_SECTION_AUTHORITY, style,
flags, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_message_sectiontotext(msg, DNS_SECTION_ADDITIONAL, style,
flags, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_message_pseudosectiontotext(msg, DNS_PSEUDOSECTION_TSIG,
style, flags, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_message_pseudosectiontotext(msg, DNS_PSEUDOSECTION_SIG0,
style, flags, target);
- return (result);
+ return result;
}
isc_region_t *
dns_message_getrawmessage(dns_message_t *msg) {
REQUIRE(DNS_MESSAGE_VALID(msg));
- return (&msg->saved);
+ return &msg->saved;
}
void
int
dns_message_gettimeadjust(dns_message_t *msg) {
REQUIRE(DNS_MESSAGE_VALID(msg));
- return (msg->timeadjust);
+ return msg->timeadjust;
}
isc_result_t
REQUIRE(opcode < 16);
if (isc_buffer_availablelength(target) < strlen(opcodetext[opcode])) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putstr(target, opcodetext[opcode]);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
result = dns_message_gettemprdatalist(message, &rdatalist);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_message_gettemprdata(message, &rdata);
if (result != ISC_R_SUCCESS) {
RUNTIME_CHECK(result == ISC_R_SUCCESS);
*rdatasetp = rdataset;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (rdata != NULL) {
if (rdatalist != NULL) {
dns_message_puttemprdatalist(message, &rdatalist);
}
- return (result);
+ return result;
}
void
dns_name_t *name = NULL;
if (msg->counts[DNS_SECTION_AUTHORITY] == 0) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
for (result = dns_message_firstname(msg, DNS_SECTION_AUTHORITY);
*pttl = ISC_MIN(
rdataset->ttl,
dns_soa_getminimum(&rdata));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
isc_result_t
REQUIRE(pttl != NULL);
if (!msg->minttl[sectionid].is_set) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
*pttl = msg->minttl[sectionid].ttl;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
result = dns_message_minttl(msg, DNS_SECTION_ANSWER, pttl);
if (result != ISC_R_SUCCESS) {
- return (message_authority_soa_min(msg, pttl));
+ return message_authority_soa_min(msg, pttl);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
unsigned int offset, count, length, nlabels;
if (!VALID_NAME(name)) {
- return (false);
+ return false;
}
if (name->length > 255U || name->labels > 127U) {
- return (false);
+ return false;
}
ndata = name->ndata;
while (offset != length) {
count = *ndata;
if (count > 63U) {
- return (false);
+ return false;
}
if (offsets != NULL && offsets[nlabels] != offset) {
- return (false);
+ return false;
}
nlabels++;
offset += count + 1;
ndata += count + 1;
if (offset > length) {
- return (false);
+ return false;
}
if (count == 0) {
}
if (nlabels != name->labels || offset != name->length) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
void
REQUIRE(VALID_NAME(name));
if (name->buffer != NULL) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
REQUIRE(VALID_NAME(name));
if ((name->attributes & DNS_NAMEATTR_ABSOLUTE) != 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
#define hyphenchar(c) ((c) == 0x2d)
* Root label.
*/
if (name->length == 1) {
- return (true);
+ return true;
}
ndata = name->ndata;
while (n--) {
ch = *ndata++;
if (!domainchar(ch)) {
- return (false);
+ return false;
}
}
if (ndata == name->ndata + name->length) {
- return (false);
+ return false;
}
/*
ch = *ndata++;
if (first || n == 0) {
if (!borderchar(ch)) {
- return (false);
+ return false;
}
} else {
if (!middlechar(ch)) {
- return (false);
+ return false;
}
}
first = false;
}
}
- return (true);
+ return true;
}
bool
* Root label.
*/
if (name->length == 1) {
- return (true);
+ return true;
}
/*
ch = *ndata++;
if (first || n == 0) {
if (!borderchar(ch)) {
- return (false);
+ return false;
}
} else {
if (!middlechar(ch)) {
- return (false);
+ return false;
}
}
first = false;
}
}
- return (true);
+ return true;
}
bool
if (name->length >= 2) {
ndata = name->ndata;
if (ndata[0] == 1 && ndata[1] == '*') {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
bool
count = *ndata++;
INSIST(count <= 63);
if (count == 1 && *ndata == '*') {
- return (true);
+ return true;
}
ndata += count;
label++;
}
- return (false);
+ return false;
}
unsigned int
REQUIRE(VALID_NAME(name));
if (name->labels == 0) {
- return (0);
+ return 0;
}
length = name->length;
}
/* High bits are more random. */
- return (isc_hash32(name->ndata, length, case_sensitive));
+ return isc_hash32(name->ndata, length, case_sensitive);
}
unsigned int
REQUIRE(VALID_NAME(name));
if (name->labels == 0) {
- return (0);
+ return 0;
}
/* High bits are more random. */
- return (isc_hash32(name->ndata, name->length, case_sensitive));
+ return isc_hash32(name->ndata, name->length, case_sensitive);
}
dns_namereln_t
if (name1 == name2) {
*orderp = 0;
*nlabelsp = name1->labels;
- return (dns_namereln_equal);
+ return dns_namereln_equal;
}
SETUP_OFFSETS(name1, offsets1, odata1);
namereln = dns_namereln_equal;
}
*nlabelsp = nlabels;
- return (namereln);
+ return namereln;
done:
*nlabelsp = nlabels;
namereln = dns_namereln_commonancestor;
}
- return (namereln);
+ return namereln;
}
int
(void)dns_name_fullcompare(name1, name2, &order, &nlabels);
- return (order);
+ return order;
}
bool
(name2->attributes & DNS_NAMEATTR_ABSOLUTE));
if (name1 == name2) {
- return (true);
+ return true;
}
if (name1->length != name2->length) {
- return (false);
+ return false;
}
l = name1->labels;
if (l != name2->labels) {
- return (false);
+ return false;
}
label1 = name1->ndata;
while (l-- > 0) {
count = *label1++;
if (count != *label2++) {
- return (false);
+ return false;
}
INSIST(count <= 63); /* no bitstring support */
while (count > 3) {
c = maptolower[label1[0]];
if (c != maptolower[label2[0]]) {
- return (false);
+ return false;
}
c = maptolower[label1[1]];
if (c != maptolower[label2[1]]) {
- return (false);
+ return false;
}
c = maptolower[label1[2]];
if (c != maptolower[label2[2]]) {
- return (false);
+ return false;
}
c = maptolower[label1[3]];
if (c != maptolower[label2[3]]) {
- return (false);
+ return false;
}
count -= 4;
label1 += 4;
while (count-- > 0) {
c = maptolower[*label1++];
if (c != maptolower[*label2++]) {
- return (false);
+ return false;
}
}
}
- return (true);
+ return true;
}
bool
(name2->attributes & DNS_NAMEATTR_ABSOLUTE));
if (name1->length != name2->length) {
- return (false);
+ return false;
}
if (memcmp(name1->ndata, name2->ndata, name1->length) != 0) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
int
INSIST(count1 <= 63 && count2 <= 63);
if (count1 != count2) {
- return ((count1 < count2) ? -1 : 1);
+ return (count1 < count2) ? -1 : 1;
}
count = count1;
while (count > 0) {
c1 = maptolower[*label1++];
c2 = maptolower[*label2++];
if (c1 < c2) {
- return (-1);
+ return -1;
} else if (c1 > c2) {
- return (1);
+ return 1;
}
}
}
*/
INSIST(l1 == l2);
- return (0);
+ return 0;
}
bool
if (namereln == dns_namereln_subdomain ||
namereln == dns_namereln_equal)
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
if (dns_name_fullcompare(name, &tname, &order, &nlabels) ==
dns_namereln_subdomain)
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
unsigned int
ENSURE(name->labels <= 128);
- return (name->labels);
+ return name->labels;
}
void
*/
if (c == '.') {
if (tlen != 0) {
- return (DNS_R_EMPTYLABEL);
+ return DNS_R_EMPTYLABEL;
}
labels++;
*ndata++ = 0;
}
state = ft_ordinary;
if (nrem == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
FALLTHROUGH;
case ft_ordinary:
if (c == '.') {
if (count == 0) {
- return (DNS_R_EMPTYLABEL);
+ return DNS_R_EMPTYLABEL;
}
*label = count;
labels++;
state = ft_escape;
} else {
if (count >= 63) {
- return (DNS_R_LABELTOOLONG);
+ return DNS_R_LABELTOOLONG;
}
count++;
CONVERTTOASCII(c);
* This looks like a bitstring label, which
* was deprecated. Intentionally drop it.
*/
- return (DNS_R_BADLABELTYPE);
+ return DNS_R_BADLABELTYPE;
}
state = ft_escape;
POST(state);
case ft_escape:
if (!isdigit((unsigned char)c)) {
if (count >= 63) {
- return (DNS_R_LABELTOOLONG);
+ return DNS_R_LABELTOOLONG;
}
count++;
CONVERTTOASCII(c);
FALLTHROUGH;
case ft_escdecimal:
if (!isdigit((unsigned char)c)) {
- return (DNS_R_BADESCAPE);
+ return DNS_R_BADESCAPE;
}
value *= 10;
value += digitvalue[c & 0xff];
digits++;
if (digits == 3) {
if (value > 255) {
- return (DNS_R_BADESCAPE);
+ return DNS_R_BADESCAPE;
}
if (count >= 63) {
- return (DNS_R_LABELTOOLONG);
+ return DNS_R_LABELTOOLONG;
}
count++;
if (downcase) {
if (!done) {
if (nrem == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
INSIST(tlen == 0);
if (state != ft_ordinary && state != ft_at) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (state == ft_ordinary) {
INSIST(count != 0);
}
if (origin != NULL) {
if (nrem < origin->length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
label = origin->ndata;
n1 = origin->length;
isc_buffer_forward(source, tused);
isc_buffer_add(target, name->length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (omit_final_dot) {
options |= DNS_NAME_OMITFINALDOT;
}
- return (dns_name_totext2(name, options, target));
+ return dns_name_totext2(name, options, target);
}
isc_result_t
dns_name_toprincipal(const dns_name_t *name, isc_buffer_t *target) {
- return (dns_name_totext2(name, DNS_NAME_OMITFINALDOT, target));
+ return dns_name_totext2(name, DNS_NAME_OMITFINALDOT, target);
}
isc_result_t
* Special handling for an empty name.
*/
if (trem == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/*
* Special handling for the root label.
*/
if (trem == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
saw_root = true;
case 0x3B: /* ';' */
case 0x5C: /* '\\' */
if (trem < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tdata++ = '\\';
CONVERTFROMASCII(c);
default:
if (c > 0x20 && c < 0x7f) {
if (trem == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
CONVERTFROMASCII(c);
*tdata++ = c;
nlen--;
} else {
if (trem < 4) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tdata++ = 0x5c;
*tdata++ = 0x30 +
* needed in the final output.
*/
if (trem == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tdata++ = '.';
trem--;
}
if (nlen != 0 && trem == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
if (!saw_root || omit_final_dot) {
isc_buffer_add(target, tlen - trem);
if (totext_filter_proc != NULL) {
- return ((totext_filter_proc)(target, oused));
+ return (totext_filter_proc)(target, oused);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
* Special handling for the root label.
*/
if (trem == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
omit_final_dot = false;
c == 0x5F) /* underscore */
{
if (trem == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/* downcase */
if (c >= 0x41 && c <= 0x5A) {
nlen--;
} else {
if (trem < 4) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
snprintf(tdata, trem, "%%%02X", c);
tdata += 3;
* needed in the final output.
*/
if (trem == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tdata++ = '.';
trem--;
}
if (nlen != 0 && trem == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
if (omit_final_dot) {
isc_buffer_add(target, tlen - trem);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (nlen > (target->length - target->used)) {
MAKE_EMPTY(name);
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
while (labels > 0 && nlen > 0) {
isc_buffer_add(target, name->length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
cursor += label_len;
name_len += label_len + 1;
if (name_len > name_max) {
- return (name_max == DNS_NAME_MAXWIRE
- ? DNS_R_NAMETOOLONG
- : ISC_R_NOSPACE);
+ return name_max == DNS_NAME_MAXWIRE
+ ? DNS_R_NAMETOOLONG
+ : ISC_R_NOSPACE;
} else if (label_len == 0) {
goto root_label;
}
} else if (label_len < 192) {
- return (DNS_R_BADLABELTYPE);
+ return DNS_R_BADLABELTYPE;
} else if ((dctx->allowed & DNS_COMPRESS_GLOBAL14) == 0) {
- return (DNS_R_DISALLOWED);
+ return DNS_R_DISALLOWED;
} else if (cursor < source_max) {
/*
* Compression pointer. Ensure it does not loop.
const uint32_t lo = *cursor++;
const uint8_t *pointer = source_buf + (256 * hi + lo);
if (pointer >= marker) {
- return (DNS_R_BADPOINTER);
+ return DNS_R_BADPOINTER;
}
const uint32_t copy_len = (cursor - 2) - marker;
uint8_t *const dest = name_buf + name_len - copy_len;
cursor = marker = pointer;
}
}
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
root_label:;
/*
* Copy labels almost like we do for compression pointers,
name->length = name_len;
isc_buffer_add(target, name_len);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
dns_name_towire(const dns_name_t *name, dns_compress_t *cctx,
isc_buffer_t *target) {
- return (dns_name_towire2(name, cctx, target, NULL));
+ return dns_name_towire2(name, cctx, target, NULL);
}
isc_result_t
(methods & DNS_COMPRESS_GLOBAL14) != 0)
{
if (target->length - target->used < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
offset = *comp_offsetp;
offset |= 0xc000;
isc_buffer_putuint16(target, offset);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (gf) {
if (target->length - target->used < gp.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
if (gp.length != 0) {
unsigned char *base = target->base;
}
isc_buffer_add(target, gp.length);
if (target->length - target->used < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint16(target, go | 0xc000);
if (gp.length != 0) {
}
} else {
if (target->length - target->used < name->length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
if (name->length != 0) {
unsigned char *base = target->base;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
if (length > DNS_NAME_MAXWIRE) {
MAKE_EMPTY(name);
- return (DNS_R_NAMETOOLONG);
+ return DNS_R_NAMETOOLONG;
}
if (length > nrem) {
MAKE_EMPTY(name);
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
if (copy_suffix) {
isc_buffer_add(target, name->length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
set_offsets(target, target->offsets, NULL);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
result = dns_name_downcase(name, &downname, &buffer);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_usedregion(&buffer, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
bool
* Returns whether there is dynamic memory associated with this name.
*/
- return ((name->attributes & DNS_NAMEATTR_DYNAMIC) != 0 ? true : false);
+ return (name->attributes & DNS_NAMEATTR_DYNAMIC) != 0 ? true : false;
}
isc_result_t
isc_buffer_init(&b, t, sizeof(t));
result = dns_name_totext(name, false, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_usedregion(&b, &r);
fprintf(stream, "%.*s", (int)r.length, (char *)r.base);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
*/
if (totext_filter_proc != NULL && proc != NULL) {
if (totext_filter_proc == proc) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
if (proc == NULL && totext_filter_proc != NULL) {
totext_filter_proc = NULL;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
totext_filter_proc = proc;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_buffer_init(&buf, txt, sizeof(txt));
result = dns_name_totext(name, false, &buf);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_usedregion(&buf, ®);
p[reg.length] = '\0';
*target = p;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
isc_result_t
dns_name_fromstring(dns_name_t *target, const char *src, unsigned int options,
isc_mem_t *mctx) {
- return (dns_name_fromstring2(target, src, dns_rootname, options, mctx));
+ return dns_name_fromstring2(target, src, dns_rootname, options, mctx);
}
isc_result_t
result = dns_name_fromtext(name, &buf, origin, options, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (name != target) {
result = dns_name_dupwithoffsets(name, mctx, target);
}
- return (result);
+ return result;
}
void
dns_name_getlabelsequence(name, 0, 3, &prefix);
for (i = 0; i < (sizeof(dns_sd) / sizeof(dns_sd[0])); i++) {
if (dns_name_equal(&prefix, &dns_sd[i])) {
- return (true);
+ return true;
}
}
}
- return (false);
+ return false;
}
static unsigned char inaddr10_offsets[] = { 0, 3, 11, 16 };
for (i = 0; i < (sizeof(rfc1918names) / sizeof(*rfc1918names)); i++) {
if (dns_name_issubdomain(name, &rfc1918names[i])) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static unsigned char ulaoffsets[] = { 0, 2, 4, 8, 13 };
for (i = 0; i < (sizeof(ulanames) / sizeof(*ulanames)); i++) {
if (dns_name_issubdomain(name, &ulanames[i])) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
/*
REQUIRE(VALID_NAME(name));
if (name->labels < 1) {
- return (false);
+ return false;
}
ndata = name->ndata;
* label length consistent with a trust-anchor-telemetry label.
*/
if ((len < 8) || (len - 3) % 5 != 0) {
- return (false);
+ return false;
}
if (ndata[0] != '_' || maptolower[ndata[1]] != 't' ||
maptolower[ndata[2]] != 'a')
{
- return (false);
+ return false;
}
ndata += 3;
len -= 3;
if (ndata[0] != '-' || !ishex[ndata[1]] || !ishex[ndata[2]] ||
!ishex[ndata[3]] || !ishex[ndata[4]])
{
- return (false);
+ return false;
}
ndata += 5;
len -= 5;
}
- return (true);
+ return true;
}
*/
isc_buffer_availableregion(buffer, &ar);
if (ar.length < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
count = dns_rdataset_count(rdataset);
INSIST(count <= 65535);
INSIST(r.length <= 65535);
isc_buffer_availableregion(buffer, &ar);
if (ar.length < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/*
* Copy the rdata length to the buffer.
*/
result = isc_buffer_copyregion(buffer, &r);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdata_reset(&rdata);
result = dns_rdataset_next(rdataset);
}
if (result != ISC_R_NOMORE) {
- return (result);
+ return result;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
dns_ncache_add(dns_message_t *message, dns_db_t *cache, dns_dbnode_t *node,
dns_rdatatype_t covers, isc_stdtime_t now, dns_ttl_t minttl,
dns_ttl_t maxttl, dns_rdataset_t *addedrdataset) {
- return (addoptout(message, cache, node, covers, now, minttl, maxttl,
- false, false, addedrdataset));
+ return addoptout(message, cache, node, covers, now, minttl, maxttl,
+ false, false, addedrdataset);
}
isc_result_t
dns_dbnode_t *node, dns_rdatatype_t covers,
isc_stdtime_t now, dns_ttl_t minttl, dns_ttl_t maxttl,
bool optout, dns_rdataset_t *addedrdataset) {
- return (addoptout(message, cache, node, covers, now, minttl, maxttl,
- optout, true, addedrdataset));
+ return addoptout(message, cache, node, covers, now, minttl, maxttl,
+ optout, true, addedrdataset);
}
static isc_result_t
result = isc_buffer_copyregion(&buffer,
&r);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
* Copy the type to the buffer.
*/
isc_buffer_availableregion(&buffer, &r);
if (r.length < 3) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint16(&buffer,
rdataset->type);
result = copy_rdataset(rdataset,
&buffer);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (next >= DNS_NCACHE_RDATA) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
dns_rdata_init(&rdata[next]);
isc_buffer_remainingregion(&buffer, &r);
result = dns_message_nextname(message, DNS_SECTION_AUTHORITY);
}
if (result != ISC_R_NOMORE) {
- return (result);
+ return result;
}
if (trust == 0xffff) {
ncrdataset.attributes |= DNS_RDATASETATTR_OPTOUT;
}
- return (dns_db_addrdataset(cache, node, NULL, now, &ncrdataset, 0,
- addedrdataset));
+ return dns_db_addrdataset(cache, node, NULL, now, &ncrdataset, 0,
+ addedrdataset);
}
isc_result_t
*countp = count;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
rollback:
INSIST(savedbuffer.used < 65536);
*countp = 0;
*target = savedbuffer;
- return (result);
+ return result;
}
static void
count = raw[0] * 256 + raw[1];
if (count == 0) {
rdataset->private5 = NULL;
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
raw += 2;
/*
rdataset->privateuint4 = count;
rdataset->private5 = raw;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
count = rdataset->privateuint4;
if (count == 0) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
count--;
rdataset->privateuint4 = count;
raw += length + 2;
rdataset->private5 = raw;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
count = raw[0] * 256 + raw[1];
- return (count);
+ return count;
}
static void
}
dns_rdataset_disassociate(&rclone);
if (result == ISC_R_NOMORE) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
INSIST(remaining.length != 0);
rdataset->privateuint4 = 0;
rdataset->private5 = NULL;
rdataset->private6 = NULL;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
dns_rdataset_disassociate(&rclone);
if (result == ISC_R_NOMORE) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
INSIST(remaining.length != 0);
rdataset->privateuint4 = 0;
rdataset->private5 = NULL;
rdataset->private6 = NULL;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
shift = 7 - (type % 8);
mask = 1 << shift;
- return ((byte & mask) != 0);
+ return (byte & mask) != 0;
}
unsigned int
int octet;
if (raw == NULL) {
- return (0);
+ return 0;
}
for (window = 0; window < 256; window++) {
map += octet + 1;
raw += 32;
}
- return ((unsigned int)(map - start));
+ return (unsigned int)(map - start);
}
isc_result_t
rdsiter = NULL;
result = dns_db_allrdatasets(db, node, version, 0, 0, &rdsiter);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (result = dns_rdatasetiter_first(rdsiter); result == ISC_R_SUCCESS;
result = dns_rdatasetiter_next(rdsiter))
dns_rdatasetiter_destroy(&rdsiter);
if (result != ISC_R_NOMORE) {
- return (result);
+ return result;
}
nsec_bits += dns_nsec_compressbitmap(nsec_bits, bm, max_type);
INSIST(r.length <= DNS_NSEC_BUFFERSIZE);
dns_rdata_fromregion(rdata, dns_db_class(db), dns_rdatatype_nsec, &r);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (dns_rdataset_isassociated(&rdataset)) {
dns_rdataset_disassociate(&rdataset);
}
- return (result);
+ return result;
}
bool
break;
}
dns_rdata_freestruct(&nsecstruct);
- return (present);
+ return present;
}
isc_result_t
result = dns_db_getoriginnode(db, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_findrdataset(db, node, version, dns_rdatatype_dnskey, 0,
*answer = false;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (result = dns_rdataset_first(&rdataset); result == ISC_R_SUCCESS;
result = dns_rdataset_next(&rdataset))
*answer = false;
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
/*%
result = dns_rdataset_first(nsecset);
if (result != ISC_R_SUCCESS) {
(*logit)(arg, ISC_LOG_DEBUG(3), "failure processing NSEC set");
- return (result);
+ return result;
}
dns_rdataset_current(nsecset, &rdata);
{
(*logit)(arg, ISC_LOG_DEBUG(3),
"NSEC missing RRSIG and/or NSEC from type map");
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
#endif
*/
(*logit)(arg, ISC_LOG_DEBUG(3),
"NSEC does not cover name, before NSEC");
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
if (order == 0) {
*/
(*logit)(arg, ISC_LOG_DEBUG(3),
"ignoring parent nsec");
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
} else if (atparent && ns && soa) {
/*
* It can not be legitimately used here.
*/
(*logit)(arg, ISC_LOG_DEBUG(3), "ignoring child nsec");
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
if (type == dns_rdatatype_cname || type == dns_rdatatype_nxt ||
type == dns_rdatatype_nsec || type == dns_rdatatype_key ||
(*logit)(arg, ISC_LOG_DEBUG(3),
"nsec proves name exists (owner) data=%d",
*data);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
(*logit)(arg, ISC_LOG_DEBUG(3), "NSEC proves CNAME exists");
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
if (relation == dns_namereln_subdomain &&
* It can not be legitimately used here.
*/
(*logit)(arg, ISC_LOG_DEBUG(3), "ignoring parent nsec");
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
if (relation == dns_namereln_subdomain &&
{
(*logit)(arg, ISC_LOG_DEBUG(3), "nsec proves covered by dname");
*exists = false;
- return (DNS_R_DNAME);
+ return DNS_R_DNAME;
}
result = dns_rdata_tostruct(&rdata, &nsec, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
relation = dns_name_fullcompare(&nsec.next, name, &order, &nlabels);
if (order == 0) {
dns_rdata_freestruct(&nsec);
(*logit)(arg, ISC_LOG_DEBUG(3),
"ignoring nsec matches next name");
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
if (order < 0 && !dns_name_issubdomain(nsecname, &nsec.next)) {
dns_rdata_freestruct(&nsec);
(*logit)(arg, ISC_LOG_DEBUG(3),
"ignoring nsec because name is past end of range");
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
if (order > 0 && relation == dns_namereln_subdomain) {
dns_rdata_freestruct(&nsec);
*exists = true;
*data = false;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (wild != NULL) {
dns_name_t common;
dns_rdata_freestruct(&nsec);
(*logit)(arg, ISC_LOG_DEBUG(3),
"failure generating wildcard name");
- return (result);
+ return result;
}
}
dns_rdata_freestruct(&nsec);
(*logit)(arg, ISC_LOG_DEBUG(3), "nsec range ok");
*exists = false;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
bool
!dns_nsec_typepresent(&rdata, dns_rdatatype_rrsig))
{
dns_rdataset_disassociate(&rdataset);
- return (false);
+ return false;
}
found = true;
}
dns_rdataset_disassociate(&rdataset);
- return (found);
+ return found;
}
rdsiter = NULL;
result = dns_db_allrdatasets(db, node, version, 0, 0, &rdsiter);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
found = found_ns = need_rrsig = false;
for (result = dns_rdatasetiter_first(rdsiter); result == ISC_R_SUCCESS;
dns_rdatasetiter_destroy(&rdsiter);
if (result != ISC_R_NOMORE) {
- return (result);
+ return result;
}
collapse_bitmap:
INSIST(r.length <= DNS_NSEC3_BUFFERSIZE);
dns_rdata_fromregion(rdata, dns_db_class(db), dns_rdatatype_nsec3, &r);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
bool
break;
}
dns_rdata_freestruct(&nsec3);
- return (present);
+ return present;
}
isc_result_t
dns_nsec3_generate_salt(unsigned char *salt, size_t saltlen) {
if (saltlen > 255U) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
isc_nonce_buf(salt, saltlen);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
(int)saltlength, downcased->ndata,
downcased->length);
if (len == 0U) {
- return (DNS_R_BADALG);
+ return DNS_R_BADALG;
}
if (hash_length != NULL) {
/* convert the hex to a domain name */
dns_fixedname_init(result);
- return (dns_name_fromtext(dns_fixedname_name(result), &namebuffer,
- origin, 0, NULL));
+ return dns_name_fromtext(dns_fixedname_name(result), &namebuffer,
+ origin, 0, NULL);
}
unsigned int
dns_nsec3_hashlength(dns_hash_t hash) {
switch (hash) {
case dns_hash_sha1:
- return (ISC_SHA1_DIGESTLENGTH);
+ return ISC_SHA1_DIGESTLENGTH;
}
- return (0);
+ return 0;
}
bool
dns_nsec3_supportedhash(dns_hash_t hash) {
switch (hash) {
case dns_hash_sha1:
- return (true);
+ return true;
}
- return (false);
+ return false;
}
/*%
ISC_LIST_UNLINK(temp_diff.tuples, *tuple, link);
if (result != ISC_R_SUCCESS) {
dns_difftuple_free(tuple);
- return (result);
+ return result;
}
/*
/*
* Do not clear temp_diff.
*/
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
result = dns_db_findnode(db, name, false, &node);
if (result == ISC_R_NOTFOUND) {
*exists = false;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_allrdatasets(db, node, version, 0, (isc_stdtime_t)0,
cleanup_node:
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
static bool
nsec3->salt_length == nsec3param->salt_length &&
!memcmp(nsec3->salt, nsec3param->salt, nsec3->salt_length))
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
/*%
result = dns_db_findnsec3node(db, name, false, &node);
if (result == ISC_R_NOTFOUND) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_init(&rdataset);
cleanup_node:
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
static bool
isc_result_t result;
if (REMOVE(param->data[1])) {
- return (true);
+ return true;
}
dns_rdataset_init(&rdataset);
}
if (CREATE(rdata.data[1]) && !CREATE(param->data[1])) {
dns_rdataset_disassociate(&rdataset);
- return (true);
+ return true;
}
}
dns_rdataset_disassociate(&rdataset);
- return (false);
+ return false;
}
static isc_result_t
}
}
failure:
- return (result);
+ return result;
}
isc_result_t
if (newnode != NULL) {
dns_db_detachnode(db, &newnode);
}
- return (result);
+ return result;
}
/*%
*/
result = dns_db_getoriginnode(db, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_findrdataset(db, node, version,
NULL);
dns_db_detachnode(db, &node);
if (result == ISC_R_NOTFOUND) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
bool
* NSEC3PARAM records from DNSKEY pointers.
*/
if (src->length < 1 || src->data[0] != 0) {
- return (false);
+ return false;
}
isc_buffer_init(&buf1, src->data + 1, src->length - 1);
&buf2);
dns_decompress_invalidate(&dctx);
- return (result == ISC_R_SUCCESS);
+ return result == ISC_R_SUCCESS;
}
void
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
isc_result_t
if (nsec3param->salt_length == 0) {
if (dstlen < 2U) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
strlcpy(dst, "-", dstlen);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
r.base = nsec3param->salt;
result = isc_hex_totext(&r, 2, "", &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (isc_buffer_availablelength(&b) < 1) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint8(&b, 0);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
result = dns_db_getoriginnode(db, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
dns_rdataset_disassociate(&rdataset);
}
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
isc_result_t
*/
result = dns_db_getoriginnode(db, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_findrdataset(db, node, version, type, 0, 0, &prdataset,
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
/*%
result == DNS_R_ZONECUT)
{
*yesno = false;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result == DNS_R_GLUE || result == DNS_R_DNAME ||
result == DNS_R_DELEGATION || result == DNS_R_NXDOMAIN)
{
*yesno = true;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
* Silence compiler.
*/
*yesno = true;
- return (result);
+ return result;
}
isc_result_t
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
isc_result_t
dns_nsec3_delnsec3s(dns_db_t *db, dns_dbversion_t *version,
const dns_name_t *name, dns_diff_t *diff) {
- return (dns_nsec3_delnsec3sx(db, version, name, 0, diff));
+ return dns_nsec3_delnsec3sx(db, version, name, 0, diff);
}
isc_result_t
*/
result = dns_db_getoriginnode(db, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_findrdataset(db, node, version,
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
isc_result_t
dns_nsec3_active(dns_db_t *db, dns_dbversion_t *version, bool complete,
bool *answer) {
- return (dns_nsec3_activex(db, version, complete, 0, answer));
+ return dns_nsec3_activex(db, version, complete, 0, answer);
}
isc_result_t
result = dns_db_getoriginnode(db, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_findrdataset(db, node, version,
if (result != ISC_R_SUCCESS) {
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
for (result = dns_rdataset_first(&rdataset); result == ISC_R_SUCCESS;
result = dns_rdataset_next(&rdataset))
if (result == ISC_R_SUCCESS) {
dns_db_detachnode(db, &node);
*answer = true;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result == ISC_R_NOMORE) {
*answer = false;
if (privatetype == 0 || complete) {
dns_db_detachnode(db, &node);
*answer = false;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = dns_db_findrdataset(db, node, version, privatetype, 0, 0,
&rdataset, NULL);
dns_db_detachnode(db, &node);
if (result == ISC_R_NOTFOUND) {
*answer = false;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (result = dns_rdataset_first(&rdataset); result == ISC_R_SUCCESS;
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
unsigned int
dns_nsec3_maxiterations(void) {
- return (DNS_NSEC3_MAXITERATIONS);
+ return DNS_NSEC3_MAXITERATIONS;
}
isc_result_t
result = dns_rdataset_first(nsec3set);
if (result != ISC_R_SUCCESS) {
(*logit)(arg, ISC_LOG_DEBUG(3), "failure processing NSEC3 set");
- return (result);
+ return result;
}
dns_rdataset_current(nsec3set, &rdata);
result = dns_rdata_tostruct(&rdata, &nsec3, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
(*logit)(arg, ISC_LOG_DEBUG(3), "looking for relevant NSEC3");
* NSEC3 records must have two or more labels to be valid.
*/
if (zlabels < 2) {
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
/*
* If not below the zone name we can ignore this record.
*/
if (!dns_name_issubdomain(name, zone)) {
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
/*
}
if (!dns_name_equal(zone, zonename)) {
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
/*
* Are we only looking for the most enclosing zone?
*/
if (exists == NULL || data == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (unknown != NULL) {
*unknown = true;
}
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
/*
isc_buffer_init(&buffer, owner, sizeof(owner));
result = isc_base32hex_decoderegion(&hashlabel, &buffer);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
* The hash lengths should match. If not ignore the record.
*/
if (isc_buffer_usedlength(&buffer) != nsec3.next_length) {
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
/*
* If there are too many iterations reject the NSEC3 record.
*/
if (nsec3.iterations > DNS_NSEC3_MAXITERATIONS) {
- return (DNS_R_NSEC3ITERRANGE);
+ return DNS_R_NSEC3ITERRANGE;
}
length = isc_iterated_hash(hash, nsec3.hash, nsec3.iterations,
(*logit)(arg, ISC_LOG_DEBUG(3),
"ignoring NSEC bad length %u vs %u", length,
nsec3.next_length);
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
order = memcmp(hash, owner, length);
*/
(*logit)(arg, ISC_LOG_DEBUG(3),
"ignoring parent NSEC3");
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
} else if (atparent && ns && soa) {
/*
*/
(*logit)(arg, ISC_LOG_DEBUG(3),
"ignoring child NSEC3");
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
if (type == dns_rdatatype_cname ||
type == dns_rdatatype_nxt ||
"NSEC3 proves name exists (owner) "
"data=%d",
*data);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
(*logit)(arg, ISC_LOG_DEBUG(3),
"NSEC3 proves CNAME exists");
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
if (order == 0 &&
*/
(*logit)(arg, ISC_LOG_DEBUG(3),
"ignoring parent NSEC3");
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
/*
dns_name_format(qname, namebuf, sizeof(namebuf));
(*logit)(arg, ISC_LOG_DEBUG(3),
"NSEC3 at super-domain %s", namebuf);
- return (answer);
+ return answer;
}
/*
}
first = false;
}
- return (answer);
+ return answer;
}
ntatable->magic = NTATABLE_MAGIC;
*ntatablep = ntatable;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_task:
isc_task_detach(&ntatable->task);
cleanup_ntatable:
isc_mem_put(view->mctx, ntatable, sizeof(*ntatable));
- return (result);
+ return result;
}
void
REQUIRE(VALID_NTA(nta));
if (ntatable->timermgr == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
view = ntatable->view;
if (view->nta_recheck == 0 || lifetime <= view->nta_recheck) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_interval_set(&interval, view->nta_recheck, 0);
if (result != ISC_R_SUCCESS) {
isc_timer_destroy(&nta->timer);
}
- return (result);
+ return result;
}
static isc_result_t
nta->magic = NTA_MAGIC;
*target = nta;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
nta_detach(view->mctx, &nta);
}
- return (result);
+ return result;
}
/*
result = ISC_R_NOTFOUND;
}
- return (result);
+ return result;
}
isc_result_t
result = deletenode(ntatable, name);
RWUNLOCK(&ntatable->rwlock, isc_rwlocktype_write);
- return (result);
+ return result;
}
bool
REQUIRE(dns_name_isabsolute(name));
if (ntatable == NULL) {
- return (false);
+ return false;
}
foundname = dns_fixedname_initname(&fn);
}
RWUNLOCK(&ntatable->rwlock, locktype);
- return (answer);
+ return answer;
}
static isc_result_t
result = isc_buffer_reserve(b, strlen(str));
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_putstr(*b, str);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
cleanup:
dns_rbtnodechain_invalidate(&chain);
RWUNLOCK(&ntatable->rwlock, isc_rwlocktype_read);
- return (result);
+ return result;
}
isc_result_t
RWUNLOCK(&ntatable->rwlock, isc_rwlocktype_read);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
} else {
- return (written ? ISC_R_SUCCESS : ISC_R_NOTFOUND);
+ return written ? ISC_R_SUCCESS : ISC_R_NOTFOUND;
}
}
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_init:
ENGINE_finish(e);
cleanup_rm:
#else
UNUSED(engine);
#endif /* if !defined(OPENSSL_NO_ENGINE) && OPENSSL_API_LEVEL < 30000 */
- return (result);
+ return result;
}
void
break;
}
- return (result);
+ return result;
}
isc_result_t
result = toresult(fallback);
ERR_clear_error();
- return (result);
+ return result;
}
isc_result_t
dst__openssl_toresult2(const char *funcname, isc_result_t fallback) {
- return (dst__openssl_toresult3(DNS_LOGCATEGORY_GENERAL, funcname,
- fallback));
+ return dst__openssl_toresult3(DNS_LOGCATEGORY_GENERAL, funcname,
+ fallback);
}
isc_result_t
done:
ERR_clear_error();
- return (result);
+ return result;
}
#if !defined(OPENSSL_NO_ENGINE) && OPENSSL_API_LEVEL < 30000
ENGINE *
dst__openssl_getengine(const char *engine) {
if (engine == NULL) {
- return (NULL);
+ return NULL;
}
if (e == NULL) {
- return (NULL);
+ return NULL;
}
if (strcmp(engine, ENGINE_get_id(e)) == 0) {
- return (e);
+ return e;
}
- return (NULL);
+ return NULL;
}
#endif /* if !defined(OPENSSL_NO_ENGINE) && OPENSSL_API_LEVEL < 30000 */
* left NULL (in case only the public key is used).
*/
if ((r->n == NULL && n == NULL) || (r->e == NULL && e == NULL)) {
- return (0);
+ return 0;
}
if (n != NULL) {
r->d = d;
}
- return (1);
+ return 1;
}
int
* parameters MUST be non-NULL.
*/
if ((r->p == NULL && p == NULL) || (r->q == NULL && q == NULL)) {
- return (0);
+ return 0;
}
if (p != NULL) {
r->q = q;
}
- return (1);
+ return 1;
}
int
(r->dmq1 == NULL && dmq1 == NULL) ||
(r->iqmp == NULL && iqmp == NULL))
{
- return (0);
+ return 0;
}
if (dmp1 != NULL) {
r->iqmp = iqmp;
}
- return (1);
+ return 1;
}
void
int
RSA_test_flags(const RSA *r, int flags) {
- return (r->flags & flags);
+ return r->flags & flags;
}
#endif /* !HAVE_RSA_SET0_KEY && OPENSSL_VERSION_NUMBER < 0x30000000L */
int
ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s) {
if (r == NULL || s == NULL) {
- return (0);
+ return 0;
}
BN_clear_free(sig->r);
sig->r = r;
sig->s = s;
- return (1);
+ return 1;
}
#endif /* !HAVE_ECDSA_SIG_GET0 */
dh->priv_key = priv_key;
}
- return (1);
+ return 1;
}
void
* parameters MUST be non-NULL. q may remain NULL.
*/
if ((dh->p == NULL && p == NULL) || (dh->g == NULL && g == NULL)) {
- return (0);
+ return 0;
}
if (p != NULL) {
dh->length = BN_num_bits(q);
}
- return (1);
+ return 1;
}
#endif /* !HAVE_DH_GET0_KEY && OPENSSL_VERSION_NUMBER < 0x30000000L */
if (func != NULL) {
*func = &err_empty_string;
}
- return (ERR_get_error_line_data(file, line, data, flags));
+ return ERR_get_error_line_data(file, line, data, flags);
}
#endif /* if !HAVE_ERR_GET_ERROR_ALL */
isc_buffer_availableregion(secret, &r);
if (r.length < len) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
#if OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000
DH_get0_key(dhpub, &pub_key, NULL);
secret_len = DH_compute_key(r.base, pub_key, dhpriv);
if (secret_len <= 0) {
- return (dst__openssl_toresult2("DH_compute_key",
- DST_R_COMPUTESECRETFAILURE));
+ return dst__openssl_toresult2("DH_compute_key",
+ DST_R_COMPUTESECRETFAILURE);
}
#else
ctx = EVP_PKEY_CTX_new_from_pkey(NULL, dhpriv, NULL);
if (ctx == NULL) {
- return (dst__openssl_toresult2("EVP_PKEY_CTX_new_from_pkey",
- DST_R_OPENSSLFAILURE));
+ return dst__openssl_toresult2("EVP_PKEY_CTX_new_from_pkey",
+ DST_R_OPENSSLFAILURE);
}
if (EVP_PKEY_derive_init(ctx) != 1) {
EVP_PKEY_CTX_free(ctx);
- return (dst__openssl_toresult2("EVP_PKEY_derive_init",
- DST_R_OPENSSLFAILURE));
+ return dst__openssl_toresult2("EVP_PKEY_derive_init",
+ DST_R_OPENSSLFAILURE);
}
if (EVP_PKEY_derive_set_peer(ctx, dhpub) != 1) {
EVP_PKEY_CTX_free(ctx);
- return (dst__openssl_toresult2("EVP_PKEY_derive_set_peer",
- DST_R_OPENSSLFAILURE));
+ return dst__openssl_toresult2("EVP_PKEY_derive_set_peer",
+ DST_R_OPENSSLFAILURE);
}
secret_len = r.length;
if (EVP_PKEY_derive(ctx, r.base, &secret_len) != 1 || secret_len == 0) {
EVP_PKEY_CTX_free(ctx);
- return (dst__openssl_toresult2("EVP_PKEY_derive",
- DST_R_COMPUTESECRETFAILURE));
+ return dst__openssl_toresult2("EVP_PKEY_derive",
+ DST_R_COMPUTESECRETFAILURE);
}
EVP_PKEY_CTX_free(ctx);
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
isc_buffer_add(secret, (unsigned int)secret_len);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
dh2 = key2->keydata.dh;
if (dh1 == NULL && dh2 == NULL) {
- return (true);
+ return true;
} else if (dh1 == NULL || dh2 == NULL) {
- return (false);
+ return false;
}
DH_get0_key(dh1, &pub_key1, &priv_key1);
pkey2 = key2->keydata.pkey;
if (pkey1 == NULL && pkey2 == NULL) {
- return (true);
+ return true;
} else if (pkey1 == NULL || pkey2 == NULL) {
- return (false);
+ return false;
}
EVP_PKEY_get_bn_param(pkey1, OSSL_PKEY_PARAM_FFC_P, &p1);
#endif /* OPENSSL_VERSION_NUMBER >= 0x30000000L && OPENSSL_API_LEVEL >= 30000 \
*/
- return (ret);
+ return ret;
}
static bool
dh2 = key2->keydata.dh;
if (dh1 == NULL && dh2 == NULL) {
- return (true);
+ return true;
} else if (dh1 == NULL || dh2 == NULL) {
- return (false);
+ return false;
}
DH_get0_pqg(dh1, &p1, NULL, &g1);
pkey2 = key2->keydata.pkey;
if (pkey1 == NULL && pkey2 == NULL) {
- return (true);
+ return true;
} else if (pkey1 == NULL || pkey2 == NULL) {
- return (false);
+ return false;
}
EVP_PKEY_get_bn_param(pkey1, OSSL_PKEY_PARAM_FFC_P, &p1);
#endif /* OPENSSL_VERSION_NUMBER >= 0x30000000L && OPENSSL_API_LEVEL >= 30000 \
*/
- return (ret);
+ return ret;
}
#if OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000
if (u.fptr != NULL) {
u.fptr(p);
}
- return (1);
+ return 1;
}
#else
static int
int p = EVP_PKEY_CTX_get_keygen_info(ctx, 0);
u.fptr(p);
}
- return (1);
+ return 1;
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
- return (ret);
+ return ret;
}
static bool
DH_get0_key(dh, NULL, &priv_key);
- return (dh != NULL && priv_key != NULL);
+ return dh != NULL && priv_key != NULL;
#else
bool ret;
EVP_PKEY *pkey;
pkey = key->keydata.pkey;
if (pkey == NULL) {
- return (false);
+ return false;
}
ret = (EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_PRIV_KEY,
BN_clear_free(priv_key);
}
- return (ret);
+ return ret;
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
}
isc_region_consume(region, 2);
- return (val);
+ return val;
}
static isc_result_t
#endif /* OPENSSL_VERSION_NUMBER >= 0x30000000L && OPENSSL_API_LEVEL >= 30000 \
*/
- return (ret);
+ return ret;
}
static isc_result_t
isc_buffer_remainingregion(data, &r);
if (r.length == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#if OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000
BN_free(pub_key);
}
- return (ret);
+ return ret;
}
static isc_result_t
isc_result_t result;
if (key->external) {
- return (DST_R_EXTERNALKEY);
+ return DST_R_EXTERNALKEY;
}
#if OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000
if (key->keydata.dh == NULL) {
- return (DST_R_NULLKEY);
+ return DST_R_NULLKEY;
}
dh = key->keydata.dh;
DH_get0_pqg(dh, &p, NULL, &g);
#else
if (key->keydata.pkey == NULL) {
- return (DST_R_NULLKEY);
+ return DST_R_NULLKEY;
}
pkey = key->keydata.pkey;
#endif /* OPENSSL_VERSION_NUMBER >= 0x30000000L && OPENSSL_API_LEVEL >= 30000 \
*/
- return (result);
+ return result;
}
static isc_result_t
/* read private key file */
ret = dst__privstruct_parse(key, DST_ALG_DH, lexer, mctx, &priv);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
if (key->external) {
dst__privstruct_free(&priv, mctx);
isc_safe_memwipe(&priv, sizeof(priv));
- return (ret);
+ return ret;
}
static void
}
*funcp = &openssldh_functions;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (bn2 != NULL) {
if (bn1536 != NULL) {
BN_free(bn1536);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
BN_clear_free(priv);
}
- return (ret);
+ return ret;
}
#endif /* OPENSSL_VERSION_NUMBER >= 0x30000000L && OPENSSL_API_LEVEL >= 30000 \
*/
dctx->ctxdata.evp_md_ctx = evp_md_ctx;
err:
- return (ret);
+ return ret;
}
static void
}
err:
- return (ret);
+ return ret;
}
static int
*buf++ = 0;
}
BN_bn2bin(bn, buf);
- return (size);
+ return size;
}
static isc_result_t
isc_mem_put(dctx->mctx, sigder, sigder_alloced);
}
- return (ret);
+ return ret;
}
static isc_result_t
isc_mem_put(dctx->mctx, sigder, sigder_alloced);
}
- return (ret);
+ return ret;
}
static bool
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
if (pkey1 == NULL && pkey2 == NULL) {
- return (true);
+ return true;
} else if (pkey1 == NULL || pkey2 == NULL) {
- return (false);
+ return false;
}
/* `EVP_PKEY_eq` checks only the public key components and paramters. */
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
- return (ret);
+ return ret;
}
static isc_result_t
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
- return (ret);
+ return ret;
}
static bool
pkey = key->keydata.pkey;
if (pkey == NULL) {
- return (false);
+ return false;
}
#if OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
- return (ret);
+ return ret;
}
static void
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
- return (ret);
+ return ret;
}
static isc_result_t
EC_KEY_free(eckey);
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
- return (ret);
+ return ret;
}
static isc_result_t
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
- return (ret);
+ return ret;
}
#if OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000
pubkey = EC_KEY_get0_public_key(eckey);
if (pubkey != NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (pubeckey != NULL) {
pubkey = EC_KEY_get0_public_key(pubeckey);
if (pubkey == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (EC_KEY_set_public_key(eckey, pubkey) != 1) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
if (EC_KEY_check_key(eckey) == 1) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
#else
static isc_result_t
BN_clear_free(y);
}
- return (ret);
+ return ret;
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
isc_result_t result = ISC_R_SUCCESS;
if (privkey == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (!EC_KEY_set_private_key(eckey, privkey)) {
}
BN_clear_free(privkey);
- return (result);
+ return result;
}
static isc_result_t
*pkey = EVP_PKEY_new();
if (*pkey == NULL) {
- return (dst__openssl_toresult(ISC_R_NOMEMORY));
+ return dst__openssl_toresult(ISC_R_NOMEMORY);
}
if (!EVP_PKEY_set1_EC_KEY(*pkey, eckey)) {
EVP_PKEY_free(*pkey);
*pkey = NULL;
- return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
+ return dst__openssl_toresult(DST_R_OPENSSLFAILURE);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
result = eckey_to_pkey(eckey, &pkey);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
key->keydata.pkey = pkey;
key->key_size = DNS_KEY_ECDSA384SIZE * 4;
}
- return (result);
+ return result;
}
#if OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000
*eckey = EC_KEY_new_by_curve_name(group_nid);
if (*eckey == NULL) {
- return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
+ return dst__openssl_toresult(DST_R_OPENSSLFAILURE);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
dst__privstruct_free(&priv, key->mctx);
isc_safe_memwipe(&priv, sizeof(priv));
- return (ret);
+ return ret;
}
static isc_result_t
UNUSED(pin);
if (engine == NULL || label == NULL) {
- return (DST_R_NOENGINE);
+ return DST_R_NOENGINE;
}
e = dst__openssl_getengine(engine);
if (e == NULL) {
EC_KEY_free(eckey);
}
- return (ret);
+ return ret;
#else
UNUSED(key);
UNUSED(engine);
UNUSED(label);
UNUSED(pin);
- return (DST_R_NOENGINE);
+ return DST_R_NOENGINE;
#endif /* !defined(OPENSSL_NO_ENGINE) && OPENSSL_API_LEVEL < 30000 */
}
if (*funcp == NULL) {
*funcp = &opensslecdsa_functions;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
#endif /* HAVE_OPENSSL_ED448 */
if (pkey_type == EVP_PKEY_NONE) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
ret = (private ? DST_R_INVALIDPRIVATEKEY : DST_R_INVALIDPUBLICKEY);
if (*key_len < len) {
- return (ret);
+ return ret;
}
if (private) {
*pkey = EVP_PKEY_new_raw_public_key(pkey_type, NULL, key, len);
}
if (*pkey == NULL) {
- return (dst__openssl_toresult(ret));
+ return dst__openssl_toresult(ret);
}
*key_len = len;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_allocate(dctx->mctx, &buf, 64);
dctx->ctxdata.generic = buf;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
result = isc_buffer_copyregion(buf, data);
if (result == ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
length = isc_buffer_length(buf) + data->length + 64;
isc_buffer_free(&buf);
dctx->ctxdata.generic = nbuf;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
key->key_alg == DST_ALG_ED448);
if (ctx == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (key->key_alg == DST_ALG_ED25519) {
isc_buffer_free(&buf);
dctx->ctxdata.generic = NULL;
- return (ret);
+ return ret;
}
static isc_result_t
key->key_alg == DST_ALG_ED448);
if (ctx == NULL) {
- return (dst__openssl_toresult(ISC_R_NOMEMORY));
+ return dst__openssl_toresult(ISC_R_NOMEMORY);
}
#if HAVE_OPENSSL_ED25519
isc_buffer_free(&buf);
dctx->ctxdata.generic = NULL;
- return (ret);
+ return ret;
}
static bool
EVP_PKEY *pkey2 = key2->keydata.pkey;
if (pkey1 == NULL && pkey2 == NULL) {
- return (true);
+ return true;
} else if (pkey1 == NULL || pkey2 == NULL) {
- return (false);
+ return false;
}
status = EVP_PKEY_eq(pkey1, pkey2);
if (status == 1) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static isc_result_t
}
#endif /* if HAVE_OPENSSL_ED448 */
if (nid == 0) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
ctx = EVP_PKEY_CTX_new_id(nid, NULL);
if (ctx == NULL) {
- return (dst__openssl_toresult2("EVP_PKEY_CTX_new_id",
- DST_R_OPENSSLFAILURE));
+ return dst__openssl_toresult2("EVP_PKEY_CTX_new_id",
+ DST_R_OPENSSLFAILURE);
}
status = EVP_PKEY_keygen_init(ctx);
err:
EVP_PKEY_CTX_free(ctx);
- return (ret);
+ return ret;
}
static bool
"increase size of 'buf'");
if (pkey == NULL) {
- return (false);
+ return false;
}
/* Must have a buffer to actually check if there is a private key. */
if (EVP_PKEY_get_raw_private_key(pkey, buf, &len) == 1) {
- return (true);
+ return true;
}
/* can check if first error is EC_R_INVALID_PRIVATE_KEY */
while (ERR_get_error() != 0) {
/**/
}
- return (false);
+ return false;
}
static void
isc_buffer_availableregion(data, &r);
if (r.length < len) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
if (EVP_PKEY_get_raw_public_key(pkey, r.base, &len) != 1) {
- return (dst__openssl_toresult(ISC_R_FAILURE));
+ return dst__openssl_toresult(ISC_R_FAILURE);
}
isc_buffer_add(data, len);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_remainingregion(data, &r);
if (r.length == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
len = r.length;
isc_buffer_forward(data, len);
key->keydata.pkey = pkey;
key->key_size = len * 8;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
key->key_alg == DST_ALG_ED448);
if (key->keydata.pkey == NULL) {
- return (DST_R_NULLKEY);
+ return DST_R_NULLKEY;
}
if (key->external) {
priv.nelements = 0;
- return (dst__privstruct_writefile(key, &priv, directory));
+ return dst__privstruct_writefile(key, &priv, directory);
}
i = 0;
if (buf != NULL) {
isc_mem_put(key->mctx, buf, len);
}
- return (ret);
+ return ret;
}
static isc_result_t
eddsa_check(EVP_PKEY *pkey, EVP_PKEY *pubpkey) {
if (pubpkey == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (EVP_PKEY_eq(pkey, pubpkey) == 1) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
static isc_result_t
pub->keydata.pkey = NULL;
dst__privstruct_free(&priv, mctx);
isc_safe_memwipe(&priv, sizeof(priv));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (pub != NULL) {
err:
dst__privstruct_free(&priv, mctx);
isc_safe_memwipe(&priv, sizeof(priv));
- return (ret);
+ return ret;
}
static isc_result_t
}
#endif /* if HAVE_OPENSSL_ED448 */
if (baseid == EVP_PKEY_NONE) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
if (engine == NULL) {
- return (DST_R_NOENGINE);
+ return DST_R_NOENGINE;
}
e = dst__openssl_getengine(engine);
if (e == NULL) {
- return (DST_R_NOENGINE);
+ return DST_R_NOENGINE;
}
pkey = ENGINE_load_private_key(e, label, NULL, NULL);
if (pkey == NULL) {
- return (dst__openssl_toresult2("ENGINE_load_private_key",
- ISC_R_NOTFOUND));
+ return dst__openssl_toresult2("ENGINE_load_private_key",
+ ISC_R_NOTFOUND);
}
if (EVP_PKEY_base_id(pkey) != baseid) {
DST_RET(DST_R_INVALIDPRIVATEKEY);
if (pkey != NULL) {
EVP_PKEY_free(pkey);
}
- return (ret);
+ return ret;
#else /* if !defined(OPENSSL_NO_ENGINE) && OPENSSL_API_LEVEL < 30000 */
UNUSED(key);
UNUSED(engine);
UNUSED(label);
UNUSED(pin);
- return (DST_R_NOENGINE);
+ return DST_R_NOENGINE;
#endif /* if !defined(OPENSSL_NO_ENGINE) && OPENSSL_API_LEVEL < 30000 */
}
if (*funcp == NULL) {
*funcp = &openssleddsa_functions;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#endif /* HAVE_OPENSSL_ED25519 || HAVE_OPENSSL_ED448 */
case DST_ALG_NSEC3RSASHA1:
/* From RFC 3110 */
if (dctx->key->key_size > 4096) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
break;
case DST_ALG_RSASHA256:
/* From RFC 5702 */
if (dctx->key->key_size < 512 || dctx->key->key_size > 4096) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
break;
case DST_ALG_RSASHA512:
/* From RFC 5702 */
if (dctx->key->key_size < 1024 || dctx->key->key_size > 4096) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
break;
default:
evp_md_ctx = EVP_MD_CTX_create();
if (evp_md_ctx == NULL) {
- return (dst__openssl_toresult(ISC_R_NOMEMORY));
+ return dst__openssl_toresult(ISC_R_NOMEMORY);
}
switch (dctx->key->key_alg) {
if (!EVP_DigestInit_ex(evp_md_ctx, type, NULL)) {
EVP_MD_CTX_destroy(evp_md_ctx);
- return (dst__openssl_toresult3(
- dctx->category, "EVP_DigestInit_ex", ISC_R_FAILURE));
+ return dst__openssl_toresult3(
+ dctx->category, "EVP_DigestInit_ex", ISC_R_FAILURE);
}
dctx->ctxdata.evp_md_ctx = evp_md_ctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
evp_md_ctx = dctx->ctxdata.evp_md_ctx;
if (!EVP_DigestUpdate(evp_md_ctx, data->base, data->length)) {
- return (dst__openssl_toresult3(
- dctx->category, "EVP_DigestUpdate", ISC_R_FAILURE));
+ return dst__openssl_toresult3(
+ dctx->category, "EVP_DigestUpdate", ISC_R_FAILURE);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_availableregion(sig, &r);
if (r.length < (unsigned int)EVP_PKEY_size(pkey)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
if (!EVP_SignFinal(evp_md_ctx, r.base, &siglen, pkey)) {
- return (dst__openssl_toresult3(dctx->category, "EVP_SignFinal",
- ISC_R_FAILURE));
+ return dst__openssl_toresult3(dctx->category, "EVP_SignFinal",
+ ISC_R_FAILURE);
}
isc_buffer_add(sig, siglen);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
#if OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000
rsa = EVP_PKEY_get1_RSA(pkey);
if (rsa == NULL) {
- return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
+ return dst__openssl_toresult(DST_R_OPENSSLFAILURE);
}
RSA_get0_key(rsa, NULL, &e, NULL);
if (e == NULL) {
RSA_free(rsa);
- return (dst__openssl_toresult(DST_R_VERIFYFAILURE));
+ return dst__openssl_toresult(DST_R_VERIFYFAILURE);
}
bits = BN_num_bits(e);
RSA_free(rsa);
#else
EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_E, &e);
if (e == NULL) {
- return (dst__openssl_toresult(DST_R_VERIFYFAILURE));
+ return dst__openssl_toresult(DST_R_VERIFYFAILURE);
}
bits = BN_num_bits(e);
BN_free(e);
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
if (bits > maxbits && maxbits != 0) {
- return (DST_R_VERIFYFAILURE);
+ return DST_R_VERIFYFAILURE;
}
status = EVP_VerifyFinal(evp_md_ctx, sig->base, sig->length, pkey);
switch (status) {
case 1:
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
case 0:
- return (dst__openssl_toresult(DST_R_VERIFYFAILURE));
+ return dst__openssl_toresult(DST_R_VERIFYFAILURE);
default:
- return (dst__openssl_toresult3(dctx->category,
- "EVP_VerifyFinal",
- DST_R_VERIFYFAILURE));
+ return dst__openssl_toresult3(dctx->category, "EVP_VerifyFinal",
+ DST_R_VERIFYFAILURE);
}
}
static isc_result_t
opensslrsa_verify(dst_context_t *dctx, const isc_region_t *sig) {
- return (opensslrsa_verify2(dctx, 0, sig));
+ return opensslrsa_verify2(dctx, 0, sig);
}
static bool
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
if (pkey1 == NULL && pkey2 == NULL) {
- return (true);
+ return true;
} else if (pkey1 == NULL || pkey2 == NULL) {
- return (false);
+ return false;
}
/* `EVP_PKEY_eq` checks only the public key components and paramters. */
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
- return (ret);
+ return ret;
}
#if OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000
if (u.fptr != NULL) {
u.fptr(p);
}
- return (1);
+ return 1;
}
#else
static int
int p = EVP_PKEY_CTX_get_keygen_info(ctx, 0);
u.fptr(p);
}
- return (1);
+ return 1;
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
if (e != NULL) {
BN_free(e);
}
- return (ret);
+ return ret;
}
static bool
pkey = key->keydata.pkey;
if (pkey == NULL) {
- return (false);
+ return false;
}
#if OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
- return (ret);
+ return ret;
}
static void
BN_free(n);
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
- return (ret);
+ return ret;
}
static isc_result_t
EVP_PKEY_free(pkey);
}
- return (ret);
+ return ret;
}
static isc_result_t
}
if (key->external) {
- return (dst__privstruct_writefile(key, &priv, directory));
+ return dst__privstruct_writefile(key, &priv, directory);
}
pkey = key->keydata.pkey;
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
- return (ret);
+ return ret;
}
#if OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000
RSA_get0_key(pub, &n2, &e2, NULL);
if (n1 != NULL) {
if (BN_cmp(n1, n2) != 0) {
- return (DST_R_INVALIDPRIVATEKEY);
+ return DST_R_INVALIDPRIVATEKEY;
}
} else {
n = BN_dup(n2);
if (n == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
}
if (e1 != NULL) {
if (n != NULL) {
BN_free(n);
}
- return (DST_R_INVALIDPRIVATEKEY);
+ return DST_R_INVALIDPRIVATEKEY;
}
} else {
e = BN_dup(e2);
if (n != NULL) {
BN_free(n);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
}
if (RSA_set0_key(rsa, n, e, NULL) == 0) {
RSA_get0_key(rsa, &n1, &e1, NULL);
if (n1 == NULL || e1 == NULL) {
- return (DST_R_INVALIDPRIVATEKEY);
+ return DST_R_INVALIDPRIVATEKEY;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#else
static isc_result_t
BN_free(e2);
}
- return (ret);
+ return ret;
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
dst__privstruct_free(&priv, mctx);
isc_safe_memwipe(&priv, sizeof(priv));
- return (ret);
+ return ret;
}
static isc_result_t
if (pubpkey != NULL) {
EVP_PKEY_free(pubpkey);
}
- return (ret);
+ return ret;
#else /* if !defined(OPENSSL_NO_ENGINE) && OPENSSL_API_LEVEL < 30000 */
UNUSED(key);
UNUSED(engine);
UNUSED(label);
UNUSED(pin);
- return (DST_R_NOENGINE);
+ return DST_R_NOENGINE;
#endif /* if !defined(OPENSSL_NO_ENGINE) && OPENSSL_API_LEVEL < 30000 */
}
EVP_MD_CTX_destroy(evp_md_ctx);
}
ERR_clear_error();
- return (ret);
+ return ret;
}
isc_result_t
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
isc_mem_attach(mctx, &order->mctx);
order->magic = DNS_ORDER_MAGIC;
*orderp = order;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
ent->mode = mode;
ISC_LINK_INIT(ent, link);
ISC_LIST_INITANDAPPEND(order->ents, ent, link);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
match(const dns_name_t *name1, const dns_name_t *name2) {
if (dns_name_iswildcard(name2)) {
- return (dns_name_matcheswildcard(name1, name2));
+ return dns_name_matcheswildcard(name1, name2);
}
- return (dns_name_equal(name1, name2));
+ return dns_name_equal(name1, name2);
}
unsigned int
continue;
}
if (match(name, dns_fixedname_name(&ent->name))) {
- return (ent->mode);
+ return ent->mode;
}
}
- return (DNS_RDATASETATTR_NONE);
+ return DNS_RDATASETATTR_NONE;
}
void
*list = l;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
res = ISC_R_NOTFOUND;
}
- return (res);
+ return res;
}
isc_result_t
dns_peer_attach(p, retval);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
UNREACHABLE();
}
- return (dns_peer_newprefix(mem, addr, prefixlen, peerptr));
+ return dns_peer_newprefix(mem, addr, prefixlen, peerptr);
}
isc_result_t
*peerptr = peer;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
peer->bogus = newval;
DNS_BIT_SET(BOGUS_BIT, &peer->bitflags);
- return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
+ return existed ? ISC_R_EXISTS : ISC_R_SUCCESS;
}
isc_result_t
if (DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags)) {
*retval = peer->bogus;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
peer->provide_ixfr = newval;
DNS_BIT_SET(PROVIDE_IXFR_BIT, &peer->bitflags);
- return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
+ return existed ? ISC_R_EXISTS : ISC_R_SUCCESS;
}
isc_result_t
if (DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags)) {
*retval = peer->provide_ixfr;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
peer->request_ixfr = newval;
DNS_BIT_SET(REQUEST_IXFR_BIT, &peer->bitflags);
- return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
+ return existed ? ISC_R_EXISTS : ISC_R_SUCCESS;
}
isc_result_t
if (DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags)) {
*retval = peer->request_ixfr;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
peer->support_edns = newval;
DNS_BIT_SET(SUPPORT_EDNS_BIT, &peer->bitflags);
- return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
+ return existed ? ISC_R_EXISTS : ISC_R_SUCCESS;
}
isc_result_t
if (DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags)) {
*retval = peer->support_edns;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
peer->request_nsid = newval;
DNS_BIT_SET(REQUEST_NSID_BIT, &peer->bitflags);
- return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
+ return existed ? ISC_R_EXISTS : ISC_R_SUCCESS;
}
isc_result_t
if (DNS_BIT_CHECK(REQUEST_NSID_BIT, &peer->bitflags)) {
*retval = peer->request_nsid;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
peer->send_cookie = newval;
DNS_BIT_SET(SEND_COOKIE_BIT, &peer->bitflags);
- return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
+ return existed ? ISC_R_EXISTS : ISC_R_SUCCESS;
}
isc_result_t
if (DNS_BIT_CHECK(SEND_COOKIE_BIT, &peer->bitflags)) {
*retval = peer->send_cookie;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
peer->request_expire = newval;
DNS_BIT_SET(REQUEST_EXPIRE_BIT, &peer->bitflags);
- return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
+ return existed ? ISC_R_EXISTS : ISC_R_SUCCESS;
}
isc_result_t
if (DNS_BIT_CHECK(REQUEST_EXPIRE_BIT, &peer->bitflags)) {
*retval = peer->request_expire;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
peer->force_tcp = newval;
DNS_BIT_SET(FORCE_TCP_BIT, &peer->bitflags);
- return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
+ return existed ? ISC_R_EXISTS : ISC_R_SUCCESS;
}
isc_result_t
if (DNS_BIT_CHECK(FORCE_TCP_BIT, &peer->bitflags)) {
*retval = peer->force_tcp;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
peer->tcp_keepalive = newval;
DNS_BIT_SET(REQUEST_TCP_KEEPALIVE_BIT, &peer->bitflags);
- return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
+ return existed ? ISC_R_EXISTS : ISC_R_SUCCESS;
}
isc_result_t
if (DNS_BIT_CHECK(REQUEST_TCP_KEEPALIVE_BIT, &peer->bitflags)) {
*retval = peer->tcp_keepalive;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
peer->transfers = newval;
DNS_BIT_SET(TRANSFERS_BIT, &peer->bitflags);
- return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
+ return existed ? ISC_R_EXISTS : ISC_R_SUCCESS;
}
isc_result_t
if (DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags)) {
*retval = peer->transfers;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
peer->transfer_format = newval;
DNS_BIT_SET(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags);
- return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
+ return existed ? ISC_R_EXISTS : ISC_R_SUCCESS;
}
isc_result_t
if (DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags)) {
*retval = peer->transfer_format;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
*retval = peer->key;
}
- return (peer->key == NULL ? ISC_R_NOTFOUND : ISC_R_SUCCESS);
+ return peer->key == NULL ? ISC_R_NOTFOUND : ISC_R_SUCCESS;
}
isc_result_t
peer->key = *keyval;
*keyval = NULL;
- return (exists ? ISC_R_EXISTS : ISC_R_SUCCESS);
+ return exists ? ISC_R_EXISTS : ISC_R_SUCCESS;
}
isc_result_t
result = dns_name_fromtext(dns_fixedname_name(&fname), &b, dns_rootname,
0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
name = isc_mem_get(peer->mem, sizeof(dns_name_t));
isc_mem_put(peer->mem, name, sizeof(dns_name_t));
}
- return (result);
+ return result;
}
isc_result_t
*peer->transfer_source = *transfer_source;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(transfer_source != NULL);
if (peer->transfer_source == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
*transfer_source = *peer->transfer_source;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
*peer->notify_source = *notify_source;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(notify_source != NULL);
if (peer->notify_source == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
*notify_source = *peer->notify_source;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
*peer->query_source = *query_source;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(query_source != NULL);
if (peer->query_source == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
*query_source = *peer->query_source;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
peer->udpsize = udpsize;
DNS_BIT_SET(SERVER_UDPSIZE_BIT, &peer->bitflags);
- return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
+ return existed ? ISC_R_EXISTS : ISC_R_SUCCESS;
}
isc_result_t
if (DNS_BIT_CHECK(SERVER_UDPSIZE_BIT, &peer->bitflags)) {
*udpsize = peer->udpsize;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
peer->maxudp = maxudp;
DNS_BIT_SET(SERVER_MAXUDP_BIT, &peer->bitflags);
- return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
+ return existed ? ISC_R_EXISTS : ISC_R_SUCCESS;
}
isc_result_t
if (DNS_BIT_CHECK(SERVER_MAXUDP_BIT, &peer->bitflags)) {
*maxudp = peer->maxudp;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
peer->padding = padding;
DNS_BIT_SET(SERVER_PADDING_BIT, &peer->bitflags);
- return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
+ return existed ? ISC_R_EXISTS : ISC_R_SUCCESS;
}
isc_result_t
if (DNS_BIT_CHECK(SERVER_PADDING_BIT, &peer->bitflags)) {
*padding = peer->padding;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
peer->ednsversion = ednsversion;
DNS_BIT_SET(EDNS_VERSION_BIT, &peer->bitflags);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (DNS_BIT_CHECK(EDNS_VERSION_BIT, &peer->bitflags)) {
*ednsversion = peer->ednsversion;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
* doesn't matter if we are removing this one.
*/
if (CREATE(rdata.data[1])) {
- return (false);
+ return false;
}
if (rdata.data[0] != param->data[0] ||
rdata.data[2] != param->data[2] ||
* the caller that it will be removed.
*/
if (NONSEC(rdata.data[1])) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
- return (false);
+ return false;
}
isc_result_t
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
isc_result_t
isc_result_t result;
if (private->length < 5) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (private->data[0] == 0) {
snprintf(keybuf, sizeof(keybuf), "key %d/%s", keyid, algbuf);
isc_buffer_putstr(buf, keybuf);
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
isc_buffer_putuint8(buf, 0);
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
hash_32(uint32_t val, unsigned int bits) {
REQUIRE(bits <= RBT_HASH_MAX_BITS);
/* High bits are more random. */
- return (val * GOLDEN_RATIO_32 >> (32 - bits));
+ return val * GOLDEN_RATIO_32 >> (32 - bits);
}
struct dns_rbt {
NODENAME(node, &name);
}
- return (name);
+ return name;
}
#endif /* DEBUG */
*/
static dns_rbtnode_t *
get_upper_node(dns_rbtnode_t *node) {
- return (UPPERNODE(node));
+ return UPPERNODE(node);
}
size_t
node = PARENT(node);
}
- return (nodes);
+ return nodes;
}
/*
node = get_upper_node(node);
} while (!dns_name_isabsolute(¤t));
- return (len);
+ return len;
}
unsigned int
dns__rbtnode_getsize(dns_rbtnode_t *node) {
REQUIRE(DNS_RBTNODE_VALID(node));
- return (NODE_SIZE(node));
+ return NODE_SIZE(node);
}
/*
*rbtp = rbt;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
deletetreeflat(rbt, quantum, false, &rbt->root);
if (rbt->root != NULL) {
- return (ISC_R_QUOTA);
+ return ISC_R_QUOTA;
}
*rbtp = NULL;
rbt->magic = 0;
isc_mem_putanddetach(&rbt->mctx, rbt, sizeof(*rbt));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
unsigned int
dns_rbt_nodecount(dns_rbt_t *rbt) {
REQUIRE(VALID_RBT(rbt));
- return (rbt->nodecount);
+ return rbt->nodecount;
}
size_t
? rbt->hashbits[0]
: rbt->hashbits[1];
- return (1 << hashbits);
+ return 1 << hashbits;
}
static isc_result_t
result = dns_name_concatenate(name, &nodename, name, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
- return (result);
+ return result;
}
static isc_result_t
chain->end = node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
*nodep = new_current;
hash_node(rbt, new_current, name);
}
- return (result);
+ return result;
}
level_count = 0;
* a new level.
*/
*nodep = new_current;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
/*
* The current node has no data,
hash_node(rbt, new_current, name);
}
- return (result);
+ return result;
}
/*
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
/*
}
if (rbt->root == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
chain, callback_name, false);
if (result != ISC_R_SUCCESS) {
dns_rbtnodechain_reset(chain);
- return (result);
+ return result;
}
result = (callback)(current,
ENSURE(*node == NULL || DNS_RBTNODE_VALID(*node));
- return (result);
+ return result;
}
/*
result = ISC_R_NOTFOUND;
}
- return (result);
+ return result;
}
/*
result = ISC_R_NOTFOUND;
}
- return (result);
+ return result;
}
/*
* of the comment at the start of this function).
* But join_nodes() function has now been removed.
*/
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
/*
* This function never fails.
*/
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
node = get_upper_node(node);
} while (!dns_name_isabsolute(name));
- return (result);
+ return result;
}
char *
isc_result_totext(result));
}
- return (printname);
+ return printname;
}
static isc_result_t
#endif /* if DNS_RBT_USEMAGIC */
*nodep = node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
newbits += 1;
}
- return (newbits);
+ return newbits;
}
/*
static bool
rehashing_in_progress(dns_rbt_t *rbt) {
- return (rbt->hashtable[RBT_HASH_NEXTTABLE(rbt->hindex)] != NULL);
+ return rbt->hashtable[RBT_HASH_NEXTTABLE(rbt->hindex)] != NULL;
}
static bool
hashtable_is_overcommited(dns_rbt_t *rbt) {
- return (rbt->nodecount >=
- (HASHSIZE(rbt->hashbits[rbt->hindex]) * RBT_HASH_OVERCOMMIT));
+ return rbt->nodecount >=
+ (HASHSIZE(rbt->hashbits[rbt->hindex]) * RBT_HASH_OVERCOMMIT);
}
/*
size_t this_height, down_height;
if (node == NULL) {
- return (0);
+ return 0;
}
dl = getheight_helper(LEFT(node));
this_height = ISC_MAX(dl + 1, dr + 1);
down_height = getheight_helper(DOWN(node));
- return (ISC_MAX(this_height, down_height));
+ return ISC_MAX(this_height, down_height);
}
size_t
dns__rbt_getheight(dns_rbt_t *rbt) {
- return (getheight_helper(rbt->root));
+ return getheight_helper(rbt->root);
}
static bool
check_properties_helper(dns_rbtnode_t *node) {
if (node == NULL) {
- return (true);
+ return true;
}
if (IS_RED(node)) {
/* Root nodes must be BLACK. */
if (IS_ROOT(node)) {
- return (false);
+ return false;
}
/* Both children of RED nodes must be BLACK. */
if (IS_RED(LEFT(node)) || IS_RED(RIGHT(node))) {
- return (false);
+ return false;
}
}
if ((DOWN(node) != NULL) && (!IS_ROOT(DOWN(node)))) {
- return (false);
+ return false;
}
if (IS_ROOT(node)) {
if ((PARENT(node) != NULL) && (DOWN(PARENT(node)) != node)) {
- return (false);
+ return false;
}
if (get_upper_node(node) != PARENT(node)) {
- return (false);
+ return false;
}
}
if (((!PARENT(node)) || (DOWN(PARENT(node)) == node)) &&
(!IS_ROOT(node)))
{
- return (false);
+ return false;
}
/* Repeat tests with this node's children. */
- return (check_properties_helper(LEFT(node)) &&
- check_properties_helper(RIGHT(node)) &&
- check_properties_helper(DOWN(node)));
+ return check_properties_helper(LEFT(node)) &&
+ check_properties_helper(RIGHT(node)) &&
+ check_properties_helper(DOWN(node));
}
static bool
if (node == NULL) {
*distance = 1;
- return (true);
+ return true;
}
if (!check_black_distance_helper(LEFT(node), &dl)) {
- return (false);
+ return false;
}
if (!check_black_distance_helper(RIGHT(node), &dr)) {
- return (false);
+ return false;
}
if (!check_black_distance_helper(DOWN(node), &dd)) {
- return (false);
+ return false;
}
/* Left and right side black node counts must match. */
if (dl != dr) {
- return (false);
+ return false;
}
if (IS_BLACK(node)) {
*distance = dl;
- return (true);
+ return true;
}
bool
size_t dd;
if (!check_properties_helper(rbt->root)) {
- return (false);
+ return false;
}
/* Path from a given node to all its leaves must contain the
* here instead of inside check_properties_helper() as
* it would take (n log n) complexity otherwise.
*/
- return (check_black_distance_helper(rbt->root, &dd));
+ return check_black_distance_helper(rbt->root, &dd);
}
static void
unsigned int l, r, d;
if (node == NULL) {
- return (0);
+ return 0;
}
l = print_dot_helper(LEFT(node), nodecount, show_pointers, f);
fprintf(f, "\"node%u\":f2 -> \"node%u\":f1;\n", *nodecount, r);
}
- return (*nodecount);
+ return *nodecount;
}
void
}
if (chain->end == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (name != NULL) {
}
}
- return (result);
+ return result;
}
isc_result_t
result = ISC_R_NOMORE;
}
- return (result);
+ return result;
}
isc_result_t
result = ISC_R_NOMORE;
}
- return (result);
+ return result;
}
isc_result_t
result = ISC_R_NOMORE;
}
- return (result);
+ return result;
}
isc_result_t
result = ISC_R_NOMORE;
}
- return (result);
+ return result;
}
isc_result_t
result = DNS_R_NEWORIGIN;
}
- return (result);
+ return result;
}
isc_result_t
result = move_chain_to_last(chain, rbt->root);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_rbtnodechain_current(chain, name, origin, NULL);
result = DNS_R_NEWORIGIN;
}
- return (result);
+ return result;
}
void
hash_32(uint32_t val, unsigned int bits) {
REQUIRE(bits <= RBTDB_GLUE_TABLE_MAX_BITS);
/* High bits are more random. */
- return (val * GOLDEN_RATIO_32 >> (32 - bits));
+ return val * GOLDEN_RATIO_32 >> (32 - bits);
}
#define EXPIREDOK(rbtiterator) \
static bool
do_stats(rdatasetheader_t *header) {
- return (EXISTS(header) && STATCOUNT(header));
+ return EXISTS(header) && STATCOUNT(header);
}
static void
case RBTDB_RDATATYPE_VALUE(dns_rdatatype_rrsig, dns_rdatatype_ptr):
case dns_rdatatype_naptr:
case RBTDB_RDATATYPE_VALUE(dns_rdatatype_rrsig, dns_rdatatype_naptr):
- return (true);
+ return true;
}
- return (false);
+ return false;
}
/*%
rdatasetheader_t *h1 = v1;
rdatasetheader_t *h2 = v2;
- return (h1->rdh_ttl < h2->rdh_ttl);
+ return h1->rdh_ttl < h2->rdh_ttl;
}
/*%
rdatasetheader_t *h1 = v1;
rdatasetheader_t *h2 = v2;
- return (h1->resign < h2->resign ||
- (h1->resign == h2->resign && h1->resign_lsb < h2->resign_lsb) ||
- (h1->resign == h2->resign && h1->resign_lsb == h2->resign_lsb &&
- h2->type == RBTDB_RDATATYPE_SIGSOA));
+ return h1->resign < h2->resign ||
+ (h1->resign == h2->resign && h1->resign_lsb < h2->resign_lsb) ||
+ (h1->resign == h2->resign && h1->resign_lsb == h2->resign_lsb &&
+ h2->type == RBTDB_RDATATYPE_SIGSOA);
}
/*%
if (old > 1000) {
old = 1000;
}
- return (old);
+ return old;
}
nodes = old * interval;
nodes /= (unsigned int)usecs;
"adjust_quantum: old=%d, new=%d", old, nodes);
}
- return (nodes);
+ return nodes;
}
static void
ISC_LIST_INIT(version->resigned_list);
ISC_LINK_INIT(version, link);
- return (version);
+ return version;
}
static isc_result_t
*versionp = version;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
- return (changed);
+ return changed;
}
static void
memset(h->upper, 0xeb, sizeof(h->upper));
init_rdataset(rbtdb, h);
h->rdh_ttl = 0;
- return (h);
+ return h;
}
static void
*/
static bool
is_last_node_on_its_level(dns_rbtnode_t *node) {
- return (node->parent != NULL && node->parent->down == node &&
- node->left == NULL && node->right == NULL);
+ return node->parent != NULL && node->parent->down == node &&
+ node->left == NULL && node->right == NULL;
}
static void
if (isc_refcount_decrement(&node->references) == 1) {
refs = isc_refcount_decrement(&nodelock->references);
INSIST(refs > 0);
- return (true);
+ return true;
} else {
- return (false);
+ return false;
}
}
if (nlock == isc_rwlocktype_read) {
NODE_DOWNGRADE(&nodelock->lock);
}
- return (false);
+ return false;
}
if (node->dirty) {
}
}
- return (no_reference);
+ return no_reference;
}
/*
dns_name_getlabelsequence(name, 1, n, &foundname);
result = dns_rbt_addnode(rbtdb->tree, &foundname, &node);
if (result != ISC_R_SUCCESS && result != ISC_R_EXISTS) {
- return (result);
+ return result;
}
if (result == ISC_R_SUCCESS) {
node->nsec = DNS_RBT_NSEC_NORMAL;
NODE_UNLOCK(&rbtdb->node_locks[node->locknum].lock,
isc_rwlocktype_write);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (dns_name_iswildcard(&foundname)) {
result = add_wildcard_magic(rbtdb, &foundname, lock);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_rbt_addnode(rbtdb->tree, &foundname,
&node);
if (result != ISC_R_SUCCESS && result != ISC_R_EXISTS) {
- return (result);
+ return result;
}
if (result == ISC_R_SUCCESS) {
node->nsec = DNS_RBT_NSEC_NORMAL;
}
i++;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
if (result == DNS_R_PARTIALMATCH) {
result = ISC_R_NOTFOUND;
}
- return (result);
+ return result;
}
/*
* It would be nice to try to upgrade the lock instead of
if (result != ISC_R_SUCCESS) {
RWUNLOCK(&rbtdb->tree_lock,
locktype);
- return (result);
+ return result;
}
}
}
}
} else if (result != ISC_R_EXISTS) {
RWUNLOCK(&rbtdb->tree_lock, locktype);
- return (result);
+ return result;
}
}
*nodep = (dns_dbnode_t *)node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(VALID_RBTDB(rbtdb));
- return (findnodeintree(rbtdb, rbtdb->tree, name, create, nodep));
+ return findnodeintree(rbtdb, rbtdb->tree, name, create, nodep);
}
static isc_result_t
REQUIRE(VALID_RBTDB(rbtdb));
- return (findnodeintree(rbtdb, rbtdb->nsec3, name, create, nodep));
+ return findnodeintree(rbtdb, rbtdb->nsec3, name, create, nodep);
}
static isc_result_t
* zonecut.
*/
if (search->zonecut != NULL) {
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
found = NULL;
NODE_UNLOCK(&(search->rbtdb->node_locks[node->locknum].lock),
isc_rwlocktype_read);
- return (result);
+ return result;
}
static void
}
if (type == dns_rdatatype_dname) {
- return (DNS_R_DNAME);
+ return DNS_R_DNAME;
}
- return (DNS_R_DELEGATION);
+ return DNS_R_DELEGATION;
}
static bool
*/
if (type == dns_rdatatype_ns) {
if (node != search->zonecut) {
- return (false);
+ return false;
}
} else if (type != dns_rdatatype_a && type != dns_rdatatype_aaaa &&
type != dns_rdatatype_a6)
{
- return (false);
+ return false;
}
header = search->zonecut_rdataset;
}
}
- return (valid);
+ return valid;
}
static bool
if (result == ISC_R_SUCCESS && dns_name_issubdomain(next, name)) {
answer = true;
}
- return (answer);
+ return answer;
}
static bool
n = dns_name_countlabels(&rname);
dns_name_getlabelsequence(&rname, 1, n - 1, &rname);
} while (!dns_name_equal(&rname, &tname));
- return (answer);
+ return answer;
}
static isc_result_t
if (activeemptynode(search, qname,
wname))
{
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
* The wildcard node is active!
}
} while (!done);
- return (result);
+ return result;
}
static bool
memcmp(nsec3.salt, search->rbtversion->salt,
nsec3.salt_length) == 0)
{
- return (true);
+ return true;
}
dns_rdata_reset(&rdata);
}
- return (false);
+ return false;
}
/*
if (type == dns_rdatatype_nsec3) {
result = dns_rbtnodechain_prev(&search->chain, NULL, NULL);
if (result != ISC_R_SUCCESS && result != DNS_R_NEWORIGIN) {
- return (result);
+ return result;
}
result = dns_rbtnodechain_current(&search->chain, name, origin,
nodep);
- return (result);
+ return result;
}
target = dns_fixedname_initname(&ftarget);
result = dns_name_concatenate(name, origin, target,
NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
nsecnode = NULL;
result = dns_rbt_findnode(
}
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
*/
result = dns_name_concatenate(name, origin, target, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
*nodep = NULL;
nodep, &search->chain,
DNS_RBTFIND_EMPTYDATA, NULL, NULL);
if (result == ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
DNS_LOGMODULE_CACHE, ISC_LOG_ERROR,
"previous_closest_nsec(): %s",
isc_result_totext(result));
- return (DNS_R_BADDB);
+ return DNS_R_BADDB;
}
}
}
prevnode = NULL;
result = dns_rbtnodechain_current(&search->chain, name, origin, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
do {
NODE_LOCK(&(search->rbtdb->node_locks[node->locknum].lock),
result = DNS_R_BADDB;
}
- return (result);
+ return result;
}
static isc_result_t
dns_rbtnodechain_reset(&search.chain);
- return (result);
+ return result;
}
static isc_result_t
FATAL_ERROR("zone_findzonecut() called!");
UNREACHABLE();
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static bool
*/
RDATASET_ATTR_SET(header,
RDATASET_ATTR_STALE_WINDOW);
- return (false);
+ return false;
} else if ((search->options &
DNS_DBFIND_STALETIMEOUT) != 0)
{
* We want stale RRset due to timeout, so we
* don't skip it.
*/
- return (false);
+ return false;
}
- return ((search->options & DNS_DBFIND_STALEOK) == 0);
+ return (search->options & DNS_DBFIND_STALEOK) == 0;
}
/*
} else {
*header_prev = header;
}
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static isc_result_t
NODE_UNLOCK(lock, locktype);
- return (result);
+ return result;
}
static isc_result_t
}
} while (!done);
- return (result);
+ return result;
}
/*
&chain, DNS_RBTFIND_EMPTYDATA, NULL, NULL);
if (result != DNS_R_PARTIALMATCH) {
dns_rbtnodechain_reset(&chain);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
prefix = dns_fixedname_initname(&fprefix);
result = dns_rbtnodechain_current(&chain, prefix, origin, NULL);
dns_rbtnodechain_reset(&chain);
if (result != ISC_R_SUCCESS && result != DNS_R_NEWORIGIN) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
result = dns_name_concatenate(prefix, origin, target, NULL);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
result = dns_rbt_findnode(search->rbtdb->tree, target, fname, &node,
NULL, DNS_RBTFIND_EMPTYDATA, NULL, NULL);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
lock = &(search->rbtdb->node_locks[node->locknum].lock);
result = ISC_R_NOTFOUND;
}
NODE_UNLOCK(lock, locktype);
- return (result);
+ return result;
}
static isc_result_t
dns_rbtnodechain_reset(&search.chain);
update_cachestats(search.rbtdb, result);
- return (result);
+ return result;
}
static isc_result_t
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
static void
NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
isc_rwlocktype_write);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
*iteratorp = (dns_dbiterator_t *)rbtdbiter;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
}
if (found == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
NODE_UNLOCK(lock, locktype);
if (found == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (NEGATIVE(found)) {
update_cachestats(rbtdb, result);
- return (result);
+ return result;
}
static isc_result_t
*iteratorp = (dns_rdatasetiter_t *)iterator;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
* with the priority list, we know there will not be
* CNAME, so we are safe to skip the rest of the types.
*/
- return (false);
+ return false;
}
if (header->type == dns_rdatatype_cname) {
/*
}
}
if (cname && other_data) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static void
static uint64_t
recordsize(rdatasetheader_t *header, unsigned int namelen) {
- return (dns_rdataslab_rdatasize((unsigned char *)header,
- sizeof(*header)) +
- sizeof(dns_ttl_t) + sizeof(dns_rdatatype_t) +
- sizeof(dns_rdataclass_t) + namelen);
+ return dns_rdataslab_rdatasize((unsigned char *)header,
+ sizeof(*header)) +
+ sizeof(dns_ttl_t) + sizeof(dns_rdatatype_t) +
+ sizeof(dns_rdataclass_t) + namelen;
}
static void
static bool
overmaxtype(dns_rbtdb_t *rbtdb, uint32_t ntypes) {
if (rbtdb->maxtypepername == 0) {
- return (false);
+ return false;
}
- return (ntypes >= rbtdb->maxtypepername);
+ return ntypes >= rbtdb->maxtypepername;
}
static bool
prio_header(rdatasetheader_t *header) {
if (NEGATIVE(header) && prio_type(RBTDB_RDATATYPE_EXT(header->type))) {
- return (true);
+ return true;
}
- return (prio_type(header->type));
+ return prio_type(header->type);
}
/*
changed = add_changed(rbtdb, rbtversion, rbtnode);
if (changed == NULL) {
free_rdataset(rbtdb, rbtdb->common.mctx, newheader);
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
}
isc_rwlocktype_write,
addedrdataset);
}
- return (DNS_R_UNCHANGED);
+ return DNS_R_UNCHANGED;
}
/*
* The new rdataset is better. Expire the
*/
if (header_nx && newheader_nx) {
free_rdataset(rbtdb, rbtdb->common.mctx, newheader);
- return (DNS_R_UNCHANGED);
+ return DNS_R_UNCHANGED;
}
/*
isc_rwlocktype_write,
addedrdataset);
}
- return (DNS_R_UNCHANGED);
+ return DNS_R_UNCHANGED;
}
/*
} else {
free_rdataset(rbtdb, rbtdb->common.mctx,
newheader);
- return (result);
+ return result;
}
}
/*
isc_rwlocktype_write,
addedrdataset);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
* If we have will be replacing a NS RRset force its TTL
isc_rwlocktype_write,
addedrdataset);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
INSIST(rbtversion == NULL ||
rbtversion->serial >= topheader->serial);
*/
if (newheader_nx) {
free_rdataset(rbtdb, rbtdb->common.mctx, newheader);
- return (DNS_R_UNCHANGED);
+ return DNS_R_UNCHANGED;
}
idx = newheader->node->locknum;
if (!IS_CACHE(rbtdb) && overmaxtype(rbtdb, ntypes)) {
free_rdataset(rbtdb, rbtdb->common.mctx,
newheader);
- return (DNS_R_TOOMANYRECORDS);
+ return DNS_R_TOOMANYRECORDS;
}
newheader->down = NULL;
if (rbtversion != NULL &&
cname_and_other_data(rbtnode, rbtversion->serial))
{
- return (DNS_R_CNAMEANDOTHER);
+ return DNS_R_CNAMEANDOTHER;
}
if (addedrdataset != NULL) {
isc_rwlocktype_write, addedrdataset);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
rbtdb_rdatatype_t type) {
if (IS_CACHE(rbtdb)) {
if (type == dns_rdatatype_dname) {
- return (true);
+ return true;
} else {
- return (false);
+ return false;
}
} else if (type == dns_rdatatype_dname ||
(type == dns_rdatatype_ns &&
(node != rbtdb->origin_node || IS_STUB(rbtdb))))
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static isc_result_t
dns_rdataset_disassociate(&neg);
dns_rdataset_disassociate(&negsig);
newheader->noqname = noqname;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_rdataset_disassociate(&neg);
dns_rdataset_disassociate(&negsig);
free_noqname(mctx, &noqname);
- return (result);
+ return result;
}
static isc_result_t
dns_rdataset_disassociate(&neg);
dns_rdataset_disassociate(&negsig);
newheader->closest = closest;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_rdataset_disassociate(&neg);
dns_rdataset_disassociate(&negsig);
free_noqname(mctx, &closest);
- return (result);
+ return result;
}
static dns_dbmethods_t zone_methods;
static size_t
rdataset_size(rdatasetheader_t *header) {
if (!NONEXISTENT(header)) {
- return (dns_rdataslab_size((unsigned char *)header,
- sizeof(*header)));
+ return dns_rdataslab_size((unsigned char *)header,
+ sizeof(*header));
}
- return (sizeof(*header));
+ return sizeof(*header);
}
static void
if (rdataset->type == dns_rdatatype_soa &&
node != rbtdb->origin_node)
{
- return (DNS_R_NOTZONETOP);
+ return DNS_R_NOTZONETOP;
}
RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
- REQUIRE(((rbtnode->nsec == DNS_RBT_NSEC_NSEC3 &&
- (rdataset->type == dns_rdatatype_nsec3 ||
- rdataset->covers == dns_rdatatype_nsec3)) ||
- (rbtnode->nsec != DNS_RBT_NSEC_NSEC3 &&
- rdataset->type != dns_rdatatype_nsec3 &&
- rdataset->covers != dns_rdatatype_nsec3)));
+ REQUIRE((rbtnode->nsec == DNS_RBT_NSEC_NSEC3 &&
+ (rdataset->type == dns_rdatatype_nsec3 ||
+ rdataset->covers == dns_rdatatype_nsec3)) ||
+ (rbtnode->nsec != DNS_RBT_NSEC_NSEC3 &&
+ rdataset->type != dns_rdatatype_nsec3 &&
+ rdataset->covers != dns_rdatatype_nsec3));
RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
}
®ion, sizeof(rdatasetheader_t),
rbtdb->maxrrperset);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
name = dns_fixedname_initname(&fixed);
if (result != ISC_R_SUCCESS) {
free_rdataset(rbtdb, rbtdb->common.mctx,
newheader);
- return (result);
+ return result;
}
}
if ((rdataset->attributes & DNS_RDATASETATTR_CLOSEST) != 0) {
if (result != ISC_R_SUCCESS) {
free_rdataset(rbtdb, rbtdb->common.mctx,
newheader);
- return (result);
+ return result;
}
}
}
RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
}
- return (result);
+ return result;
}
static isc_result_t
if (rbtdb->common.methods == &zone_methods) {
RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
- REQUIRE(((rbtnode->nsec == DNS_RBT_NSEC_NSEC3 &&
- (rdataset->type == dns_rdatatype_nsec3 ||
- rdataset->covers == dns_rdatatype_nsec3)) ||
- (rbtnode->nsec != DNS_RBT_NSEC_NSEC3 &&
- rdataset->type != dns_rdatatype_nsec3 &&
- rdataset->covers != dns_rdatatype_nsec3)));
+ REQUIRE((rbtnode->nsec == DNS_RBT_NSEC_NSEC3 &&
+ (rdataset->type == dns_rdatatype_nsec3 ||
+ rdataset->covers == dns_rdatatype_nsec3)) ||
+ (rbtnode->nsec != DNS_RBT_NSEC_NSEC3 &&
+ rdataset->type != dns_rdatatype_nsec3 &&
+ rdataset->covers != dns_rdatatype_nsec3));
RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
}
®ion, sizeof(rdatasetheader_t),
0);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
newheader = (rdatasetheader_t *)region.base;
init_rdataset(rbtdb, newheader);
free_rdataset(rbtdb, rbtdb->common.mctx, newheader);
NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
isc_rwlocktype_write);
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
topheader_prev = NULL;
NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
isc_rwlocktype_write);
- return (result);
+ return result;
}
static isc_result_t
INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
if (type == dns_rdatatype_any) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
if (type == dns_rdatatype_rrsig && covers == 0) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
newheader = new_rdataset(rbtdb, rbtdb->common.mctx);
if (newheader == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
init_rdataset(rbtdb, newheader);
set_ttl(rbtdb, newheader, 0);
NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
isc_rwlocktype_write);
- return (result);
+ return result;
}
/*
*nodep = node;
}
- return (noderesult);
+ return noderesult;
}
static isc_result_t
if (rdataset->type == dns_rdatatype_soa && !IS_CACHE(rbtdb) &&
!dns_name_equal(name, &rbtdb->common.origin))
{
- return (DNS_R_NOTZONETOP);
+ return DNS_R_NOTZONETOP;
}
if (rdataset->type != dns_rdatatype_nsec3 &&
* NS record owners cannot legally be wild cards.
*/
if (rdataset->type == dns_rdatatype_ns) {
- return (DNS_R_INVALIDNS);
+ return DNS_R_INVALIDNS;
}
/*
* NSEC3 record owners cannot legally be wild cards.
*/
if (rdataset->type == dns_rdatatype_nsec3) {
- return (DNS_R_INVALIDNSEC3);
+ return DNS_R_INVALIDNSEC3;
}
result = add_wildcard_magic(rbtdb, name, false);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
result = loadnode(rbtdb, name, &node, false);
}
if (result != ISC_R_SUCCESS && result != ISC_R_EXISTS) {
- return (result);
+ return result;
}
if (result == ISC_R_SUCCESS) {
node->locknum = node->hashval % rbtdb->node_lock_count;
®ion, sizeof(rdatasetheader_t),
rbtdb->maxrrperset);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
newheader = (rdatasetheader_t *)region.base;
init_rdataset(rbtdb, newheader);
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
static isc_result_t
callbacks->add = loading_addrdataset;
callbacks->add_private = loadctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_mem_put(rbtdb->common.mctx, loadctx, sizeof(*loadctx));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(VALID_RBTDB(rbtdb));
INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
- return (dns_master_dump(rbtdb->common.mctx, db, version,
- &dns_master_style_default, filename,
- masterformat, NULL));
+ return dns_master_dump(rbtdb->common.mctx, db, version,
+ &dns_master_style_default, filename,
+ masterformat, NULL);
}
static void
secure = (rbtdb->current_version->secure == dns_db_secure);
RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
- return (secure);
+ return secure;
}
static bool
dnssec = (rbtdb->current_version->secure != dns_db_insecure);
RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
- return (dnssec);
+ return dnssec;
}
static unsigned int
}
RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
- return (count);
+ return count;
}
static size_t
size = dns_rbt_hashsize(rbtdb->tree);
RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
- return (size);
+ return size;
}
static void
static bool
ispersistent(dns_db_t *db) {
UNUSED(db);
- return (false);
+ return false;
}
static isc_result_t
result = ISC_R_NOTFOUND;
}
- return (result);
+ return result;
}
static isc_result_t
}
RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
- return (result);
+ return result;
}
static isc_result_t
RWUNLOCK(&rbtversion->rwlock, isc_rwlocktype_read);
RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
- return (result);
+ return result;
}
static isc_result_t
}
NODE_UNLOCK(&rbtdb->node_locks[header->node->locknum].lock,
isc_rwlocktype_write);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
- return (result);
+ return result;
}
static void
REQUIRE(stats != NULL);
isc_stats_attach(stats, &rbtdb->cachestats);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(stats != NULL);
isc_stats_attach(stats, &rbtdb->gluecachestats);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
REQUIRE(VALID_RBTDB(rbtdb));
REQUIRE(IS_CACHE(rbtdb)); /* current restriction */
- return (rbtdb->rrsetstats);
+ return rbtdb->rrsetstats;
}
static isc_result_t
result = dns_rbt_fullnamefromnode(rbtnode, name);
RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
- return (result);
+ return result;
}
static isc_result_t
/* currently no bounds checking. 0 means disable. */
rbtdb->serve_stale_ttl = ttl;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(IS_CACHE(rbtdb));
*ttl = rbtdb->serve_stale_ttl;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
/* currently no bounds checking. 0 means disable. */
rbtdb->serve_stale_refresh = interval;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(IS_CACHE(rbtdb));
*interval = rbtdb->serve_stale_refresh;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static dns_dbmethods_t zone_methods = { attach,
result = dns_name_dupwithoffsets(origin, mctx, &rbtdb->common.origin);
if (result != ISC_R_SUCCESS) {
free_rbtdb(rbtdb, false, NULL);
- return (result);
+ return result;
}
/*
result = dns_rbt_create(mctx, delete_callback, rbtdb, &rbtdb->tree);
if (result != ISC_R_SUCCESS) {
free_rbtdb(rbtdb, false, NULL);
- return (result);
+ return result;
}
result = dns_rbt_create(mctx, delete_callback, rbtdb, &rbtdb->nsec);
if (result != ISC_R_SUCCESS) {
free_rbtdb(rbtdb, false, NULL);
- return (result);
+ return result;
}
result = dns_rbt_create(mctx, delete_callback, rbtdb, &rbtdb->nsec3);
if (result != ISC_R_SUCCESS) {
free_rbtdb(rbtdb, false, NULL);
- return (result);
+ return result;
}
/*
if (result != ISC_R_SUCCESS) {
INSIST(result != ISC_R_EXISTS);
free_rbtdb(rbtdb, false, NULL);
- return (result);
+ return result;
}
INSIST(rbtdb->origin_node != NULL);
rbtdb->origin_node->nsec = DNS_RBT_NSEC_NORMAL;
if (result != ISC_R_SUCCESS) {
INSIST(result != ISC_R_EXISTS);
free_rbtdb(rbtdb, false, NULL);
- return (result);
+ return result;
}
rbtdb->nsec3_origin_node->nsec = DNS_RBT_NSEC_NSEC3;
/*
*dbp = (dns_db_t *)rbtdb;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_node_locks:
isc_mem_put(mctx, rbtdb->node_locks,
isc_rwlock_destroy(&rbtdb->tree_lock);
RBTDB_DESTROYLOCK(&rbtdb->lock);
isc_mem_put(mctx, rbtdb, sizeof(*rbtdb));
- return (result);
+ return result;
}
/*
count = raw[0] * 256 + raw[1];
if (count == 0) {
rdataset->private5 = NULL;
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
if ((rdataset->attributes & DNS_RDATASETATTR_LOADORDER) == 0) {
rdataset->privateuint4 = count;
rdataset->private5 = raw;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
count = rdataset->privateuint4;
if (count == 0) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
count--;
rdataset->privateuint4 = count;
rdataset->private5 = raw + DNS_RDATASET_ORDER + DNS_RDATASET_LENGTH;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
count = raw[0] * 256 + raw[1];
- return (count);
+ return count;
}
static isc_result_t
dns_name_clone(&noqname->name, name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_clone(&closest->name, name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
* Is this a "this rdataset doesn't exist" record?
*/
if (NONEXISTENT(header)) {
- return (false);
+ return false;
}
/*
* If this is a zone or this header still active then return it.
*/
if (!IS_CACHE(rbtdb) || ACTIVE(header, rbtiterator->common.now)) {
- return (true);
+ return true;
}
/*
* too old don't return it.
*/
if (!STALEOK(rbtiterator) || (rbtiterator->common.now > stale_ttl)) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static isc_result_t
rbtiterator->current = header;
if (header == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
header = rbtiterator->current;
if (header == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
rbtiterator->current = header;
if (header == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
rbtdbiter->result != DNS_R_PARTIALMATCH &&
rbtdbiter->result != ISC_R_NOMORE)
{
- return (rbtdbiter->result);
+ return rbtdbiter->result;
}
if (rbtdbiter->paused) {
ENSURE(!rbtdbiter->paused);
}
- return (result);
+ return result;
}
static isc_result_t
rbtdbiter->result != DNS_R_PARTIALMATCH &&
rbtdbiter->result != ISC_R_NOMORE)
{
- return (rbtdbiter->result);
+ return rbtdbiter->result;
}
if (rbtdbiter->paused) {
rbtdbiter->result = result;
- return (result);
+ return result;
}
static isc_result_t
rbtdbiter->result != DNS_R_PARTIALMATCH &&
rbtdbiter->result != ISC_R_NOMORE)
{
- return (rbtdbiter->result);
+ return rbtdbiter->result;
}
if (rbtdbiter->paused) {
rbtdbiter->result = (result == DNS_R_PARTIALMATCH) ? ISC_R_SUCCESS
: result;
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(rbtdbiter->node != NULL);
if (rbtdbiter->result != ISC_R_SUCCESS) {
- return (rbtdbiter->result);
+ return rbtdbiter->result;
}
if (rbtdbiter->paused) {
rbtdbiter->result = result;
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(rbtdbiter->node != NULL);
if (rbtdbiter->result != ISC_R_SUCCESS) {
- return (rbtdbiter->result);
+ return rbtdbiter->result;
}
if (rbtdbiter->paused) {
rbtdbiter->result = result;
- return (result);
+ return result;
}
static isc_result_t
}
result = dns_name_concatenate(nodename, origin, name, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (rbtdbiter->common.relative_names && rbtdbiter->new_origin) {
result = DNS_R_NEWORIGIN;
}
}
- return (result);
+ return result;
}
static isc_result_t
rbtdbiter->result != DNS_R_PARTIALMATCH &&
rbtdbiter->result != ISC_R_NOMORE)
{
- return (rbtdbiter->result);
+ return rbtdbiter->result;
}
if (rbtdbiter->paused) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
rbtdbiter->paused = true;
flush_deletions(rbtdbiter);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_t *origin = dns_fixedname_name(&rbtdbiter->origin);
if (rbtdbiter->result != ISC_R_SUCCESS) {
- return (rbtdbiter->result);
+ return rbtdbiter->result;
}
dns_name_copy(origin, name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
newbits += 1;
}
- return (newbits);
+ return newbits;
}
/*%
detachnode((dns_db_t *)ctx->rbtdb, (dns_dbnode_t *)&node_aaaa);
}
- return (result);
+ return result;
}
static isc_result_t
RWUNLOCK(&rbtversion->glue_rwlock, isc_rwlocktype_read);
if (found) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (restarted) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
RDATASET_ATTR_ANCIENT |
RDATASET_ATTR_ZEROTTL)) != 0)
{
- return (false);
+ return false;
}
#if DNS_RBTDB_LIMITLRUUPDATE
* Glue records are updated if at least DNS_RBTDB_LRUUPDATE_GLUE
* seconds have passed since the previous update time.
*/
- return (header->last_used + DNS_RBTDB_LRUUPDATE_GLUE <= now);
+ return header->last_used + DNS_RBTDB_LRUUPDATE_GLUE <= now;
}
/*
* Other records are updated if DNS_RBTDB_LRUUPDATE_REGULAR seconds
* have passed.
*/
- return (header->last_used + DNS_RBTDB_LRUUPDATE_REGULAR <= now);
+ return header->last_used + DNS_RBTDB_LRUUPDATE_REGULAR <= now;
#else
UNUSED(now);
- return (true);
+ return true;
#endif /* if DNS_RBTDB_LIMITLRUUPDATE */
}
purged += header_size;
}
- return (purged);
+ return purged;
}
/*%
l = strlen(source);
if (l > region.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, source, l);
isc_buffer_add(target, l);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
if (!isdigit((unsigned char)source->base[0]) ||
source->length > NUMBERSIZE - 1)
{
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
/*
v = snprintf(buffer, sizeof(buffer), "%.*s", (int)source->length,
source->base);
if (v < 0 || (unsigned)v != source->length) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
INSIST(buffer[source->length] == '\0');
result = isc_parse_uint32(&n, buffer, 16);
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (n > max) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
*valuep = n;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
result = maybe_numeric(valuep, source, max, false);
if (result != ISC_R_BADNUMBER) {
- return (result);
+ return result;
}
for (i = 0; table[i].name != NULL; i++) {
strncasecmp(source->base, table[i].name, n) == 0)
{
*valuep = table[i].value;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return (DNS_R_UNKNOWN);
+ return DNS_R_UNKNOWN;
}
static isc_result_t
char buf[sizeof("4294967296")];
while (table[i].name != NULL) {
if (table[i].value == value) {
- return (str_totext(table[i].name, target));
+ return str_totext(table[i].name, target);
}
i++;
}
snprintf(buf, sizeof(buf), "%u", value);
- return (str_totext(buf, target));
+ return str_totext(buf, target);
}
isc_result_t
unsigned int value;
RETERR(dns_mnemonic_fromtext(&value, source, rcodes, 0xffff));
*rcodep = value;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
dns_rcode_totext(dns_rcode_t rcode, isc_buffer_t *target) {
- return (dns_mnemonic_totext(rcode, target, rcodes));
+ return dns_mnemonic_totext(rcode, target, rcodes);
}
isc_result_t
unsigned int value;
RETERR(dns_mnemonic_fromtext(&value, source, tsigrcodes, 0xffff));
*rcodep = value;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
dns_tsigrcode_totext(dns_rcode_t rcode, isc_buffer_t *target) {
- return (dns_mnemonic_totext(rcode, target, tsigrcodes));
+ return dns_mnemonic_totext(rcode, target, tsigrcodes);
}
isc_result_t
unsigned int value;
RETERR(dns_mnemonic_fromtext(&value, source, certs, 0xffff));
*certp = value;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
dns_cert_totext(dns_cert_t cert, isc_buffer_t *target) {
- return (dns_mnemonic_totext(cert, target, certs));
+ return dns_mnemonic_totext(cert, target, certs);
}
isc_result_t
unsigned int value;
RETERR(dns_mnemonic_fromtext(&value, source, secalgs, 0xff));
*secalgp = value;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
dns_secalg_totext(dns_secalg_t secalg, isc_buffer_t *target) {
- return (dns_mnemonic_totext(secalg, target, secalgs));
+ return dns_mnemonic_totext(secalg, target, secalgs);
}
void
unsigned int value;
RETERR(dns_mnemonic_fromtext(&value, source, secprotos, 0xff));
*secprotop = value;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
dns_secproto_totext(dns_secproto_t secproto, isc_buffer_t *target) {
- return (dns_mnemonic_totext(secproto, target, secprotos));
+ return dns_mnemonic_totext(secproto, target, secprotos);
}
isc_result_t
unsigned int value;
RETERR(dns_mnemonic_fromtext(&value, source, hashalgs, 0xff));
*hashalg = value;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
result = maybe_numeric(&value, source, 0xffff, true);
if (result == ISC_R_SUCCESS) {
*flagsp = value;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_BADNUMBER) {
- return (result);
+ return result;
}
text = source->base;
}
}
if (p->name == NULL) {
- return (DNS_R_UNKNOWNFLAG);
+ return DNS_R_UNKNOWNFLAG;
}
value |= p->value;
#ifdef notyet
}
}
*flagsp = value;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
unsigned int value;
RETERR(dns_mnemonic_fromtext(&value, source, dsdigests, 0xff));
*dsdigestp = value;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
dns_dsdigest_totext(dns_dsdigest_t dsdigest, isc_buffer_t *target) {
- return (dns_mnemonic_totext(dsdigest, target, dsdigests));
+ return dns_mnemonic_totext(dsdigest, target, dsdigests);
}
void
val = strtoul(buf, &endp, 10);
if (*endp == '\0' && val <= 0xffff) {
*classp = (dns_rdataclass_t)val;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
break;
#undef COMPARE
- return (DNS_R_UNKNOWN);
+ return DNS_R_UNKNOWN;
}
isc_result_t
dns_rdataclass_totext(dns_rdataclass_t rdclass, isc_buffer_t *target) {
switch (rdclass) {
case dns_rdataclass_any:
- return (str_totext("ANY", target));
+ return str_totext("ANY", target);
case dns_rdataclass_chaos:
- return (str_totext("CH", target));
+ return str_totext("CH", target);
case dns_rdataclass_hs:
- return (str_totext("HS", target));
+ return str_totext("HS", target);
case dns_rdataclass_in:
- return (str_totext("IN", target));
+ return str_totext("IN", target);
case dns_rdataclass_none:
- return (str_totext("NONE", target));
+ return str_totext("NONE", target);
case dns_rdataclass_reserved0:
- return (str_totext("RESERVED0", target));
+ return str_totext("RESERVED0", target);
default:
- return (dns_rdataclass_tounknowntext(rdclass, target));
+ return dns_rdataclass_tounknowntext(rdclass, target);
}
}
char buf[sizeof("CLASS65535")];
snprintf(buf, sizeof(buf), "CLASS%u", rdclass);
- return (str_totext(buf, target));
+ return str_totext(buf, target);
}
void
val <<= 4;
val |= (pch - xdigits);
if (++seen_xdigits > 4) {
- return (0);
+ return 0;
}
continue;
}
if (ch == ':') {
if (!seen_xdigits) {
- return (0);
+ return 0;
}
if (tp + NS_INT16SZ > endp) {
- return (0);
+ return 0;
}
*tp++ = (unsigned char)(val >> 8) & 0xff;
*tp++ = (unsigned char)val & 0xff;
val = 0;
continue;
}
- return (0);
+ return 0;
}
if (seen_xdigits) {
if (tp + NS_INT16SZ > endp) {
- return (0);
+ return 0;
}
*tp++ = (unsigned char)(val >> 8) & 0xff;
*tp++ = (unsigned char)val & 0xff;
}
if (tp != endp) {
- return (0);
+ return 0;
}
memmove(dst, tmp, NS_LOCATORSZ);
- return (1);
+ return 1;
}
static void
void *copy;
if (mctx == NULL) {
- return (source);
+ return source;
}
copy = isc_mem_allocate(mctx, length);
memmove(copy, source, length);
- return (copy);
+ return copy;
}
static isc_result_t
} while (1);
isc_lex_ungettoken(lexer, &token);
if (!allow_empty && first) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
for (window = 0; window < 256; window++) {
RETERR(uint8_tobuffer(octet + 1, target));
RETERR(mem_tobuffer(target, &bm[window * 32], octet + 1));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
}
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
first = false;
}
if (i != sr->length) {
- return (DNS_R_EXTRADATA);
+ return DNS_R_EXTRADATA;
}
if (!allow_empty && first) {
RETERR(DNS_R_FORMERR);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static const char hexdigits[] = "0123456789abcdef";
REQUIRE(DNS_RDATA_VALIDFLAGS(rdata2));
if (rdata1->rdclass != rdata2->rdclass) {
- return (rdata1->rdclass < rdata2->rdclass ? -1 : 1);
+ return rdata1->rdclass < rdata2->rdclass ? -1 : 1;
}
if (rdata1->type != rdata2->type) {
- return (rdata1->type < rdata2->type ? -1 : 1);
+ return rdata1->type < rdata2->type ? -1 : 1;
}
COMPARESWITCH
dns_rdata_toregion(rdata2, &r2);
result = isc_region_compare(&r1, &r2);
}
- return (result);
+ return result;
}
int
REQUIRE(DNS_RDATA_VALIDFLAGS(rdata2));
if (rdata1->rdclass != rdata2->rdclass) {
- return (rdata1->rdclass < rdata2->rdclass ? -1 : 1);
+ return rdata1->rdclass < rdata2->rdclass ? -1 : 1;
}
if (rdata1->type != rdata2->type) {
- return (rdata1->type < rdata2->type ? -1 : 1);
+ return rdata1->type < rdata2->type ? -1 : 1;
}
CASECOMPARESWITCH
dns_rdata_toregion(rdata2, &r2);
result = isc_region_compare(&r1, &r2);
}
- return (result);
+ return result;
}
/***
REQUIRE(target != NULL);
if (type == 0) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
ss = *source;
*source = ss;
*target = st;
}
- return (result);
+ return result;
}
isc_result_t
*/
if ((rdata->flags & DNS_RDATA_UPDATE) != 0) {
INSIST(rdata->length == 0);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
st = *target;
if (use_default) {
isc_buffer_availableregion(target, &tr);
if (tr.length < rdata->length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tr.base, rdata->data, rdata->length);
isc_buffer_add(target, rdata->length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
*target = st;
INSIST(target->used < 65536);
dns_compress_rollback(cctx, (uint16_t)target->used);
}
- return (result);
+ return result;
}
/*
result = dns_rdata_fromwire(NULL, rdclass, type, src, &dctx, 0, dest);
dns_decompress_invalidate(&dctx);
- return (result);
+ return result;
}
static isc_result_t
isc_token_t token;
if (type == 0 || dns_rdatatype_ismeta(type)) {
- return (DNS_R_METATYPE);
+ return DNS_R_METATYPE;
}
RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
false));
if (token.value.as_ulong > 65535U) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
isc_buffer_allocate(mctx, &buf, token.value.as_ulong);
}
isc_buffer_free(&buf);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
isc_buffer_free(&buf);
- return (result);
+ return result;
}
isc_result_t
name = isc_lex_getsourcename(lexer);
line = isc_lex_getsourceline(lexer);
fromtext_error(callback, callbacks, name, line, NULL, result);
- return (result);
+ return result;
}
unknown = false;
if (result != ISC_R_SUCCESS) {
*target = st;
}
- return (result);
+ return result;
}
static isc_result_t
strlcpy(buf, "\\# ", sizeof(buf));
result = str_totext(buf, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdata_toregion(rdata, &sr);
snprintf(buf, sizeof(buf), "%u", sr.length);
result = str_totext(buf, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (sr.length != 0U) {
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (tctx->width == 0) { /* No splitting */
result = str_totext(" )", target);
}
}
- return (result);
+ return result;
}
static isc_result_t
*/
if ((rdata->flags & DNS_RDATA_UPDATE) != 0) {
INSIST(rdata->length == 0);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if ((tctx->flags & DNS_STYLEFLAG_UNKNOWNFORMAT) != 0) {
- return (unknown_totext(rdata, tctx, target));
+ return unknown_totext(rdata, tctx, target);
}
cur = isc_buffer_usedlength(target);
result = unknown_totext(rdata, tctx, target);
}
- return (result);
+ return result;
}
isc_result_t
tctx.flags = 0;
tctx.width = 60;
tctx.linebreak = " ";
- return (rdata_totext(rdata, &tctx, target));
+ return rdata_totext(rdata, &tctx, target);
}
isc_result_t
}
tctx.linebreak = " ";
}
- return (rdata_totext(rdata, &tctx, target));
+ return rdata_totext(rdata, &tctx, target);
}
isc_result_t
if (result != ISC_R_SUCCESS) {
*target = st;
}
- return (result);
+ return result;
}
isc_result_t
(void)NULL;
}
- return (result);
+ return result;
}
void
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
isc_result_t
result = (digest)(arg, &r);
}
- return (result);
+ return result;
}
bool
bool result;
CHECKOWNERSWITCH
- return (result);
+ return result;
}
bool
bool result;
CHECKNAMESSWITCH
- return (result);
+ return result;
}
unsigned int
dns_rdatatype_attributes(dns_rdatatype_t type) {
RDATATYPE_ATTRIBUTE_SW
if (type >= (dns_rdatatype_t)128 && type <= (dns_rdatatype_t)255) {
- return (DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META);
+ return DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META;
}
- return (DNS_RDATATYPEATTR_UNKNOWN);
+ return DNS_RDATATYPEATTR_UNKNOWN;
}
isc_result_t
n = source->length;
if (n == 0) {
- return (DNS_R_UNKNOWN);
+ return DNS_R_UNKNOWN;
}
a = tolower((unsigned char)source->base[0]);
val = strtoul(buf, &endp, 10);
if (*endp == '\0' && val <= 0xffff) {
*typep = (dns_rdatatype_t)val;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return (DNS_R_UNKNOWN);
+ return DNS_R_UNKNOWN;
}
isc_result_t
dns_rdatatype_totext(dns_rdatatype_t type, isc_buffer_t *target) {
RDATATYPE_TOTEXT_SW
- return (dns_rdatatype_tounknowntext(type, target));
+ return dns_rdatatype_tounknowntext(type, target);
}
isc_result_t
char buf[sizeof("TYPE65535")];
snprintf(buf, sizeof(buf), "TYPE%u", type);
- return (str_totext(buf, target));
+ return str_totext(buf, target);
}
void
static unsigned int
name_length(const dns_name_t *name) {
- return (name->length);
+ return name->length;
}
static isc_result_t
if (quote) {
if (tl < 1) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tp++ = '"';
tl--;
*/
if (*sp < (quote ? ' ' : '!') || *sp >= 0x7f) {
if (tl < 4) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tp++ = '\\';
*tp++ = '0' + ((*sp / 100) % 10);
(!comma && !quote && (*sp == '@' || *sp == ';')))
{
if (tl < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tp++ = '\\';
tl--;
*/
if (comma && (*sp == ',' || *sp == '\\')) {
if (tl < ((*sp == '\\') ? 3 : 2)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tp++ = '\\';
tl--;
}
}
if (tl < 1) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tp++ = *sp++;
tl--;
}
if (quote) {
if (tl < 1) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tp++ = '"';
tl--;
}
isc_buffer_add(target, (unsigned int)(tp - (char *)region.base));
isc_region_consume(source, *source->base + 1);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
txt_totext(isc_region_t *source, bool quote, isc_buffer_t *target) {
- return (commatxt_totext(source, quote, false, target));
+ return commatxt_totext(source, quote, false, target);
}
static isc_result_t
t = tregion.base;
nrem = tregion.length;
if (nrem < 1) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/*
* Length byte.
if (escape && (d = decvalue((char)c)) != -1) {
c = d;
if (n == 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
n--;
if ((d = decvalue(*s++)) != -1) {
c = c * 10 + d;
} else {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
if (n == 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
n--;
if ((d = decvalue(*s++)) != -1) {
c = c * 10 + d;
} else {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
if (c > 255) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
} else if (!escape && c == '\\') {
escape = true;
}
comma_escape = false;
if (nrem == 0) {
- return ((tregion.length <= 256U) ? ISC_R_NOSPACE
- : DNS_R_SYNTAX);
+ return (tregion.length <= 256U) ? ISC_R_NOSPACE
+ : DNS_R_SYNTAX;
}
*t++ = c;
nrem--;
* Incomplete escape processing?
*/
if (escape || (comma && comma_escape)) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
if (comma) {
* in the middle ("h1,,h2" or "h1\,\,h2").
*/
if ((t - tregion.base - 1) == 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
/*
* Disallow empty ALPN at end ("h1," or "h1\,").
*/
if (seen_comma && source->length == 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
}
*tregion.base = (unsigned char)(t - tregion.base - 1);
isc_buffer_add(target, *tregion.base + 1);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
txt_fromtext(isc_textregion_t *source, isc_buffer_t *target) {
- return (commatxt_fromtext(source, false, target));
+ return commatxt_fromtext(source, false, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sregion);
if (sregion.length == 0) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
n = *sregion.base + 1;
if (n > sregion.length) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_buffer_availableregion(target, &tregion);
if (n > tregion.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
if (tregion.base != sregion.base) {
}
isc_buffer_forward(source, n);
isc_buffer_add(target, n);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
tl = region.length;
if (tl < 1) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tp++ = '"';
tl--;
while (n--) {
if (*sp < ' ' || *sp >= 0x7f) {
if (tl < 4) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tp++ = '\\';
*tp++ = '0' + ((*sp / 100) % 10);
/* double quote, backslash */
if (*sp == '"' || *sp == '\\') {
if (tl < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tp++ = '\\';
tl--;
}
if (tl < 1) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tp++ = *sp++;
tl--;
isc_region_consume(source, n0 + 1);
} while (source->length != 0);
if (tl < 1) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tp++ = '"';
tl--;
POST(tl);
isc_buffer_add(target, (unsigned int)(tp - (char *)region.base));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
t0 = t = tregion.base;
nrem = tregion.length;
if (nrem < 1) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
while (n != 0) {
if (escape && (d = decvalue((char)c)) != -1) {
c = d;
if (n == 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
n--;
if ((d = decvalue(*s++)) != -1) {
c = c * 10 + d;
} else {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
if (n == 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
n--;
if ((d = decvalue(*s++)) != -1) {
c = c * 10 + d;
} else {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
if (c > 255) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
} else if (!escape && c == '\\') {
escape = true;
}
}
if (escape) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
isc_buffer_add(target, (unsigned int)(t - t0));
} while (n != 0);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
}
dns_name_getlabelsequence(name, 0, l1 - l2, target);
- return (true);
+ return true;
return_false:
*target = *name;
- return (false);
+ return false;
}
static isc_result_t
l = strlen(source);
if (l > region.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, source, l);
isc_buffer_add(target, l);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
/* Note - inet_ntop doesn't do size checking on its input. */
if (inet_ntop(af, src->base, tmpbuf, sizeof(tmpbuf)) == NULL) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
if (strlen(tmpbuf) > isc_buffer_availablelength(target)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putstr(target, tmpbuf);
isc_buffer_usedregion(target, &r);
if (r.length > 0 && r.base[r.length - 1] == ':') {
if (isc_buffer_availablelength(target) == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putmem(target, (const unsigned char *)"0",
1);
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
buffer_empty(isc_buffer_t *source) {
- return ((source->current == source->active) ? true : false);
+ return (source->current == source->active) ? true : false;
}
static void
isc_buffer_availableregion(target, ®ion);
if (region.length < 4) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint32(target, value);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_region_t region;
if (value > 0xffff) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
isc_buffer_availableregion(target, ®ion);
if (region.length < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint16(target, (uint16_t)value);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_region_t region;
if (value > 0xff) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
isc_buffer_availableregion(target, ®ion);
if (region.length < 1) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint8(target, (uint8_t)value);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
name_tobuffer(const dns_name_t *name, isc_buffer_t *target) {
isc_region_t r;
dns_name_toregion(name, &r);
- return (isc_buffer_copyregion(target, &r));
+ return isc_buffer_copyregion(target, &r);
}
static uint32_t
value |= (uint32_t)region->base[1] << 16;
value |= (uint32_t)region->base[2] << 8;
value |= (uint32_t)region->base[3];
- return (value);
+ return value;
}
static uint16_t
uint16_t r = uint16_fromregion(region);
isc_region_consume(region, 2);
- return (r);
+ return r;
}
static uint16_t
uint16_fromregion(isc_region_t *region) {
REQUIRE(region->length >= 2);
- return ((region->base[0] << 8) | region->base[1]);
+ return (region->base[0] << 8) | region->base[1];
}
static uint8_t
uint8_fromregion(isc_region_t *region) {
REQUIRE(region->length >= 1);
- return (region->base[0]);
+ return region->base[0];
}
static uint8_t
uint8_t r = uint8_fromregion(region);
isc_region_consume(region, 1);
- return (r);
+ return r;
}
static isc_result_t
isc_region_t tr;
if (length == 0U) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_buffer_availableregion(target, &tr);
if (length > tr.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
if (tr.base != base) {
memmove(tr.base, base, length);
}
isc_buffer_add(target, length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static int
c = (unsigned char)value;
if (!isascii(c)) {
- return (-1);
+ return -1;
}
if (isupper(c)) {
c = tolower(c);
}
if ((s = strchr(hexdigits, c)) == NULL) {
- return (-1);
+ return -1;
}
- return ((int)(s - hexdigits));
+ return (int)(s - hexdigits);
}
static int
* mask or cast.
*/
if (!isascii((unsigned char)value)) {
- return (-1);
+ return -1;
}
if ((s = strchr(decdigits, value)) == NULL) {
- return (-1);
+ return -1;
}
- return ((int)(s - decdigits));
+ return (int)(s - decdigits);
}
static void
dns_rdatatype_t
dns_rdata_covers(dns_rdata_t *rdata) {
if (rdata->type == dns_rdatatype_rrsig) {
- return (covers_rrsig(rdata));
+ return covers_rrsig(rdata);
}
- return (covers_sig(rdata));
+ return covers_sig(rdata);
}
bool
dns_rdatatype_ismeta(dns_rdatatype_t type) {
if ((dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_META) != 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
dns_rdatatype_issingleton(dns_rdatatype_t type) {
if ((dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_SINGLETON) != 0)
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
if ((dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_NOTQUESTION) !=
0)
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
if ((dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_QUESTIONONLY) !=
0)
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
dns_rdatatype_atcname(dns_rdatatype_t type) {
if ((dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_ATCNAME) != 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
dns_rdatatype_atparent(dns_rdatatype_t type) {
if ((dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_ATPARENT) != 0)
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
if ((dns_rdatatype_attributes(type) &
DNS_RDATATYPEATTR_FOLLOWADDITIONAL) != 0)
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
if (rdclass == dns_rdataclass_reserved0 ||
rdclass == dns_rdataclass_none || rdclass == dns_rdataclass_any)
{
- return (true);
+ return true;
}
- return (false); /* Assume it is not a meta class. */
+ return false; /* Assume it is not a meta class. */
}
bool
dns_rdatatype_isdnssec(dns_rdatatype_t type) {
if ((dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_DNSSEC) != 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
dns_rdatatype_iskeymaterial(dns_rdatatype_t type) {
- return (type == dns_rdatatype_dnskey || type == dns_rdatatype_cdnskey ||
- type == dns_rdatatype_cds);
+ return type == dns_rdatatype_dnskey || type == dns_rdatatype_cdnskey ||
+ type == dns_rdatatype_cds;
}
bool
if ((dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_ZONECUTAUTH) !=
0)
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
dns_rdatatype_isknown(dns_rdatatype_t type) {
if ((dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_UNKNOWN) == 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
void
case dns_rdataclass_none:
switch (rdata->type) {
case dns_rdatatype_any:
- return ("domain doesn't exist");
+ return "domain doesn't exist";
default:
- return ("rrset doesn't exist");
+ return "rrset doesn't exist";
}
case dns_rdataclass_any:
switch (rdata->type) {
case dns_rdatatype_any:
- return ("domain exists");
+ return "domain exists";
default:
- return ("rrset exists (value independent)");
+ return "rrset exists (value independent)";
}
default:
- return ("rrset exists (value dependent)");
+ return "rrset exists (value dependent)";
}
case DNS_SECTION_UPDATE:
switch (rdata->rdclass) {
case dns_rdataclass_none:
- return ("delete");
+ return "delete";
case dns_rdataclass_any:
switch (rdata->type) {
case dns_rdatatype_any:
- return ("delete all rrsets");
+ return "delete all rrsets";
default:
- return ("delete rrset");
+ return "delete rrset";
}
default:
- return ("add");
+ return "add";
}
}
- return ("invalid");
+ return "invalid";
}
/*
* Other Data.
*/
- return (isc_base64_tobuffer(lexer, target, (int)token.value.as_ulong));
+ return isc_base64_tobuffer(lexer, target, (int)token.value.as_ulong);
}
static isc_result_t
* Other.
*/
if (tctx->width == 0) { /* No splitting */
- return (isc_base64_totext(&sr, 60, "", target));
+ return isc_base64_totext(&sr, 60, "", target);
} else {
- return (isc_base64_totext(&sr, 60, " ", target));
+ return isc_base64_totext(&sr, 60, " ", target);
}
}
* Time Signed + Fudge.
*/
if (sr.length < 8) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, sr.base, 8));
isc_region_consume(&sr, 8);
* Signature Length + Signature.
*/
if (sr.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
n = uint16_fromregion(&sr);
if (sr.length < n + 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, sr.base, n + 2));
isc_region_consume(&sr, n + 2);
* Original ID + Error.
*/
if (sr.length < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, sr.base, 4));
isc_region_consume(&sr, 4);
* Other Length + Other.
*/
if (sr.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
n = uint16_fromregion(&sr);
if (sr.length < n + 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_buffer_forward(source, n + 2);
- return (mem_tobuffer(target, sr.base, n + 2));
+ return mem_tobuffer(target, sr.base, n + 2);
}
static isc_result_t
dns_name_fromregion(&name, &sr);
RETERR(dns_name_towire(&name, cctx, target));
isc_region_consume(&sr, name_length(&name));
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_name_fromregion(&name2, &r2);
order = dns_name_rdatacompare(&name1, &name2);
if (order != 0) {
- return (order);
+ return order;
}
isc_region_consume(&r1, name_length(&name1));
isc_region_consume(&r2, name_length(&name2));
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
isc_buffer_availableregion(target, &tr);
if (tr.length < 6 + 2 + 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/*
isc_buffer_availableregion(target, &tr);
if (tr.length < 2 + 2 + 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/*
/*
* Other Data.
*/
- return (mem_tobuffer(target, tsig->other, tsig->otherlen));
+ return mem_tobuffer(target, tsig->other, tsig->otherlen);
}
static isc_result_t
}
tsig->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (mctx != NULL) {
if (mctx != NULL && tsig->signature != NULL) {
isc_mem_free(mctx, tsig->signature);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(digest);
UNUSED(arg);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_any_tsig(ARGS_COMPARE) {
- return (compare_any_tsig(rdata1, rdata2));
+ return compare_any_tsig(rdata1, rdata2);
}
#endif /* RDATA_ANY_255_TSIG_250_C */
if (token.value.as_ulong > 0xffffU) {
RETTOK(ISC_R_RANGE);
}
- return (uint16_tobuffer(token.value.as_ulong, target));
+ return uint16_tobuffer(token.value.as_ulong, target);
}
static isc_result_t
snprintf(buf, sizeof(buf), "%o", addr); /* note octal */
RETERR(str_totext(" ", target));
- return (str_totext(buf, target));
+ return str_totext(buf, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sregion);
isc_buffer_availableregion(target, &tregion);
if (sregion.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (tregion.length < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tregion.base, sregion.base, 2);
isc_buffer_forward(source, 2);
isc_buffer_add(target, 2);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_availableregion(target, &tregion);
if (tregion.length < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tregion.base, sregion.base, 2);
isc_buffer_add(target, 2);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static int
order = dns_name_rdatacompare(&name1, &name2);
if (order != 0) {
- return (order);
+ return order;
}
order = memcmp(region1.base, region2.base, 2);
if (order != 0) {
order = (order < 0) ? -1 : 1;
}
- return (order);
+ return order;
}
static isc_result_t
dns_name_toregion(&a->ch_addr_dom, ®ion);
RETERR(isc_buffer_copyregion(target, ®ion));
- return (uint16_tobuffer(ntohs(a->ch_addr), target));
+ return uint16_tobuffer(ntohs(a->ch_addr), target);
}
static isc_result_t
name_duporclone(&name, mctx, &a->ch_addr_dom);
a->ch_addr = htons(uint16_fromregion(®ion));
a->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_fromregion(&name, &r);
isc_region_consume(&r, name_length(&name));
RETERR(dns_name_digest(&name, digest, arg));
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(type);
- return (dns_name_ishostname(name, wildcard));
+ return dns_name_ishostname(name, wildcard);
}
static bool
if (bad != NULL) {
dns_name_clone(&name, bad);
}
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static int
casecompare_ch_a(ARGS_COMPARE) {
- return (compare_ch_a(rdata1, rdata2));
+ return compare_ch_a(rdata1, rdata2);
}
#endif /* RDATA_CH_3_A_1_C */
if (!ok && callbacks != NULL) {
warn_badname(&name, lexer, callbacks);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
RETERR(str_totext(buf, target));
dns_name_fromregion(&name, ®ion);
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sr);
isc_buffer_availableregion(target, &tr);
if (tr.length < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
if (sr.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
memmove(tr.base, sr.base, 2);
isc_buffer_forward(source, 2);
isc_buffer_add(target, 2);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
isc_buffer_availableregion(target, &tr);
dns_rdata_toregion(rdata, &sr);
if (tr.length < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tr.base, sr.base, 2);
isc_region_consume(&sr, 2);
dns_name_init(&name, offsets);
dns_name_fromregion(&name, &sr);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
result = memcmp(rdata1->data, rdata2->data, 2);
if (result != 0) {
- return (result < 0 ? -1 : 1);
+ return result < 0 ? -1 : 1;
}
dns_name_init(&name1, NULL);
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
RETERR(uint16_tobuffer(afsdb->subtype, target));
dns_name_toregion(&afsdb->server, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
name_duporclone(&name, mctx, &afsdb->server);
afsdb->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
isc_region_consume(®ion, 2);
dns_name_fromregion(&name, ®ion);
- return ((add)(arg, &name, dns_rdatatype_a, NULL));
+ return (add)(arg, &name, dns_rdatatype_a, NULL);
}
static isc_result_t
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r2);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
if (bad != NULL) {
dns_name_clone(&name, bad);
}
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static int
casecompare_afsdb(ARGS_COMPARE) {
- return (compare_afsdb(rdata1, rdata2));
+ return compare_afsdb(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_AFSDB_18_C */
gateway = token.value.as_ulong;
if (gateway == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (gateway > 3) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
/*
}
isc_buffer_availableregion(target, ®ion);
if (region.length < 4) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, &addr, 4);
isc_buffer_add(target, 4);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
case 2:
if (inet_pton(AF_INET6, DNS_AS_STR(token), addr6) != 1) {
}
isc_buffer_availableregion(target, ®ion);
if (region.length < 16) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, addr6, 16);
isc_buffer_add(target, 16);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
case 3:
dns_name_init(&name, NULL);
if (origin == NULL) {
origin = dns_rootname;
}
- return (dns_name_fromtext(&name, &buffer, origin, options,
- target));
+ return dns_name_fromtext(&name, &buffer, origin, options,
+ target);
default:
UNREACHABLE();
}
REQUIRE(rdata->length >= 2);
if ((rdata->data[1] & 0x7f) > 3U) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
/*
case 0:
break;
case 1:
- return (inet_totext(AF_INET, tctx->flags, ®ion, target));
+ return inet_totext(AF_INET, tctx->flags, ®ion, target);
case 2:
- return (inet_totext(AF_INET6, tctx->flags, ®ion, target));
+ return inet_totext(AF_INET6, tctx->flags, ®ion, target);
case 3:
dns_name_init(&name, NULL);
dns_name_fromregion(&name, ®ion);
- return (dns_name_totext(&name, false, target));
+ return dns_name_totext(&name, false, target);
default:
UNREACHABLE();
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_activeregion(source, ®ion);
if (region.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
switch (region.base[1] & 0x7f) {
case 0:
if (region.length != 2) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
isc_buffer_forward(source, region.length);
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
case 1:
if (region.length != 6) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
isc_buffer_forward(source, region.length);
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
case 2:
if (region.length != 18) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
isc_buffer_forward(source, region.length);
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
case 3:
RETERR(mem_tobuffer(target, region.base, 2));
isc_buffer_forward(source, 2);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, options,
- target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
default:
isc_buffer_forward(source, region.length);
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
}
}
UNUSED(cctx);
dns_rdata_toregion(rdata, ®ion);
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
}
static int
dns_rdata_toregion(rdata1, ®ion1);
dns_rdata_toregion(rdata2, ®ion2);
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
static isc_result_t
switch (amtrelay->gateway_type) {
case 0:
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
case 1:
n = ntohl(amtrelay->in_addr.s_addr);
- return (uint32_tobuffer(n, target));
+ return uint32_tobuffer(n, target);
case 2:
- return (mem_tobuffer(target, amtrelay->in6_addr.s6_addr, 16));
+ return mem_tobuffer(target, amtrelay->in6_addr.s6_addr, 16);
break;
case 3:
dns_name_toregion(&amtrelay->gateway, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
break;
default:
- return (mem_tobuffer(target, amtrelay->data, amtrelay->length));
+ return mem_tobuffer(target, amtrelay->data, amtrelay->length);
}
}
amtrelay->data = mem_maybedup(mctx, region.base,
region.length);
if (amtrelay->data == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
}
amtrelay->length = region.length;
}
amtrelay->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_amtrelay);
dns_rdata_toregion(rdata, ®ion);
- return ((digest)(arg, ®ion));
+ return (digest)(arg, ®ion);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
if (memcmp(region1.base, region2.base, 2) != 0 ||
(region1.base[1] & 0x7f) != 3)
{
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
dns_name_init(&name1, NULL);
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
#endif /* RDATA_GENERIC_AMTRELAY_260_C */
fromtext_avc(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_avc);
- return (generic_fromtext_txt(CALL_FROMTEXT));
+ return generic_fromtext_txt(CALL_FROMTEXT);
}
static isc_result_t
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_avc);
- return (generic_totext_txt(CALL_TOTEXT));
+ return generic_totext_txt(CALL_TOTEXT);
}
static isc_result_t
fromwire_avc(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_avc);
- return (generic_fromwire_txt(CALL_FROMWIRE));
+ return generic_fromwire_txt(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
fromstruct_avc(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_avc);
- return (generic_fromstruct_txt(CALL_FROMSTRUCT));
+ return generic_fromstruct_txt(CALL_FROMSTRUCT);
}
static isc_result_t
avc->common.rdtype = rdata->type;
ISC_LINK_INIT(&avc->common, link);
- return (generic_tostruct_txt(CALL_TOSTRUCT));
+ return generic_tostruct_txt(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_avc(ARGS_COMPARE) {
- return (compare_avc(rdata1, rdata2));
+ return compare_avc(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_AVC_258_C */
RETERR(DNS_R_SYNTAX);
}
RETERR(multitxt_fromtext(&token.value.as_textregion, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
* Value
*/
RETERR(multitxt_totext(®ion, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*/
isc_buffer_activeregion(source, &sr);
if (sr.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/*
* Tag + Value
*/
isc_buffer_forward(source, sr.length);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, ®ion);
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
*/
region.base = caa->value;
region.length = caa->value_len;
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
* Flags
*/
if (sr.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
caa->flags = uint8_fromregion(&sr);
isc_region_consume(&sr, 1);
* Tag length
*/
if (sr.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
caa->tag_len = uint8_fromregion(&sr);
isc_region_consume(&sr, 1);
* Tag
*/
if (sr.length < caa->tag_len) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
caa->tag = mem_maybedup(mctx, sr.base, caa->tag_len);
if (caa->tag == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
isc_region_consume(&sr, caa->tag_len);
caa->value_len = sr.length;
caa->value = mem_maybedup(mctx, sr.base, sr.length);
if (caa->value == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
caa->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_caa(ARGS_COMPARE) {
- return (compare_caa(rdata1, rdata2));
+ return compare_caa(rdata1, rdata2);
}
#endif /* GENERIC_CAA_257_C */
fromtext_cdnskey(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_cdnskey);
- return (generic_fromtext_key(CALL_FROMTEXT));
+ return generic_fromtext_key(CALL_FROMTEXT);
}
static isc_result_t
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_cdnskey);
- return (generic_totext_key(CALL_TOTEXT));
+ return generic_totext_key(CALL_TOTEXT);
}
static isc_result_t
fromwire_cdnskey(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_cdnskey);
- return (generic_fromwire_key(CALL_FROMWIRE));
+ return generic_fromwire_key(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
fromstruct_cdnskey(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_cdnskey);
- return (generic_fromstruct_key(CALL_FROMSTRUCT));
+ return generic_fromstruct_key(CALL_FROMSTRUCT);
}
static isc_result_t
dnskey->common.rdtype = rdata->type;
ISC_LINK_INIT(&dnskey->common, link);
- return (generic_tostruct_key(CALL_TOSTRUCT));
+ return generic_tostruct_key(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
/*
* Treat ALG 253 (private DNS) subtype name case sensitively.
*/
- return (compare_cdnskey(rdata1, rdata2));
+ return compare_cdnskey(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_CDNSKEY_60_C */
fromtext_cds(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_cds);
- return (generic_fromtext_ds(CALL_FROMTEXT));
+ return generic_fromtext_ds(CALL_FROMTEXT);
}
static isc_result_t
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_cds);
- return (generic_totext_ds(CALL_TOTEXT));
+ return generic_totext_ds(CALL_TOTEXT);
}
static isc_result_t
fromwire_cds(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_cds);
- return (generic_fromwire_ds(CALL_FROMWIRE));
+ return generic_fromwire_ds(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
fromstruct_cds(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_cds);
- return (generic_fromstruct_ds(CALL_FROMSTRUCT));
+ return generic_fromstruct_ds(CALL_FROMSTRUCT);
}
static isc_result_t
cds->common.rdtype = rdata->type;
ISC_LINK_INIT(&cds->common, link);
- return (generic_tostruct_ds(CALL_TOSTRUCT));
+ return generic_tostruct_ds(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_cds(ARGS_COMPARE) {
- return (compare_cds(rdata1, rdata2));
+ return compare_cds(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_CDS_59_C */
RETTOK(dns_secalg_fromtext(&secalg, &token.value.as_textregion));
RETERR(mem_tobuffer(target, &secalg, 1));
- return (isc_base64_tobuffer(lexer, target, -2));
+ return isc_base64_tobuffer(lexer, target, -2);
}
static isc_result_t
if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) {
RETERR(str_totext(" )", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_activeregion(source, &sr);
if (sr.length < 6) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_buffer_forward(source, sr.length);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
RETERR(uint16_tobuffer(cert->key_tag, target));
RETERR(uint8_tobuffer(cert->algorithm, target));
- return (mem_tobuffer(target, cert->certificate, cert->length));
+ return mem_tobuffer(target, cert->certificate, cert->length);
}
static isc_result_t
cert->certificate = mem_maybedup(mctx, region.base, region.length);
if (cert->certificate == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
cert->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_cert(ARGS_COMPARE) {
- return (compare_cert(rdata1, rdata2));
+ return compare_cert(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_CERT_37_C */
origin = dns_rootname;
}
RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
dns_decompress_setmethods(dctx, DNS_COMPRESS_GLOBAL14);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
UNUSED(rdclass);
dns_name_toregion(&cname->cname, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&cname->cname, NULL);
name_duporclone(&name, mctx, &cname->cname);
cname->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
REQUIRE(rdata->type == dns_rdatatype_cname);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_cname(ARGS_COMPARE) {
- return (compare_cname(rdata1, rdata2));
+ return compare_cname(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_CNAME_5_C */
RETERR(uint16_tobuffer(token.value.as_ulong, target));
/* Type Map */
- return (typemap_fromtext(lexer, target, true));
+ return typemap_fromtext(lexer, target, true);
}
static isc_result_t
if (sr.length > 0) {
RETERR(str_totext(" ", target));
}
- return (typemap_totext(&sr, NULL, target));
+ return typemap_totext(&sr, NULL, target);
}
static isc_result_t
*/
isc_buffer_activeregion(source, &sr);
if (sr.length < 6) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, sr.base, 6));
RETERR(mem_tobuffer(target, sr.base, sr.length));
isc_buffer_forward(source, sr.length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
region.base = csync->typebits;
region.length = csync->len;
RETERR(typemap_test(®ion, true));
- return (mem_tobuffer(target, csync->typebits, csync->len));
+ return mem_tobuffer(target, csync->typebits, csync->len);
}
static isc_result_t
}
csync->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_csync);
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
dns_rdata_toregion(rdata1, ®ion1);
dns_rdata_toregion(rdata2, ®ion2);
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
#endif /* RDATA_GENERIC_CSYNC_62_C */
fromtext_dlv(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_dlv);
- return (generic_fromtext_ds(CALL_FROMTEXT));
+ return generic_fromtext_ds(CALL_FROMTEXT);
}
static isc_result_t
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_dlv);
- return (generic_totext_ds(CALL_TOTEXT));
+ return generic_totext_ds(CALL_TOTEXT);
}
static isc_result_t
fromwire_dlv(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_dlv);
- return (generic_fromwire_ds(CALL_FROMWIRE));
+ return generic_fromwire_ds(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
fromstruct_dlv(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_dlv);
- return (generic_fromstruct_ds(CALL_FROMSTRUCT));
+ return generic_fromstruct_ds(CALL_FROMSTRUCT);
}
static isc_result_t
dlv->common.rdtype = rdata->type;
ISC_LINK_INIT(&dlv->common, link);
- return (generic_tostruct_ds(CALL_TOSTRUCT));
+ return generic_tostruct_ds(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_dlv(ARGS_COMPARE) {
- return (compare_dlv(rdata1, rdata2));
+ return compare_dlv(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_DLV_32769_C */
origin = dns_rootname;
}
RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
dns_decompress_setmethods(dctx, DNS_COMPRESS_NONE);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
UNUSED(rdclass);
dns_name_toregion(&dname->dname, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&dname->dname, NULL);
name_duporclone(&name, mctx, &dname->dname);
dname->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_dname(ARGS_COMPARE) {
- return (compare_dname(rdata1, rdata2));
+ return compare_dname(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_DNAME_39_C */
fromtext_dnskey(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_dnskey);
- return (generic_fromtext_key(CALL_FROMTEXT));
+ return generic_fromtext_key(CALL_FROMTEXT);
}
static isc_result_t
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_dnskey);
- return (generic_totext_key(CALL_TOTEXT));
+ return generic_totext_key(CALL_TOTEXT);
}
static isc_result_t
fromwire_dnskey(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_dnskey);
- return (generic_fromwire_key(CALL_FROMWIRE));
+ return generic_fromwire_key(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
fromstruct_dnskey(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_dnskey);
- return (generic_fromstruct_key(CALL_FROMSTRUCT));
+ return generic_fromstruct_key(CALL_FROMSTRUCT);
}
static isc_result_t
dnskey->common.rdtype = rdata->type;
ISC_LINK_INIT(&dnskey->common, link);
- return (generic_tostruct_key(CALL_TOSTRUCT));
+ return generic_tostruct_key(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
/*
* Treat ALG 253 (private DNS) subtype name case sensitively.
*/
- return (compare_dnskey(rdata1, rdata2));
+ return compare_dnskey(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_DNSKEY_48_C */
RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
false));
if (strcmp(DNS_AS_STR(token), "-") == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
isc_lex_ungettoken(lexer, &token);
- return (isc_base64_tobuffer(lexer, target, -1));
+ return isc_base64_tobuffer(lexer, target, -1);
}
}
* DOA-DATA
*/
if (region.length == 0) {
- return (str_totext("-", target));
+ return str_totext("-", target);
} else {
- return (isc_base64_totext(®ion, 60, "", target));
+ return isc_base64_totext(®ion, 60, "", target);
}
}
* zero length.
*/
if (region.length < 4 + 4 + 1 + 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/*
* Check whether DOA-MEDIA-TYPE length is not malformed.
*/
if (region.base[9] > region.length - 10) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_buffer_forward(source, region.length);
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
}
static isc_result_t
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, ®ion);
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
RETERR(uint8_tobuffer(doa->location, target));
RETERR(uint8_tobuffer(doa->mediatype_len, target));
RETERR(mem_tobuffer(target, doa->mediatype, doa->mediatype_len));
- return (mem_tobuffer(target, doa->data, doa->data_len));
+ return mem_tobuffer(target, doa->data, doa->data_len);
}
static isc_result_t
* DOA-ENTERPRISE
*/
if (region.length < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
doa->enterprise = uint32_fromregion(®ion);
isc_region_consume(®ion, 4);
* DOA-TYPE
*/
if (region.length < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
doa->type = uint32_fromregion(®ion);
isc_region_consume(®ion, 4);
* DOA-LOCATION
*/
if (region.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
doa->location = uint8_fromregion(®ion);
isc_region_consume(®ion, 1);
* DOA-MEDIA-TYPE
*/
if (region.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
doa->mediatype_len = uint8_fromregion(®ion);
isc_region_consume(®ion, 1);
doa->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (mctx != NULL && doa->mediatype != NULL) {
isc_mem_free(mctx, doa->mediatype);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
REQUIRE(type == dns_rdatatype_doa);
- return (true);
+ return true;
}
static bool
REQUIRE(rdata->type == dns_rdatatype_doa);
- return (true);
+ return true;
}
static int
casecompare_doa(ARGS_COMPARE) {
- return (compare_doa(rdata1, rdata2));
+ return compare_doa(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_DOA_259_C */
length = -2;
break;
}
- return (isc_hex_tobuffer(lexer, target, length));
+ return isc_hex_tobuffer(lexer, target, length);
}
static isc_result_t
fromtext_ds(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_ds);
- return (generic_fromtext_ds(CALL_FROMTEXT));
+ return generic_fromtext_ds(CALL_FROMTEXT);
}
static isc_result_t
if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) {
RETERR(str_totext(" )", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_ds);
- return (generic_totext_ds(CALL_TOTEXT));
+ return generic_totext_ds(CALL_TOTEXT);
}
static isc_result_t
(sr.base[3] == DNS_DSDIGEST_SHA384 &&
sr.length < 4 + ISC_SHA384_DIGESTLENGTH))
{
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/*
}
isc_buffer_forward(source, sr.length);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static isc_result_t
fromwire_ds(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_ds);
- return (generic_fromwire_ds(CALL_FROMWIRE));
+ return generic_fromwire_ds(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
RETERR(uint8_tobuffer(ds->algorithm, target));
RETERR(uint8_tobuffer(ds->digest_type, target));
- return (mem_tobuffer(target, ds->digest, ds->length));
+ return mem_tobuffer(target, ds->digest, ds->length);
}
static isc_result_t
fromstruct_ds(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_ds);
- return (generic_fromstruct_ds(CALL_FROMSTRUCT));
+ return generic_fromstruct_ds(CALL_FROMSTRUCT);
}
static isc_result_t
ds->digest = mem_maybedup(mctx, region.base, region.length);
if (ds->digest == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
ds->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
ds->common.rdtype = rdata->type;
ISC_LINK_INIT(&ds->common, link);
- return (generic_tostruct_ds(CALL_TOSTRUCT));
+ return generic_tostruct_ds(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_ds(ARGS_COMPARE) {
- return (compare_ds(rdata1, rdata2));
+ return compare_ds(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_DS_43_C */
if (n != 6 || l0 > 255U || l1 > 255U || l2 > 255U || l3 > 255U ||
l4 > 255U || l5 > 255U)
{
- return (DNS_R_BADEUI);
+ return DNS_R_BADEUI;
}
eui48[0] = l0;
eui48[3] = l3;
eui48[4] = l4;
eui48[5] = l5;
- return (mem_tobuffer(target, eui48, sizeof(eui48)));
+ return mem_tobuffer(target, eui48, sizeof(eui48));
}
static isc_result_t
(void)snprintf(buf, sizeof(buf), "%02x-%02x-%02x-%02x-%02x-%02x",
rdata->data[0], rdata->data[1], rdata->data[2],
rdata->data[3], rdata->data[4], rdata->data[5]);
- return (str_totext(buf, target));
+ return str_totext(buf, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sregion);
if (sregion.length != 6) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
isc_buffer_forward(source, sregion.length);
- return (mem_tobuffer(target, sregion.base, sregion.length));
+ return mem_tobuffer(target, sregion.base, sregion.length);
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, ®ion1);
dns_rdata_toregion(rdata2, ®ion2);
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
static isc_result_t
UNUSED(type);
UNUSED(rdclass);
- return (mem_tobuffer(target, eui48->eui48, sizeof(eui48->eui48)));
+ return mem_tobuffer(target, eui48->eui48, sizeof(eui48->eui48));
}
static isc_result_t
ISC_LINK_INIT(&eui48->common, link);
memmove(eui48->eui48, rdata->data, rdata->length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_eui48(ARGS_COMPARE) {
- return (compare_eui48(rdata1, rdata2));
+ return compare_eui48(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_EUI48_108_C */
if (n != 8 || l0 > 255U || l1 > 255U || l2 > 255U || l3 > 255U ||
l4 > 255U || l5 > 255U || l6 > 255U || l7 > 255U)
{
- return (DNS_R_BADEUI);
+ return DNS_R_BADEUI;
}
eui64[0] = l0;
eui64[5] = l5;
eui64[6] = l6;
eui64[7] = l7;
- return (mem_tobuffer(target, eui64, sizeof(eui64)));
+ return mem_tobuffer(target, eui64, sizeof(eui64));
}
static isc_result_t
buf, sizeof(buf), "%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x",
rdata->data[0], rdata->data[1], rdata->data[2], rdata->data[3],
rdata->data[4], rdata->data[5], rdata->data[6], rdata->data[7]);
- return (str_totext(buf, target));
+ return str_totext(buf, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sregion);
if (sregion.length != 8) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
isc_buffer_forward(source, sregion.length);
- return (mem_tobuffer(target, sregion.base, sregion.length));
+ return mem_tobuffer(target, sregion.base, sregion.length);
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, ®ion1);
dns_rdata_toregion(rdata2, ®ion2);
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
static isc_result_t
UNUSED(type);
UNUSED(rdclass);
- return (mem_tobuffer(target, eui64->eui64, sizeof(eui64->eui64)));
+ return mem_tobuffer(target, eui64->eui64, sizeof(eui64->eui64));
}
static isc_result_t
ISC_LINK_INIT(&eui64->common, link);
memmove(eui64->eui64, rdata->data, rdata->length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_eui64(ARGS_COMPARE) {
- return (compare_eui64(rdata1, rdata2));
+ return compare_eui64(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_EUI64_109_C */
isc_tokentype_qstring, false));
RETTOK(txt_fromtext(&token.value.as_textregion, target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
for (i = 0; i < 3; i++) {
RETERR(txt_fromwire(source, target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
RETERR(uint8_tobuffer(gpos->lat_len, target));
RETERR(mem_tobuffer(target, gpos->latitude, gpos->lat_len));
RETERR(uint8_tobuffer(gpos->alt_len, target));
- return (mem_tobuffer(target, gpos->altitude, gpos->alt_len));
+ return mem_tobuffer(target, gpos->altitude, gpos->alt_len);
}
static isc_result_t
isc_region_consume(®ion, 1);
gpos->longitude = mem_maybedup(mctx, region.base, gpos->long_len);
if (gpos->longitude == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
isc_region_consume(®ion, gpos->long_len);
}
gpos->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_latitude:
if (mctx != NULL && gpos->longitude != NULL) {
if (mctx != NULL && gpos->latitude != NULL) {
isc_mem_free(mctx, gpos->latitude);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_gpos(ARGS_COMPARE) {
- return (compare_gpos(rdata1, rdata2));
+ return compare_gpos(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_GPOS_27_C */
isc_tokentype_qstring, false));
RETTOK(txt_fromtext(&token.value.as_textregion, target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
RETERR(txt_totext(®ion, true, target));
RETERR(str_totext(" ", target));
- return (txt_totext(®ion, true, target));
+ return txt_totext(®ion, true, target);
}
static isc_result_t
UNUSED(options);
RETERR(txt_fromwire(source, target));
- return (txt_fromwire(source, target));
+ return txt_fromwire(source, target);
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_hinfo);
REQUIRE(rdata->length != 0);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
RETERR(uint8_tobuffer(hinfo->cpu_len, target));
RETERR(mem_tobuffer(target, hinfo->cpu, hinfo->cpu_len));
RETERR(uint8_tobuffer(hinfo->os_len, target));
- return (mem_tobuffer(target, hinfo->os, hinfo->os_len));
+ return mem_tobuffer(target, hinfo->os, hinfo->os_len);
}
static isc_result_t
isc_region_consume(®ion, 1);
hinfo->cpu = mem_maybedup(mctx, region.base, hinfo->cpu_len);
if (hinfo->cpu == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
isc_region_consume(®ion, hinfo->cpu_len);
}
hinfo->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (mctx != NULL && hinfo->cpu != NULL) {
isc_mem_free(mctx, hinfo->cpu);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_hinfo(ARGS_COMPARE) {
- return (compare_hinfo(rdata1, rdata2));
+ return compare_hinfo(rdata1, rdata2);
}
*/
isc_lex_ungettoken(lexer, &token);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) {
RETERR(str_totext(" )", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_init(&name, NULL);
RETERR(dns_name_fromwire(&name, source, dctx, options, target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, ®ion);
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
}
static int
dns_rdata_toregion(rdata1, ®ion1);
dns_rdata_toregion(rdata2, ®ion2);
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
static isc_result_t
/* initialize the names */
}
- return (mem_tobuffer(target, hip->servers, hip->servers_len));
+ return mem_tobuffer(target, hip->servers, hip->servers_len);
}
static isc_result_t
hip->offset = hip->servers_len;
hip->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (hip->hit != NULL) {
if (hip->servers != NULL) {
isc_mem_free(mctx, hip->servers);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_hip);
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
isc_result_t
dns_rdata_hip_first(dns_rdata_hip_t *hip) {
if (hip->servers_len == 0) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
hip->offset = 0;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
dns_name_t name;
if (hip->offset >= hip->servers_len) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
region.base = hip->servers + hip->offset;
dns_name_fromregion(&name, ®ion);
hip->offset += name.length;
INSIST(hip->offset <= hip->servers_len);
- return (hip->offset < hip->servers_len ? ISC_R_SUCCESS : ISC_R_NOMORE);
+ return hip->offset < hip->servers_len ? ISC_R_SUCCESS : ISC_R_NOMORE;
}
void
INSIST(r2.length > 4);
order = memcmp(r1.base, r2.base, 4);
if (order != 0) {
- return (order);
+ return order;
}
hit_len = uint8_fromregion(&r1);
INSIST(r2.length >= (unsigned)(hit_len + key_len));
order = memcmp(r1.base, r2.base, hit_len + key_len);
if (order != 0) {
- return (order);
+ return order;
}
isc_region_consume(&r1, hit_len + key_len);
isc_region_consume(&r2, hit_len + key_len);
dns_name_fromregion(&name2, &r2);
order = dns_name_rdatacompare(&name1, &name2);
if (order != 0) {
- return (order);
+ return order;
}
isc_region_consume(&r1, name_length(&name1));
isc_region_consume(&r2, name_length(&name2));
}
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
}
isc_buffer_availableregion(target, ®ion);
if (region.length < 4) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, &addr, 4);
isc_buffer_add(target, 4);
}
isc_buffer_availableregion(target, ®ion);
if (region.length < 16) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, addr6, 16);
isc_buffer_add(target, 16);
/*
* Public key.
*/
- return (isc_base64_tobuffer(lexer, target, -2));
+ return isc_base64_tobuffer(lexer, target, -2);
}
static isc_result_t
dns_name_init(&name, NULL);
if (rdata->data[1] > 3U) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) {
if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) {
RETERR(str_totext(" )", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_activeregion(source, ®ion);
if (region.length < 3) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
switch (region.base[1]) {
case 0:
if (region.length < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_buffer_forward(source, region.length);
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
case 1:
if (region.length < 8) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_buffer_forward(source, region.length);
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
case 2:
if (region.length < 20) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_buffer_forward(source, region.length);
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
case 3:
RETERR(mem_tobuffer(target, region.base, 3));
isc_buffer_activeregion(source, ®ion);
isc_buffer_forward(source, region.length);
if (region.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
default:
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
}
UNUSED(cctx);
dns_rdata_toregion(rdata, ®ion);
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
}
static int
dns_rdata_toregion(rdata1, ®ion1);
dns_rdata_toregion(rdata2, ®ion2);
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
static isc_result_t
UNUSED(rdclass);
if (ipseckey->gateway_type > 3U) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
RETERR(uint8_tobuffer(ipseckey->precedence, target));
break;
}
- return (mem_tobuffer(target, ipseckey->key, ipseckey->keylength));
+ return mem_tobuffer(target, ipseckey->key, ipseckey->keylength);
}
static isc_result_t
REQUIRE(rdata->length >= 3);
if (rdata->data[1] > 3U) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
ipseckey->common.rdclass = rdata->rdclass;
dns_name_free(&ipseckey->gateway,
ipseckey->mctx);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
} else {
ipseckey->key = NULL;
}
ipseckey->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_ipseckey);
dns_rdata_toregion(rdata, ®ion);
- return ((digest)(arg, ®ion));
+ return (digest)(arg, ®ion);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
if (memcmp(region1.base, region2.base, 3) != 0 || region1.base[1] != 3)
{
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
dns_name_init(&name1, NULL);
order = dns_name_rdatacompare(&name1, &name2);
if (order != 0) {
- return (order);
+ return order;
}
isc_region_consume(®ion1, name_length(&name1));
isc_region_consume(®ion2, name_length(&name2));
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
#endif /* RDATA_GENERIC_IPSECKEY_45_C */
token.type != isc_tokentype_qstring)
{
isc_lex_ungettoken(lexer, &token);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
RETTOK(txt_fromtext(&token.value.as_textregion, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
RETERR(txt_totext(®ion, true, target));
if (region.length == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
RETERR(str_totext(" ", target));
- return (txt_totext(®ion, true, target));
+ return txt_totext(®ion, true, target);
}
static isc_result_t
RETERR(txt_fromwire(source, target));
if (buffer_empty(source)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (txt_fromwire(source, target));
+ return txt_fromwire(source, target);
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_isdn);
REQUIRE(rdata->length != 0);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
RETERR(uint8_tobuffer(isdn->isdn_len, target));
RETERR(mem_tobuffer(target, isdn->isdn, isdn->isdn_len));
if (isdn->subaddress == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
RETERR(uint8_tobuffer(isdn->subaddress_len, target));
- return (mem_tobuffer(target, isdn->subaddress, isdn->subaddress_len));
+ return mem_tobuffer(target, isdn->subaddress, isdn->subaddress_len);
}
static isc_result_t
isc_region_consume(&r, 1);
isdn->isdn = mem_maybedup(mctx, r.base, isdn->isdn_len);
if (isdn->isdn == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
isc_region_consume(&r, isdn->isdn_len);
}
isdn->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (mctx != NULL && isdn->isdn != NULL) {
isc_mem_free(mctx, isdn->isdn);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_isdn(ARGS_COMPARE) {
- return (compare_isdn(rdata1, rdata2));
+ return compare_isdn(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_ISDN_20_C */
case dns_rdatatype_cdnskey:
case dns_rdatatype_dnskey:
case dns_rdatatype_rkey:
- return (false);
+ return false;
case dns_rdatatype_key:
default:
- return ((flags & DNS_KEYFLAG_TYPEMASK) == DNS_KEYTYPE_NOKEY);
+ return (flags & DNS_KEYFLAG_TYPEMASK) == DNS_KEYTYPE_NOKEY;
}
}
/* No Key? */
if (generic_key_nokey(type, flags)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (isc_base64_tobuffer(lexer, target, -2));
+ return isc_base64_tobuffer(lexer, target, -2);
}
static isc_result_t
/* No Key? */
if (generic_key_nokey(rdata->type, flags)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if ((tctx->flags & DNS_STYLEFLAG_RRCOMMENT) != 0 &&
snprintf(buf, sizeof(buf), "%u", dst_region_computeid(&tmpr));
RETERR(str_totext(buf, target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_activeregion(source, &sr);
if (sr.length < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
flags = (sr.base[0] << 8) | sr.base[1];
if (type == dns_rdatatype_rkey && flags != 0U) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
algorithm = sr.base[3];
isc_buffer_forward(source, 4);
if (generic_key_nokey(type, flags)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (sr.length == 0) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (algorithm == DNS_KEYALG_PRIVATEDNS) {
isc_buffer_activeregion(source, &sr);
isc_buffer_forward(source, sr.length);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static isc_result_t
fromtext_key(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_key);
- return (generic_fromtext_key(CALL_FROMTEXT));
+ return generic_fromtext_key(CALL_FROMTEXT);
}
static isc_result_t
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_key);
- return (generic_totext_key(CALL_TOTEXT));
+ return generic_totext_key(CALL_TOTEXT);
}
static isc_result_t
fromwire_key(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_key);
- return (generic_fromwire_key(CALL_FROMWIRE));
+ return generic_fromwire_key(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
RETERR(uint8_tobuffer(key->algorithm, target));
/* Data */
- return (mem_tobuffer(target, key->data, key->datalen));
+ return mem_tobuffer(target, key->data, key->datalen);
}
static isc_result_t
/* Flags */
if (sr.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
key->flags = uint16_fromregion(&sr);
isc_region_consume(&sr, 2);
/* Protocol */
if (sr.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
key->protocol = uint8_fromregion(&sr);
isc_region_consume(&sr, 1);
/* Algorithm */
if (sr.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
key->algorithm = uint8_fromregion(&sr);
isc_region_consume(&sr, 1);
key->datalen = sr.length;
key->data = mem_maybedup(mctx, sr.base, key->datalen);
if (key->data == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
key->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
fromstruct_key(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_key);
- return (generic_fromstruct_key(CALL_FROMSTRUCT));
+ return generic_fromstruct_key(CALL_FROMSTRUCT);
}
static isc_result_t
key->common.rdtype = rdata->type;
ISC_LINK_INIT(&key->common, link);
- return (generic_tostruct_key(CALL_TOSTRUCT));
+ return generic_tostruct_key(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_key(ARGS_COMPARE) {
- return (compare_key(rdata1, rdata2));
+ return compare_key(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_KEY_25_C */
/* Do we have a placeholder KEYDATA record? */
if (flags == 0 && proto == 0 && alg == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* No Key? */
if ((flags & 0xc000) == 0xc000) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (isc_base64_tobuffer(lexer, target, -2));
+ return isc_base64_tobuffer(lexer, target, -2);
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_keydata);
if ((tctx->flags & DNS_STYLEFLAG_KEYDATA) == 0 || rdata->length < 16) {
- return (unknown_totext(rdata, tctx, target));
+ return unknown_totext(rdata, tctx, target);
}
dns_rdata_toregion(rdata, &sr);
if ((tctx->flags & DNS_STYLEFLAG_RRCOMMENT) != 0) {
RETERR(str_totext(" ; placeholder", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* No Key? */
if ((flags & 0xc000) == 0xc000) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* key */
}
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_activeregion(source, &sr);
isc_buffer_forward(source, sr.length);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
RETERR(uint8_tobuffer(keydata->algorithm, target));
/* Data */
- return (mem_tobuffer(target, keydata->data, keydata->datalen));
+ return mem_tobuffer(target, keydata->data, keydata->datalen);
}
static isc_result_t
/* Refresh timer */
if (sr.length < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
keydata->refresh = uint32_fromregion(&sr);
isc_region_consume(&sr, 4);
/* Add hold-down */
if (sr.length < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
keydata->addhd = uint32_fromregion(&sr);
isc_region_consume(&sr, 4);
/* Remove hold-down */
if (sr.length < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
keydata->removehd = uint32_fromregion(&sr);
isc_region_consume(&sr, 4);
/* Flags */
if (sr.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
keydata->flags = uint16_fromregion(&sr);
isc_region_consume(&sr, 2);
/* Protocol */
if (sr.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
keydata->protocol = uint8_fromregion(&sr);
isc_region_consume(&sr, 1);
/* Algorithm */
if (sr.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
keydata->algorithm = uint8_fromregion(&sr);
isc_region_consume(&sr, 1);
keydata->datalen = sr.length;
keydata->data = mem_maybedup(mctx, sr.base, keydata->datalen);
if (keydata->data == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
keydata->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_keydata(ARGS_COMPARE) {
- return (compare_keydata(rdata1, rdata2));
+ return compare_keydata(rdata1, rdata2);
}
#endif /* GENERIC_KEYDATA_65533_C */
}
isc_buffer_availableregion(target, ®ion);
if (region.length < 4) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, &addr, 4);
isc_buffer_add(target, 4);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
RETERR(str_totext(" ", target));
- return (inet_totext(AF_INET, tctx->flags, ®ion, target));
+ return inet_totext(AF_INET, tctx->flags, ®ion, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sregion);
if (sregion.length != 6) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
isc_buffer_forward(source, sregion.length);
- return (mem_tobuffer(target, sregion.base, sregion.length));
+ return mem_tobuffer(target, sregion.base, sregion.length);
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, ®ion1);
dns_rdata_toregion(rdata2, ®ion2);
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
static isc_result_t
RETERR(uint16_tobuffer(l32->pref, target));
n = ntohl(l32->l32.s_addr);
- return (uint32_tobuffer(n, target));
+ return uint32_tobuffer(n, target);
}
static isc_result_t
l32->pref = uint16_fromregion(®ion);
n = uint32_fromregion(®ion);
l32->l32.s_addr = htonl(n);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_l32(ARGS_COMPARE) {
- return (compare_l32(rdata1, rdata2));
+ return compare_l32(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_L32_105_C */
if (locator_pton(DNS_AS_STR(token), locator) != 1) {
RETTOK(DNS_R_SYNTAX);
}
- return (mem_tobuffer(target, locator, NS_LOCATORSZ));
+ return mem_tobuffer(target, locator, NS_LOCATORSZ);
}
static isc_result_t
region.base[2] << 8 | region.base[3],
region.base[4] << 8 | region.base[5],
region.base[6] << 8 | region.base[7]);
- return (str_totext(buf, target));
+ return str_totext(buf, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sregion);
if (sregion.length != 10) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
isc_buffer_forward(source, sregion.length);
- return (mem_tobuffer(target, sregion.base, sregion.length));
+ return mem_tobuffer(target, sregion.base, sregion.length);
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, ®ion1);
dns_rdata_toregion(rdata2, ®ion2);
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
static isc_result_t
UNUSED(rdclass);
RETERR(uint16_tobuffer(l64->pref, target));
- return (mem_tobuffer(target, l64->l64, sizeof(l64->l64)));
+ return mem_tobuffer(target, l64->l64, sizeof(l64->l64));
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
l64->pref = uint16_fromregion(®ion);
memmove(l64->l64, region.base, region.length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_l64(ARGS_COMPARE) {
- return (compare_l64(rdata1, rdata2));
+ return compare_l64(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_L64_106_C */
value = strtoul(str, &e, 10);
if (*e != 0 && *e != '.' && *e != units) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
if (value > max) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
ok = e != str;
if (*e == '.') {
break;
}
if ((tmp = decvalue(*e++)) < 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
ok = true;
value *= 10;
e++;
}
if (!ok || *e != 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
*valuep = value;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
m = strtoul(str, &e, 10);
if (*e != 0 && *e != '.' && *e != 'm') {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
if (m > 90000000) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
cm = 0;
ok = e != str;
break;
}
if ((tmp = decvalue(*e++)) < 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
ok = true;
cm *= 10;
e++;
}
if (!ok || *e != 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
/*
exp = 0;
}
*valuep = (man << 4) + exp;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
false));
*d = token->value.as_ulong;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
check_coordinate(unsigned long d, unsigned long m, unsigned long s,
unsigned long maxd) {
if (d > maxd || m > 59U) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
if (d == maxd && (m != 0 || s != 0)) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*m = token->value.as_ulong;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
false));
RETERR(loc_getdecimal(DNS_AS_STR(*token), 59, 3, '\0', s));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
DNS_AS_STR(*token)[1] == 0)
{
*direction = DNS_AS_STR(*token)[0];
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (DNS_AS_STR(*token)[0] == directions[0] &&
DNS_AS_STR(*token)[1] == 0)
{
*direction = DNS_AS_STR(*token)[0];
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
*direction = 0;
isc_lex_ungettoken(lexer, token);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*mp = m;
*sp = s;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNREACHABLE();
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNREACHABLE();
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*altitude = 10000000 + cm;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
if (token.type == isc_tokentype_eol || token.type == isc_tokentype_eof)
{
isc_lex_ungettoken(lexer, &token);
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
RETTOK(loc_getprecision(DNS_AS_STR(token), valuep));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
loc_getsize(isc_lex_t *lexer, unsigned char *sizep) {
- return (loc_getoptionalprecision(lexer, sizep));
+ return loc_getoptionalprecision(lexer, sizep);
}
static isc_result_t
loc_gethorizontalprecision(isc_lex_t *lexer, unsigned char *hpp) {
- return (loc_getoptionalprecision(lexer, hpp));
+ return loc_getoptionalprecision(lexer, hpp);
}
static isc_result_t
loc_getverticalprecision(isc_lex_t *lexer, unsigned char *vpp) {
- return (loc_getoptionalprecision(lexer, vpp));
+ return loc_getoptionalprecision(lexer, vpp);
}
/* The LOC record is expressed in a master file in the following format:
RETERR(uint32_tobuffer(longitude, target));
RETERR(uint32_tobuffer(altitude, target));
- return (result);
+ return result;
}
static isc_result_t
dns_rdata_toregion(rdata, &sr);
if (sr.base[0] != 0) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
REQUIRE(rdata->length == 16);
east ? "E" : "W", below ? "-" : "", altitude / 100,
altitude % 100, sbuf, hbuf, vbuf);
- return (str_totext(buf, target));
+ return str_totext(buf, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sr);
if (sr.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (sr.base[0] != 0) {
/* Treat as unknown. */
isc_buffer_forward(source, sr.length);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
if (sr.length < 16) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/*
if ((c & 0xf) > 9 || ((c >> 4) & 0xf) > 9 ||
((c >> 4) & 0xf) == 0)
{
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
/*
* Horizontal precision.
if ((c & 0xf) > 9 || ((c >> 4) & 0xf) > 9 ||
((c >> 4) & 0xf) == 0)
{
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
/*
* Vertical precision.
if ((c & 0xf) > 9 || ((c >> 4) & 0xf) > 9 ||
((c >> 4) & 0xf) == 0)
{
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
}
isc_region_consume(&sr, 4);
if (latitude < (0x80000000UL - 90 * 3600000) ||
latitude > (0x80000000UL + 90 * 3600000))
{
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
isc_region_consume(&sr, 4);
if (longitude < (0x80000000UL - 180 * 3600000) ||
longitude > (0x80000000UL + 180 * 3600000))
{
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
/*
isc_buffer_activeregion(source, &sr);
isc_buffer_forward(source, 16);
- return (mem_tobuffer(target, sr.base, 16));
+ return mem_tobuffer(target, sr.base, 16);
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_loc);
REQUIRE(rdata->length != 0);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
UNUSED(rdclass);
if (loc->v.v0.version != 0) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
RETERR(uint8_tobuffer(loc->v.v0.version, target));
c = loc->v.v0.size;
if ((c & 0xf) > 9 || ((c >> 4) & 0xf) > 9 || ((c >> 4) & 0xf) == 0) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
RETERR(uint8_tobuffer(loc->v.v0.size, target));
c = loc->v.v0.horizontal;
if ((c & 0xf) > 9 || ((c >> 4) & 0xf) > 9 || ((c >> 4) & 0xf) == 0) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
RETERR(uint8_tobuffer(loc->v.v0.horizontal, target));
c = loc->v.v0.vertical;
if ((c & 0xf) > 9 || ((c >> 4) & 0xf) > 9 || ((c >> 4) & 0xf) == 0) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
RETERR(uint8_tobuffer(loc->v.v0.vertical, target));
if (loc->v.v0.latitude < (0x80000000UL - 90 * 3600000) ||
loc->v.v0.latitude > (0x80000000UL + 90 * 3600000))
{
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
RETERR(uint32_tobuffer(loc->v.v0.latitude, target));
if (loc->v.v0.longitude < (0x80000000UL - 180 * 3600000) ||
loc->v.v0.longitude > (0x80000000UL + 180 * 3600000))
{
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
RETERR(uint32_tobuffer(loc->v.v0.longitude, target));
- return (uint32_tobuffer(loc->v.v0.altitude, target));
+ return uint32_tobuffer(loc->v.v0.altitude, target);
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
version = uint8_fromregion(&r);
if (version != 0) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
loc->common.rdclass = rdata->rdclass;
isc_region_consume(&r, 4);
loc->v.v0.altitude = uint32_fromregion(&r);
isc_region_consume(&r, 4);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_loc(ARGS_COMPARE) {
- return (compare_loc(rdata1, rdata2));
+ return compare_loc(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_LOC_29_C */
if (origin == NULL) {
origin = dns_rootname;
}
- return (dns_name_fromtext(&name, &buffer, origin, options, target));
+ return dns_name_fromtext(&name, &buffer, origin, options, target);
}
static isc_result_t
dns_name_fromregion(&name, ®ion);
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sregion);
if (sregion.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, sregion.base, 2));
isc_buffer_forward(source, 2);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, ®ion1);
dns_rdata_toregion(rdata2, ®ion2);
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
static isc_result_t
RETERR(uint16_tobuffer(lp->pref, target));
dns_name_toregion(&lp->lp, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&lp->lp, NULL);
name_duporclone(&name, mctx, &lp->lp);
lp->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
result = (add)(arg, &name, dns_rdatatype_l32, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return ((add)(arg, &name, dns_rdatatype_l64, NULL));
+ return (add)(arg, &name, dns_rdatatype_l64, NULL);
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_lp);
dns_rdata_toregion(rdata, ®ion);
- return ((digest)(arg, ®ion));
+ return (digest)(arg, ®ion);
}
static bool
UNUSED(name);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(bad);
UNUSED(owner);
- return (true);
+ return true;
}
static int
order = memcmp(rdata1->data, rdata2->data, 2);
if (order != 0) {
- return (order < 0 ? -1 : 1);
+ return order < 0 ? -1 : 1;
}
dns_name_init(&name1, NULL);
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
#endif /* RDATA_GENERIC_LP_107_C */
origin = dns_rootname;
}
RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
dns_decompress_setmethods(dctx, DNS_COMPRESS_GLOBAL14);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
UNUSED(rdclass);
dns_name_toregion(&mb->mb, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&mb->mb, NULL);
name_duporclone(&name, mctx, &mb->mb);
mb->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return ((add)(arg, &name, dns_rdatatype_a, NULL));
+ return (add)(arg, &name, dns_rdatatype_a, NULL);
}
static isc_result_t
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (dns_name_ismailbox(name));
+ return dns_name_ismailbox(name);
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_mb(ARGS_COMPARE) {
- return (compare_mb(rdata1, rdata2));
+ return compare_mb(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_MB_7_C */
origin = dns_rootname;
}
RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
dns_decompress_setmethods(dctx, DNS_COMPRESS_GLOBAL14);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
UNUSED(rdclass);
dns_name_toregion(&md->md, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&md->md, NULL);
name_duporclone(&name, mctx, &md->md);
md->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return ((add)(arg, &name, dns_rdatatype_a, NULL));
+ return (add)(arg, &name, dns_rdatatype_a, NULL);
}
static isc_result_t
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_md(ARGS_COMPARE) {
- return (compare_md(rdata1, rdata2));
+ return compare_md(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_MD_3_C */
origin = dns_rootname;
}
RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
dns_decompress_setmethods(dctx, DNS_COMPRESS_GLOBAL14);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
UNUSED(rdclass);
dns_name_toregion(&mf->mf, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&mf->mf, NULL);
name_duporclone(&name, mctx, &mf->mf);
mf->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return ((add)(arg, &name, dns_rdatatype_a, NULL));
+ return (add)(arg, &name, dns_rdatatype_a, NULL);
}
static isc_result_t
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_mf(ARGS_COMPARE) {
- return (compare_mf(rdata1, rdata2));
+ return compare_mf(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_MF_4_C */
origin = dns_rootname;
}
RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
dns_decompress_setmethods(dctx, DNS_COMPRESS_GLOBAL14);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
UNUSED(rdclass);
dns_name_toregion(&mg->mg, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&mg->mg, NULL);
name_duporclone(&name, mctx, &mg->mg);
mg->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(rdata);
UNUSED(owner);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (dns_name_ismailbox(name));
+ return dns_name_ismailbox(name);
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_mg(ARGS_COMPARE) {
- return (compare_mg(rdata1, rdata2));
+ return compare_mg(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_MG_8_C */
warn_badname(&name, lexer, callbacks);
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
RETERR(str_totext(" ", target));
sub = name_prefix(&email, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
dns_name_init(&email, NULL);
RETERR(dns_name_fromwire(&rmail, source, dctx, options, target));
- return (dns_name_fromwire(&email, source, dctx, options, target));
+ return dns_name_fromwire(&email, source, dctx, options, target);
}
static isc_result_t
dns_name_fromregion(&rmail, ®ion);
isc_region_consume(®ion, rmail.length);
- return (dns_name_towire(&rmail, cctx, target));
+ return dns_name_towire(&rmail, cctx, target);
}
static int
order = dns_name_rdatacompare(&name1, &name2);
if (order != 0) {
- return (order);
+ return order;
}
isc_region_consume(®ion1, name_length(&name1));
dns_name_fromregion(&name2, ®ion2);
order = dns_name_rdatacompare(&name1, &name2);
- return (order);
+ return order;
}
static isc_result_t
dns_name_toregion(&minfo->rmailbox, ®ion);
RETERR(isc_buffer_copyregion(target, ®ion));
dns_name_toregion(&minfo->emailbox, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&minfo->emailbox, NULL);
name_duporclone(&name, mctx, &minfo->emailbox);
minfo->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_fromregion(&name, &r);
result = dns_name_digest(&name, digest, arg);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_region_consume(&r, name_length(&name));
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
if (bad != NULL) {
dns_name_clone(&name, bad);
}
- return (false);
+ return false;
}
isc_region_consume(®ion, name_length(&name));
dns_name_fromregion(&name, ®ion);
if (bad != NULL) {
dns_name_clone(&name, bad);
}
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static int
casecompare_minfo(ARGS_COMPARE) {
- return (compare_minfo(rdata1, rdata2));
+ return compare_minfo(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_MINFO_14_C */
origin = dns_rootname;
}
RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
dns_decompress_setmethods(dctx, DNS_COMPRESS_GLOBAL14);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
UNUSED(rdclass);
dns_name_toregion(&mr->mr, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&mr->mr, NULL);
name_duporclone(&name, mctx, &mr->mr);
mr->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_mr(ARGS_COMPARE) {
- return (compare_mr(rdata1, rdata2));
+ return compare_mr(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_MR_9_C */
struct in6_addr addr6;
if (strlcpy(tmp, DNS_AS_STR(*token), sizeof(tmp)) >= sizeof(tmp)) {
- return (true);
+ return true;
}
if (tmp[strlen(tmp) - 1] == '.') {
if (inet_pton(AF_INET, tmp, &addr) == 1 ||
inet_pton(AF_INET6, tmp, &addr6) == 1)
{
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static isc_result_t
if (!ok && callbacks != NULL) {
warn_badname(&name, lexer, callbacks);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_fromregion(&name, ®ion);
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sregion);
if (sregion.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, sregion.base, 2));
isc_buffer_forward(source, 2);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
dns_name_init(&name, offsets);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
order = memcmp(rdata1->data, rdata2->data, 2);
if (order != 0) {
- return (order < 0 ? -1 : 1);
+ return order < 0 ? -1 : 1;
}
dns_name_init(&name1, NULL);
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
RETERR(uint16_tobuffer(mx->pref, target));
dns_name_toregion(&mx->mx, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&mx->mx, NULL);
name_duporclone(&name, mctx, &mx->mx);
mx->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
dns_name_fromregion(&name, ®ion);
if (dns_name_equal(&name, dns_rootname)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = (add)(arg, &name, dns_rdatatype_a, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_fixedname_init(&fixed);
result = dns_name_concatenate(&port25, &name,
dns_fixedname_name(&fixed), NULL);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return ((add)(arg, dns_fixedname_name(&fixed), dns_rdatatype_tlsa,
- NULL));
+ return (add)(arg, dns_fixedname_name(&fixed), dns_rdatatype_tlsa, NULL);
}
static isc_result_t
RETERR((digest)(arg, &r1));
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r2);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(type);
UNUSED(rdclass);
- return (dns_name_ishostname(name, wildcard));
+ return dns_name_ishostname(name, wildcard);
}
static bool
if (bad != NULL) {
dns_name_clone(&name, bad);
}
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static int
casecompare_mx(ARGS_COMPARE) {
- return (compare_mx(rdata1, rdata2));
+ return compare_mx(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_MX_15_C */
len = *txt++;
if (len == 0U) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
delim = *txt++;
case '\\':
case 'i':
case 0:
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
cp = regex;
while (len-- > 0) {
c = *txt++;
if (c == 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
if (c == delim && !replace) {
replace = true;
flags = true;
continue;
} else if (c == delim) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
/*
* Flags are not escaped.
case 'i':
continue;
default:
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
}
if (!replace) {
}
if (c == '\\') {
if (len == 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
c = *txt++;
if (c == 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
len--;
if (replace) {
switch (c) {
case '0':
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
case '1':
if (nsub < 1) {
nsub = 1;
}
}
if (!flags) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
*cp = '\0';
n = isc_regex_validate(regex);
if (n < 0 || nsub > (unsigned int)n) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
origin = dns_rootname;
}
RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*/
dns_name_fromregion(&name, ®ion);
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
*/
isc_buffer_activeregion(source, &sr);
if (sr.length < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, sr.base, 4));
isc_buffer_forward(source, 4);
/*
* Replacement.
*/
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
*/
dns_name_init(&name, offsets);
dns_name_fromregion(&name, &sr);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
*/
order = memcmp(region1.base, region2.base, 4);
if (order != 0) {
- return (order < 0 ? -1 : 1);
+ return order < 0 ? -1 : 1;
}
isc_region_consume(®ion1, 4);
isc_region_consume(®ion2, 4);
len = ISC_MIN(region1.base[0], region2.base[0]);
order = memcmp(region1.base, region2.base, len + 1);
if (order != 0) {
- return (order < 0 ? -1 : 1);
+ return order < 0 ? -1 : 1;
}
isc_region_consume(®ion1, region1.base[0] + 1);
isc_region_consume(®ion2, region2.base[0] + 1);
len = ISC_MIN(region1.base[0], region2.base[0]);
order = memcmp(region1.base, region2.base, len + 1);
if (order != 0) {
- return (order < 0 ? -1 : 1);
+ return order < 0 ? -1 : 1;
}
isc_region_consume(®ion1, region1.base[0] + 1);
isc_region_consume(®ion2, region2.base[0] + 1);
len = ISC_MIN(region1.base[0], region2.base[0]);
order = memcmp(region1.base, region2.base, len + 1);
if (order != 0) {
- return (order < 0 ? -1 : 1);
+ return order < 0 ? -1 : 1;
}
isc_region_consume(®ion1, region1.base[0] + 1);
isc_region_consume(®ion2, region2.base[0] + 1);
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
RETERR(uint8_tobuffer(naptr->regexp_len, target));
RETERR(mem_tobuffer(target, naptr->regexp, naptr->regexp_len));
dns_name_toregion(&naptr->replacement, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&naptr->replacement, NULL);
name_duporclone(&name, mctx, &naptr->replacement);
naptr->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (mctx != NULL && naptr->flags != NULL) {
if (mctx != NULL && naptr->regexp != NULL) {
isc_mem_free(mctx, naptr->regexp);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
static void
dns_name_fromregion(&name, &sr);
if (atype != 0) {
- return ((add)(arg, &name, atype, NULL));
+ return (add)(arg, &name, atype, NULL);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
r1.length = length;
result = (digest)(arg, &r1);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r2);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_naptr(ARGS_COMPARE) {
- return (compare_naptr(rdata1, rdata2));
+ return compare_naptr(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_NAPTR_35_C */
if (locator_pton(DNS_AS_STR(token), locator) != 1) {
RETTOK(DNS_R_SYNTAX);
}
- return (mem_tobuffer(target, locator, NS_LOCATORSZ));
+ return mem_tobuffer(target, locator, NS_LOCATORSZ);
}
static isc_result_t
region.base[2] << 8 | region.base[3],
region.base[4] << 8 | region.base[5],
region.base[6] << 8 | region.base[7]);
- return (str_totext(buf, target));
+ return str_totext(buf, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sregion);
if (sregion.length != 10) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
isc_buffer_forward(source, sregion.length);
- return (mem_tobuffer(target, sregion.base, sregion.length));
+ return mem_tobuffer(target, sregion.base, sregion.length);
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, ®ion1);
dns_rdata_toregion(rdata2, ®ion2);
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
static isc_result_t
UNUSED(rdclass);
RETERR(uint16_tobuffer(nid->pref, target));
- return (mem_tobuffer(target, nid->nid, sizeof(nid->nid)));
+ return mem_tobuffer(target, nid->nid, sizeof(nid->nid));
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
nid->pref = uint16_fromregion(®ion);
memmove(nid->nid, region.base, region.length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_nid(ARGS_COMPARE) {
- return (compare_nid(rdata1, rdata2));
+ return compare_nid(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_NID_104_C */
fromtext_ninfo(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_ninfo);
- return (generic_fromtext_txt(CALL_FROMTEXT));
+ return generic_fromtext_txt(CALL_FROMTEXT);
}
static isc_result_t
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_ninfo);
- return (generic_totext_txt(CALL_TOTEXT));
+ return generic_totext_txt(CALL_TOTEXT);
}
static isc_result_t
fromwire_ninfo(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_ninfo);
- return (generic_fromwire_txt(CALL_FROMWIRE));
+ return generic_fromwire_txt(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
fromstruct_ninfo(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_ninfo);
- return (generic_fromstruct_txt(CALL_FROMSTRUCT));
+ return generic_fromstruct_txt(CALL_FROMSTRUCT);
}
static isc_result_t
ninfo->common.rdtype = rdata->type;
ISC_LINK_INIT(&ninfo->common, link);
- return (generic_tostruct_txt(CALL_TOSTRUCT));
+ return generic_tostruct_txt(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_ninfo(ARGS_COMPARE) {
- return (compare_ninfo(rdata1, rdata2));
+ return compare_ninfo(rdata1, rdata2);
}
isc_result_t
REQUIRE(ninfo != NULL);
REQUIRE(ninfo->common.rdtype == dns_rdatatype_ninfo);
- return (generic_txt_first(ninfo));
+ return generic_txt_first(ninfo);
}
isc_result_t
REQUIRE(ninfo != NULL);
REQUIRE(ninfo->common.rdtype == dns_rdatatype_ninfo);
- return (generic_txt_next(ninfo));
+ return generic_txt_next(ninfo);
}
isc_result_t
REQUIRE(ninfo != NULL);
REQUIRE(ninfo->common.rdtype == dns_rdatatype_ninfo);
- return (generic_txt_current(ninfo, string));
+ return generic_txt_current(ninfo, string);
}
#endif /* RDATA_GENERIC_NINFO_56_C */
if (!ok && callbacks != NULL) {
warn_badname(&name, lexer, callbacks);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
dns_decompress_setmethods(dctx, DNS_COMPRESS_GLOBAL14);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
UNUSED(rdclass);
dns_name_toregion(&ns->name, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&ns->name, NULL);
name_duporclone(&name, mctx, &ns->name);
ns->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return ((add)(arg, &name, dns_rdatatype_a, NULL));
+ return (add)(arg, &name, dns_rdatatype_a, NULL);
}
static isc_result_t
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
if (bad != NULL) {
dns_name_clone(&name, bad);
}
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static int
casecompare_ns(ARGS_COMPARE) {
- return (compare_ns(rdata1, rdata2));
+ return compare_ns(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_NS_2_C */
RETERR(uint8_tobuffer(isc_buffer_usedlength(&b), target));
RETERR(mem_tobuffer(target, &buf, isc_buffer_usedlength(&b)));
- return (typemap_fromtext(lexer, target, true));
+ return typemap_fromtext(lexer, target, true);
}
static isc_result_t
RETERR(str_totext(" )", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
RETERR(mem_tobuffer(target, rr.base, rr.length));
isc_buffer_forward(source, rr.length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
region.base = nsec3->typebits;
region.length = nsec3->len;
RETERR(typemap_test(®ion, true));
- return (mem_tobuffer(target, nsec3->typebits, nsec3->len));
+ return mem_tobuffer(target, nsec3->typebits, nsec3->len);
}
static isc_result_t
INSIST(nsec3->salt_length <= region.length);
nsec3->salt = mem_maybedup(mctx, region.base, nsec3->salt_length);
if (nsec3->salt == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
isc_region_consume(®ion, nsec3->salt_length);
}
nsec3->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (nsec3->next != NULL) {
isc_mem_free(mctx, nsec3->next);
}
isc_mem_free(mctx, nsec3->salt);
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_nsec3);
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
isc_region_consume(&label, 1);
isc_buffer_init(&buffer, owner, sizeof(owner));
if (isc_base32hexnp_decoderegion(&label, &buffer) == ISC_R_SUCCESS) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_nsec3(ARGS_COMPARE) {
- return (compare_nsec3(rdata1, rdata2));
+ return compare_nsec3(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_NSEC3_50_C */
RETERR(isc_hex_decodestring(DNS_AS_STR(token), target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
RETERR(str_totext("-", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_region_consume(&sr, saltlen);
RETERR(mem_tobuffer(target, rr.base, rr.length));
isc_buffer_forward(source, rr.length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
RETERR(uint16_tobuffer(nsec3param->iterations, target));
RETERR(uint8_tobuffer(nsec3param->salt_length, target));
RETERR(mem_tobuffer(target, nsec3param->salt, nsec3param->salt_length));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
nsec3param->salt = mem_maybedup(mctx, region.base,
nsec3param->salt_length);
if (nsec3param->salt == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
isc_region_consume(®ion, nsec3param->salt_length);
nsec3param->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_nsec3param);
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_nsec3param(ARGS_COMPARE) {
- return (compare_nsec3param(rdata1, rdata2));
+ return compare_nsec3param(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_NSEC3PARAM_51_C */
}
RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));
- return (typemap_fromtext(lexer, target, false));
+ return typemap_fromtext(lexer, target, false);
}
static isc_result_t
if (sr.length > 0) {
RETERR(str_totext(" ", target));
}
- return (typemap_totext(&sr, NULL, target));
+ return typemap_totext(&sr, NULL, target);
}
static isc_result_t
RETERR(typemap_test(&sr, false));
RETERR(mem_tobuffer(target, sr.base, sr.length));
isc_buffer_forward(source, sr.length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_region_consume(&sr, name_length(&name));
RETERR(dns_name_towire(&name, cctx, target));
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
region.base = nsec->typebits;
region.length = nsec->len;
RETERR(typemap_test(®ion, false));
- return (mem_tobuffer(target, nsec->typebits, nsec->len));
+ return mem_tobuffer(target, nsec->typebits, nsec->len);
}
static isc_result_t
}
nsec->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (mctx != NULL) {
dns_name_free(&nsec->next, mctx);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_nsec);
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
order = dns_name_rdatacompare(&name1, &name2);
if (order != 0) {
- return (order);
+ return order;
}
isc_region_consume(®ion1, name_length(&name1));
isc_region_consume(®ion2, name_length(&name2));
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
#endif /* RDATA_GENERIC_NSEC_47_C */
UNUSED(target);
UNUSED(callbacks);
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
static isc_result_t
totext_null(ARGS_TOTEXT) {
REQUIRE(rdata->type == dns_rdatatype_null);
- return (unknown_totext(rdata, tctx, target));
+ return unknown_totext(rdata, tctx, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sr);
isc_buffer_forward(source, sr.length);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
UNUSED(type);
UNUSED(rdclass);
- return (mem_tobuffer(target, null->data, null->length));
+ return mem_tobuffer(target, null->data, null->length);
}
static isc_result_t
null->length = r.length;
null->data = mem_maybedup(mctx, r.base, r.length);
if (null->data == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
null->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_null(ARGS_COMPARE) {
- return (compare_null(rdata1, rdata2));
+ return compare_null(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_NULL_10_C */
* NXT is only specified for types 1..127.
*/
if (covered < 1 || covered > 127) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
if (first || covered > maxcovered) {
maxcovered = covered;
} while (1);
isc_lex_ungettoken(lexer, &token);
if (first) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
n = (maxcovered + 8) / 8;
- return (mem_tobuffer(target, bm, n));
+ return mem_tobuffer(target, bm, n);
}
static isc_result_t
}
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
if (sr.length > 0 && ((sr.base[0] & 0x80) != 0 || sr.length > 16 ||
sr.base[sr.length - 1] == 0))
{
- return (DNS_R_BADBITMAP);
+ return DNS_R_BADBITMAP;
}
RETERR(mem_tobuffer(target, sr.base, sr.length));
isc_buffer_forward(source, sr.length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_region_consume(&sr, name_length(&name));
RETERR(dns_name_towire(&name, cctx, target));
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_name_fromregion(&name2, &r2);
order = dns_name_rdatacompare(&name1, &name2);
if (order != 0) {
- return (order);
+ return order;
}
isc_region_consume(&r1, name_length(&name1));
isc_region_consume(&r2, name_length(&name2));
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
dns_name_toregion(&nxt->next, ®ion);
RETERR(isc_buffer_copyregion(target, ®ion));
- return (mem_tobuffer(target, nxt->typebits, nxt->len));
+ return mem_tobuffer(target, nxt->typebits, nxt->len);
}
static isc_result_t
}
nxt->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (mctx != NULL) {
dns_name_free(&nxt->next, mctx);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_fromregion(&name, &r);
result = dns_name_digest(&name, digest, arg);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_region_consume(&r, name_length(&name));
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_nxt(ARGS_COMPARE) {
- return (compare_nxt(rdata1, rdata2));
+ return compare_nxt(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_NXT_30_C */
/*
* Keyring.
*/
- return (isc_base64_tobuffer(lexer, target, -2));
+ return isc_base64_tobuffer(lexer, target, -2);
}
static isc_result_t
RETERR(str_totext(" )", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*/
isc_buffer_activeregion(source, &sr);
if (sr.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_buffer_forward(source, sr.length);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
/*
* Keyring.
*/
- return (mem_tobuffer(target, sig->keyring, sig->length));
+ return mem_tobuffer(target, sig->keyring, sig->length);
}
static isc_result_t
}
sig->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
#endif /* RDATA_GENERIC_OPENPGPKEY_61_C */
UNUSED(target);
UNUSED(callbacks);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static isc_result_t
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_activeregion(source, &sregion);
if (sregion.length == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
total = 0;
while (sregion.length != 0) {
if (sregion.length < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
opt = uint16_fromregion(&sregion);
isc_region_consume(&sregion, 2);
isc_region_consume(&sregion, 2);
total += 4;
if (sregion.length < length) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
switch (opt) {
case DNS_OPT_LLQ:
if (length != 18U) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
isc_region_consume(&sregion, length);
break;
uint8_t addrbytes;
if (length < 4) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
family = uint16_fromregion(&sregion);
isc_region_consume(&sregion, 2);
* family is unknown.
*/
if (addrlen != 0U || scope != 0U) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
break;
case 1:
if (addrlen > 32U || scope > 32U) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
break;
case 2:
if (addrlen > 128U || scope > 128U) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
break;
default:
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
addrbytes = (addrlen + 7) / 8;
if (addrbytes + 4 != length) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
if (addrbytes != 0U && (addrlen % 8) != 0) {
uint8_t bits = ~0U << (8 - (addrlen % 8));
bits &= sregion.base[addrbytes - 1];
if (bits != sregion.base[addrbytes - 1]) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
}
isc_region_consume(&sregion, addrbytes);
* Request has zero length. Response is 32 bits.
*/
if (length != 0 && length != 4) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
isc_region_consume(&sregion, length);
break;
* Client + server cookie is 8 + [8..32].
*/
if (length != 8 && (length < 16 || length > 40)) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
isc_region_consume(&sregion, length);
break;
case DNS_OPT_KEY_TAG:
if (length == 0 || (length % 2) != 0) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
isc_region_consume(&sregion, length);
break;
case DNS_OPT_EDE:
if (length < 2) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
/* UTF-8 Byte Order Mark is not permitted. RFC 5198 */
if (isc_utf8_bom(sregion.base + 2, length - 2)) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
/*
* The EXTRA-TEXT field is specified as UTF-8, and
* according to RFC 3269 security considerations.
*/
if (!isc_utf8_valid(sregion.base + 2, length - 2)) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
isc_region_consume(&sregion, length);
break;
FALLTHROUGH;
case DNS_OPT_SERVER_TAG:
if (length != 2) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
isc_region_consume(&sregion, length);
break;
isc_buffer_activeregion(source, &sregion);
isc_buffer_availableregion(target, &tregion);
if (tregion.length < total) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tregion.base, sregion.base, total);
isc_buffer_forward(source, total);
isc_buffer_add(target, total);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
length = uint16_fromregion(®ion);
isc_region_consume(®ion, 2);
if (region.length < length) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_region_consume(®ion, length);
}
if (region.length != 0) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
- return (mem_tobuffer(target, opt->options, opt->length));
+ return mem_tobuffer(target, opt->options, opt->length);
}
static isc_result_t
opt->length = r.length;
opt->options = mem_maybedup(mctx, r.base, r.length);
if (opt->options == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
opt->offset = 0;
opt->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(digest);
UNUSED(arg);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (dns_name_equal(name, dns_rootname));
+ return dns_name_equal(name, dns_rootname);
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_opt(ARGS_COMPARE) {
- return (compare_opt(rdata1, rdata2));
+ return compare_opt(rdata1, rdata2);
}
isc_result_t
REQUIRE(opt->options != NULL || opt->length == 0);
if (opt->length == 0) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
opt->offset = 0;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
INSIST(opt->offset + 4 + length <= opt->length);
opt->offset = opt->offset + 4 + length;
if (opt->offset == opt->length) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
opcode->data = r.base;
INSIST(opt->offset + 4 + opcode->length <= opt->length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#endif /* RDATA_GENERIC_OPT_41_C */
RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
false));
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static isc_result_t totext_ #(ARGS_TOTEXT) {
REQUIRE(rdata->rdclass == #);
REQUIRE(rdata->length != 0); /* XXX */
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static isc_result_t fromwire_ #(ARGS_FROMWIRE) {
/* NONE or GLOBAL14 */
dns_decompress_setmethods(dctx, DNS_COMPRESS_NONE);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static isc_result_t towire_ #(ARGS_TOWIRE) {
/* NONE or GLOBAL14 */
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static int compare_ #(ARGS_COMPARE) {
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t fromstruct_ #(ARGS_FROMSTRUCT) {
REQUIRE(#->common.rdtype == dns_rdatatype_proforma.ctype);
REQUIRE(#->common.rdclass == rdclass);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static isc_result_t tostruct_ #(ARGS_TOSTRUCT) {
REQUIRE(rdata->rdclass == #);
REQUIRE(rdata->length != 0); /* XXX */
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static void freestruct_ #(ARGS_FREESTRUCT) {
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t digest_ #(ARGS_DIGEST) {
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool checkowner_ #(ARGS_CHECKOWNER) {
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool checknames_ #(ARGS_CHECKNAMES) {
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int casecompare_ #(ARGS_COMPARE) {
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
#endif /* RDATA_GENERIC_#_#_C */
warn_badname(&name, lexer, callbacks);
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
dns_decompress_setmethods(dctx, DNS_COMPRESS_GLOBAL14);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
UNUSED(rdclass);
dns_name_toregion(&ptr->ptr, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&ptr->ptr, NULL);
name_duporclone(&name, mctx, &ptr->ptr);
ptr->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static unsigned char ip6_arpa_data[] = "\003IP6\004ARPA";
REQUIRE(rdata->type == dns_rdatatype_ptr);
if (rdata->rdclass != dns_rdataclass_in) {
- return (true);
+ return true;
}
if (dns_name_isdnssd(owner)) {
- return (true);
+ return true;
}
if (dns_name_issubdomain(owner, &in_addr_arpa) ||
if (bad != NULL) {
dns_name_clone(&name, bad);
}
- return (false);
+ return false;
}
}
- return (true);
+ return true;
}
static int
casecompare_ptr(ARGS_COMPARE) {
- return (compare_ptr(rdata1, rdata2));
+ return compare_ptr(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_PTR_12_C */
fromtext_resinfo(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_resinfo);
- return (generic_fromtext_txt(CALL_FROMTEXT));
+ return generic_fromtext_txt(CALL_FROMTEXT);
}
static isc_result_t
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_resinfo);
- return (generic_totext_txt(CALL_TOTEXT));
+ return generic_totext_txt(CALL_TOTEXT);
}
static isc_result_t
fromwire_resinfo(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_resinfo);
- return (generic_fromwire_txt(CALL_FROMWIRE));
+ return generic_fromwire_txt(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
fromstruct_resinfo(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_resinfo);
- return (generic_fromstruct_txt(CALL_FROMSTRUCT));
+ return generic_fromstruct_txt(CALL_FROMSTRUCT);
}
static isc_result_t
resinfo->common.rdtype = rdata->type;
ISC_LINK_INIT(&resinfo->common, link);
- return (generic_tostruct_txt(CALL_TOSTRUCT));
+ return generic_tostruct_txt(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_resinfo(ARGS_COMPARE) {
- return (compare_resinfo(rdata1, rdata2));
+ return compare_resinfo(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_RESINFO_261_C */
fromtext_rkey(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_rkey);
- return (generic_fromtext_key(CALL_FROMTEXT));
+ return generic_fromtext_key(CALL_FROMTEXT);
}
static isc_result_t
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_rkey);
- return (generic_totext_key(CALL_TOTEXT));
+ return generic_totext_key(CALL_TOTEXT);
}
static isc_result_t
fromwire_rkey(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_rkey);
- return (generic_fromwire_key(CALL_FROMWIRE));
+ return generic_fromwire_key(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
fromstruct_rkey(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_rkey);
- return (generic_fromstruct_key(CALL_FROMSTRUCT));
+ return generic_fromstruct_key(CALL_FROMSTRUCT);
}
static isc_result_t
rkey->common.rdtype = rdata->type;
ISC_LINK_INIT(&rkey->common, link);
- return (generic_tostruct_key(CALL_TOSTRUCT));
+ return generic_tostruct_key(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
/*
* Treat ALG 253 (private DNS) subtype name case sensitively.
*/
- return (compare_rkey(rdata1, rdata2));
+ return compare_rkey(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_RKEY_57_C */
warn_badname(&name, lexer, callbacks);
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
RETERR(str_totext(" ", target));
sub = name_prefix(&email, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
dns_name_init(&email, NULL);
RETERR(dns_name_fromwire(&rmail, source, dctx, options, target));
- return (dns_name_fromwire(&email, source, dctx, options, target));
+ return dns_name_fromwire(&email, source, dctx, options, target);
}
static isc_result_t
dns_name_fromregion(&rmail, ®ion);
isc_region_consume(®ion, rmail.length);
- return (dns_name_towire(&rmail, cctx, target));
+ return dns_name_towire(&rmail, cctx, target);
}
static int
order = dns_name_rdatacompare(&name1, &name2);
if (order != 0) {
- return (order);
+ return order;
}
isc_region_consume(®ion1, name_length(&name1));
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
dns_name_toregion(&rp->mail, ®ion);
RETERR(isc_buffer_copyregion(target, ®ion));
dns_name_toregion(&rp->text, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&rp->text, NULL);
name_duporclone(&name, mctx, &rp->text);
rp->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
if (bad != NULL) {
dns_name_clone(&name, bad);
}
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static int
casecompare_rp(ARGS_COMPARE) {
- return (compare_rp(rdata1, rdata2));
+ return compare_rp(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_RP_17_C */
/*
* Sig.
*/
- return (isc_base64_tobuffer(lexer, target, -2));
+ return isc_base64_tobuffer(lexer, target, -2);
}
static isc_result_t
RETERR(str_totext(" )", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
* key footprint: 2
*/
if (sr.length < 18) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_buffer_forward(source, 18);
*/
isc_buffer_activeregion(source, &sr);
if (sr.length < 1) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
isc_buffer_forward(source, sr.length);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static isc_result_t
/*
* Signature.
*/
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
/*
* Signature.
*/
- return (mem_tobuffer(target, sig->signature, sig->siglen));
+ return mem_tobuffer(target, sig->signature, sig->siglen);
}
static isc_result_t
}
sig->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (mctx != NULL) {
dns_name_free(&sig->signer, mctx);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(digest);
UNUSED(arg);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static dns_rdatatype_t
dns_rdata_toregion(rdata, &r);
type = uint16_fromregion(&r);
- return (type);
+ return type;
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
r2.length = 18;
order = isc_region_compare(&r1, &r2);
if (order != 0) {
- return (order);
+ return order;
}
dns_name_init(&name1, NULL);
dns_name_fromregion(&name2, &r2);
order = dns_name_rdatacompare(&name1, &name2);
if (order != 0) {
- return (order);
+ return order;
}
isc_region_consume(&r1, name_length(&name1));
isc_region_consume(&r2, name_length(&name2));
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
#endif /* RDATA_GENERIC_RRSIG_46_C */
if (!ok && callbacks != NULL) {
warn_badname(&name, lexer, callbacks);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
RETERR(str_totext(" ", target));
dns_name_fromregion(&name, ®ion);
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sregion);
isc_buffer_availableregion(target, &tregion);
if (tregion.length < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
if (sregion.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
memmove(tregion.base, sregion.base, 2);
isc_buffer_forward(source, 2);
isc_buffer_add(target, 2);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
isc_buffer_availableregion(target, &tr);
dns_rdata_toregion(rdata, ®ion);
if (tr.length < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tr.base, region.base, 2);
isc_region_consume(®ion, 2);
dns_name_init(&name, offsets);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
order = memcmp(rdata1->data, rdata2->data, 2);
if (order != 0) {
- return (order < 0 ? -1 : 1);
+ return order < 0 ? -1 : 1;
}
dns_name_init(&name1, NULL);
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
RETERR(uint16_tobuffer(rt->preference, target));
dns_name_toregion(&rt->host, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
name_duporclone(&name, mctx, &rt->host);
rt->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
result = (add)(arg, &name, dns_rdatatype_x25, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = (add)(arg, &name, dns_rdatatype_isdn, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return ((add)(arg, &name, dns_rdatatype_a, NULL));
+ return (add)(arg, &name, dns_rdatatype_a, NULL);
}
static isc_result_t
r1.length = 2;
result = (digest)(arg, &r1);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r2);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
if (bad != NULL) {
dns_name_clone(&name, bad);
}
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static int
casecompare_rt(ARGS_COMPARE) {
- return (compare_rt(rdata1, rdata2));
+ return compare_rt(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_RT_21_C */
/*
* Sig.
*/
- return (isc_base64_tobuffer(lexer, target, -2));
+ return isc_base64_tobuffer(lexer, target, -2);
}
static isc_result_t
RETERR(str_totext(" )", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
* key footprint: 2
*/
if (sr.length < 18) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_buffer_forward(source, 18);
*/
isc_buffer_activeregion(source, &sr);
if (sr.length == 0) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_buffer_forward(source, sr.length);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static isc_result_t
/*
* Signature.
*/
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
r2.length = 18;
order = isc_region_compare(&r1, &r2);
if (order != 0) {
- return (order);
+ return order;
}
dns_name_init(&name1, NULL);
dns_name_fromregion(&name2, &r2);
order = dns_name_rdatacompare(&name1, &name2);
if (order != 0) {
- return (order);
+ return order;
}
isc_region_consume(&r1, name_length(&name1));
isc_region_consume(&r2, name_length(&name2));
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
/*
* Signature.
*/
- return (mem_tobuffer(target, sig->signature, sig->siglen));
+ return mem_tobuffer(target, sig->signature, sig->siglen);
}
static isc_result_t
}
sig->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (mctx != NULL) {
dns_name_free(&sig->signer, mctx);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(digest);
UNUSED(arg);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static dns_rdatatype_t
dns_rdata_toregion(rdata, &r);
type = uint16_fromregion(&r);
- return (type);
+ return type;
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_sig(ARGS_COMPARE) {
- return (compare_sig(rdata1, rdata2));
+ return compare_sig(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_SIG_24_C */
}
RETERR(uint8_tobuffer(token.value.as_ulong, target));
- return (isc_base64_tobuffer(lexer, target, -1));
+ return isc_base64_tobuffer(lexer, target, -1);
}
static isc_result_t
RETERR(str_totext(buf, target));
if (sr.length == 0U) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* data */
RETERR(str_totext(" )", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_activeregion(source, &sr);
if (sr.length < 3) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, sr.base, sr.length));
isc_buffer_forward(source, sr.length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
RETERR(uint8_tobuffer(sink->subcoding, target));
/* Data */
- return (mem_tobuffer(target, sink->data, sink->datalen));
+ return mem_tobuffer(target, sink->data, sink->datalen);
}
static isc_result_t
/* Meaning */
if (sr.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
sink->meaning = uint8_fromregion(&sr);
isc_region_consume(&sr, 1);
/* Coding */
if (sr.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
sink->coding = uint8_fromregion(&sr);
isc_region_consume(&sr, 1);
/* Subcoding */
if (sr.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
sink->subcoding = uint8_fromregion(&sr);
isc_region_consume(&sr, 1);
sink->datalen = sr.length;
sink->data = mem_maybedup(mctx, sr.base, sink->datalen);
if (sink->data == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
sink->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_sink(ARGS_COMPARE) {
- return (compare_sink(rdata1, rdata2));
+ return compare_sink(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_SINK_40_C */
fromtext_smimea(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_smimea);
- return (generic_fromtext_tlsa(CALL_FROMTEXT));
+ return generic_fromtext_tlsa(CALL_FROMTEXT);
}
static isc_result_t
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_smimea);
- return (generic_totext_tlsa(CALL_TOTEXT));
+ return generic_totext_tlsa(CALL_TOTEXT);
}
static isc_result_t
fromwire_smimea(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_smimea);
- return (generic_fromwire_tlsa(CALL_FROMWIRE));
+ return generic_fromwire_tlsa(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
fromstruct_smimea(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_smimea);
- return (generic_fromstruct_tlsa(CALL_FROMSTRUCT));
+ return generic_fromstruct_tlsa(CALL_FROMSTRUCT);
}
static isc_result_t
smimea->common.rdtype = rdata->type;
ISC_LINK_INIT(&smimea->common, link);
- return (generic_tostruct_tlsa(CALL_TOSTRUCT));
+ return generic_tostruct_tlsa(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_smimea(ARGS_COMPARE) {
- return (compare_smimea(rdata1, rdata2));
+ return compare_smimea(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_SMIMEA_53_C */
RETERR(uint32_tobuffer(n, target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static const char *soa_fieldnames[5] = { "serial", "refresh", "retry", "expire",
RETERR(str_totext(")", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_availableregion(target, &tregion);
if (sregion.length < 20) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (tregion.length < 20) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tregion.base, sregion.base, 20);
isc_buffer_forward(source, 20);
isc_buffer_add(target, 20);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_availableregion(target, &tregion);
if (tregion.length < 20) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tregion.base, sregion.base, 20);
isc_buffer_add(target, 20);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static int
order = dns_name_rdatacompare(&name1, &name2);
if (order != 0) {
- return (order);
+ return order;
}
isc_region_consume(®ion1, name_length(&name1));
order = dns_name_rdatacompare(&name1, &name2);
if (order != 0) {
- return (order);
+ return order;
}
isc_region_consume(®ion1, name_length(&name1));
isc_region_consume(®ion2, name_length(&name2));
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
static isc_result_t
RETERR(uint32_tobuffer(soa->refresh, target));
RETERR(uint32_tobuffer(soa->retry, target));
RETERR(uint32_tobuffer(soa->expire, target));
- return (uint32_tobuffer(soa->minimum, target));
+ return uint32_tobuffer(soa->minimum, target);
}
static isc_result_t
soa->minimum = uint32_fromregion(®ion);
soa->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
RETERR(dns_name_digest(&name, digest, arg));
isc_region_consume(&r, name_length(&name));
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
if (bad != NULL) {
dns_name_clone(&name, bad);
}
- return (false);
+ return false;
}
isc_region_consume(®ion, name_length(&name));
dns_name_fromregion(&name, ®ion);
if (bad != NULL) {
dns_name_clone(&name, bad);
}
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static int
casecompare_soa(ARGS_COMPARE) {
- return (compare_soa(rdata1, rdata2));
+ return compare_soa(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_SOA_6_C */
fromtext_spf(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_spf);
- return (generic_fromtext_txt(CALL_FROMTEXT));
+ return generic_fromtext_txt(CALL_FROMTEXT);
}
static isc_result_t
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_spf);
- return (generic_totext_txt(CALL_TOTEXT));
+ return generic_totext_txt(CALL_TOTEXT);
}
static isc_result_t
fromwire_spf(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_spf);
- return (generic_fromwire_txt(CALL_FROMWIRE));
+ return generic_fromwire_txt(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
fromstruct_spf(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_spf);
- return (generic_fromstruct_txt(CALL_FROMSTRUCT));
+ return generic_fromstruct_txt(CALL_FROMSTRUCT);
}
static isc_result_t
spf->common.rdtype = rdata->type;
ISC_LINK_INIT(&spf->common, link);
- return (generic_tostruct_txt(CALL_TOSTRUCT));
+ return generic_tostruct_txt(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_spf(ARGS_COMPARE) {
- return (compare_spf(rdata1, rdata2));
+ return compare_spf(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_SPF_99_C */
/*
* Digest.
*/
- return (isc_hex_tobuffer(lexer, target, len));
+ return isc_hex_tobuffer(lexer, target, len);
}
static isc_result_t
RETERR(str_totext(buf, target));
if (sr.length == 0U) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) {
RETERR(str_totext(" )", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_activeregion(source, &sr);
if (sr.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if ((sr.base[1] == 1 && sr.length != ISC_SHA1_DIGESTLENGTH + 2) ||
(sr.base[1] == 2 && sr.length != ISC_SHA256_DIGESTLENGTH + 2))
{
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
isc_buffer_forward(source, sr.length);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
RETERR(uint8_tobuffer(sshfp->algorithm, target));
RETERR(uint8_tobuffer(sshfp->digest_type, target));
- return (mem_tobuffer(target, sshfp->digest, sshfp->length));
+ return mem_tobuffer(target, sshfp->digest, sshfp->length);
}
static isc_result_t
sshfp->digest = mem_maybedup(mctx, region.base, region.length);
if (sshfp->digest == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
sshfp->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_sshfp(ARGS_COMPARE) {
- return (compare_sshfp(rdata1, rdata2));
+ return compare_sshfp(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_SSHFP_44_C */
fromtext_ta(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_ta);
- return (generic_fromtext_ds(CALL_FROMTEXT));
+ return generic_fromtext_ds(CALL_FROMTEXT);
}
static isc_result_t
totext_ta(ARGS_TOTEXT) {
REQUIRE(rdata->type == dns_rdatatype_ta);
- return (generic_totext_ds(CALL_TOTEXT));
+ return generic_totext_ds(CALL_TOTEXT);
}
static isc_result_t
fromwire_ta(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_ta);
- return (generic_fromwire_ds(CALL_FROMWIRE));
+ return generic_fromwire_ds(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
fromstruct_ta(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_ta);
- return (generic_fromstruct_ds(CALL_FROMSTRUCT));
+ return generic_fromstruct_ds(CALL_FROMSTRUCT);
}
static isc_result_t
ds->common.rdtype = rdata->type;
ISC_LINK_INIT(&ds->common, link);
- return (generic_tostruct_ds(CALL_TOSTRUCT));
+ return generic_tostruct_ds(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_ta(ARGS_COMPARE) {
- return (compare_ta(rdata1, rdata2));
+ return compare_ta(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_TA_32768_C */
target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
RETERR(str_totext(" ", target));
sub = name_prefix(&next, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
dns_name_init(&next, NULL);
RETERR(dns_name_fromwire(&prev, source, dctx, options, target));
- return (dns_name_fromwire(&next, source, dctx, options, target));
+ return dns_name_fromwire(&next, source, dctx, options, target);
}
static isc_result_t
dns_name_fromregion(&next, &sregion);
isc_region_consume(&sregion, name_length(&next));
- return (dns_name_towire(&next, cctx, target));
+ return dns_name_towire(&next, cctx, target);
}
static int
dns_rdata_toregion(rdata1, ®ion1);
dns_rdata_toregion(rdata2, ®ion2);
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
static isc_result_t
dns_name_toregion(&talink->prev, ®ion);
RETERR(isc_buffer_copyregion(target, ®ion));
dns_name_toregion(&talink->next, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
name_duporclone(&name, mctx, &talink->next);
talink->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_talink);
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(bad);
UNUSED(owner);
- return (true);
+ return true;
}
static int
casecompare_talink(ARGS_COMPARE) {
- return (compare_talink(rdata1, rdata2));
+ return compare_talink(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_TALINK_58_C */
/*
* Other Data.
*/
- return (isc_base64_tobuffer(lexer, target, (int)token.value.as_ulong));
+ return isc_base64_tobuffer(lexer, target, (int)token.value.as_ulong);
}
static isc_result_t
RETERR(str_totext(" )", target));
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*/
isc_buffer_activeregion(source, &sr);
if (sr.length < 12) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, sr.base, 12));
isc_region_consume(&sr, 12);
* Key Length + Key Data.
*/
if (sr.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
n = uint16_fromregion(&sr);
if (sr.length < n + 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, sr.base, n + 2));
isc_region_consume(&sr, n + 2);
* Other Length + Other Data.
*/
if (sr.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
n = uint16_fromregion(&sr);
if (sr.length < n + 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_buffer_forward(source, n + 2);
- return (mem_tobuffer(target, sr.base, n + 2));
+ return mem_tobuffer(target, sr.base, n + 2);
}
static isc_result_t
RETERR(dns_name_towire(&name, cctx, target));
isc_region_consume(&sr, name_length(&name));
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_name_fromregion(&name1, &r1);
dns_name_fromregion(&name2, &r2);
if ((order = dns_name_rdatacompare(&name1, &name2)) != 0) {
- return (order);
+ return order;
}
isc_region_consume(&r1, name_length(&name1));
isc_region_consume(&r2, name_length(&name2));
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
/*
* Other data.
*/
- return (mem_tobuffer(target, tkey->other, tkey->otherlen));
+ return mem_tobuffer(target, tkey->other, tkey->otherlen);
}
static isc_result_t
}
tkey->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (mctx != NULL) {
if (mctx != NULL && tkey->key != NULL) {
isc_mem_free(mctx, tkey->key);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_tkey);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_tkey(ARGS_COMPARE) {
- return (compare_tkey(rdata1, rdata2));
+ return compare_tkey(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_TKEY_249_C */
/*
* Certificate Association Data.
*/
- return (isc_hex_tobuffer(lexer, target, -2));
+ return isc_hex_tobuffer(lexer, target, -2);
}
static isc_result_t
if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) {
RETERR(str_totext(" )", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
/* Usage(1), Selector(1), Type(1), Data(1+) */
if (sr.length < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_buffer_forward(source, sr.length);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static isc_result_t
fromtext_tlsa(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_tlsa);
- return (generic_fromtext_tlsa(CALL_FROMTEXT));
+ return generic_fromtext_tlsa(CALL_FROMTEXT);
}
static isc_result_t
totext_tlsa(ARGS_TOTEXT) {
REQUIRE(rdata->type == dns_rdatatype_tlsa);
- return (generic_totext_tlsa(CALL_TOTEXT));
+ return generic_totext_tlsa(CALL_TOTEXT);
}
static isc_result_t
fromwire_tlsa(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_tlsa);
- return (generic_fromwire_tlsa(CALL_FROMWIRE));
+ return generic_fromwire_tlsa(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
RETERR(uint8_tobuffer(tlsa->selector, target));
RETERR(uint8_tobuffer(tlsa->match, target));
- return (mem_tobuffer(target, tlsa->data, tlsa->length));
+ return mem_tobuffer(target, tlsa->data, tlsa->length);
}
static isc_result_t
tlsa->data = mem_maybedup(mctx, region.base, region.length);
if (tlsa->data == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
tlsa->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
fromstruct_tlsa(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_tlsa);
- return (generic_fromstruct_tlsa(CALL_FROMSTRUCT));
+ return generic_fromstruct_tlsa(CALL_FROMSTRUCT);
}
static isc_result_t
tlsa->common.rdtype = rdata->type;
ISC_LINK_INIT(&tlsa->common, link);
- return (generic_tostruct_tlsa(CALL_TOSTRUCT));
+ return generic_tostruct_tlsa(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_tlsa(ARGS_COMPARE) {
- return (compare_tlsa(rdata1, rdata2));
+ return compare_tlsa(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_TLSA_52_C */
}
/* Let upper layer handle eol/eof. */
isc_lex_ungettoken(lexer, &token);
- return (strings == 0 ? ISC_R_UNEXPECTEDEND : ISC_R_SUCCESS);
+ return strings == 0 ? ISC_R_UNEXPECTEDEND : ISC_R_SUCCESS;
}
static isc_result_t
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
do {
result = txt_fromwire(source, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
} while (!buffer_empty(source));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
fromtext_txt(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_txt);
- return (generic_fromtext_txt(CALL_FROMTEXT));
+ return generic_fromtext_txt(CALL_FROMTEXT);
}
static isc_result_t
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_txt);
- return (generic_totext_txt(CALL_TOTEXT));
+ return generic_totext_txt(CALL_TOTEXT);
}
static isc_result_t
fromwire_txt(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_txt);
- return (generic_fromwire_txt(CALL_FROMWIRE));
+ return generic_fromwire_txt(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
length = uint8_fromregion(®ion);
isc_region_consume(®ion, 1);
if (region.length < length) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_region_consume(®ion, length);
}
- return (mem_tobuffer(target, txt->txt, txt->txt_len));
+ return mem_tobuffer(target, txt->txt, txt->txt_len);
}
static isc_result_t
txt->txt_len = r.length;
txt->txt = mem_maybedup(mctx, r.base, r.length);
if (txt->txt == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
txt->offset = 0;
txt->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
fromstruct_txt(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_txt);
- return (generic_fromstruct_txt(CALL_FROMSTRUCT));
+ return generic_fromstruct_txt(CALL_FROMSTRUCT);
}
static isc_result_t
txt->common.rdtype = rdata->type;
ISC_LINK_INIT(&txt->common, link);
- return (generic_tostruct_txt(CALL_TOSTRUCT));
+ return generic_tostruct_txt(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_txt(ARGS_COMPARE) {
- return (compare_txt(rdata1, rdata2));
+ return compare_txt(rdata1, rdata2);
}
static isc_result_t
REQUIRE(txt->txt != NULL || txt->txt_len == 0);
if (txt->txt_len == 0) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
txt->offset = 0;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
INSIST(txt->offset + 1 + length <= txt->txt_len);
txt->offset = txt->offset + 1 + length;
if (txt->offset == txt->txt_len) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
string->data = r.base;
INSIST(txt->offset + 1 + string->length <= txt->txt_len);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(txt != NULL);
REQUIRE(txt->common.rdtype == dns_rdatatype_txt);
- return (generic_txt_first(txt));
+ return generic_txt_first(txt);
}
isc_result_t
REQUIRE(txt != NULL);
REQUIRE(txt->common.rdtype == dns_rdatatype_txt);
- return (generic_txt_next(txt));
+ return generic_txt_next(txt);
}
isc_result_t
REQUIRE(txt != NULL);
REQUIRE(txt->common.rdtype == dns_rdatatype_txt);
- return (generic_txt_current(txt, string));
+ return generic_txt_current(txt, string);
}
#endif /* RDATA_GENERIC_TXT_16_C */
RETTOK(DNS_R_SYNTAX);
}
RETTOK(multitxt_fromtext(&token.value.as_textregion, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
* Target URI
*/
RETERR(multitxt_totext(®ion, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*/
isc_buffer_activeregion(source, ®ion);
if (region.length < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/*
* Priority, weight and target URI
*/
isc_buffer_forward(source, region.length);
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, ®ion);
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
}
static int
*/
order = memcmp(r1.base, r2.base, 2);
if (order != 0) {
- return (order < 0 ? -1 : 1);
+ return order < 0 ? -1 : 1;
}
isc_region_consume(&r1, 2);
isc_region_consume(&r2, 2);
*/
order = memcmp(r1.base, r2.base, 2);
if (order != 0) {
- return (order < 0 ? -1 : 1);
+ return order < 0 ? -1 : 1;
}
isc_region_consume(&r1, 2);
isc_region_consume(&r2, 2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
/*
* Target URI
*/
- return (mem_tobuffer(target, uri->target, uri->tgt_len));
+ return mem_tobuffer(target, uri->target, uri->tgt_len);
}
static isc_result_t
* Priority
*/
if (sr.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
uri->priority = uint16_fromregion(&sr);
isc_region_consume(&sr, 2);
* Weight
*/
if (sr.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
uri->weight = uint16_fromregion(&sr);
isc_region_consume(&sr, 2);
uri->tgt_len = sr.length;
uri->target = mem_maybedup(mctx, sr.base, sr.length);
if (uri->target == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
uri->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_uri(ARGS_COMPARE) {
- return (compare_uri(rdata1, rdata2));
+ return compare_uri(rdata1, rdata2);
}
#endif /* GENERIC_URI_256_C */
fromtext_wallet(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_wallet);
- return (generic_fromtext_txt(CALL_FROMTEXT));
+ return generic_fromtext_txt(CALL_FROMTEXT);
}
static isc_result_t
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_wallet);
- return (generic_totext_txt(CALL_TOTEXT));
+ return generic_totext_txt(CALL_TOTEXT);
}
static isc_result_t
fromwire_wallet(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_wallet);
- return (generic_fromwire_txt(CALL_FROMWIRE));
+ return generic_fromwire_txt(CALL_FROMWIRE);
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
fromstruct_wallet(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_wallet);
- return (generic_fromstruct_txt(CALL_FROMSTRUCT));
+ return generic_fromstruct_txt(CALL_FROMSTRUCT);
}
static isc_result_t
wallet->common.rdtype = rdata->type;
ISC_LINK_INIT(&wallet->common, link);
- return (generic_tostruct_txt(CALL_TOSTRUCT));
+ return generic_tostruct_txt(CALL_TOSTRUCT);
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_wallet(ARGS_COMPARE) {
- return (compare_wallet(rdata1, rdata2));
+ return compare_wallet(rdata1, rdata2);
}
isc_result_t
REQUIRE(wallet != NULL);
REQUIRE(wallet->common.rdtype == dns_rdatatype_wallet);
- return (generic_txt_first(wallet));
+ return generic_txt_first(wallet);
}
isc_result_t
REQUIRE(wallet != NULL);
REQUIRE(wallet->common.rdtype == dns_rdatatype_wallet);
- return (generic_txt_next(wallet));
+ return generic_txt_next(wallet);
}
isc_result_t
REQUIRE(wallet != NULL);
REQUIRE(wallet->common.rdtype == dns_rdatatype_wallet);
- return (generic_txt_current(wallet, string));
+ return generic_txt_current(wallet, string);
}
#endif /* RDATA_GENERIC_WALLET_262_C */
}
}
RETTOK(txt_fromtext(&token.value.as_textregion, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, ®ion);
- return (txt_totext(®ion, true, target));
+ return txt_totext(®ion, true, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sr);
if (sr.length < 5 || sr.base[0] != (sr.length - 1)) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
for (i = 1; i < sr.length; i++) {
if (sr.base[i] < 0x30 || sr.base[i] > 0x39) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
}
- return (txt_fromwire(source, target));
+ return txt_fromwire(source, target);
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_x25);
REQUIRE(rdata->length != 0);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
UNUSED(rdclass);
if (x25->x25_len < 4) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
for (i = 0; i < x25->x25_len; i++) {
if (!isdigit((unsigned char)x25->x25[i])) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
}
RETERR(uint8_tobuffer(x25->x25_len, target));
- return (mem_tobuffer(target, x25->x25, x25->x25_len));
+ return mem_tobuffer(target, x25->x25, x25->x25_len);
}
static isc_result_t
isc_region_consume(&r, 1);
x25->x25 = mem_maybedup(mctx, r.base, x25->x25_len);
if (x25->x25 == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
x25->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_x25(ARGS_COMPARE) {
- return (compare_x25(rdata1, rdata2));
+ return compare_x25(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_X25_19_C */
result = isc_hex_tobuffer(lexer, target, length);
/* Minimum length of digest is 12 octets. */
if (isc_buffer_usedlength(target) - isc_buffer_usedlength(&save) < 12) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
- return (result);
+ return result;
}
static isc_result_t
if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) {
RETERR(str_totext(" )", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
* correct length.
*/
if (sr.length < 18) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
switch (sr.base[5]) {
}
if (digestlen != 0 && sr.length < 6 + digestlen) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/*
}
isc_buffer_forward(source, sr.length);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
RETERR(uint8_tobuffer(zonemd->scheme, target));
RETERR(uint8_tobuffer(zonemd->digest_type, target));
- return (mem_tobuffer(target, zonemd->digest, zonemd->length));
+ return mem_tobuffer(target, zonemd->digest, zonemd->length);
}
static isc_result_t
zonemd->digest = mem_maybedup(mctx, region.base, region.length);
if (zonemd->digest == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
zonemd->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_zonemd(ARGS_COMPARE) {
- return (compare_zonemd(rdata1, rdata2));
+ return compare_zonemd(rdata1, rdata2);
}
#endif /* RDATA_GENERIC_ZONEMD_63_C */
}
isc_buffer_availableregion(target, ®ion);
if (region.length < 4) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, &addr, 4);
isc_buffer_add(target, 4);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(tctx);
dns_rdata_toregion(rdata, ®ion);
- return (inet_totext(AF_INET, tctx->flags, ®ion, target));
+ return inet_totext(AF_INET, tctx->flags, ®ion, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sregion);
isc_buffer_availableregion(target, &tregion);
if (sregion.length < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (tregion.length < 4) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tregion.base, sregion.base, 4);
isc_buffer_forward(source, 4);
isc_buffer_add(target, 4);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_availableregion(target, ®ion);
if (region.length < rdata->length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, rdata->data, rdata->length);
isc_buffer_add(target, 4);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static int
order = (order < 0) ? -1 : 1;
}
- return (order);
+ return order;
}
static isc_result_t
n = ntohl(a->in_addr.s_addr);
- return (uint32_tobuffer(n, target));
+ return uint32_tobuffer(n, target);
}
static isc_result_t
n = uint32_fromregion(®ion);
a->in_addr.s_addr = htonl(n);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_hs_a(ARGS_COMPARE) {
- return (compare_hs_a(rdata1, rdata2));
+ return compare_hs_a(rdata1, rdata2);
}
}
if (prefixlen == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
if (!ok && callbacks != NULL) {
warn_badname(&name, lexer, callbacks);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
}
if (prefixlen == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
RETERR(str_totext(" ", target));
dns_name_init(&prefix, NULL);
dns_name_fromregion(&name, &sr);
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
* Prefix length.
*/
if (sr.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
prefixlen = sr.base[0];
if (prefixlen > 128) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
isc_region_consume(&sr, 1);
RETERR(mem_tobuffer(target, &prefixlen, 1));
if (prefixlen != 128) {
octets = 16 - prefixlen / 8;
if (sr.length < octets) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
mask = 0xff >> (prefixlen % 8);
if ((sr.base[0] & ~mask) != 0) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
RETERR(mem_tobuffer(target, sr.base, octets));
isc_buffer_forward(source, octets);
}
if (prefixlen == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
isc_region_consume(&sr, octets);
if (prefixlen == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_name_init(&name, offsets);
dns_name_fromregion(&name, &sr);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
isc_region_consume(®ion1, 1);
isc_region_consume(®ion2, 1);
if (prefixlen1 < prefixlen2) {
- return (-1);
+ return -1;
} else if (prefixlen1 > prefixlen2) {
- return (1);
+ return 1;
}
/*
* Prefix lengths are equal.
if (octets > 0) {
order = memcmp(region1.base, region2.base, octets);
if (order < 0) {
- return (-1);
+ return -1;
} else if (order > 0) {
- return (1);
+ return 1;
}
/*
* Address suffixes are equal.
*/
if (prefixlen1 == 0) {
- return (order);
+ return order;
}
isc_region_consume(®ion1, octets);
isc_region_consume(®ion2, octets);
dns_name_init(&name2, NULL);
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
UNUSED(rdclass);
if (a6->prefixlen > 128) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
RETERR(uint8_tobuffer(a6->prefixlen, target));
}
if (a6->prefixlen == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_name_toregion(&a6->prefix, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
name_duporclone(&name, mctx, &a6->prefix);
}
a6->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
r1.length = octets;
result = (digest)(arg, &r1);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (prefixlen == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_region_consume(&r2, octets);
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r2);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(type);
UNUSED(rdclass);
- return (dns_name_ishostname(name, wildcard));
+ return dns_name_ishostname(name, wildcard);
}
static bool
dns_rdata_toregion(rdata, ®ion);
prefixlen = uint8_fromregion(®ion);
if (prefixlen == 0) {
- return (true);
+ return true;
}
isc_region_consume(®ion, 1 + 16 - prefixlen / 8);
dns_name_init(&name, NULL);
if (bad != NULL) {
dns_name_clone(&name, bad);
}
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static int
casecompare_in_a6(ARGS_COMPARE) {
- return (compare_in_a6(rdata1, rdata2));
+ return compare_in_a6(rdata1, rdata2);
}
#endif /* RDATA_IN_1_A6_38_C */
}
isc_buffer_availableregion(target, ®ion);
if (region.length < 4) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, &addr, 4);
isc_buffer_add(target, 4);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(tctx);
dns_rdata_toregion(rdata, ®ion);
- return (inet_totext(AF_INET, tctx->flags, ®ion, target));
+ return inet_totext(AF_INET, tctx->flags, ®ion, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sregion);
isc_buffer_availableregion(target, &tregion);
if (sregion.length < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (tregion.length < 4) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tregion.base, sregion.base, 4);
isc_buffer_forward(source, 4);
isc_buffer_add(target, 4);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_availableregion(target, ®ion);
if (region.length < rdata->length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, rdata->data, rdata->length);
isc_buffer_add(target, 4);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
n = ntohl(a->in_addr.s_addr);
- return (uint32_tobuffer(n, target));
+ return uint32_tobuffer(n, target);
}
static isc_result_t
n = uint32_fromregion(®ion);
a->in_addr.s_addr = htonl(n);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
if (dns_name_equal(&gc_msdcs, &prefix) &&
dns_name_ishostname(&suffix, false))
{
- return (true);
+ return true;
}
/*
strncasecmp((char *)label.base, "\x09_spf_rate",
10) == 0))
{
- return (true);
+ return true;
}
}
}
- return (dns_name_ishostname(name, wildcard));
+ return dns_name_ishostname(name, wildcard);
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_in_a(ARGS_COMPARE) {
- return (compare_in_a(rdata1, rdata2));
+ return compare_in_a(rdata1, rdata2);
}
#endif /* RDATA_IN_1_A_1_C */
}
isc_buffer_availableregion(target, ®ion);
if (region.length < 16) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, addr, 16);
isc_buffer_add(target, 16);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
n = snprintf(buf + len, sizeof(buf) - len, "%s%02x%02x",
sep, rdata->data[i], rdata->data[i + 1]);
if (n < 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
len += n;
sep = ":";
}
- return (str_totext(buf, target));
+ return str_totext(buf, target);
}
dns_rdata_toregion(rdata, ®ion);
- return (inet_totext(AF_INET6, tctx->flags, ®ion, target));
+ return inet_totext(AF_INET6, tctx->flags, ®ion, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sregion);
isc_buffer_availableregion(target, &tregion);
if (sregion.length < 16) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (tregion.length < 16) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tregion.base, sregion.base, 16);
isc_buffer_forward(source, 16);
isc_buffer_add(target, 16);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_availableregion(target, ®ion);
if (region.length < rdata->length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, rdata->data, rdata->length);
isc_buffer_add(target, 16);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
UNUSED(type);
UNUSED(rdclass);
- return (mem_tobuffer(target, aaaa->in6_addr.s6_addr, 16));
+ return mem_tobuffer(target, aaaa->in6_addr.s6_addr, 16);
}
static isc_result_t
INSIST(r.length == 16);
memmove(aaaa->in6_addr.s6_addr, r.base, 16);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
if (dns_name_equal(&gc_msdcs, &prefix) &&
dns_name_ishostname(&suffix, false))
{
- return (true);
+ return true;
}
}
- return (dns_name_ishostname(name, wildcard));
+ return dns_name_ishostname(name, wildcard);
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_in_aaaa(ARGS_COMPARE) {
- return (compare_in_aaaa(rdata1, rdata2));
+ return compare_in_aaaa(rdata1, rdata2);
}
#endif /* RDATA_IN_1_AAAA_28_C */
*/
isc_lex_ungettoken(lexer, &token);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
break;
default:
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
n = snprintf(txt, sizeof(txt), "/%u", prefix);
INSIST(n < (int)sizeof(txt));
isc_region_consume(&sr, len);
sep = " ";
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_activeregion(source, &sr);
isc_buffer_availableregion(target, &tr);
if (sr.length > tr.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
sr2 = sr;
/* Zero or more items */
while (sr.length > 0) {
if (sr.length < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
afi = uint16_fromregion(&sr);
isc_region_consume(&sr, 2);
len = (*sr.base & 0x7f);
isc_region_consume(&sr, 1);
if (len > sr.length) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
switch (afi) {
case 1:
if (prefix > 32 || len > 4) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
break;
case 2:
if (prefix > 128 || len > 16) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
}
if (len > 0 && sr.base[len - 1] == 0) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
isc_region_consume(&sr, len);
}
isc_buffer_forward(source, sr2.length);
- return (mem_tobuffer(target, sr2.base, sr2.length));
+ return mem_tobuffer(target, sr2.base, sr2.length);
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_apl);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
isc_buffer_init(&b, apl->apl, apl->apl_len);
isc_buffer_add(&b, apl->apl_len);
isc_buffer_setactive(&b, apl->apl_len);
- return (fromwire_in_apl(rdclass, type, &b, NULL, false, target));
+ return fromwire_in_apl(rdclass, type, &b, NULL, false, target);
}
static isc_result_t
apl->apl_len = r.length;
apl->apl = mem_maybedup(mctx, r.base, r.length);
if (apl->apl == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
apl->offset = 0;
apl->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
* If no APL return ISC_R_NOMORE.
*/
if (apl->apl == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
/*
INSIST(4 + length <= apl->apl_len);
apl->offset = 0;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
* No APL or have already reached the end return ISC_R_NOMORE.
*/
if (apl->apl == NULL || apl->offset == apl->apl_len) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
/*
INSIST(4 + length + apl->offset <= apl->apl_len);
apl->offset += 4 + length;
- return ((apl->offset < apl->apl_len) ? ISC_R_SUCCESS : ISC_R_NOMORE);
+ return (apl->offset < apl->apl_len) ? ISC_R_SUCCESS : ISC_R_NOMORE;
}
isc_result_t
REQUIRE(apl->offset <= apl->apl_len);
if (apl->offset == apl->apl_len) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
/*
} else {
ent->data = NULL;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
unsigned int
dns_rdata_apl_count(const dns_rdata_in_apl_t *apl) {
- return (apl->apl_len);
+ return apl->apl_len;
}
static isc_result_t
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_in_apl(ARGS_COMPARE) {
- return (compare_in_apl(rdata1, rdata2));
+ return compare_in_apl(rdata1, rdata2);
}
#endif /* RDATA_IN_1_APL_42_C */
RETTOK(ISC_R_UNEXPECTEDEND);
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
RETERR(mem_tobuffer(target, region.base, region.length));
break;
default:
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_activeregion(source, ®ion);
if (region.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (region.base[0] == 1) {
unsigned int i;
for (i = 1; i < region.length; i++) {
if (!isdigit((unsigned char)region.base[i])) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
}
}
RETERR(mem_tobuffer(target, region.base, region.length));
isc_buffer_forward(source, region.length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
UNUSED(rdclass);
RETERR(mem_tobuffer(target, &atma->format, 1));
- return (mem_tobuffer(target, atma->atma, atma->atma_len));
+ return mem_tobuffer(target, atma->atma, atma->atma_len);
}
static isc_result_t
atma->atma_len = r.length;
atma->atma = mem_maybedup(mctx, r.base, r.length);
if (atma->atma == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
atma->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_in_atma(ARGS_COMPARE) {
- return (compare_in_atma(rdata1, rdata2));
+ return compare_in_atma(rdata1, rdata2);
}
#endif /* RDATA_IN_1_atma_22_C */
UNUSED(options);
UNUSED(callbacks);
- return (isc_base64_tobuffer(lexer, target, -2));
+ return isc_base64_tobuffer(lexer, target, -2);
}
static isc_result_t
RETERR(str_totext(buf, target));
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_activeregion(source, &sr);
if (sr.length == 0) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
isc_buffer_forward(source, sr.length);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static isc_result_t
UNUSED(cctx);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
UNUSED(type);
UNUSED(rdclass);
- return (mem_tobuffer(target, dhcid->dhcid, dhcid->length));
+ return mem_tobuffer(target, dhcid->dhcid, dhcid->length);
}
static isc_result_t
dhcid->dhcid = mem_maybedup(mctx, region.base, region.length);
if (dhcid->dhcid == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
dhcid->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_in_dhcid(ARGS_COMPARE) {
- return (compare_in_dhcid(rdata1, rdata2));
+ return compare_in_dhcid(rdata1, rdata2);
}
#endif /* RDATA_IN_1_DHCID_49_C */
UNUSED(rdclass);
UNUSED(callbacks);
- return (isc_hex_tobuffer(lexer, target, -2));
+ return isc_hex_tobuffer(lexer, target, -2);
}
static isc_result_t
if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) {
RETERR(str_totext(" )", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_activeregion(source, ®ion);
if (region.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, region.base, region.length));
isc_buffer_forward(source, region.length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
UNUSED(type);
UNUSED(rdclass);
- return (mem_tobuffer(target, eid->eid, eid->eid_len));
+ return mem_tobuffer(target, eid->eid, eid->eid_len);
}
static isc_result_t
eid->eid_len = r.length;
eid->eid = mem_maybedup(mctx, r.base, r.length);
if (eid->eid == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
eid->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_in_eid(ARGS_COMPARE) {
- return (compare_in_eid(rdata1, rdata2));
+ return compare_in_eid(rdata1, rdata2);
}
#endif /* RDATA_IN_1_EID_31_C */
REQUIRE(type == dns_rdatatype_https);
REQUIRE(rdclass == dns_rdataclass_in);
- return (generic_fromtext_in_svcb(CALL_FROMTEXT));
+ return generic_fromtext_in_svcb(CALL_FROMTEXT);
}
static isc_result_t
REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
- return (generic_totext_in_svcb(CALL_TOTEXT));
+ return generic_totext_in_svcb(CALL_TOTEXT);
}
static isc_result_t
REQUIRE(type == dns_rdatatype_https);
REQUIRE(rdclass == dns_rdataclass_in);
- return (generic_fromwire_in_svcb(CALL_FROMWIRE));
+ return generic_fromwire_in_svcb(CALL_FROMWIRE);
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_https);
REQUIRE(rdata->length != 0);
- return (generic_towire_in_svcb(CALL_TOWIRE));
+ return generic_towire_in_svcb(CALL_TOWIRE);
}
static int
dns_rdata_toregion(rdata1, ®ion1);
dns_rdata_toregion(rdata2, ®ion2);
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
static isc_result_t
REQUIRE(https->common.rdtype == type);
REQUIRE(https->common.rdclass == rdclass);
- return (generic_fromstruct_in_svcb(CALL_FROMSTRUCT));
+ return generic_fromstruct_in_svcb(CALL_FROMSTRUCT);
}
static isc_result_t
REQUIRE(https != NULL);
REQUIRE(rdata->length != 0);
- return (generic_tostruct_in_svcb(CALL_TOSTRUCT));
+ return generic_tostruct_in_svcb(CALL_TOSTRUCT);
}
static void
REQUIRE(rdata->type == dns_rdatatype_https);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
- return (generic_additionaldata_in_svcb(CALL_ADDLDATA));
+ return generic_additionaldata_in_svcb(CALL_ADDLDATA);
}
static isc_result_t
REQUIRE(rdata->rdclass == dns_rdataclass_in);
dns_rdata_toregion(rdata, ®ion1);
- return ((digest)(arg, ®ion1));
+ return (digest)(arg, ®ion1);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
REQUIRE(rdata->type == dns_rdatatype_https);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
- return (generic_checknames_in_svcb(CALL_CHECKNAMES));
+ return generic_checknames_in_svcb(CALL_CHECKNAMES);
}
static int
casecompare_in_https(ARGS_COMPARE) {
- return (compare_in_https(rdata1, rdata2));
+ return compare_in_https(rdata1, rdata2);
}
isc_result_t
REQUIRE(https->common.rdtype == dns_rdatatype_https);
REQUIRE(https->common.rdclass == dns_rdataclass_in);
- return (generic_rdata_in_svcb_first(https));
+ return generic_rdata_in_svcb_first(https);
}
isc_result_t
REQUIRE(https->common.rdtype == dns_rdatatype_https);
REQUIRE(https->common.rdclass == dns_rdataclass_in);
- return (generic_rdata_in_svcb_next(https));
+ return generic_rdata_in_svcb_next(https);
}
void
origin = dns_rootname;
}
RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_fromregion(&name, ®ion);
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
isc_buffer_activeregion(source, &sregion);
if (sregion.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, sregion.base, 2));
isc_buffer_forward(source, 2);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
dns_name_init(&name, offsets);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
order = memcmp(rdata1->data, rdata2->data, 2);
if (order != 0) {
- return (order < 0 ? -1 : 1);
+ return order < 0 ? -1 : 1;
}
dns_name_init(&name1, NULL);
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
RETERR(uint16_tobuffer(kx->preference, target));
dns_name_toregion(&kx->exchange, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&kx->exchange, NULL);
name_duporclone(&name, mctx, &kx->exchange);
kx->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
isc_region_consume(®ion, 2);
dns_name_fromregion(&name, ®ion);
- return ((add)(arg, &name, dns_rdatatype_a, NULL));
+ return (add)(arg, &name, dns_rdatatype_a, NULL);
}
static isc_result_t
RETERR((digest)(arg, &r1));
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r2);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_in_kx(ARGS_COMPARE) {
- return (compare_in_kx(rdata1, rdata2));
+ return compare_in_kx(rdata1, rdata2);
}
#endif /* RDATA_IN_1_KX_36_C */
UNUSED(rdclass);
UNUSED(callbacks);
- return (isc_hex_tobuffer(lexer, target, -2));
+ return isc_hex_tobuffer(lexer, target, -2);
}
static isc_result_t
if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) {
RETERR(str_totext(" )", target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_activeregion(source, ®ion);
if (region.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, region.base, region.length));
isc_buffer_forward(source, region.length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
UNUSED(type);
UNUSED(rdclass);
- return (mem_tobuffer(target, nimloc->nimloc, nimloc->nimloc_len));
+ return mem_tobuffer(target, nimloc->nimloc, nimloc->nimloc_len);
}
static isc_result_t
nimloc->nimloc_len = r.length;
nimloc->nimloc = mem_maybedup(mctx, r.base, r.length);
if (nimloc->nimloc == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
nimloc->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_in_nimloc(ARGS_COMPARE) {
- return (compare_in_nimloc(rdata1, rdata2));
+ return compare_in_nimloc(rdata1, rdata2);
}
#endif /* RDATA_IN_1_NIMLOC_32_C */
origin = dns_rootname;
}
RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
dns_decompress_setmethods(dctx, DNS_COMPRESS_NONE);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
UNUSED(rdclass);
dns_name_toregion(&nsap_ptr->owner, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&nsap_ptr->owner, NULL);
name_duporclone(&name, mctx, &nsap_ptr->owner);
nsap_ptr->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_in_nsap_ptr(ARGS_COMPARE) {
- return (compare_in_nsap_ptr(rdata1, rdata2));
+ return compare_in_nsap_ptr(rdata1, rdata2);
}
#endif /* RDATA_IN_1_NSAP_PTR_23_C */
if (digits != 0 || !valid) {
RETTOK(ISC_R_UNEXPECTEDEND);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_region_consume(®ion, 1);
RETERR(str_totext(buf, target));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_activeregion(source, ®ion);
if (region.length < 1) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, region.base, region.length));
isc_buffer_forward(source, region.length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(cctx);
- return (mem_tobuffer(target, rdata->data, rdata->length));
+ return mem_tobuffer(target, rdata->data, rdata->length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
UNUSED(type);
UNUSED(rdclass);
- return (mem_tobuffer(target, nsap->nsap, nsap->nsap_len));
+ return mem_tobuffer(target, nsap->nsap, nsap->nsap_len);
}
static isc_result_t
nsap->nsap_len = r.length;
nsap->nsap = mem_maybedup(mctx, r.base, r.length);
if (nsap->nsap == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
nsap->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_in_nsap(ARGS_COMPARE) {
- return (compare_in_nsap(rdata1, rdata2));
+ return compare_in_nsap(rdata1, rdata2);
}
#endif /* RDATA_IN_1_NSAP_22_C */
dns_name_init(&name, NULL);
buffer_fromregion(&buffer, &token.value.as_region);
RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*/
dns_name_fromregion(&name, ®ion);
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
*/
isc_buffer_activeregion(source, &sregion);
if (sregion.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, sregion.base, 2));
isc_buffer_forward(source, 2);
/*
* MAPX400.
*/
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
*/
dns_name_init(&name, offsets);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
order = memcmp(rdata1->data, rdata2->data, 2);
if (order != 0) {
- return (order < 0 ? -1 : 1);
+ return order < 0 ? -1 : 1;
}
dns_name_init(&name1, NULL);
order = dns_name_rdatacompare(&name1, &name2);
if (order != 0) {
- return (order);
+ return order;
}
isc_region_consume(®ion1, name_length(&name1));
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
dns_name_toregion(&px->map822, ®ion);
RETERR(isc_buffer_copyregion(target, ®ion));
dns_name_toregion(&px->mapx400, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
name_duporclone(&name, mctx, &px->mapx400);
px->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
r1.length = 2;
result = (digest)(arg, &r1);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r2);
result = dns_name_digest(&name, digest, arg);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_region_consume(&r2, name_length(&name));
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r2);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_in_px(ARGS_COMPARE) {
- return (compare_in_px(rdata1, rdata2));
+ return compare_in_px(rdata1, rdata2);
}
#endif /* RDATA_IN_1_PX_26_C */
if (!ok && callbacks != NULL) {
warn_badname(&name, lexer, callbacks);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*/
dns_name_fromregion(&name, ®ion);
sub = name_prefix(&name, tctx->origin, &prefix);
- return (dns_name_totext(&prefix, sub, target));
+ return dns_name_totext(&prefix, sub, target);
}
static isc_result_t
*/
isc_buffer_activeregion(source, &sr);
if (sr.length < 6) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, sr.base, 6));
isc_buffer_forward(source, 6);
/*
* Target.
*/
- return (dns_name_fromwire(&name, source, dctx, options, target));
+ return dns_name_fromwire(&name, source, dctx, options, target);
}
static isc_result_t
*/
dns_name_init(&name, offsets);
dns_name_fromregion(&name, &sr);
- return (dns_name_towire(&name, cctx, target));
+ return dns_name_towire(&name, cctx, target);
}
static int
*/
order = memcmp(rdata1->data, rdata2->data, 6);
if (order != 0) {
- return (order < 0 ? -1 : 1);
+ return order < 0 ? -1 : 1;
}
/*
dns_name_fromregion(&name1, ®ion1);
dns_name_fromregion(&name2, ®ion2);
- return (dns_name_rdatacompare(&name1, &name2));
+ return dns_name_rdatacompare(&name1, &name2);
}
static isc_result_t
RETERR(uint16_tobuffer(srv->weight, target));
RETERR(uint16_tobuffer(srv->port, target));
dns_name_toregion(&srv->target, ®ion);
- return (isc_buffer_copyregion(target, ®ion));
+ return isc_buffer_copyregion(target, ®ion);
}
static isc_result_t
dns_name_init(&srv->target, NULL);
name_duporclone(&name, mctx, &srv->target);
srv->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
dns_name_fromregion(&name, ®ion);
if (dns_name_equal(&name, dns_rootname)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = (add)(arg, &name, dns_rdatatype_a, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_fixedname_init(&fixed);
result = dns_name_fromstring2(dns_fixedname_name(&fixed), buf, NULL, 0,
NULL);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = dns_name_concatenate(dns_fixedname_name(&fixed), &name,
dns_fixedname_name(&fixed), NULL);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return ((add)(arg, dns_fixedname_name(&fixed), dns_rdatatype_tlsa,
- NULL));
+ return (add)(arg, dns_fixedname_name(&fixed), dns_rdatatype_tlsa, NULL);
}
static isc_result_t
RETERR((digest)(arg, &r1));
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r2);
- return (dns_name_digest(&name, digest, arg));
+ return dns_name_digest(&name, digest, arg);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
if (bad != NULL) {
dns_name_clone(&name, bad);
}
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static int
casecompare_in_srv(ARGS_COMPARE) {
- return (compare_in_srv(rdata1, rdata2));
+ return compare_in_srv(rdata1, rdata2);
}
#endif /* RDATA_IN_1_SRV_33_C */
do {
RETERR(commatxt_fromtext(&source0, true, target));
} while (source0.length != 0);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static int
svckeycmp(const void *a1, const void *a2) {
const unsigned char *u1 = a1, *u2 = a2;
if (*u1 != *u2) {
- return (*u1 - *u2);
+ return *u1 - *u2;
}
- return (*(++u1) - *(++u2));
+ return *(++u1) - *(++u2);
}
static isc_result_t
if (region.base[0] == region.base[2] &&
region.base[1] == region.base[3])
{
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
isc_region_consume(®ion, 2);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
switch (sbpr[i].encoding) {
case sbpr_port:
if (region->length != 2) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
break;
case sbpr_ipv4s:
if ((region->length % 4) != 0 ||
region->length == 0)
{
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
break;
case sbpr_ipv6s:
if ((region->length % 16) != 0 ||
region->length == 0)
{
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
break;
case sbpr_alpn: {
if (region->length == 0) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
while (region->length != 0) {
size_t l = *region->base + 1;
if (l == 1U || l > region->length) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
isc_region_consume(region, l);
}
if ((region->length % 2) != 0 ||
region->length == 0)
{
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
/* In order? */
while (region->length >= 4) {
region->base[1] >=
region->base[3]))
{
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
isc_region_consume(region, 2);
}
* MUST contain "{?dns}".
*/
if (region->length < 7) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
/* MUST be relative */
if (region->base[0] != '/') {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
/* MUST be UTF8 */
if (!isc_utf8_valid(region->base,
region->length))
{
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
/* MUST contain "{?dns}" */
if (strnstr((char *)region->base, "{?dns}",
region->length) == NULL)
{
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
break;
case sbpr_empty:
if (region->length != 0) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
break;
}
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
}
/* Handle keyXXXXX form. */
if (strncmp(region->base, "key", 3) != 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
isc_textregion_consume(region, 3);
/* Disallow [+-]XXXXX which is allowed by strtoul. */
if (region->length == 0 || *region->base == '-' || *region->base == '+')
{
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
/* No zero padding. */
if (region->length > 1 && *region->base == '0' &&
region->base[1] != sep)
{
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
ul = strtoul(region->base, &e, 10);
/* Valid number? */
if (e == region->base || (*e != sep && *e != 0)) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
if (ul > 0xffff) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
isc_textregion_consume(region, e - region->base);
finish:
if (sep == ',' && region->length == 1) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
/* Consume separator. */
if (region->length != 0) {
if (value != NULL) {
*value = ul;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
break;
case sbpr_port:
if (!isdigit((unsigned char)*region->base)) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
ul = strtoul(region->base, &e, 10);
if (*e != '\0') {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
if (ul > 0xffff) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
RETERR(uint16_tobuffer(ul, target));
break;
e - tbuf);
}
if (inet_pton(AF_INET, tbuf, abuf) != 1) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
mem_tobuffer(target, abuf, 4);
} while (e != NULL);
e - tbuf);
}
if (inet_pton(AF_INET6, tbuf, abuf) != 1) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
mem_tobuffer(target, abuf, 16);
} while (e != NULL);
break;
case sbpr_empty:
if (region->length != 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
break;
case sbpr_keylist:
if (region->length == 0) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
used = isc_buffer_usedlength(target);
while (region->length != 0) {
default:
break;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
RETERR(svc_keyfromregion(region, '=', &key, target));
/* Sanity check keyXXXXX form. */
keyregion.base = isc_buffer_used(target);
keyregion.length = 0;
- return (svcb_validate(key, &keyregion));
+ return svcb_validate(key, &keyregion);
}
sb = *target;
RETERR(uint16_tobuffer(0, target)); /* dummy length */
/* Sanity check keyXXXXX form. */
keyregion.base = isc_buffer_used(&sb);
keyregion.length = len;
- return (svcb_validate(key, &keyregion));
+ return svcb_validate(key, &keyregion);
}
static const char *
for (i = 0; i < ARRAY_SIZE(sbpr); i++) {
if (sbpr[i].value == value && sbpr[i].initial) {
*encoding = sbpr[i].encoding;
- return (sbpr[i].name);
+ return sbpr[i].name;
}
}
n = snprintf(buf, len, "key%u", value);
INSIST(n > 0 && (unsigned)n < len);
*encoding = sbpr_text;
- return (buf);
+ return buf;
}
static isc_result_t
bool have_alpn = false;
if (isc_buffer_usedlength(target) == used) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (mankey != 0) {
/* Is this the last mandatory key? */
if (key1 != mankey || man.length != 0) {
- return (DNS_R_INCONSISTENTRR);
+ return DNS_R_INCONSISTENTRR;
}
} else if (key1 == SVCB_MAN_KEY) {
/* Lone mandatory field. */
- return (DNS_R_DISALLOWED);
+ return DNS_R_DISALLOWED;
} else if (key1 == SVCB_NO_DEFAULT_ALPN_KEY &&
!have_alpn)
{
/* Missing required ALPN field. */
- return (DNS_R_DISALLOWED);
+ return DNS_R_DISALLOWED;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
isc_region_consume(&r1, 2);
isc_region_consume(&r1, len2);
if (key2 == key1) {
- return (DNS_R_DUPLICATE);
+ return DNS_R_DUPLICATE;
}
if (key2 < key1) {
base1 = base2;
have_alpn = true;
} else if (key1 == SVCB_NO_DEFAULT_ALPN_KEY && !have_alpn) {
/* Missing required ALPN field. */
- return (DNS_R_DISALLOWED);
+ return DNS_R_DISALLOWED;
}
/*
*/
if (mankey != 0) {
if (key1 > mankey) {
- return (DNS_R_INCONSISTENTRR);
+ return DNS_R_INCONSISTENTRR;
}
if (key1 == mankey) {
if (man.length >= 2) {
mankey = uint16_fromregion(&man);
isc_region_consume(&man, 2);
if (mankey == SVCB_MAN_KEY) {
- return (DNS_R_DISALLOWED);
+ return DNS_R_DISALLOWED;
}
} else {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
}
token.type == isc_tokentype_eof)
{
isc_lex_ungettoken(lexer, &token);
- return (svcsortkeys(target, used));
+ return svcsortkeys(target, used);
}
if (token.type != isc_tokentype_string && /* key only */
UNUSED(rdclass);
UNUSED(callbacks);
- return (generic_fromtext_in_svcb(CALL_FROMTEXT));
+ return generic_fromtext_in_svcb(CALL_FROMTEXT);
}
static isc_result_t
UNREACHABLE();
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
- return (generic_totext_in_svcb(CALL_TOTEXT));
+ return generic_totext_in_svcb(CALL_TOTEXT);
}
static isc_result_t
*/
isc_buffer_activeregion(source, ®ion);
if (region.length < 2) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, region.base, 2));
isc_buffer_forward(source, 2);
* SvcParamKey
*/
if (region.length < 2U) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, region.base, 2));
key = uint16_fromregion(®ion);
* Keys must be unique and in order.
*/
if (!first && key <= lastkey) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
/*
if (mankey != 0) {
/* Missing mandatory key? */
if (key > mankey) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
if (key == mankey) {
/* Get next mandatory key. */
if (key == SVCB_ALPN_KEY) {
have_alpn = true;
} else if (key == SVCB_NO_DEFAULT_ALPN_KEY && !have_alpn) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
first = false;
* SvcParamValue length.
*/
if (region.length < 2U) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
RETERR(mem_tobuffer(target, region.base, 2));
len = uint16_fromregion(®ion);
* SvcParamValue.
*/
if (region.length < len) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/*
mankey = uint16_fromregion(&man);
isc_region_consume(&man, 2);
if (mankey == SVCB_MAN_KEY) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
} else {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
}
keyregion = region;
* Do we have an outstanding mandatory key?
*/
if (mankey != 0) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(type == dns_rdatatype_svcb);
REQUIRE(rdclass == dns_rdataclass_in);
- return (generic_fromwire_in_svcb(CALL_FROMWIRE));
+ return generic_fromwire_in_svcb(CALL_FROMWIRE);
}
static isc_result_t
/*
* SvcParams.
*/
- return (mem_tobuffer(target, region.base, region.length));
+ return mem_tobuffer(target, region.base, region.length);
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_svcb);
REQUIRE(rdata->length != 0);
- return (generic_towire_in_svcb(CALL_TOWIRE));
+ return generic_towire_in_svcb(CALL_TOWIRE);
}
static int
dns_rdata_toregion(rdata1, ®ion1);
dns_rdata_toregion(rdata2, ®ion2);
- return (isc_region_compare(®ion1, ®ion2));
+ return isc_region_compare(®ion1, ®ion2);
}
static isc_result_t
dns_name_toregion(&svcb->svcdomain, ®ion);
RETERR(isc_buffer_copyregion(target, ®ion));
- return (mem_tobuffer(target, svcb->svc, svcb->svclen));
+ return mem_tobuffer(target, svcb->svc, svcb->svclen);
}
static isc_result_t
REQUIRE(svcb->common.rdtype == type);
REQUIRE(svcb->common.rdclass == rdclass);
- return (generic_fromstruct_in_svcb(CALL_FROMSTRUCT));
+ return generic_fromstruct_in_svcb(CALL_FROMSTRUCT);
}
static isc_result_t
if (mctx != NULL) {
dns_name_free(&svcb->svcdomain, svcb->mctx);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
svcb->offset = 0;
svcb->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(svcb != NULL);
REQUIRE(rdata->length != 0);
- return (generic_tostruct_in_svcb(CALL_TOSTRUCT));
+ return generic_tostruct_in_svcb(CALL_TOSTRUCT);
}
static void
if (alias || dns_name_equal(owner, dns_rootname) ||
!dns_name_ishostname(owner, false))
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* Only lookup address records */
- return ((add)(arg, owner, dns_rdatatype_a, NULL));
+ return (add)(arg, owner, dns_rdatatype_a, NULL);
}
/*
* Stop following a potentially infinite CNAME chain.
*/
if (!done && cnames++ > MAX_CNAMES) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
} while (!done);
*/
if (dns_rdataset_isassociated(&rdataset)) {
dns_rdataset_disassociate(&rdataset);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return ((add)(arg, &name, dns_rdatatype_a, NULL));
+ return (add)(arg, &name, dns_rdatatype_a, NULL);
}
static isc_result_t
REQUIRE(rdata->type == dns_rdatatype_svcb);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
- return (generic_additionaldata_in_svcb(CALL_ADDLDATA));
+ return generic_additionaldata_in_svcb(CALL_ADDLDATA);
}
static isc_result_t
REQUIRE(rdata->rdclass == dns_rdataclass_in);
dns_rdata_toregion(rdata, ®ion1);
- return ((digest)(arg, ®ion1));
+ return (digest)(arg, ®ion1);
}
static bool
UNUSED(rdclass);
UNUSED(wildcard);
- return (true);
+ return true;
}
static bool
if (bad != NULL) {
dns_name_clone(&name, bad);
}
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static bool
REQUIRE(rdata->type == dns_rdatatype_svcb);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
- return (generic_checknames_in_svcb(CALL_CHECKNAMES));
+ return generic_checknames_in_svcb(CALL_CHECKNAMES);
}
static int
casecompare_in_svcb(ARGS_COMPARE) {
- return (compare_in_svcb(rdata1, rdata2));
+ return compare_in_svcb(rdata1, rdata2);
}
static isc_result_t
generic_rdata_in_svcb_first(dns_rdata_in_svcb_t *svcb) {
if (svcb->svclen == 0) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
svcb->offset = 0;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
size_t len;
if (svcb->offset >= svcb->svclen) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
region.base = svcb->svc + svcb->offset;
len = uint16_fromregion(®ion);
INSIST(region.length >= len + 2);
svcb->offset += len + 4;
- return (svcb->offset >= svcb->svclen ? ISC_R_NOMORE : ISC_R_SUCCESS);
+ return svcb->offset >= svcb->svclen ? ISC_R_NOMORE : ISC_R_SUCCESS;
}
static void
REQUIRE(svcb->common.rdtype == dns_rdatatype_svcb);
REQUIRE(svcb->common.rdclass == dns_rdataclass_in);
- return (generic_rdata_in_svcb_first(svcb));
+ return generic_rdata_in_svcb_first(svcb);
}
isc_result_t
REQUIRE(svcb->common.rdtype == dns_rdatatype_svcb);
REQUIRE(svcb->common.rdclass == dns_rdataclass_in);
- return (generic_rdata_in_svcb_next(svcb));
+ return generic_rdata_in_svcb_next(svcb);
}
void
*proto = pe->p_proto;
}
UNLOCK(&wks_lock);
- return (pe != NULL);
+ return pe != NULL;
}
static bool
*port = ntohs(se->s_port);
}
UNLOCK(&wks_lock);
- return (se != NULL);
+ return se != NULL;
}
static isc_result_t
CHECKTOK(DNS_R_BADDOTTEDQUAD);
}
if (region.length < 4) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, &addr, 4);
isc_buffer_add(target, 4);
result = mem_tobuffer(target, bm, n);
cleanup:
- return (result);
+ return result;
}
static isc_result_t
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_availableregion(target, &tr);
if (sr.length < 5) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (sr.length > 8 * 1024 + 5) {
- return (DNS_R_EXTRADATA);
+ return DNS_R_EXTRADATA;
}
if (sr.length > 5 && sr.base[sr.length - 1] == 0) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
if (tr.length < sr.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tr.base, sr.base, sr.length);
isc_buffer_add(target, sr.length);
isc_buffer_forward(source, sr.length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, &sr);
- return (mem_tobuffer(target, sr.base, sr.length));
+ return mem_tobuffer(target, sr.base, sr.length);
}
static int
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
- return (isc_region_compare(&r1, &r2));
+ return isc_region_compare(&r1, &r2);
}
static isc_result_t
a = ntohl(wks->in_addr.s_addr);
RETERR(uint32_tobuffer(a, target));
RETERR(uint8_tobuffer(wks->protocol, target));
- return (mem_tobuffer(target, wks->map, wks->map_len));
+ return mem_tobuffer(target, wks->map, wks->map_len);
}
static isc_result_t
wks->map_len = region.length;
wks->map = mem_maybedup(mctx, region.base, region.length);
if (wks->map == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
wks->mctx = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNUSED(add);
UNUSED(arg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdata_toregion(rdata, &r);
- return ((digest)(arg, &r));
+ return (digest)(arg, &r);
}
static bool
UNUSED(type);
UNUSED(rdclass);
- return (dns_name_ishostname(name, wildcard));
+ return dns_name_ishostname(name, wildcard);
}
static bool
UNUSED(owner);
UNUSED(bad);
- return (true);
+ return true;
}
static int
casecompare_in_wks(ARGS_COMPARE) {
- return (compare_in_wks(rdata1, rdata2));
+ return compare_in_wks(rdata1, rdata2);
}
#endif /* RDATA_IN_1_WKS_11_C */
rdataset->privateuint4 = 0;
rdataset->private5 = NULL;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(rdatalist != NULL && rdataset != NULL);
*rdatalist = rdataset->private1;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
rdataset->private2 = ISC_LIST_HEAD(rdatalist->rdata);
if (rdataset->private2 == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
rdata = rdataset->private2;
if (rdata == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
rdataset->private2 = ISC_LIST_NEXT(rdata, link);
if (rdataset->private2 == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
count++;
}
- return (count);
+ return count;
}
isc_result_t
}
}
if (neg == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
for (rdset = ISC_LIST_HEAD(name->list); rdset != NULL;
}
if (negsig == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
* Minimise ttl.
rdataset->ttl = neg->ttl = negsig->ttl = ttl;
rdataset->attributes |= DNS_RDATASETATTR_NOQNAME;
rdataset->private6 = name;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
}
if (tneg == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
for (rdataset = ISC_LIST_HEAD(noqname->list); rdataset != NULL;
}
}
if (tnegsig == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
dns_name_clone(noqname, name);
dns_rdataset_clone(tneg, neg);
dns_rdataset_clone(tnegsig, negsig);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
}
if (neg == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
for (rdset = ISC_LIST_HEAD(name->list); rdset != NULL;
}
if (negsig == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
* Minimise ttl.
rdataset->ttl = neg->ttl = negsig->ttl = ttl;
rdataset->attributes |= DNS_RDATASETATTR_CLOSEST;
rdataset->private7 = name;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
}
if (tneg == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
for (rdataset = ISC_LIST_HEAD(closest->list); rdataset != NULL;
}
}
if (tnegsig == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
dns_name_clone(closest, name);
dns_rdataset_clone(tneg, neg);
dns_rdataset_clone(tnegsig, negsig);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
const char *
dns_trust_totext(dns_trust_t trust) {
if (trust >= sizeof(trustnames) / sizeof(*trustnames)) {
- return ("bad");
+ return "bad";
}
- return (trustnames[trust]);
+ return trustnames[trust];
}
void
REQUIRE(DNS_RDATASET_VALID(rdataset));
if (rdataset->methods != NULL) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static void
question_cursor(dns_rdataset_t *rdataset) {
UNUSED(rdataset);
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
static void
UNUSED(rdataset);
REQUIRE(0);
- return (0);
+ return 0;
}
static dns_rdatasetmethods_t question_methods = {
REQUIRE(DNS_RDATASET_VALID(rdataset));
REQUIRE(rdataset->methods != NULL);
- return ((rdataset->methods->count)(rdataset));
+ return (rdataset->methods->count)(rdataset);
}
void
REQUIRE(DNS_RDATASET_VALID(rdataset));
REQUIRE(rdataset->methods != NULL);
- return ((rdataset->methods->first)(rdataset));
+ return (rdataset->methods->first)(rdataset);
}
isc_result_t
REQUIRE(DNS_RDATASET_VALID(rdataset));
REQUIRE(rdataset->methods != NULL);
- return ((rdataset->methods->next)(rdataset));
+ return (rdataset->methods->next)(rdataset);
}
void
towire_compare(const void *av, const void *bv) {
const struct towire_sort *a = (const struct towire_sort *)av;
const struct towire_sort *b = (const struct towire_sort *)bv;
- return (a->key - b->key);
+ return a->key - b->key;
}
static void
if ((options & DNS_RDATASETTOWIRE_OMITDNSSEC) != 0) {
ncache_opts |= DNS_NCACHETOWIRE_OMITDNSSEC;
}
- return (dns_ncache_towire(rdataset, cctx, target, ncache_opts,
- countp));
+ return dns_ncache_towire(rdataset, cctx, target, ncache_opts,
+ countp);
} else {
count = (rdataset->methods->count)(rdataset);
result = dns_rdataset_first(rdataset);
if (result == ISC_R_NOMORE) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
}
}
- if ((shuffle || sort)) {
+ if (shuffle || sort) {
if (count > MAX_SHUFFLE) {
in = isc_mem_get(cctx->mctx, count * sizeof(*in));
out = isc_mem_get(cctx->mctx, count * sizeof(*out));
}
}
- if ((shuffle || sort)) {
+ if (shuffle || sort) {
uint32_t seed = 0;
unsigned int j = 0;
if (in != NULL && in != in_fixed) {
isc_mem_put(cctx->mctx, in, count * sizeof(*in));
}
- return (result);
+ return result;
}
isc_result_t
isc_buffer_t *target, dns_rdatasetorderfunc_t order,
const void *order_arg, unsigned int options,
unsigned int *countp) {
- return (towiresorted(rdataset, owner_name, cctx, target, order,
- order_arg, false, options, countp, NULL));
+ return towiresorted(rdataset, owner_name, cctx, target, order,
+ order_arg, false, options, countp, NULL);
}
isc_result_t
const void *order_arg, unsigned int options,
unsigned int *countp, void **state) {
REQUIRE(state == NULL); /* XXX remove when implemented */
- return (towiresorted(rdataset, owner_name, cctx, target, order,
- order_arg, true, options, countp, state));
+ return towiresorted(rdataset, owner_name, cctx, target, order,
+ order_arg, true, options, countp, state);
}
isc_result_t
dns_rdataset_towire(dns_rdataset_t *rdataset, const dns_name_t *owner_name,
dns_compress_t *cctx, isc_buffer_t *target,
unsigned int options, unsigned int *countp) {
- return (towiresorted(rdataset, owner_name, cctx, target, NULL, NULL,
- false, options, countp, NULL));
+ return towiresorted(rdataset, owner_name, cctx, target, NULL, NULL,
+ false, options, countp, NULL);
}
isc_result_t
result = dns_rdataset_first(rdataset);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
do {
} while (result == ISC_R_SUCCESS);
if (result != ISC_R_NOMORE) {
- return (result);
+ return result;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(DNS_RDATASET_VALID(rdataset));
REQUIRE(rdataset->methods != NULL);
if (rdataset->methods->addnoqname == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
- return ((rdataset->methods->addnoqname)(rdataset, name));
+ return (rdataset->methods->addnoqname)(rdataset, name);
}
isc_result_t
REQUIRE(rdataset->methods != NULL);
if (rdataset->methods->getnoqname == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
- return ((rdataset->methods->getnoqname)(rdataset, name, neg, negsig));
+ return (rdataset->methods->getnoqname)(rdataset, name, neg, negsig);
}
isc_result_t
REQUIRE(DNS_RDATASET_VALID(rdataset));
REQUIRE(rdataset->methods != NULL);
if (rdataset->methods->addclosest == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
- return ((rdataset->methods->addclosest)(rdataset, name));
+ return (rdataset->methods->addclosest)(rdataset, name);
}
isc_result_t
REQUIRE(rdataset->methods != NULL);
if (rdataset->methods->getclosest == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
- return ((rdataset->methods->getclosest)(rdataset, name, neg, negsig));
+ return (rdataset->methods->getclosest)(rdataset, name, neg, negsig);
}
void
REQUIRE(rdataset->type == dns_rdatatype_ns);
if (rdataset->methods->addglue == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
- return ((rdataset->methods->addglue)(rdataset, version, msg));
+ return (rdataset->methods->addglue)(rdataset, version, msg);
}
REQUIRE(DNS_RDATASETITER_VALID(iterator));
- return (iterator->methods->first(iterator));
+ return iterator->methods->first(iterator);
}
isc_result_t
REQUIRE(DNS_RDATASETITER_VALID(iterator));
- return (iterator->methods->next(iterator));
+ return iterator->methods->next(iterator);
}
void
compare_rdata(const void *p1, const void *p2) {
const struct xrdata *x1 = p1;
const struct xrdata *x2 = p2;
- return (dns_rdata_compare(&x1->rdata, &x2->rdata));
+ return dns_rdata_compare(&x1->rdata, &x2->rdata);
}
#if DNS_RDATASET_FIXED
*/
if (nitems == 0) {
if (rdataset->type != 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
rawbuf = isc_mem_get(mctx, buflen);
region->base = rawbuf;
rawbuf += reservelen;
*rawbuf++ = 0;
*rawbuf = 0;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (maxrrperset > 0 && nitems > maxrrperset) {
- return (DNS_R_TOOMANYRECORDS);
+ return DNS_R_TOOMANYRECORDS;
}
if (nitems > 0xffff) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/*
free_rdatas:
isc_mem_put(mctx, x, nalloc * sizeof(struct xrdata));
- return (result);
+ return result;
}
unsigned int
#endif /* if DNS_RDATASET_FIXED */
}
- return ((unsigned int)(current - slab));
+ return (unsigned int)(current - slab);
}
unsigned int
#endif /* if DNS_RDATASET_FIXED */
}
- return (rdatalen);
+ return rdatalen;
}
unsigned int
current = slab + reservelen;
count = *current++ * 256;
count += *current++;
- return (count);
+ return count;
}
/*
n = dns_rdata_compare(&trdata, rdata);
if (n == 0) {
- return (true);
+ return true;
}
if (n > 0) { /* In DNSSEC order. */
break;
}
dns_rdata_reset(&trdata);
}
- return (false);
+ return false;
}
isc_result_t
INSIST(ocount > 0 && ncount > 0);
if (maxrrperset > 0 && ocount + ncount > maxrrperset) {
- return (DNS_R_TOOMANYRECORDS);
+ return DNS_R_TOOMANYRECORDS;
}
#if DNS_RDATASET_FIXED
if (((flags & DNS_RDATASLAB_EXACT) != 0) && (tcount != ncount + ocount))
{
- return (DNS_R_NOTEXACT);
+ return DNS_R_NOTEXACT;
}
if (!added_something && (flags & DNS_RDATASLAB_FORCE) == 0) {
- return (DNS_R_UNCHANGED);
+ return DNS_R_UNCHANGED;
}
/*
* We have a singleton type, but there's more than one
* RR in the rdataset.
*/
- return (DNS_R_SINGLETON);
+ return DNS_R_SINGLETON;
}
if (tcount > 0xffff) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/*
*tslabp = tstart;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
* check only works as rdataslabs do not contain duplicates.
*/
if (((flags & DNS_RDATASLAB_EXACT) != 0) && (rcount != scount)) {
- return (DNS_R_NOTEXACT);
+ return DNS_R_NOTEXACT;
}
/*
* Don't continue if the new rdataslab would be empty.
*/
if (tcount == 0) {
- return (DNS_R_NXRRSET);
+ return DNS_R_NXRRSET;
}
/*
* If nothing is going to change, we can stop.
*/
if (rcount == 0) {
- return (DNS_R_UNCHANGED);
+ return DNS_R_UNCHANGED;
}
/*
*tslabp = tstart;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
bool
count2 += *current2++;
if (count1 != count2) {
- return (false);
+ return false;
}
#if DNS_RDATASET_FIXED
if (length1 != length2 ||
memcmp(current1, current2, length1) != 0)
{
- return (false);
+ return false;
}
current1 += length1;
count1--;
}
- return (true);
+ return true;
}
bool
count2 += *current2++;
if (count1 != count2) {
- return (false);
+ return false;
}
#if DNS_RDATASET_FIXED
rdata_from_slab(¤t1, rdclass, type, &rdata1);
rdata_from_slab(¤t2, rdclass, type, &rdata2);
if (dns_rdata_compare(&rdata1, &rdata2) != 0) {
- return (false);
+ return false;
}
dns_rdata_reset(&rdata1);
dns_rdata_reset(&rdata2);
}
- return (true);
+ return true;
}
req_log(ISC_LOG_DEBUG(3), "dns_requestmgr_create: %p", requestmgr);
*requestmgrp = requestmgr;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
* Locked by caller.
*/
requestmgr->hash++;
- return (requestmgr->hash % DNS_REQUEST_NLOCKS);
+ return requestmgr->hash % DNS_REQUEST_NLOCKS;
}
static void
request->magic = REQUEST_MAGIC;
*requestp = request;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
blackhole = dns_dispatchmgr_getblackhole(dispatchmgr);
if (blackhole == NULL) {
- return (false);
+ return false;
}
isc_netaddr_fromsockaddr(&netaddr, destaddr);
result = dns_acl_match(&netaddr, NULL, blackhole, NULL, &match, NULL);
if (result != ISC_R_SUCCESS || match <= 0) {
- return (false);
+ return false;
}
isc_netaddr_format(&netaddr, netaddrstr, sizeof(netaddrstr));
req_log(ISC_LOG_DEBUG(10), "blackholed address %s", netaddrstr);
- return (true);
+ return true;
}
static isc_result_t
isc_sockaddr_format(destaddr, peer, sizeof(peer));
req_log(ISC_LOG_DEBUG(1),
"attached to TCP connection to %s", peer);
- return (result);
+ return result;
}
}
result = dns_dispatch_createtcp(requestmgr->dispatchmgr, srcaddr,
destaddr, dispatchp);
- return (result);
+ return result;
}
static isc_result_t
break;
default:
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
if (disp == NULL) {
- return (ISC_R_FAMILYNOSUPPORT);
+ return ISC_R_FAMILYNOSUPPORT;
}
dns_dispatch_attach(disp, dispatchp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (dns_dispatch_createudp(requestmgr->dispatchmgr, srcaddr,
- dispatchp));
+ return dns_dispatch_createudp(requestmgr->dispatchmgr, srcaddr,
+ dispatchp);
}
static isc_result_t
} else {
result = udp_dispatch(requestmgr, srcaddr, destaddr, dispatchp);
}
- return (result);
+ return result;
}
isc_result_t
req_log(ISC_LOG_DEBUG(3), "dns_request_createraw");
if (atomic_load_acquire(&requestmgr->exiting)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
if (isblackholed(requestmgr->dispatchmgr, destaddr)) {
- return (DNS_R_BLACKHOLED);
+ return DNS_R_BLACKHOLED;
}
/* detached in dns_request_destroy() */
result = new_request(mctx, &request);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
request->udpcount = udpretries + 1;
req_log(ISC_LOG_DEBUG(3), "dns_request_createraw: request %p", request);
*requestp = request;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
unlink:
LOCK(&requestmgr->lock);
req_detach(&request);
req_log(ISC_LOG_DEBUG(3), "dns_request_createraw: failed %s",
isc_result_totext(result));
- return (result);
+ return result;
}
isc_result_t
req_log(ISC_LOG_DEBUG(3), "dns_request_create");
if (atomic_load_acquire(&requestmgr->exiting)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
if (srcaddr != NULL &&
isc_sockaddr_pf(srcaddr) != isc_sockaddr_pf(destaddr))
{
- return (ISC_R_FAMILYMISMATCH);
+ return ISC_R_FAMILYMISMATCH;
}
if (isblackholed(requestmgr->dispatchmgr, destaddr)) {
- return (DNS_R_BLACKHOLED);
+ return DNS_R_BLACKHOLED;
}
/* detached in dns_request_destroy() */
result = new_request(mctx, &request);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
request->udpcount = udpretries + 1;
req_log(ISC_LOG_DEBUG(3), "dns_request_create: request %p", request);
*requestp = request;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
unlink:
LOCK(&requestmgr->lock);
req_detach(&request);
req_log(ISC_LOG_DEBUG(3), "dns_request_create: failed %s",
isc_result_totext(result));
- return (result);
+ return result;
}
static isc_result_t
result = dns_compress_init(&cctx, -1, mctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
cleanup_cctx = true;
*/
isc_buffer_free(&buf1);
*bufferp = buf2;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_message_renderreset(message);
if (cleanup_cctx) {
dns_compress_invalidate(&cctx);
}
- return (result);
+ return result;
}
void
result = dns_message_setquerytsig(message, request->tsig);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_message_settsigkey(message, request->tsigkey);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_message_parse(message, request->answer, options);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (request->tsigkey != NULL) {
result = dns_tsig_verify(request->answer, message, NULL, NULL);
}
- return (result);
+ return result;
}
isc_buffer_t *
dns_request_getanswer(dns_request_t *request) {
REQUIRE(VALID_REQUEST(request));
- return (request->answer);
+ return request->answer;
}
bool
dns_request_usedtcp(dns_request_t *request) {
REQUIRE(VALID_REQUEST(request));
- return ((request->flags & DNS_REQUEST_F_TCP) != 0);
+ return (request->flags & DNS_REQUEST_F_TCP) != 0;
}
void
hash_32(uint32_t val, unsigned int bits) {
REQUIRE(bits <= RES_DOMAIN_MAX_BITS);
/* High bits are more random. */
- return (val * GOLDEN_RATIO_32 >> (32 - bits));
+ return val * GOLDEN_RATIO_32 >> (32 - bits);
}
/*%
fctx_detach(&valarg->fctx);
isc_mem_put(fctx->mctx, valarg, sizeof(*valarg));
}
- return (result);
+ return result;
}
static bool
namereln = dns_name_fullcompare(&rrsig.signer, fctx->domain,
&order, &labels);
if (namereln == dns_namereln_subdomain) {
- return (true);
+ return true;
}
dns_rdata_reset(&rdata);
}
- return (false);
+ return false;
}
static bool
bool keep_auth = false;
if (message->rcode == dns_rcode_nxdomain) {
- return (false);
+ return false;
}
/*
if (type == dns_rdatatype_rrsig &&
rrsig_fromchildzone(fctx, rdataset))
{
- return (false);
+ return false;
}
/*
* Direct query for apex records or DS.
type == dns_rdatatype_soa ||
type == dns_rdatatype_dnskey))
{
- return (false);
+ return false;
}
/*
* Indirect query for apex records or DS.
type == dns_rdatatype_soa ||
type == dns_rdatatype_dnskey))
{
- return (false);
+ return false;
}
}
result = dns_message_nextname(message,
if (fctx->type == dns_rdatatype_ds &&
message->counts[DNS_SECTION_ANSWER] == 0)
{
- return (false);
+ return false;
}
/* Look for referral or indication of answer from child zone? */
if (type == dns_rdatatype_rrsig) {
if (rrsig_fromchildzone(fctx, rdataset)) {
- return (false);
+ return false;
} else {
continue;
}
if (message->counts[DNS_SECTION_ANSWER] == 0 &&
fctx->type == dns_rdatatype_any)
{
- return (false);
+ return false;
}
} else if (dns_name_issubdomain(name, domain)) {
/* Referral or answer from child zone. */
- return (false);
+ return false;
}
}
result = dns_message_nextname(message, DNS_SECTION_AUTHORITY);
message->counts[DNS_SECTION_AUTHORITY] = 0;
}
message->counts[DNS_SECTION_ADDITIONAL] = 0;
- return (true);
+ return true;
}
static void
*/
static isc_result_t
fctx_starttimer(fetchctx_t *fctx) {
- return (isc_timer_reset(fctx->timer, isc_timertype_once, &fctx->final,
- NULL, true));
+ return isc_timer_reset(fctx->timer, isc_timertype_once, &fctx->final,
+ NULL, true);
}
static void
fctx->dbucketnum = dbucketnum;
}
- return (result);
+ return result;
}
static void
result = dns_message_buildopt(message, &rdataset, version, udpsize,
DNS_MESSAGEEXTFLAG_DO, ednsopts, count);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return (dns_message_setopt(message, rdataset));
+ return dns_message_setopt(message, rdataset);
}
static void
* If not configured for serve-stale, do nothing.
*/
if ((fctx->options & DNS_FETCHOPT_TRYSTALE_ONTIMEOUT) == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
isc_time_now(&now);
timeleft = isc_time_microdiff(&fctx->expires_try_stale, &now);
if (timeleft >= US_PER_MS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
timeleft = isc_time_microdiff(&fctx->next_timeout, &now);
if (timeleft >= US_PER_MS) {
dns_dispatch_resume(query->dispentry, (timeleft / US_PER_MS));
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
fctx_setretryinterval(fctx, srtt);
if (isc_interval_iszero(&fctx->interval)) {
FCTXTRACE("fetch expired");
- return (ISC_R_TIMEDOUT);
+ return ISC_R_TIMEDOUT;
}
INSIST(ISC_LIST_EMPTY(fctx->validators));
RUNTIME_CHECK(result == ISC_R_SUCCESS);
- return (result);
+ return result;
cleanup_udpfetch:
if (!RESQUERY_CANCELED(query)) {
dns_message_detach(&query->rmessage);
isc_mem_put(fctx->mctx, query, sizeof(*query));
- return (result);
+ return result;
}
static bool
sa = ISC_LIST_NEXT(sa, link))
{
if (isc_sockaddr_equal(sa, address)) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static void
tried = ISC_LIST_NEXT(tried, link))
{
if (isc_sockaddr_equal(&tried->addr, address)) {
- return (tried);
+ return tried;
}
}
- return (NULL);
+ return NULL;
}
static void
case AF_INET:
INSIST(bufsize >= 4);
memmove(buf, &netaddr.type.in, 4);
- return (4);
+ return 4;
case AF_INET6:
INSIST(bufsize >= 16);
memmove(buf, &netaddr.type.in6, 16);
- return (16);
+ return 16;
default:
UNREACHABLE();
}
- return (0);
+ return 0;
}
static size_t
add_serveraddr(uint8_t *buf, const size_t bufsize, const resquery_t *query) {
- return (addr2buf(buf, bufsize, &query->addrinfo->sockaddr));
+ return addr2buf(buf, bufsize, &query->addrinfo->sockaddr);
}
/*
name = &suffix;
}
- return (dns_view_issecuredomain(view, name, now, checknta, ntap,
- issecure));
+ return dns_view_issecuredomain(view, name, now, checknta, ntap,
+ issecure);
}
static isc_result_t
if (atomic_load_acquire(&res->exiting)) {
FCTXTRACE("resquery_send: resolver shutting down");
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
result = dns_message_gettempname(fctx->qmessage, &qname);
tcp, &zr, &query->start, NULL, &buffer);
#endif /* HAVE_DNSTAP */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_message:
if (cleanup_cctx) {
dns_message_puttemprdataset(fctx->qmessage, &qrdataset);
}
- return (result);
+ return result;
}
static void
sa = ISC_LIST_NEXT(sa, link))
{
if (isc_sockaddr_equal(sa, address)) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static bool
#ifdef ENABLE_AFL
if (dns_fuzzing_resolver) {
- return (false);
+ return false;
}
#endif /* ifdef ENABLE_AFL */
}
}
- return (all_bad);
+ return all_bad;
}
static void
waiting_for(dns_adbfind_t *find, dns_rdatatype_t type) {
switch (type) {
case dns_rdatatype_a:
- return ((find->query_pending & DNS_ADBFIND_INET) != 0);
+ return (find->query_pending & DNS_ADBFIND_INET) != 0;
case dns_rdatatype_aaaa:
- return ((find->query_pending & DNS_ADBFIND_INET6) != 0);
+ return (find->query_pending & DNS_ADBFIND_INET6) != 0;
default:
- return (false);
+ return false;
}
}
dns_namereln_t namereln;
namereln = dns_name_fullcompare(name1, name2, &order, &nlabels);
- return (namereln == dns_namereln_subdomain);
+ return namereln == dns_namereln_subdomain;
}
static isc_result_t
fctx->restarts++;
if (fctx->restarts > 100) {
FCTXTRACE("too many restarts");
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
res = fctx->res;
"too much NS indirection resolving '%s' "
"(depth=%u, maxdepth=%u)",
fctx->info, fctx->depth, res->maxdepth);
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
/*
dns_name_copy(domain, fctx->domain);
result = fcount_incr(fctx, true);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
}
}
if ((stdoptions & DNS_ADBFIND_ADDRESSMASK) == 0) {
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
isc_stdtime_get(&now);
}
}
if (result != ISC_R_NOMORE) {
- return (result);
+ return result;
}
/*
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
static void
* state.
*/
fctx->minimized = false;
- return (addrinfo);
+ return addrinfo;
}
}
fctx->find = find;
if (addrinfo != NULL) {
- return (addrinfo);
+ return addrinfo;
}
/*
fctx->altfind = find;
}
- return (addrinfo);
+ return addrinfo;
}
static void
fetch->magic = DNS_FETCH_MAGIC;
fctx_attach(fctx, &fetch->private);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
*fctxp = fctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_timer:
isc_timer_destroy(&fctx->timer);
dns_resolver_detach(&fctx->res);
isc_mem_put(res->mctx, fctx, sizeof(*fctx));
- return (result);
+ return result;
}
/*
message->rcode != dns_rcode_yxdomain &&
message->rcode != dns_rcode_nxdomain)
{
- return (false);
+ return false;
}
if (message->counts[DNS_SECTION_ANSWER] != 0) {
- return (false);
+ return false;
}
if (message->counts[DNS_SECTION_AUTHORITY] == 0) {
- return (false);
+ return false;
}
result = dns_message_firstname(message, DNS_SECTION_AUTHORITY);
if (namereln == dns_namereln_equal &&
(message->flags & DNS_MESSAGEFLAG_AA) != 0)
{
- return (false);
+ return false;
}
if (namereln == dns_namereln_subdomain) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
result = dns_message_nextname(message, DNS_SECTION_AUTHORITY);
}
- return (false);
+ return false;
}
static void
*/
log_formerr(fctx, "empty question section, "
"accepting it anyway as TC=1");
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
log_formerr(fctx, "empty question section");
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
} else if (message->counts[DNS_SECTION_QUESTION] > 1) {
log_formerr(fctx, "too many questions");
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
result = dns_message_firstname(message, DNS_SECTION_QUESTION);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_message_currentname(message, DNS_SECTION_QUESTION, &name);
dns_rdatatype_format(rdataset->type, typebuf, sizeof(typebuf));
log_formerr(fctx, "question section mismatch: got %s/%s/%s",
namebuf, classbuf, typebuf);
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
memcmp(nsec.typebits, minimal_typemap, nsec.len) == 0)
{
dns_rdataset_disassociate(&rdataset);
- return (true);
+ return true;
}
}
dns_rdataset_disassociate(&rdataset);
- return (false);
+ return false;
}
/*
!dns_nsec_typepresent(&rdata, dns_rdatatype_ns)))
{
dns_rdataset_disassociate(&rdataset);
- return (false);
+ return false;
}
}
dns_rdataset_disassociate(&rdataset);
- return (true);
+ return true;
}
/*
rdata.data[1] == 0)
{
dns_rdataset_disassociate(&rdataset);
- return (true);
+ return true;
}
}
dns_rdataset_disassociate(&rdataset);
- return (false);
+ return false;
}
/*
}
if (sigrdataset == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
labels = dns_name_countlabels(name);
}
if (result == ISC_R_NOMORE) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
zonename = dns_fixedname_initname(&fzonename);
*noqnamep = noqname;
}
}
- return (result);
+ return result;
}
static isc_result_t
result = issecuredomain(res->view, name, fctx->type, now,
checknta, NULL, &secure_domain);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
node = NULL;
result = dns_db_findnode(fctx->cache, name, true, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
if (fail) {
if (ANSWER(rdataset)) {
dns_db_detachnode(fctx->cache, &node);
- return (DNS_R_BADNAME);
+ return DNS_R_BADNAME;
}
continue;
}
dns_db_detachnode(fctx->cache, &node);
}
- return (result);
+ return result;
}
static isc_result_t
UNLOCK(&fctx->res->buckets[fctx->bucketnum].lock);
- return (result);
+ return result;
}
/*
dns_rdataset_disassociate(ardataset);
}
- return (result);
+ return result;
}
static isc_result_t
result = issecuredomain(res->view, name, fctx->type, now,
checknta, NULL, &secure_domain);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
DNS_SECTION_AUTHORITY);
}
if (result != ISC_R_NOMORE) {
- return (result);
+ return result;
}
}
* continue to process the message, letting the
* validation complete in its own good time.
*/
- return (result);
+ return result;
}
LOCK(&res->buckets[fctx->bucketnum].lock);
dns_db_detachnode(fctx->cache, &node);
}
- return (result);
+ return result;
}
static void
rel = dns_name_fullcompare(name, apex, &(int){ 0 },
&(unsigned int){ 0U });
if (rel != dns_namereln_subdomain && rel != dns_namereln_equal) {
- return (true);
+ return true;
}
/*
name = &suffix;
} else if (rel == dns_namereln_equal) {
/* If 'name' is 'apex', no further checking is needed. */
- return (false);
+ return false;
}
/*
dns_namereln_subdomain)
{
UNLOCK(&fctx->res->view->lock);
- return (true);
+ return true;
}
}
}
* See if the forwarder declaration is better.
*/
if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) {
- return (!dns_name_equal(fname, fctx->fwdname));
+ return !dns_name_equal(fname, fctx->fwdname);
}
/*
* If the lookup failed, the configuration must have
* changed: play it safe and don't cache.
*/
- return (true);
+ return true;
} else if ((result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) &&
forwarders->fwdpolicy == dns_fwdpolicy_only &&
!ISC_LIST_EMPTY(forwarders->fwdrs))
* If 'name' is covered by a 'forward only' clause then we
* can't cache this repsonse.
*/
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static isc_result_t
#if CHECK_FOR_GLUE_IN_ANSWER
if (section == DNS_SECTION_ANSWER && type != dns_rdatatype_a) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#endif /* if CHECK_FOR_GLUE_IN_ANSWER */
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
check_related(void *arg, const dns_name_t *addname, dns_rdatatype_t type,
dns_rdataset_t *found) {
- return (check_section(arg, addname, type, found,
- DNS_SECTION_ADDITIONAL));
+ return check_section(arg, addname, type, found, DNS_SECTION_ADDITIONAL);
}
#ifndef CHECK_FOR_GLUE_IN_ANSWER
static isc_result_t
check_answer(void *arg, const dns_name_t *addname, dns_rdatatype_t type,
dns_rdataset_t *found) {
- return (check_section(arg, addname, type, found, DNS_SECTION_ANSWER));
+ return check_section(arg, addname, type, found, DNS_SECTION_ANSWER);
}
#endif /* if CHECK_FOR_GLUE_IN_ANSWER */
/* By default, we allow any addresses. */
if (view->denyansweracl == NULL) {
- return (true);
+ return true;
}
/*
&node, NULL, 0, NULL, NULL);
if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) {
- return (true);
+ return true;
}
}
DNS_LOGMODULE_RESOLVER, ISC_LOG_NOTICE,
"answer address %s denied for %s/%s/%s",
addrbuf, namebuf, typebuf, classbuf);
- return (false);
+ return false;
}
}
- return (true);
+ return true;
}
static bool
* If newqname != NULL we also need to extract the newqname.
*/
if (chainingp == NULL && view->denyanswernames == NULL) {
- return (true);
+ return true;
}
result = dns_rdataset_first(rdataset);
if (dns_name_fullcompare(qname, rname, &order, &nlabels) !=
dns_namereln_subdomain)
{
- return (true);
+ return true;
}
result = dns_rdata_tostruct(&rdata, &dname, NULL);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
if (chainingp != NULL) {
*chainingp = true;
}
- return (true);
+ return true;
}
RUNTIME_CHECK(result == ISC_R_SUCCESS);
break;
}
if (view->denyanswernames == NULL) {
- return (true);
+ return true;
}
/*
result = dns_rbt_findnode(view->answernames_exclude, qname,
NULL, &node, NULL, 0, NULL, NULL);
if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) {
- return (true);
+ return true;
}
}
* filters can be applied; see GL #1574.
*/
if (!fctx->forwarding && dns_name_issubdomain(tname, fctx->domain)) {
- return (true);
+ return true;
}
/*
DNS_LOGMODULE_RESOLVER, ISC_LOG_NOTICE,
"%s target %s denied for %s/%s", typebuf,
tnamebuf, qnamebuf, classbuf);
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static void
* appear in the answer section.
*/
log_formerr(fctx, "NSEC3 in answer");
- return (false);
+ return false;
}
if (rdataset->type == dns_rdatatype_tkey) {
/*
* response to any query we can make.
*/
log_formerr(fctx, "TKEY in answer");
- return (false);
+ return false;
}
if (rdataset->rdclass != fctx->res->rdclass) {
log_formerr(fctx, "Mismatched class in answer");
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static void
result = dns_message_findname(message, DNS_SECTION_ANSWER, name,
dns_rdatatype_cname, 0, NULL, NULL);
- return (result == ISC_R_SUCCESS ? true : false);
+ return result == ISC_R_SUCCESS ? true : false;
}
static bool
rdataset = ISC_LIST_NEXT(rdataset, link))
{
if (rdataset->type == dns_rdatatype_ns) {
- return (true);
+ return true;
}
}
}
- return (false);
+ return false;
}
/*
fetchctx_t *fctx = rctx->fctx;
if (rctx->result == ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
FCTXTRACE3("dispatcher failure", rctx->result);
rctx_done(rctx, ISC_R_SUCCESS);
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
/*
}
rctx_done(rctx, rctx->result);
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
result = dns_message_parse(query->rmessage, &rctx->buffer, 0);
if (result == ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
FCTXTRACE3("message failed to parse", result);
* check out this message further.
*/
rctx->truncated = true;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
break;
}
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
/*
*/
if ((rctx->fctx->options & DNS_FETCHOPT_NOFOLLOW) != 0)
{
- return (result);
+ return result;
}
result = ISC_R_SUCCESS;
} else {
rctx->next_server = true;
FCTXTRACE3("rctx_answer lame", result);
rctx_done(rctx, result);
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
}
}
FCTXTRACE3("rctx_answer failed", result);
rctx_done(rctx, result);
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (rctx->aname != NULL && rctx->type == dns_rdatatype_any) {
result = rctx_answer_any(rctx);
if (result == ISC_R_COMPLETE) {
- return (rctx->result);
+ return rctx->result;
}
} else if (rctx->aname != NULL) {
result = rctx_answer_match(rctx);
if (result == ISC_R_COMPLETE) {
- return (rctx->result);
+ return rctx->result;
}
} else if (rctx->cname != NULL) {
result = rctx_answer_cname(rctx);
if (result == ISC_R_COMPLETE) {
- return (rctx->result);
+ return rctx->result;
}
} else if (rctx->dname != NULL) {
result = rctx_answer_dname(rctx);
if (result == ISC_R_COMPLETE) {
- return (rctx->result);
+ return rctx->result;
}
} else {
log_formerr(fctx, "reply has no answer");
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
/*
* Did chaining end before we got the final answer?
*/
if (rctx->chaining) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (rctx->query->rmessage->rcode != dns_rcode_noerror) {
log_formerr(fctx, "CNAME/DNAME chain complete, but RCODE "
"indicates error");
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
/*
trim_ns_ttl(fctx, rctx->ns_name, rctx->ns_rdataset);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
{
if (!validinanswer(rdataset, fctx)) {
rctx->result = DNS_R_FORMERR;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
if ((fctx->type == dns_rdatatype_sig ||
rdataset))
{
rctx->result = DNS_R_SERVFAIL;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
if ((rdataset->type == dns_rdatatype_cname ||
rdataset, NULL))
{
rctx->result = DNS_R_SERVFAIL;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
rctx->aname->attributes |= DNS_NAMEATTR_CACHE;
check_related, rctx);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (!validinanswer(rctx->ardataset, fctx)) {
rctx->result = DNS_R_FORMERR;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
if ((rctx->ardataset->type == dns_rdatatype_a ||
rctx->ardataset))
{
rctx->result = DNS_R_SERVFAIL;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
if ((rctx->ardataset->type == dns_rdatatype_cname ||
rctx->ardataset->type == dns_rdatatype_dname) &&
rctx->ardataset, NULL))
{
rctx->result = DNS_R_SERVFAIL;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
rctx->aname->attributes |= DNS_NAMEATTR_CACHE;
{
if (!validinanswer(sigrdataset, fctx)) {
rctx->result = DNS_R_FORMERR;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
if (sigrdataset->type != dns_rdatatype_rrsig ||
break;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (!validinanswer(rctx->crdataset, fctx)) {
rctx->result = DNS_R_FORMERR;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
if (rctx->type == dns_rdatatype_rrsig ||
dns_rdatatype_format(rctx->type, buf, sizeof(buf));
log_formerr(fctx, "CNAME response for %s RR", buf);
rctx->result = DNS_R_FORMERR;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
if (!is_answertarget_allowed(fctx, fctx->name, rctx->cname,
rctx->crdataset, NULL))
{
rctx->result = DNS_R_SERVFAIL;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
rctx->cname->attributes |= DNS_NAMEATTR_CACHE;
{
if (!validinanswer(sigrdataset, fctx)) {
rctx->result = DNS_R_FORMERR;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
if (sigrdataset->type != dns_rdatatype_rrsig ||
}
rctx->chaining = true;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (!validinanswer(rctx->drdataset, fctx)) {
rctx->result = DNS_R_FORMERR;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
if (!is_answertarget_allowed(fctx, fctx->name, rctx->dname,
rctx->drdataset, &rctx->chaining))
{
rctx->result = DNS_R_SERVFAIL;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
rctx->dname->attributes |= DNS_NAMEATTR_CACHE;
{
if (!validinanswer(sigrdataset, fctx)) {
rctx->result = DNS_R_FORMERR;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
if (sigrdataset->type != dns_rdatatype_rrsig ||
break;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
*/
result = rctx_authority_negative(rctx);
if (result == ISC_R_COMPLETE) {
- return (rctx->result);
+ return rctx->result;
}
log_ns_ttl(fctx, "rctx_answer_none");
*/
result = rctx_authority_dnssec(rctx);
if (result == ISC_R_COMPLETE) {
- return (rctx->result);
+ return rctx->result;
}
}
dns_name_equal(rctx->soa_name, fctx->name) &&
!dns_name_equal(fctx->name, dns_rootname))
{
- return (DNS_R_CHASEDSSERVERS);
+ return DNS_R_CHASEDSSERVERS;
}
/*
*/
if (rctx->found_name == NULL) {
log_formerr(fctx, "invalid response");
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
if (!dns_name_issubdomain(rctx->found_name, fctx->domain)) {
char nbuf[DNS_NAME_FORMATSIZE];
} else {
log_formerr(fctx, "invalid response");
}
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
/*
rctx->ns_name != rctx->soa_name)
{
log_formerr(fctx, "NS/SOA mismatch");
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
/*
*/
result = rctx_referral(rctx);
if (result == ISC_R_COMPLETE) {
- return (rctx->result);
+ return rctx->result;
}
/*
FCTX_ATTR_SET(fctx, FCTX_ATTR_WANTNCACHE);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
result = dns_message_firstname(rctx->query->rmessage, section);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
while (!finished) {
if (type == dns_rdatatype_rrsig) {
type = rdataset->covers;
}
- if (((type == dns_rdatatype_ns ||
- type == dns_rdatatype_soa) &&
- !dns_name_issubdomain(fctx->name, name)))
+ if ((type == dns_rdatatype_ns ||
+ type == dns_rdatatype_soa) &&
+ !dns_name_issubdomain(fctx->name, name))
{
char qbuf[DNS_NAME_FORMATSIZE];
char nbuf[DNS_NAME_FORMATSIZE];
"authority "
"section");
rctx->result = DNS_R_FORMERR;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
rctx->ns_name = name;
rctx->ns_rdataset = rdataset;
"authority "
"section");
rctx->result = DNS_R_FORMERR;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
rctx->soa_name = name;
}
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
result = dns_message_firstname(rctx->query->rmessage,
DNS_SECTION_AUTHORITY);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
while (!finished) {
log_formerr(fctx, "DS with no "
"referral");
rctx->result = DNS_R_FORMERR;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
if (rdataset->type == dns_rdatatype_ds) {
"referral "
"(NS)");
rctx->result = DNS_R_FORMERR;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
rctx->ds_name = name;
}
dns_rdatatype_ds, fctx->now,
checknta, NULL, &secure_domain);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
if (secure_domain) {
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
fetchctx_t *fctx = rctx->fctx;
if (rctx->negative || rctx->ns_name == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (dns_name_equal(rctx->ns_name, fctx->domain)) {
log_formerr(fctx, "non-improving referral");
rctx->result = DNS_R_FORMERR;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
/*
log_formerr(fctx, "referral to non-parent");
FCTXTRACE("referral to non-parent");
rctx->result = DNS_R_FORMERR;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
/*
result = fcount_incr(fctx, true);
if (result != ISC_R_SUCCESS) {
rctx->result = result;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
FCTX_ATTR_SET(fctx, FCTX_ATTR_WANTCACHE);
rctx->fctx->adberr = 0;
}
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
/*
INSIST(rctx->query->dispentry != NULL);
dns_message_reset(rctx->query->rmessage, DNS_MESSAGE_INTENTPARSE);
result = dns_dispatch_getnext(rctx->query->dispentry);
- return (result);
+ return result;
}
/*
if (rcode == dns_rcode_noerror || rcode == dns_rcode_yxdomain ||
rcode == dns_rcode_nxdomain)
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if ((rcode == dns_rcode_formerr) && rctx->opt == NULL &&
FCTXTRACE2("remote server broken: returned ", code);
rctx_done(rctx, result);
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
/*
resquery_t *query = rctx->query;
if (ISFORWARDER(query->addrinfo) || !is_lame(fctx, query->rmessage)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
inc_stats(fctx->res, dns_resstatscounter_lame);
FCTXTRACE("lame server");
rctx_done(rctx, result);
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
/*
*resp = res;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_primelock:
isc_mutex_destroy(&res->primelock);
cleanup_res:
isc_mem_put(view->mctx, res, sizeof(*res));
- return (result);
+ return result;
}
static void
if (fctx->cloned || fctx->state == fetchstate_done ||
ISC_LIST_EMPTY(fctx->events))
{
- return (false);
+ return false;
}
if (fctx->type != type || fctx->options != options) {
- return (false);
+ return false;
}
- return (dns_name_equal(fctx->name, name));
+ return dns_name_equal(fctx->name, name);
}
static void
REQUIRE(fetchp != NULL && *fetchp == NULL);
if (atomic_load_acquire(&res->exiting)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
log_fetch(name, type);
isc_mem_putanddetach(&fetch->mctx, fetch, sizeof(*fetch));
}
- return (result);
+ return result;
}
void
dns_dispatchmgr_t *
dns_resolver_dispatchmgr(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
- return (resolver->dispatchmgr);
+ return resolver->dispatchmgr;
}
dns_dispatch_t *
dns_resolver_dispatchv4(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
- return (dns_dispatchset_get(resolver->dispatches4));
+ return dns_dispatchset_get(resolver->dispatches4);
}
dns_dispatch_t *
dns_resolver_dispatchv6(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
- return (dns_dispatchset_get(resolver->dispatches6));
+ return dns_dispatchset_get(resolver->dispatches6);
}
isc_taskmgr_t *
dns_resolver_taskmgr(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
- return (resolver->taskmgr);
+ return resolver->taskmgr;
}
uint32_t
dns_resolver_getlamettl(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
- return (resolver->lame_ttl);
+ return resolver->lame_ttl;
}
void
uint16_t
dns_resolver_getudpsize(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
- return (resolver->udpsize);
+ return resolver->udpsize;
}
void
bool
dns_resolver_getbadcache(dns_resolver_t *resolver, const dns_name_t *name,
dns_rdatatype_t type, isc_time_t *now) {
- return (dns_badcache_find(resolver->badcache, name, type, NULL, now));
+ return dns_badcache_find(resolver->badcache, name, type, NULL, now);
}
void
REQUIRE(VALID_RESOLVER(resolver));
if (alg > 255) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
if (resolver->algorithms == NULL) {
}
result = ISC_R_SUCCESS;
cleanup:
- return (result);
+ return result;
}
bool
* DH is unsupported for DNSKEYs, see RFC 4034 sec. A.1.
*/
if ((alg == DST_ALG_DH) || (alg == DST_ALG_INDIRECT)) {
- return (false);
+ return false;
}
if (resolver->algorithms == NULL) {
}
unlock:
if (found) {
- return (false);
+ return false;
}
- return (dst_algorithm_supported(alg));
+ return dst_algorithm_supported(alg);
}
static void
REQUIRE(VALID_RESOLVER(resolver));
if (digest_type > 255) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
if (resolver->digests == NULL) {
}
result = ISC_R_SUCCESS;
cleanup:
- return (result);
+ return result;
}
bool
}
unlock:
if (found) {
- return (false);
+ return false;
}
- return (dst_ds_digest_supported(digest_type));
+ return dst_ds_digest_supported(digest_type);
}
void
result = dns_rbt_addname(resolver->mustbesecure, name,
value ? &yes : &no);
cleanup:
- return (result);
+ return result;
}
bool
value = *(bool *)data;
}
unlock:
- return (value);
+ return value;
}
void
dns_resolver_getzeronosoattl(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
- return (resolver->zero_no_soa_ttl);
+ return resolver->zero_no_soa_ttl;
}
void
dns_resolver_getoptions(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
- return (resolver->options);
+ return resolver->options;
}
unsigned int
dns_resolver_gettimeout(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
- return (resolver->query_timeout);
+ return resolver->query_timeout;
}
void
unsigned int
dns_resolver_getmaxdepth(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
- return (resolver->maxdepth);
+ return resolver->maxdepth;
}
void
unsigned int
dns_resolver_getmaxqueries(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
- return (resolver->maxqueries);
+ return resolver->maxqueries;
}
void
REQUIRE(VALID_RESOLVER(resolver));
REQUIRE(which == dns_quotatype_zone || which == dns_quotatype_server);
- return (resolver->quotaresp[which]);
+ return resolver->quotaresp[which];
}
unsigned int
dns_resolver_getretryinterval(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
- return (resolver->retryinterval);
+ return resolver->retryinterval;
}
void
dns_resolver_getnonbackofftries(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
- return (resolver->nonbackofftries);
+ return resolver->nonbackofftries;
}
void
switch (result) {
case DNS_R_NOERROR:
case ISC_R_SUCCESS:
- return (dns_rcode_noerror);
+ return dns_rcode_noerror;
case DNS_R_FORMERR:
case ISC_R_BADBASE64:
case ISC_R_RANGE:
case DNS_R_UNKNOWN:
case DNS_R_NAMETOOLONG:
case DNS_R_OPTERR:
- return (dns_rcode_formerr);
+ return dns_rcode_formerr;
case DNS_R_SERVFAIL:
- return (dns_rcode_servfail);
+ return dns_rcode_servfail;
case DNS_R_NXDOMAIN:
- return (dns_rcode_nxdomain);
+ return dns_rcode_nxdomain;
case DNS_R_NOTIMP:
- return (dns_rcode_notimp);
+ return dns_rcode_notimp;
case DNS_R_REFUSED:
case DNS_R_DISALLOWED:
- return (dns_rcode_refused);
+ return dns_rcode_refused;
case DNS_R_YXDOMAIN:
- return (dns_rcode_yxdomain);
+ return dns_rcode_yxdomain;
case DNS_R_YXRRSET:
- return (dns_rcode_yxrrset);
+ return dns_rcode_yxrrset;
case DNS_R_NXRRSET:
- return (dns_rcode_nxrrset);
+ return dns_rcode_nxrrset;
case DNS_R_NOTAUTH:
case DNS_R_TSIGVERIFYFAILURE:
case DNS_R_CLOCKSKEW:
- return (dns_rcode_notauth);
+ return dns_rcode_notauth;
case DNS_R_NOTZONE:
- return (dns_rcode_notzone);
+ return dns_rcode_notzone;
case DNS_R_RCODE11:
case DNS_R_RCODE12:
case DNS_R_RCODE13:
case DNS_R_RCODE14:
case DNS_R_RCODE15:
- return (result - DNS_R_NOERROR);
+ return result - DNS_R_NOERROR;
case DNS_R_BADVERS:
- return (dns_rcode_badvers);
+ return dns_rcode_badvers;
case DNS_R_BADCOOKIE:
- return (dns_rcode_badcookie);
+ return dns_rcode_badcookie;
default:
- return (dns_rcode_servfail);
+ return dns_rcode_servfail;
}
}
dns_result_fromrcode(dns_rcode_t rcode) {
switch (rcode) {
case dns_rcode_noerror:
- return (DNS_R_NOERROR);
+ return DNS_R_NOERROR;
case dns_rcode_formerr:
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
case dns_rcode_servfail:
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
case dns_rcode_nxdomain:
- return (DNS_R_NXDOMAIN);
+ return DNS_R_NXDOMAIN;
case dns_rcode_notimp:
- return (DNS_R_NOTIMP);
+ return DNS_R_NOTIMP;
case dns_rcode_refused:
- return (DNS_R_REFUSED);
+ return DNS_R_REFUSED;
case dns_rcode_yxdomain:
- return (DNS_R_YXDOMAIN);
+ return DNS_R_YXDOMAIN;
case dns_rcode_yxrrset:
- return (DNS_R_YXRRSET);
+ return DNS_R_YXRRSET;
case dns_rcode_nxrrset:
- return (DNS_R_NXRRSET);
+ return DNS_R_NXRRSET;
case dns_rcode_notauth:
- return (DNS_R_NOTAUTH);
+ return DNS_R_NOTAUTH;
case dns_rcode_notzone:
- return (DNS_R_NOTZONE);
+ return DNS_R_NOTZONE;
case dns_rcode_badvers:
- return (DNS_R_BADVERS);
+ return DNS_R_BADVERS;
case dns_rcode_badcookie:
- return (DNS_R_BADCOOKIE);
+ return DNS_R_BADCOOKIE;
default:
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
}
dns_rdata_ns_t ns;
if (!dns_rdataset_isassociated(rootns)) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
result = dns_rdataset_first(rootns);
dns_rdataset_current(rootns, &rdata);
result = dns_rdata_tostruct(&rdata, &ns, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (dns_name_compare(name, &ns.name) == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = dns_rdataset_next(rootns);
dns_rdata_reset(&rdata);
if (result == ISC_R_NOMORE) {
result = ISC_R_NOTFOUND;
}
- return (result);
+ return result;
}
static isc_result_t
if (dns_rdataset_isassociated(&rdataset)) {
dns_rdataset_disassociate(&rdataset);
}
- return (result);
+ return result;
}
static isc_result_t
if (dbiter != NULL) {
dns_dbiterator_destroy(&dbiter);
}
- return (result);
+ return result;
}
isc_result_t
(filename != NULL) ? filename : "<BUILT-IN>");
}
*target = db;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_HINTS,
dns_db_detach(&db);
}
- return (result);
+ return result;
}
static void
while (result == ISC_R_SUCCESS) {
dns_rdataset_current(rrset, ¤t);
if (dns_rdata_compare(rdata, ¤t) == 0) {
- return (true);
+ return true;
}
dns_rdata_reset(¤t);
result = dns_rdataset_next(rrset);
}
- return (false);
+ return false;
}
static bool
if (upcoming[i].time > now && upcoming[i].type == type &&
dns_name_equal(&upcoming[i].name, name))
{
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
/*
dns_rpz_type2str(dns_rpz_type_t type) {
switch (type) {
case DNS_RPZ_TYPE_CLIENT_IP:
- return ("CLIENT-IP");
+ return "CLIENT-IP";
case DNS_RPZ_TYPE_QNAME:
- return ("QNAME");
+ return "QNAME";
case DNS_RPZ_TYPE_IP:
- return ("IP");
+ return "IP";
case DNS_RPZ_TYPE_NSIP:
- return ("NSIP");
+ return "NSIP";
case DNS_RPZ_TYPE_NSDNAME:
- return ("NSDNAME");
+ return "NSDNAME";
case DNS_RPZ_TYPE_BAD:
break;
}
FATAL_ERROR("impossible rpz type %d", type);
- return ("impossible");
+ return "impossible";
}
dns_rpz_policy_t
unsigned int n;
if (str == NULL) {
- return (DNS_RPZ_POLICY_ERROR);
+ return DNS_RPZ_POLICY_ERROR;
}
for (n = 0; n < sizeof(tbl) / sizeof(tbl[0]); ++n) {
if (!strcasecmp(tbl[n].str, str)) {
- return (tbl[n].policy);
+ return tbl[n].policy;
}
}
- return (DNS_RPZ_POLICY_ERROR);
+ return DNS_RPZ_POLICY_ERROR;
}
const char *
default:
UNREACHABLE();
}
- return (str);
+ return str;
}
/*
if ((zbit & 2) != 0) {
++rpz_num;
}
- return (rpz_num);
+ return rpz_num;
}
/*
node->ip.w[i++] = 0;
}
- return (node);
+ return node;
}
static void
(tgt_ip->w[3] >> 16) & 0xffU,
(tgt_ip->w[3] >> 24) & 0xffU);
if (len < 0 || (size_t)len >= sizeof(str)) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
} else {
int w[DNS_RPZ_CIDR_WORDS * 2];
len = snprintf(str, sizeof(str), "%d", tgt_prefix);
if (len < 0 || (size_t)len >= sizeof(str)) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
for (int n = 0; n < DNS_RPZ_CIDR_WORDS; n++) {
".%x", w[n]);
}
if (i < 0 || (size_t)i >= (size_t)(sizeof(str) - len)) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
len += i;
}
isc_buffer_init(&buffer, str, sizeof(str));
isc_buffer_add(&buffer, len);
result = dns_name_fromtext(ip_name, &buffer, base_name, 0, NULL);
- return (result);
+ return result;
}
/*
type_from_name(const dns_rpz_zones_t *rpzs, dns_rpz_zone_t *rpz,
const dns_name_t *name) {
if (dns_name_issubdomain(name, &rpz->ip)) {
- return (DNS_RPZ_TYPE_IP);
+ return DNS_RPZ_TYPE_IP;
}
if (dns_name_issubdomain(name, &rpz->client_ip)) {
- return (DNS_RPZ_TYPE_CLIENT_IP);
+ return DNS_RPZ_TYPE_CLIENT_IP;
}
if ((rpzs->p.nsip_on & DNS_RPZ_ZBIT(rpz->num)) != 0 &&
dns_name_issubdomain(name, &rpz->nsip))
{
- return (DNS_RPZ_TYPE_NSIP);
+ return DNS_RPZ_TYPE_NSIP;
}
if ((rpzs->p.nsdname_on & DNS_RPZ_ZBIT(rpz->num)) != 0 &&
dns_name_issubdomain(name, &rpz->nsdname))
{
- return (DNS_RPZ_TYPE_NSDNAME);
+ return DNS_RPZ_TYPE_NSDNAME;
}
- return (DNS_RPZ_TYPE_QNAME);
+ return DNS_RPZ_TYPE_QNAME;
}
/*
}
if (ip_labels < 2) {
badname(log_level, src_name, "; too short", "");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
dns_name_init(&ip_name, ip_name_offsets);
dns_name_getlabelsequence(src_name, 0, ip_labels, &ip_name);
if (*cp2 != '.') {
badname(log_level, src_name, "; invalid leading prefix length",
"");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
* Patch in trailing nul character to print just the length
if (prefix_num < 1U || prefix_num > 128U) {
badname(log_level, src_name, "; invalid prefix length of ",
prefix_str);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
cp = cp2 + 1;
if (prefix_num > 32U) {
badname(log_level, src_name,
"; invalid IPv4 prefix length of ", prefix_str);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
prefix_num += 96;
*tgt_prefix = (dns_rpz_prefix_t)prefix_num;
}
badname(log_level, src_name,
"; invalid IPv4 octet ", cp);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
tgt_ip->w[3] |= l << i;
cp = cp2 + 1;
}
badname(log_level, src_name,
"; invalid IPv6 word ", cp);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if ((i & 1) == 0) {
tgt_ip->w[3 - i / 2] = l;
}
if (cp != end) {
badname(log_level, src_name, "", "");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
if ((aword & ~DNS_RPZ_WORD_MASK(i)) != 0) {
badname(log_level, src_name,
"; too small prefix length of ", prefix_str);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
prefix -= i;
prefix += DNS_RPZ_CIDR_WORD_BITS;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
--bit;
}
- return (bit);
+ return bit;
}
#endif /* ifndef HAVE_BUILTIN_CLZ */
break;
}
}
- return (ISC_MIN(bit, maxbit));
+ return ISC_MIN(bit, maxbit);
}
/*
x &= (~x + 1);
x = (x << 1) - 1;
zbits &= x;
- return (zbits);
+ return zbits;
}
/*
* or add the target as a child of the current parent.
*/
if (!create) {
- return (find_result);
+ return find_result;
}
child = new_node(rpzs, tgt_ip, tgt_prefix, NULL);
if (child == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (parent == NULL) {
rpzs->cidr = child;
child->set.nsip |= tgt_set->nsip;
set_sum_pair(child);
*found = child;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if ((cur->sum.client_ip & set.client_ip) == 0 &&
* a node and mark/put this node in the correct tree.
*/
if (!create) {
- return (find_result);
+ return find_result;
}
}
*found = cur;
find_result = ISC_R_SUCCESS;
}
- return (find_result);
+ return find_result;
}
/*
* Add the target as the current node's parent.
*/
if (!create) {
- return (find_result);
+ return find_result;
}
new_parent = new_node(rpzs, tgt_ip, tgt_prefix, cur);
if (new_parent == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
new_parent->parent = parent;
if (parent == NULL) {
new_parent->set = *tgt_set;
set_sum_pair(new_parent);
*found = new_parent;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (dbit == cur->prefix) {
* add the target as a sibling of the current node
*/
if (!create) {
- return (find_result);
+ return find_result;
}
sibling = new_node(rpzs, tgt_ip, tgt_prefix, NULL);
if (sibling == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
new_parent = new_node(rpzs, tgt_ip, dbit, cur);
if (new_parent == NULL) {
isc_mem_put(rpzs->mctx, sibling, sizeof(*sibling));
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
new_parent->parent = parent;
if (parent == NULL) {
sibling->set = *tgt_set;
set_sum_pair(sibling);
*found = sibling;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
* Log complaints about bad owner names but let the zone load.
*/
if (result != ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = search(rpz->rpzs, &tgt_ip, tgt_prefix, &set, true, &found);
* because diff_apply() likes to add nodes before deleting.
*/
if (result == ISC_R_EXISTS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
DNS_LOGMODULE_RBTDB, DNS_RPZ_ERROR_LEVEL,
"rpz add_cidr(%s) failed: %s", namebuf,
isc_result_totext(result));
- return (result);
+ return result;
}
adj_trigger_cnt(rpz, rpz_type, &tgt_ip, tgt_prefix, true);
- return (result);
+ return result;
}
static isc_result_t
nm_data = isc_mem_get(rpzs->mctx, sizeof(*nm_data));
*nm_data = *new_data;
nmnode->data = nm_data;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
break;
default:
- return (result);
+ return result;
}
/*
(nm_data->wild.qname & new_data->wild.qname) != 0 ||
(nm_data->wild.ns & new_data->wild.ns) != 0)
{
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
nm_data->set.qname |= new_data->set.qname;
nm_data->set.ns |= new_data->set.ns;
nm_data->wild.qname |= new_data->wild.qname;
nm_data->wild.ns |= new_data->wild.ns;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
* because diff_apply() likes to add nodes before deleting.
*/
if (result == ISC_R_EXISTS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result == ISC_R_SUCCESS) {
adj_trigger_cnt(rpz, rpz_type, NULL, 0, true);
}
- return (result);
+ return result;
}
/*
isc_mem_attach(mctx, &rpzs->mctx);
*rpzsp = rpzs;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_task:
dns_rbt_destroy(&rpzs->rbt);
isc_rwlock_destroy(&rpzs->search_lock);
isc_mem_put(mctx, rpzs, sizeof(*rpzs));
- return (result);
+ return result;
}
isc_result_t
REQUIRE(rpzp != NULL && *rpzp == NULL);
if (rpzs->p.num_zones >= DNS_RPZ_MAX_ZONES) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
result = dns__rpz_shuttingdown(rpzs);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
rpz = isc_mem_get(rpzs->mctx, sizeof(*rpz));
*rpzp = rpz;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_timer:
isc_mem_put(rpzs->mctx, rpz, sizeof(*rpz));
- return (result);
+ return result;
}
isc_result_t
unlock:
UNLOCK(&rpz->rpzs->maint_lock);
- return (result);
+ return result;
}
static void
DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
"rpz: %s: failed to create DB iterator - %s",
domain, isc_result_totext(result));
- return (result);
+ return result;
}
result = dns_dbiterator_first(updbit);
cleanup:
dns_dbiterator_destroy(&updbit);
- return (result);
+ return result;
}
static isc_result_t
isc_ht_iter_destroy(&iter);
- return (result);
+ return result;
}
static isc_result_t
UNLOCK(&rpzs->maint_lock);
if (shuttingdown) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
}
RWUNLOCK(&rpzs->search_lock, isc_rwlocktype_write);
- return (result);
+ return result;
}
/*
break;
}
} else {
- return (DNS_RPZ_INVALID_NUM);
+ return DNS_RPZ_INVALID_NUM;
}
if (zbits == 0) {
- return (DNS_RPZ_INVALID_NUM);
+ return DNS_RPZ_INVALID_NUM;
}
make_addr_set(&tgt_set, zbits, rpz_type);
* There are no eligible zones for this IP address.
*/
RWUNLOCK(&rpzs->search_lock, isc_rwlocktype_read);
- return (DNS_RPZ_INVALID_NUM);
+ return DNS_RPZ_INVALID_NUM;
}
/*
DNS_LOGMODULE_RBTDB, DNS_RPZ_ERROR_LEVEL,
"rpz ip2name() failed: %s",
isc_result_totext(result));
- return (DNS_RPZ_INVALID_NUM);
+ return DNS_RPZ_INVALID_NUM;
}
- return (rpz_num);
+ return rpz_num;
}
/*
int i;
if (zbits == 0) {
- return (0);
+ return 0;
}
found_zbits = 0;
dns_rbtnodechain_invalidate(&chain);
- return (zbits & found_zbits);
+ return zbits & found_zbits;
}
/*
* CNAME . means NXDOMAIN
*/
if (dns_name_equal(&cname.cname, dns_rootname)) {
- return (DNS_RPZ_POLICY_NXDOMAIN);
+ return DNS_RPZ_POLICY_NXDOMAIN;
}
if (dns_name_iswildcard(&cname.cname)) {
* CNAME *. means NODATA
*/
if (dns_name_countlabels(&cname.cname) == 2) {
- return (DNS_RPZ_POLICY_NODATA);
+ return DNS_RPZ_POLICY_NODATA;
}
/*
* evil.com CNAME evil.com.garden.net
*/
if (dns_name_countlabels(&cname.cname) > 2) {
- return (DNS_RPZ_POLICY_WILDCNAME);
+ return DNS_RPZ_POLICY_WILDCNAME;
}
}
* CNAME rpz-tcp-only. means "send truncated UDP responses."
*/
if (dns_name_equal(&cname.cname, &rpz->tcp_only)) {
- return (DNS_RPZ_POLICY_TCP_ONLY);
+ return DNS_RPZ_POLICY_TCP_ONLY;
}
/*
* CNAME rpz-drop. means "do not respond."
*/
if (dns_name_equal(&cname.cname, &rpz->drop)) {
- return (DNS_RPZ_POLICY_DROP);
+ return DNS_RPZ_POLICY_DROP;
}
/*
* CNAME rpz-passthru. means "do not rewrite."
*/
if (dns_name_equal(&cname.cname, &rpz->passthru)) {
- return (DNS_RPZ_POLICY_PASSTHRU);
+ return DNS_RPZ_POLICY_PASSTHRU;
}
/*
* 128.1.0.127.rpz-ip CNAME 128.1.0.0.127. is obsolete PASSTHRU
*/
if (selfname != NULL && dns_name_equal(&cname.cname, selfname)) {
- return (DNS_RPZ_POLICY_PASSTHRU);
+ return DNS_RPZ_POLICY_PASSTHRU;
}
/*
* Any other rdata gives a response consisting of the rdata.
*/
- return (DNS_RPZ_POLICY_RECORD);
+ return DNS_RPZ_POLICY_RECORD;
}
it->node = NULL;
result = dns_db_createiterator(it->db, 0, &it->dbit);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
it->rdatasetit = NULL;
dns_rdata_init(&it->rdata);
dns_fixedname_init(&it->fixedname);
INSIST(!dns_rdataset_isassociated(&it->rdataset));
it->result = ISC_R_SUCCESS;
- return (it->result);
+ return it->result;
}
isc_result_t
it->dbit, &it->node,
dns_fixedname_name(&it->fixedname));
if (it->result != ISC_R_SUCCESS) {
- return (it->result);
+ return it->result;
}
it->result = dns_db_allrdatasets(it->db, it->node, it->ver, 0,
it->now, &it->rdatasetit);
if (it->result != ISC_R_SUCCESS) {
- return (it->result);
+ return it->result;
}
it->result = dns_rdatasetiter_first(it->rdatasetit);
dns_fixedname_name(&it->fixedname));
it->rdataset.attributes |= DNS_RDATASETATTR_LOADORDER;
it->result = dns_rdataset_first(&it->rdataset);
- return (it->result);
+ return it->result;
}
- return (it->result);
+ return it->result;
}
isc_result_t
it->result = dns_dbiterator_next(it->dbit);
if (it->result == ISC_R_NOMORE) {
/* We are at the end of the entire database. */
- return (it->result);
+ return it->result;
}
if (it->result != ISC_R_SUCCESS) {
- return (it->result);
+ return it->result;
}
it->result = dns_dbiterator_current(
it->dbit, &it->node,
dns_fixedname_name(&it->fixedname));
if (it->result != ISC_R_SUCCESS) {
- return (it->result);
+ return it->result;
}
it->result = dns_db_allrdatasets(it->db, it->node, it->ver, 0,
it->now, &it->rdatasetit);
if (it->result != ISC_R_SUCCESS) {
- return (it->result);
+ return it->result;
}
it->result = dns_rdatasetiter_first(it->rdatasetit);
}
if (it->result != ISC_R_SUCCESS) {
- return (it->result);
+ return it->result;
}
dns_rdatasetiter_current(it->rdatasetit, &it->rdataset);
dns_rdataset_getownercase(&it->rdataset,
dns_fixedname_name(&it->fixedname));
it->rdataset.attributes |= DNS_RDATASETATTR_LOADORDER;
it->result = dns_rdataset_first(&it->rdataset);
- return (it->result);
+ return it->result;
}
isc_result_t
dns_rriterator_next(dns_rriterator_t *it) {
REQUIRE(VALID_RRITERATOR(it));
if (it->result != ISC_R_SUCCESS) {
- return (it->result);
+ return it->result;
}
INSIST(it->dbit != NULL);
it->result = dns_rdataset_next(&it->rdataset);
if (it->result == ISC_R_NOMORE) {
- return (dns_rriterator_nextrrset(it));
+ return dns_rriterator_nextrrset(it);
}
- return (it->result);
+ return it->result;
}
void
while (*pp < result) {
++pp;
}
- return (*pp);
+ return *pp;
}
if ((result & 1) == 0) {
divisions, tries, result, initial);
}
- return (result);
+ return result;
}
/*
delta = now - ts;
if (delta >= 0) {
- return (delta);
+ return delta;
}
/*
* the past, make existing timestamps appear to be in the past.
*/
if (delta < -DNS_RRL_MAX_TIME_TRAVEL) {
- return (DNS_RRL_FOREVER);
+ return DNS_RRL_FOREVER;
}
- return (0);
+ return 0;
}
static int
get_age(const dns_rrl_t *rrl, const dns_rrl_entry_t *e, isc_stdtime_t now) {
if (!e->ts_valid) {
- return (DNS_RRL_FOREVER);
+ return DNS_RRL_FOREVER;
}
- return (delta_rrl_time(e->ts + rrl->ts_bases[e->ts_gen], now));
+ return delta_rrl_time(e->ts + rrl->ts_bases[e->ts_gen], now);
}
static void
{
newsize = rrl->max_entries - rrl->num_entries;
if (newsize <= 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
rrl->num_entries += newsize;
ISC_LIST_INITANDAPPEND(rrl->blocks, b, link);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static dns_rrl_bin_t *
get_bin(dns_rrl_hash_t *hash, unsigned int hval) {
INSIST(hash != NULL);
- return (&hash->bins[hval % hash->length]);
+ return &hash->bins[hval % hash->length];
}
static void
}
rrl->hash = hash;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
static bool
key_cmp(const dns_rrl_key_t *a, const dns_rrl_key_t *b) {
if (memcmp(a, b, sizeof(dns_rrl_key_t)) == 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static uint32_t
for (i = sizeof(key->w) / sizeof(key->w[0]) - 1; i >= 0; --i) {
hval = key->w[i] + (hval << 1);
}
- return (hval);
+ return hval;
}
/*
get_rate(dns_rrl_t *rrl, dns_rrl_rtype_t rtype) {
switch (rtype) {
case DNS_RRL_RTYPE_QUERY:
- return (&rrl->responses_per_second);
+ return &rrl->responses_per_second;
case DNS_RRL_RTYPE_REFERRAL:
- return (&rrl->referrals_per_second);
+ return &rrl->referrals_per_second;
case DNS_RRL_RTYPE_NODATA:
- return (&rrl->nodata_per_second);
+ return &rrl->nodata_per_second;
case DNS_RRL_RTYPE_NXDOMAIN:
- return (&rrl->nxdomains_per_second);
+ return &rrl->nxdomains_per_second;
case DNS_RRL_RTYPE_ERROR:
- return (&rrl->errors_per_second);
+ return &rrl->errors_per_second;
case DNS_RRL_RTYPE_ALL:
- return (&rrl->all_per_second);
+ return &rrl->all_per_second;
default:
UNREACHABLE();
}
if (balance > rate) {
balance = rate;
}
- return (balance);
+ return balance;
}
/*
while (e != NULL) {
if (key_cmp(&e->key, &key)) {
ref_entry(rrl, e, probes, now);
- return (e);
+ return e;
}
++probes;
e = ISC_LIST_NEXT(e, hlink);
ISC_LIST_PREPEND(*new_bin, e, hlink);
e->hash_gen = rrl->hash_gen;
ref_entry(rrl, e, probes, now);
- return (e);
+ return e;
}
e = ISC_LIST_NEXT(e, hlink);
}
}
if (!create) {
- return (NULL);
+ return NULL;
}
/*
e->key = key;
e->ts_valid = false;
ref_entry(rrl, e, probes, now);
- return (e);
+ return e;
}
static void
ratep = get_rate(rrl, e->key.s.rtype);
rate = ratep->r;
if (rate == 0) {
- return (DNS_RRL_RESULT_OK);
+ return DNS_RRL_RESULT_OK;
}
if (scale < 1.0) {
if (isc_log_wouldlog(dns_lctx, DNS_RRL_LOG_DEBUG3)) {
debit_log(e, age, "");
}
- return (DNS_RRL_RESULT_OK);
+ return DNS_RRL_RESULT_OK;
}
if (e->responses < min) {
if (isc_log_wouldlog(dns_lctx, DNS_RRL_LOG_DEBUG3)) {
debit_log(e, age, "slip");
}
- return (DNS_RRL_RESULT_SLIP);
+ return DNS_RRL_RESULT_SLIP;
} else if ((int)e->slip_cnt >= slip) {
e->slip_cnt = 0;
}
if (isc_log_wouldlog(dns_lctx, DNS_RRL_LOG_DEBUG3)) {
debit_log(e, age, "drop");
}
- return (DNS_RRL_RESULT_DROP);
+ return DNS_RRL_RESULT_DROP;
}
static dns_rrl_qname_buf_t *
qbuf = rrl->qnames[e->log_qname];
if (qbuf == NULL || qbuf->e != e) {
- return (NULL);
+ return NULL;
}
- return (qbuf);
+ return qbuf;
}
static void
result = dns_acl_match(&netclient, NULL, rrl->exempt,
view->aclenv, &exempt_match, NULL);
if (result == ISC_R_SUCCESS && exempt_match > 0) {
- return (DNS_RRL_RESULT_OK);
+ return DNS_RRL_RESULT_OK;
}
}
}
}
UNLOCK(&rrl->lock);
- return (DNS_RRL_RESULT_OK);
+ return DNS_RRL_RESULT_OK;
}
/*
true, log_buf, log_buf_len);
if (e == NULL) {
UNLOCK(&rrl->lock);
- return (DNS_RRL_RESULT_OK);
+ return DNS_RRL_RESULT_OK;
}
if (isc_log_wouldlog(dns_lctx, DNS_RRL_LOG_DEBUG1)) {
log_buf_len);
if (e_all == NULL) {
UNLOCK(&rrl->lock);
- return (DNS_RRL_RESULT_OK);
+ return DNS_RRL_RESULT_OK;
}
rrl_all_result = debit_rrl_entry(rrl, e_all, qps, scale,
client_addr, now, log_buf,
if (rrl_result == DNS_RRL_RESULT_OK) {
UNLOCK(&rrl->lock);
- return (DNS_RRL_RESULT_OK);
+ return DNS_RRL_RESULT_OK;
}
/*
UNLOCK(&rrl->lock);
}
- return (rrl_result);
+ return rrl_result;
}
void
result = expand_entries(rrl, min_entries);
if (result != ISC_R_SUCCESS) {
dns_rrl_view_destroy(view);
- return (result);
+ return result;
}
result = expand_rrl_hash(rrl, 0);
if (result != ISC_R_SUCCESS) {
dns_rrl_view_destroy(view);
- return (result);
+ return result;
}
*rrlp = rrl;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
*sdbimp = imp;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_mutex:
isc_mutex_destroy(&imp->driverlock);
isc_mem_put(mctx, imp, sizeof(dns_sdbimplementation_t));
- return (result);
+ return result;
}
void
for (size = 1024; size < (64 * 1024); size *= 2) {
if (len < size) {
- return (size);
+ return size;
}
}
- return (65535);
+ return 65535;
}
isc_result_t
rdatalist->ttl = ttl;
ISC_LIST_APPEND(lookup->lists, rdatalist, link);
} else if (rdatalist->ttl != ttl) {
- return (DNS_R_BADTTL);
+ return DNS_R_BADTTL;
}
rdata = isc_mem_get(mctx, sizeof(dns_rdata_t));
ISC_LIST_APPEND(rdatalist->rdata, rdata, link);
ISC_LIST_APPEND(lookup->buffers, rdatabuf, link);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
r.length = strlen(type);
result = dns_rdatatype_fromtext(&typeval, &r);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
imp = lookup->sdb->implementation;
isc_lex_destroy(&lex);
}
- return (result);
+ return result;
}
static isc_result_t
result = dns_name_fromtext(newname, &b, origin, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (allnodes->common.relative_names) {
sdbnode = NULL;
result = createnode(sdb, &sdbnode);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
sdbnode->name = isc_mem_get(mctx, sizeof(dns_name_t));
dns_name_init(sdbnode->name, NULL);
}
}
*nodep = sdbnode;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
dns_sdbnode_t *sdbnode = NULL;
result = getnode(allnodes, name, &sdbnode);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return (dns_sdb_putrr(sdbnode, type, ttl, data));
+ return dns_sdb_putrr(sdbnode, type, ttl, data);
}
isc_result_t
dns_sdbnode_t *sdbnode = NULL;
result = getnode(allnodes, name, &sdbnode);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return (dns_sdb_putrdata(sdbnode, type, ttl, rdata, rdlen));
+ return dns_sdb_putrdata(sdbnode, type, ttl, rdata, rdlen);
}
isc_result_t
serial, SDB_DEFAULT_REFRESH, SDB_DEFAULT_RETRY,
SDB_DEFAULT_EXPIRE, SDB_DEFAULT_MINIMUM);
if (n >= (int)sizeof(str) || n < 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
- return (dns_sdb_putrr(lookup, "SOA", SDB_DEFAULT_TTL, str));
+ return dns_sdb_putrr(lookup, "SOA", SDB_DEFAULT_TTL, str);
}
/*
beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
UNUSED(db);
UNUSED(callbacks);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static isc_result_t
endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
UNUSED(db);
UNUSED(callbacks);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static isc_result_t
UNUSED(version);
UNUSED(filename);
UNUSED(masterformat);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static void
UNUSED(db);
UNUSED(versionp);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static void
node->magic = SDBLOOKUP_MAGIC;
*nodep = node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
dns_name_init(&relname, NULL);
result = dns_name_totext(&relname, true, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
} else {
result = dns_name_totext(name, true, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
isc_buffer_putuint8(&b, 0);
result = createnode(sdb, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
MAYBE_LOCK(sdb);
!(result == ISC_R_NOTFOUND && imp->methods->authority != NULL))
{
destroynode(node);
- return (result);
+ return result;
}
if (imp->methods->authority != NULL) {
MAYBE_UNLOCK(sdb);
if (result != ISC_R_SUCCESS) {
destroynode(node);
- return (result);
+ return result;
}
}
*nodep = node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_name_getlabelsequence(name, 0, labels, &relname);
result = dns_name_totext(&relname, true, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
} else {
result = dns_name_totext(name, true, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
isc_buffer_putuint8(&b, 0);
result = createnode(sdb, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
MAYBE_LOCK(sdb);
imp->methods->authority != NULL))
{
destroynode(node);
- return (result);
+ return result;
}
if (isorigin && imp->methods->authority != NULL) {
MAYBE_UNLOCK(sdb);
if (result != ISC_R_SUCCESS) {
destroynode(node);
- return (result);
+ return result;
}
}
*nodep = node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(options);
if (!dns_name_issubdomain(name, &db->origin)) {
- return (DNS_R_NXDOMAIN);
+ return DNS_R_NXDOMAIN;
}
olabels = dns_name_countlabels(&db->origin);
* No data at zone apex?
*/
if (i == olabels) {
- return (DNS_R_BADDB);
+ return DNS_R_BADDB;
}
result = DNS_R_NXDOMAIN;
continue;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
detachnode(db, &node);
}
- return (result);
+ return result;
}
static isc_result_t
UNUSED(rdataset);
UNUSED(sigrdataset);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static void
dns_sdbimplementation_t *imp = sdb->implementation;
if (imp->methods->allnodes == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
if ((options & DNS_DB_NSEC3ONLY) != 0 ||
(options & DNS_DB_NONSEC3) != 0)
{
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
sdbiter = isc_mem_get(sdb->common.mctx, sizeof(sdb_dbiterator_t));
MAYBE_UNLOCK(sdb);
if (result != ISC_R_SUCCESS) {
dbiterator_destroy((dns_dbiterator_t **)(void *)&sdbiter);
- return (result);
+ return result;
}
if (sdbiter->origin != NULL) {
*iteratorp = (dns_dbiterator_t *)sdbiter;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(sigrdataset);
if (type == dns_rdatatype_rrsig) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
list = ISC_LIST_HEAD(sdbnode->lists);
list = ISC_LIST_NEXT(list, link);
}
if (list == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
list_tordataset(list, db, node, rdataset);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*iteratorp = (dns_rdatasetiter_t *)iterator;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(options);
UNUSED(addedrdataset);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static isc_result_t
UNUSED(options);
UNUSED(newrdataset);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static isc_result_t
UNUSED(type);
UNUSED(covers);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static bool
issecure(dns_db_t *db) {
UNUSED(db);
- return (false);
+ return false;
}
static unsigned int
UNUSED(db);
UNUSED(tree);
- return (0);
+ return 0;
}
static bool
ispersistent(dns_db_t *db) {
UNUSED(db);
- return (true);
+ return true;
}
static void
imp = driverarg;
if (type != dns_dbtype_zone) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
sdb = isc_mem_get(mctx, sizeof(dns_sdb_t));
*dbp = (dns_db_t *)sdb;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_zonestr:
isc_mem_free(mctx, sdb->zone);
cleanup_lock:
isc_mem_putanddetach(&mctx, sdb, sizeof(dns_sdb_t));
- return (result);
+ return result;
}
/*
sdbiter->current = ISC_LIST_HEAD(sdbiter->nodelist);
if (sdbiter->current == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
sdbiter->current = ISC_LIST_TAIL(sdbiter->nodelist);
if (sdbiter->current == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
sdbiter->current = ISC_LIST_HEAD(sdbiter->nodelist);
while (sdbiter->current != NULL) {
if (dns_name_equal(sdbiter->current->name, name)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
sdbiter->current = ISC_LIST_NEXT(sdbiter->current, link);
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
static isc_result_t
sdbiter->current = ISC_LIST_PREV(sdbiter->current, link);
if (sdbiter->current == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
sdbiter->current = ISC_LIST_NEXT(sdbiter->current, link);
if (sdbiter->current == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
attachnode(iterator->db, sdbiter->current, nodep);
if (name != NULL) {
dns_name_copy(sdbiter->current->name, name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dbiterator_pause(dns_dbiterator_t *iterator) {
UNUSED(iterator);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dbiterator_origin(dns_dbiterator_t *iterator, dns_name_t *name) {
UNUSED(iterator);
dns_name_copy(dns_rootname, name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
dns_sdbnode_t *sdbnode = (dns_sdbnode_t *)iterator->node;
if (ISC_LIST_EMPTY(sdbnode->lists)) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
sdbiterator->current = ISC_LIST_HEAD(sdbnode->lists);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sdbiterator->current = ISC_LIST_NEXT(sdbiterator->current, link);
if (sdbiterator->current == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
static unsigned int
initial_size(const char *data) {
unsigned int len = (strlen(data) / 64) + 1;
- return (len * 64 + 64);
+ return len * 64 + 64;
}
/*
dns_sdlznode_t *sdlznode = (dns_sdlznode_t *)iterator->node;
if (ISC_LIST_EMPTY(sdlznode->lists)) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
sdlziterator->current = ISC_LIST_HEAD(sdlznode->lists);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sdlziterator->current = ISC_LIST_NEXT(sdlziterator->current, link);
if (sdlziterator->current == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
UNUSED(db);
UNUSED(callbacks);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static isc_result_t
endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
UNUSED(db);
UNUSED(callbacks);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static isc_result_t
UNUSED(version);
UNUSED(filename);
UNUSED(masterformat);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static void
REQUIRE(VALID_SDLZDB(sdlz));
if (sdlz->dlzimp->methods->newversion == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
dns_name_format(&sdlz->common.origin, origin, sizeof(origin));
sdlz_log(ISC_LOG_ERROR,
"sdlz newversion on origin %s failed : %s", origin,
isc_result_totext(result));
- return (result);
+ return result;
}
sdlz->future_version = *versionp;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
node->magic = SDLZLOOKUP_MAGIC;
*nodep = node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
dns_name_getlabelsequence(name, 0, labels, &relname);
result = dns_name_totext(&relname, true, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
} else {
result = dns_name_totext(name, true, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
isc_buffer_putuint8(&b, 0);
isc_buffer_init(&b2, zonestr, sizeof(zonestr));
result = dns_name_totext(&sdlz->common.origin, true, &b2);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_putuint8(&b2, 0);
result = createnode(sdlz, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isorigin = dns_name_equal(name, &sdlz->common.origin);
dns_wildcardname, fname, fname, NULL);
if (result != ISC_R_SUCCESS) {
MAYBE_UNLOCK(sdlz->dlzimp);
- return (result);
+ return result;
}
wild = fname;
}
result = dns_name_totext(wild, true, &b);
if (result != ISC_R_SUCCESS) {
MAYBE_UNLOCK(sdlz->dlzimp);
- return (result);
+ return result;
}
isc_buffer_putuint8(&b, 0);
if (result != ISC_R_SUCCESS) {
isc_refcount_decrementz(&node->references);
destroynode(node);
- return (result);
+ return result;
}
if (isorigin && sdlz->dlzimp->methods->authority != NULL) {
if (result != ISC_R_SUCCESS && result != ISC_R_NOTIMPLEMENTED) {
isc_refcount_decrementz(&node->references);
destroynode(node);
- return (result);
+ return result;
}
}
}
*nodep = node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
findnodeext(dns_db_t *db, const dns_name_t *name, bool create,
dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
dns_dbnode_t **nodep) {
- return (getnodedata(db, name, create, 0, methods, clientinfo, nodep));
+ return getnodedata(db, name, create, 0, methods, clientinfo, nodep);
}
static isc_result_t
findnode(dns_db_t *db, const dns_name_t *name, bool create,
dns_dbnode_t **nodep) {
- return (getnodedata(db, name, create, 0, NULL, NULL, nodep));
+ return getnodedata(db, name, create, 0, NULL, NULL, nodep);
}
static isc_result_t
UNUSED(rdataset);
UNUSED(sigrdataset);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static void
REQUIRE(VALID_SDLZDB(sdlz));
if (sdlz->dlzimp->methods->allnodes == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
if ((options & DNS_DB_NSEC3ONLY) != 0 ||
(options & DNS_DB_NONSEC3) != 0)
{
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_buffer_init(&b, zonestr, sizeof(zonestr));
result = dns_name_totext(&sdlz->common.origin, true, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_putuint8(&b, 0);
if (result != ISC_R_SUCCESS) {
dns_dbiterator_t *iter = &sdlziter->common;
dbiterator_destroy(&iter);
- return (result);
+ return result;
}
if (sdlziter->origin != NULL) {
*iteratorp = (dns_dbiterator_t *)sdlziter;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(sigrdataset);
if (type == dns_rdatatype_sig || type == dns_rdatatype_rrsig) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
list = ISC_LIST_HEAD(sdlznode->lists);
list = ISC_LIST_NEXT(list, link);
}
if (list == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
list_tordataset(list, db, node, rdataset);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
UNUSED(sdlz);
if (!dns_name_issubdomain(name, &db->origin)) {
- return (DNS_R_NXDOMAIN);
+ return DNS_R_NXDOMAIN;
}
olabels = dns_name_countlabels(&db->origin);
detachnode(db, &node);
}
- return (result);
+ return result;
}
static isc_result_t
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset) {
- return (findext(db, name, version, type, options, now, nodep, foundname,
- NULL, NULL, rdataset, sigrdataset));
+ return findext(db, name, version, type, options, now, nodep, foundname,
+ NULL, NULL, rdataset, sigrdataset);
}
static isc_result_t
*iteratorp = (dns_rdatasetiter_t *)iterator;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(VALID_SDLZDB(sdlz));
if (mod_function == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
sdlznode = (dns_sdlznode_t *)node;
dns_master_styledestroy(&style, mctx);
}
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(VALID_SDLZDB(sdlz));
if (sdlz->dlzimp->methods->addrdataset == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
result = modrdataset(db, node, version, rdataset, options,
sdlz->dlzimp->methods->addrdataset);
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(VALID_SDLZDB(sdlz));
if (sdlz->dlzimp->methods->subtractrdataset == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
result = modrdataset(db, node, version, rdataset, options,
sdlz->dlzimp->methods->subtractrdataset);
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(VALID_SDLZDB(sdlz));
if (sdlz->dlzimp->methods->delrdataset == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
sdlznode = (dns_sdlznode_t *)node;
name, b_type, sdlz->dlzimp->driverarg, sdlz->dbdata, version);
MAYBE_UNLOCK(sdlz->dlzimp);
- return (result);
+ return result;
}
static bool
issecure(dns_db_t *db) {
UNUSED(db);
- return (false);
+ return false;
}
static unsigned int
UNUSED(db);
UNUSED(tree);
- return (0);
+ return 0;
}
static bool
ispersistent(dns_db_t *db) {
UNUSED(db);
- return (true);
+ return true;
}
static void
REQUIRE(VALID_SDLZDB(sdlz));
if (sdlz->dlzimp->methods->newversion == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
result = getnodedata(db, &sdlz->common.origin, false, 0, NULL, NULL,
sdlz_log(ISC_LOG_ERROR, "sdlz getoriginnode failed: %s",
isc_result_totext(result));
}
- return (result);
+ return result;
}
static dns_dbmethods_t sdlzdb_methods = {
sdlziter->current = ISC_LIST_HEAD(sdlziter->nodelist);
if (sdlziter->current == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
sdlziter->current = ISC_LIST_TAIL(sdlziter->nodelist);
if (sdlziter->current == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
sdlziter->current = ISC_LIST_HEAD(sdlziter->nodelist);
while (sdlziter->current != NULL) {
if (dns_name_equal(sdlziter->current->name, name)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
sdlziter->current = ISC_LIST_NEXT(sdlziter->current, link);
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
static isc_result_t
sdlziter->current = ISC_LIST_PREV(sdlziter->current, link);
if (sdlziter->current == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
sdlziter->current = ISC_LIST_NEXT(sdlziter->current, link);
if (sdlziter->current == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
attachnode(iterator->db, sdlziter->current, nodep);
if (name != NULL) {
dns_name_copy(sdlziter->current->name, name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dbiterator_pause(dns_dbiterator_t *iterator) {
UNUSED(iterator);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dbiterator_origin(dns_dbiterator_t *iterator, dns_name_t *name) {
UNUSED(iterator);
dns_name_copy(dns_rootname, name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
sdlzdb->common.impmagic = SDLZDB_MAGIC;
*dbp = (dns_db_t *)sdlzdb;
- return (result);
+ return result;
mem_cleanup:
isc_mem_put(mctx, sdlzdb, sizeof(dns_sdlz_db_t));
- return (result);
+ return result;
}
static isc_result_t
isc_buffer_init(&b, namestr, sizeof(namestr));
result = dns_name_totext(name, true, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_putuint8(&b, 0);
isc_netaddr_fromsockaddr(&netaddr, clientaddr);
result = isc_netaddr_totext(&netaddr, &b2);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_putuint8(&b2, 0);
if (rresult != ISC_R_SUCCESS) {
result = rresult;
}
- return (result);
+ return result;
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static isc_result_t
sdlz_log(ISC_LOG_ERROR, "SDLZ driver failed to load.");
}
- return (result);
+ return result;
}
static void
isc_buffer_init(&b, namestr, sizeof(namestr));
result = dns_name_totext(name, true, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_putuint8(&b, 0);
rdclass, dbp);
}
- return (result);
+ return result;
}
static isc_result_t
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
static bool
imp = (dns_sdlzimplementation_t *)driverarg;
if (imp->methods->ssumatch == NULL) {
- return (false);
+ return false;
}
/*
token_len != 0 ? token_region.base : NULL,
imp->driverarg, dbdata);
MAYBE_UNLOCK(imp);
- return (ret);
+ return ret;
}
static dns_dlzmethods_t sdlzmethods = { dns_sdlzcreate, dns_sdlzdestroy,
r.length = strlen(type);
result = dns_rdatatype_fromtext(&typeval, (void *)&r);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
rdatalist = ISC_LIST_HEAD(lookup->lists);
isc_lex_destroy(&lex);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
if (rdatabuf != NULL) {
}
isc_mem_put(mctx, rdata, sizeof(dns_rdata_t));
- return (result);
+ return result;
}
isc_result_t
result = dns_name_fromtext(newname, &b, origin, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (allnodes->common.relative_names) {
sdlznode = NULL;
result = createnode(sdlz, &sdlznode);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
sdlznode->name = isc_mem_get(mctx, sizeof(dns_name_t));
dns_name_init(sdlznode->name, NULL);
allnodes->origin = sdlznode;
}
}
- return (dns_sdlz_putrr(sdlznode, type, ttl, data));
+ return dns_sdlz_putrr(sdlznode, type, ttl, data);
}
isc_result_t
serial, SDLZ_DEFAULT_REFRESH, SDLZ_DEFAULT_RETRY,
SDLZ_DEFAULT_EXPIRE, SDLZ_DEFAULT_MINIMUM);
if (n >= (int)sizeof(str) || n < 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
- return (dns_sdlz_putrr(lookup, "SOA", SDLZ_DEFAULT_TTL, str));
+ return dns_sdlz_putrr(lookup, "SOA", SDLZ_DEFAULT_TTL, str);
}
isc_result_t
*sdlzimp = imp;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_mutex:
/* destroy the driver lock, we don't need it anymore */
* remove it from the memory context.
*/
isc_mem_putanddetach(&imp->mctx, imp, sizeof(dns_sdlzimplementation_t));
- return (result);
+ return result;
}
void
result = dns_sdlzcreateDBP(dlzdatabase->mctx,
dlzdatabase->implementation->driverarg,
dlzdatabase->dbdata, name, rdclass, dbp);
- return (result);
+ return result;
}
static uint32_t
decode_uint32(unsigned char *p) {
- return (((uint32_t)p[0] << 24) + ((uint32_t)p[1] << 16) +
- ((uint32_t)p[2] << 8) + ((uint32_t)p[3] << 0));
+ return ((uint32_t)p[0] << 24) + ((uint32_t)p[1] << 16) +
+ ((uint32_t)p[2] << 8) + ((uint32_t)p[3] << 0);
}
static void
*/
INSIST(rdata->length >= 20);
INSIST(offset >= 0 && offset <= 16);
- return (decode_uint32(rdata->data + rdata->length - 20 + offset));
+ return decode_uint32(rdata->data + rdata->length - 20 + offset);
}
isc_result_t
dns_name_init(&soa.contact, NULL);
dns_name_clone(contact, &soa.contact);
- return (dns_rdata_fromstruct(rdata, rdclass, dns_rdatatype_soa, &soa,
- &rdatabuf));
+ return dns_rdata_fromstruct(rdata, rdclass, dns_rdatatype_soa, &soa,
+ &rdatabuf);
}
uint32_t
dns_soa_getserial(dns_rdata_t *rdata) {
- return (soa_get(rdata, 0));
+ return soa_get(rdata, 0);
}
uint32_t
dns_soa_getrefresh(dns_rdata_t *rdata) {
- return (soa_get(rdata, 4));
+ return soa_get(rdata, 4);
}
uint32_t
dns_soa_getretry(dns_rdata_t *rdata) {
- return (soa_get(rdata, 8));
+ return soa_get(rdata, 8);
}
uint32_t
dns_soa_getexpire(dns_rdata_t *rdata) {
- return (soa_get(rdata, 12));
+ return soa_get(rdata, 12);
}
uint32_t
dns_soa_getminimum(dns_rdata_t *rdata) {
- return (soa_get(rdata, 16));
+ return soa_get(rdata, 16);
}
static void
static bool
isusertype(dns_rdatatype_t type) {
- return (type != dns_rdatatype_ns && type != dns_rdatatype_soa &&
- type != dns_rdatatype_rrsig);
+ return type != dns_rdatatype_ns && type != dns_rdatatype_soa &&
+ type != dns_rdatatype_rrsig;
}
static void
REQUIRE(addr == NULL || env != NULL);
if (signer == NULL && addr == NULL) {
- return (false);
+ return false;
}
for (rule = ISC_LIST_HEAD(table->rules); rule != NULL;
if (rule->grant && rulep != NULL) {
*rulep = rule;
}
- return (rule->grant);
+ return rule->grant;
}
- return (false);
+ return false;
}
bool
dns_ssurule_isgrant(const dns_ssurule_t *rule) {
REQUIRE(VALID_SSURULE(rule));
- return (rule->grant);
+ return rule->grant;
}
dns_name_t *
dns_ssurule_identity(const dns_ssurule_t *rule) {
REQUIRE(VALID_SSURULE(rule));
- return (rule->identity);
+ return rule->identity;
}
unsigned int
dns_ssurule_matchtype(const dns_ssurule_t *rule) {
REQUIRE(VALID_SSURULE(rule));
- return (rule->matchtype);
+ return rule->matchtype;
}
dns_name_t *
dns_ssurule_name(const dns_ssurule_t *rule) {
REQUIRE(VALID_SSURULE(rule));
- return (rule->name);
+ return rule->name;
}
unsigned int
REQUIRE(VALID_SSURULE(rule));
REQUIRE(types != NULL && *types != NULL);
*types = rule->types;
- return (rule->ntypes);
+ return rule->ntypes;
}
unsigned int
max = rule->types[i].max;
}
if (rule->types[i].type == type) {
- return (rule->types[i].max);
+ return rule->types[i].max;
}
}
- return (max);
+ return max;
}
isc_result_t
REQUIRE(VALID_SSUTABLE(table));
REQUIRE(rule != NULL && *rule == NULL);
*rule = ISC_LIST_HEAD(table->rules);
- return (*rule != NULL ? ISC_R_SUCCESS : ISC_R_NOMORE);
+ return *rule != NULL ? ISC_R_SUCCESS : ISC_R_NOMORE;
}
isc_result_t
REQUIRE(VALID_SSURULE(rule));
REQUIRE(nextrule != NULL && *nextrule == NULL);
*nextrule = ISC_LIST_NEXT(rule, link);
- return (*nextrule != NULL ? ISC_R_SUCCESS : ISC_R_NOMORE);
+ return *nextrule != NULL ? ISC_R_SUCCESS : ISC_R_NOMORE;
}
/*
} else if (strcasecmp(str, "external") == 0) {
*mtype = dns_ssumatchtype_external;
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
"ssu_external: socket path '%s' "
"longer than system maximum %zu",
path, sizeof(addr.sun_path));
- return (-1);
+ return -1;
}
memset(&addr, 0, sizeof(addr));
strerror_r(errno, strbuf, sizeof(strbuf));
ssu_e_log(3, "ssu_external: unable to create socket - %s",
strbuf);
- return (-1);
+ return -1;
}
if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
"socket '%s' - %s",
path, strbuf);
close(fd);
- return (-1);
+ return -1;
}
- return (fd);
+ return fd;
}
/* Change this version if you update the format of the request */
if (strncmp(b_identity, "local:", 6) != 0) {
ssu_e_log(3, "ssu_external: invalid socket path '%s'",
b_identity);
- return (false);
+ return false;
}
sock_path = &b_identity[6];
fd = ux_socket_connect(sock_path);
if (fd == -1) {
- return (false);
+ return false;
}
if (key != NULL) {
ssu_e_log(3, "ssu_external: unable to send request - %s",
strbuf);
close(fd);
- return (false);
+ return false;
}
/* Receive the reply */
ssu_e_log(3, "ssu_external: unable to receive reply - %s",
strbuf);
close(fd);
- return (false);
+ return false;
}
close(fd);
if (reply == 0) {
ssu_e_log(3, "ssu_external: denied external auth for '%s'",
b_name);
- return (false);
+ return false;
} else if (reply == 1) {
ssu_e_log(3, "ssu_external: allowed external auth for '%s'",
b_name);
- return (true);
+ return true;
}
ssu_e_log(3, "ssu_external: invalid reply 0x%08x", reply);
- return (false);
+ return false;
}
isc_mem_attach(mctx, &stats->mctx);
*statsp = stats;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
clean_mutex:
isc_mem_put(mctx, stats, sizeof(*stats));
- return (result);
+ return result;
}
isc_result_t
dns_generalstats_create(isc_mem_t *mctx, dns_stats_t **statsp, int ncounters) {
REQUIRE(statsp != NULL && *statsp == NULL);
- return (create_stats(mctx, dns_statstype_general, ncounters, statsp));
+ return create_stats(mctx, dns_statstype_general, ncounters, statsp);
}
isc_result_t
* Create rdtype statistics for the first 255 RRtypes,
* plus one additional for other RRtypes.
*/
- return (create_stats(mctx, dns_statstype_rdtype,
- (RDTYPECOUNTER_MAXTYPE + 1), statsp));
+ return create_stats(mctx, dns_statstype_rdtype,
+ (RDTYPECOUNTER_MAXTYPE + 1), statsp);
}
isc_result_t
dns_rdatasetstats_create(isc_mem_t *mctx, dns_stats_t **statsp) {
REQUIRE(statsp != NULL && *statsp == NULL);
- return (create_stats(mctx, dns_statstype_rdataset,
- (RDTYPECOUNTER_MAXVAL + 1), statsp));
+ return create_stats(mctx, dns_statstype_rdataset,
+ (RDTYPECOUNTER_MAXVAL + 1), statsp);
}
isc_result_t
dns_opcodestats_create(isc_mem_t *mctx, dns_stats_t **statsp) {
REQUIRE(statsp != NULL && *statsp == NULL);
- return (create_stats(mctx, dns_statstype_opcode, 16, statsp));
+ return create_stats(mctx, dns_statstype_opcode, 16, statsp);
}
isc_result_t
dns_rcodestats_create(isc_mem_t *mctx, dns_stats_t **statsp) {
REQUIRE(statsp != NULL && *statsp == NULL);
- return (create_stats(mctx, dns_statstype_rcode, dns_rcode_badcookie + 1,
- statsp));
+ return create_stats(mctx, dns_statstype_rcode, dns_rcode_badcookie + 1,
+ statsp);
}
isc_result_t
* Create two counters per key, one is the key id, the other two are
* the actual counters for creating and refreshing signatures.
*/
- return (create_stats(mctx, dns_statstype_dnssec,
- dnssecsign_num_keys * dnssecsign_block_size,
- statsp));
+ return create_stats(mctx, dns_statstype_dnssec,
+ dnssecsign_num_keys * dnssecsign_block_size,
+ statsp);
}
/*%
static isc_statscounter_t
rdatatype2counter(dns_rdatatype_t type) {
if (type > (dns_rdatatype_t)RDTYPECOUNTER_MAXTYPE) {
- return (0);
+ return 0;
}
- return ((isc_statscounter_t)type);
+ return (isc_statscounter_t)type;
}
void
int i;
uint64_t *p = isc_mem_get(mctx, DNS_STATS_NCOUNTERS * sizeof(uint64_t));
if (p == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
for (i = 0; i < DNS_STATS_NCOUNTERS; i++) {
p[i] = 0;
}
*ctrp = p;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
tm.tm_year = 70;
while (t < 0) {
if (tm.tm_year == 0) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
tm.tm_year--;
secs = year_secs(tm.tm_year + 1900);
t -= secs;
tm.tm_year++;
if (tm.tm_year + 1900 > 9999) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
}
tm.tm_mon = 0;
l = strlen(buf);
if (l > region.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, buf, l);
isc_buffer_add(target, l);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
int64_t
t = start - (now - value);
}
- return (t);
+ return t;
}
isc_result_t
dns_time32_totext(uint32_t value, isc_buffer_t *target) {
- return (dns_time64_totext(dns_time64_from32(value), target));
+ return dns_time64_totext(dns_time64_from32(value), target);
}
isc_result_t
} while (0)
if (strlen(source) != 14U) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
/*
* Confirm the source only consists digits. sscanf() allows some
*/
for (i = 0; i < 14; i++) {
if (!isdigit((unsigned char)source[i])) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
}
if (sscanf(source, "%4d%2d%2d%2d%2d%2d", &year, &month, &day, &hour,
&minute, &second) != 6)
{
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
RANGE(0, 9999, year);
}
*target = value;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
isc_result_t result;
result = dns_time64_fromtext(source, &value64);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
*target = (uint32_t)value64;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
tctx->gssapi_keytab = NULL;
*tctxp = tctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
ISC_LIST_APPEND(*namelist, newname, link);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
if (newrdata != NULL) {
if (newlist != NULL) {
dns_message_puttemprdatalist(msg, &newlist);
}
- return (result);
+ return result;
}
static void
md = isc_md_new();
if (md == NULL) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/*
isc_buffer_availableregion(secret, &r);
isc_buffer_usedregion(shared, &r2);
if (r.length < digestslen || r.length < r2.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
if (r2.length > digestslen) {
memmove(r.base, r2.base, r2.length);
if (md != NULL) {
isc_md_free(md);
}
- return (result);
+ return result;
}
static isc_result_t
if (tctx->dhkey == NULL) {
tkey_log("process_dhtkey: tkey-dhkey not defined");
tkeyout->error = dns_tsigerror_badalg;
- return (DNS_R_REFUSED);
+ return DNS_R_REFUSED;
}
if (!dns_name_equal(&tkeyin->algorithm, DNS_TSIG_HMACMD5_NAME)) {
tkey_log("process_dhtkey: algorithms other than "
"hmac-md5 are not supported");
tkeyout->error = dns_tsigerror_badalg;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (found_incompatible) {
tkey_log("process_dhtkey: found an incompatible key");
tkeyout->error = dns_tsigerror_badkey;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
tkey_log("process_dhtkey: failed to find a key");
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
}
tkeyout->key = randomdata;
tkeyout->keylen = TKEY_RANDOM_AMOUNT;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
if (!ISC_LIST_EMPTY(*namelist)) {
if (randomdata != NULL) {
isc_mem_put(tkeyout->mctx, randomdata, TKEY_RANDOM_AMOUNT);
}
- return (result);
+ return result;
}
static isc_result_t
if (tctx->gsscred == NULL && tctx->gssapi_keytab == NULL) {
tkey_log("process_gsstkey(): no tkey-gssapi-credential "
"or tkey-gssapi-keytab configured");
- return (DNS_R_REFUSED);
+ return DNS_R_REFUSED;
}
if (!dns_name_equal(&tkeyin->algorithm, DNS_TSIG_GSSAPI_NAME) &&
tkeyout->error = dns_tsigerror_badalg;
tkey_log("process_gsstkey(): dns_tsigerror_badalg"); /* XXXSRA
*/
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
tkeyout->error = dns_tsigerror_badkey;
tkey_log("process_gsstkey(): dns_tsigerror_badkey"); /* XXXSRA
*/
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != DNS_R_CONTINUE && result != ISC_R_SUCCESS) {
goto failure;
dns_tsigkey_detach(&tsigkey);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
if (tsigkey != NULL) {
tkey_log("process_gsstkey(): %s", isc_result_totext(result)); /* XXXSRA
*/
- return (result);
+ return result;
}
static isc_result_t
result = dns_tsigkey_find(&tsigkey, name, &tkeyin->algorithm, ring);
if (result != ISC_R_SUCCESS) {
tkeyout->error = dns_tsigerror_badname;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
identity = dns_tsigkey_identity(tsigkey);
if (identity == NULL || !dns_name_equal(identity, signer)) {
dns_tsigkey_detach(&tsigkey);
- return (DNS_R_REFUSED);
+ return DNS_R_REFUSED;
}
/*
/* Release the reference */
dns_tsigkey_detach(&tsigkey);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
*/
result = dns_message_firstname(msg, DNS_SECTION_QUESTION);
if (result != ISC_R_SUCCESS) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
qname = NULL;
name = next;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
if (!ISC_LIST_EMPTY(namelist)) {
free_namelist(msg, &namelist);
}
- return (result);
+ return result;
}
static isc_result_t
dns_message_addname(msg, aname, DNS_SECTION_ADDITIONAL);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
if (qname != NULL) {
}
dns_message_puttemprdataset(msg, &tkeyset);
}
- return (result);
+ return result;
}
isc_result_t
item = next;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
if (dynbuf != NULL) {
isc_buffer_free(&dynbuf);
}
- return (result);
+ return result;
}
isc_result_t
result = dst_gssapi_initctx(gname, NULL, &token, context, mctx,
err_message);
if (result != DNS_R_CONTINUE && result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
tkey.common.rdclass = dns_rdataclass_any;
tkey.other = NULL;
tkey.otherlen = 0;
- return (buildquery(msg, name, &tkey, win2k));
+ return buildquery(msg, name, &tkey, win2k);
}
isc_result_t
tkey.keylen = tkey.otherlen = 0;
tkey.key = tkey.other = NULL;
- return (buildquery(msg, &key->name, &tkey, false));
+ return buildquery(msg, &key->name, &tkey, false);
}
static isc_result_t
if (result == ISC_R_SUCCESS) {
result = dns_rdataset_first(tkeyset);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_current(tkeyset, rdata);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = dns_message_nextname(msg, section);
}
if (result == ISC_R_NOMORE) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
- return (result);
+ return result;
}
isc_result_t
}
if (rmsg->rcode != dns_rcode_noerror) {
- return (dns_result_fromrcode(rmsg->rcode));
+ return dns_result_fromrcode(rmsg->rcode);
}
RETERR(find_tkey(rmsg, &tkeyname, &rtkeyrdata, DNS_SECTION_ANSWER));
RETERR(dns_rdata_tostruct(&rtkeyrdata, &rtkey, NULL));
isc_buffer_free(&shared);
dns_rdata_freestruct(&rtkey);
dst_key_free(&theirkey);
- return (result);
+ return result;
failure:
if (shared != NULL) {
dns_rdata_freestruct(&rtkey);
}
- return (result);
+ return result;
}
isc_result_t
}
if (rmsg->rcode != dns_rcode_noerror) {
- return (dns_result_fromrcode(rmsg->rcode));
+ return dns_result_fromrcode(rmsg->rcode);
}
RETERR(find_tkey(rmsg, &tkeyname, &rtkeyrdata, DNS_SECTION_ANSWER));
RETERR(dns_rdata_tostruct(&rtkeyrdata, &rtkey, NULL));
rtkey.inception, rtkey.expire, ring->mctx, ring, outkey));
dst_key_free(&dstkey);
dns_rdata_freestruct(&rtkey);
- return (result);
+ return result;
failure:
/*
if (dstkey != NULL) {
dst_key_free(&dstkey);
}
- return (result);
+ return result;
}
isc_result_t
REQUIRE(rmsg != NULL);
if (rmsg->rcode != dns_rcode_noerror) {
- return (dns_result_fromrcode(rmsg->rcode));
+ return dns_result_fromrcode(rmsg->rcode);
}
RETERR(find_tkey(rmsg, &tkeyname, &rtkeyrdata, DNS_SECTION_ANSWER));
dns_tsigkey_detach(&tsigkey);
failure:
- return (result);
+ return result;
}
isc_result_t
}
if (rmsg->rcode != dns_rcode_noerror) {
- return (dns_result_fromrcode(rmsg->rcode));
+ return dns_result_fromrcode(rmsg->rcode);
}
RETERR(find_tkey(rmsg, &tkeyname, &rtkeyrdata, DNS_SECTION_ANSWER));
result = dst_gssapi_initctx(server, &intoken, &outtoken, context,
ring->mctx, err_message);
if (result != DNS_R_CONTINUE && result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (result == DNS_R_CONTINUE) {
dns_message_reset(qmsg, DNS_MESSAGE_INTENTRENDER);
RETERR(buildquery(qmsg, tkeyname, &tkey, win2k));
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
RETERR(dst_key_fromgssapi(dns_rootname, *context, rmsg->mctx, &dstkey,
outkey));
dst_key_free(&dstkey);
dns_rdata_freestruct(&rtkey);
- return (result);
+ return result;
failure:
/*
if (dstkey != NULL) {
dst_key_free(&dstkey);
}
- return (result);
+ return result;
}
RWUNLOCK(&list->lock, isc_rwlocktype_write);
- return (result);
+ return result;
}
dns_transport_type_t
dns_transport_get_type(dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->type);
+ return transport->type;
}
char *
dns_transport_get_certfile(dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->tls.certfile);
+ return transport->tls.certfile;
}
char *
dns_transport_get_keyfile(dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->tls.keyfile);
+ return transport->tls.keyfile;
}
char *
dns_transport_get_cafile(dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->tls.cafile);
+ return transport->tls.cafile;
}
char *
dns_transport_get_remote_hostname(dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->tls.remote_hostname);
+ return transport->tls.remote_hostname;
}
char *
dns_transport_get_endpoint(dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->doh.endpoint);
+ return transport->doh.endpoint;
}
dns_http_mode_t
dns_transport_get_mode(dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->doh.mode);
+ return transport->doh.mode;
}
dns_transport_t *
list_add(list, name, type, transport);
- return (transport);
+ return transport;
}
void
dns_transport_get_tls_versions(const dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->tls.protocol_versions);
+ return transport->tls.protocol_versions;
}
void
dns_transport_get_ciphers(dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->tls.ciphers);
+ return transport->tls.ciphers;
}
char *
dns_transport_get_tlsname(dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->tls.tlsname);
+ return transport->tls.tlsname;
}
void
REQUIRE(VALID_TRANSPORT(transport));
REQUIRE(preferp != NULL);
if (transport->tls.prefer_server_ciphers == ter_none) {
- return (false);
+ return false;
} else if (transport->tls.prefer_server_ciphers == ter_true) {
*preferp = true;
- return (true);
+ return true;
} else if (transport->tls.prefer_server_ciphers == ter_false) {
*preferp = false;
- return (true);
+ return true;
}
UNREACHABLE();
}
RWUNLOCK(&list->lock, isc_rwlocktype_read);
- return (transport);
+ return transport;
}
dns_transport_list_t *
RUNTIME_CHECK(result == ISC_R_SUCCESS);
}
- return (list);
+ return list;
}
void
break;
default:
isc_mem_put(mctx, tsec, sizeof(*tsec));
- return (DNS_R_BADALG);
+ return DNS_R_BADALG;
}
result = dns_tsigkey_createfromkey(dst_key_name(key), algname,
key, false, NULL, 0, 0, mctx,
NULL, &tsigkey);
if (result != ISC_R_SUCCESS) {
isc_mem_put(mctx, tsec, sizeof(*tsec));
- return (result);
+ return result;
}
tsec->ukey.tsigkey = tsigkey;
break;
tsec->magic = DNS_TSEC_MAGIC;
*tsecp = tsec;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
dns_tsec_gettype(dns_tsec_t *tsec) {
REQUIRE(DNS_TSEC_VALID(tsec));
- return (tsec->type);
+ return tsec->type;
}
void
bool
dns__tsig_algvalid(unsigned int alg) {
- return (alg == DST_ALG_HMACMD5 || alg == DST_ALG_HMACSHA1 ||
- alg == DST_ALG_HMACSHA224 || alg == DST_ALG_HMACSHA256 ||
- alg == DST_ALG_HMACSHA384 || alg == DST_ALG_HMACSHA512);
+ return alg == DST_ALG_HMACMD5 || alg == DST_ALG_HMACSHA1 ||
+ alg == DST_ALG_HMACSHA224 || alg == DST_ALG_HMACSHA256 ||
+ alg == DST_ALG_HMACSHA384 || alg == DST_ALG_HMACSHA512;
}
static void
RWUNLOCK(&ring->lock, isc_rwlocktype_write);
- return (result);
+ return result;
}
isc_result_t
*key = tkey;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_refs:
tkey->magic = 0;
dns_name_free(&tkey->name, mctx);
isc_mem_put(mctx, tkey, sizeof(dns_tsigkey_t));
- return (ret);
+ return ret;
}
/*
for (i = 0; i < n; ++i) {
const dns_name_t *name = known_algs[i].name;
if (algorithm == name || dns_name_equal(algorithm, name)) {
- return (known_algs[i].dstalg);
+ return known_algs[i].dstalg;
}
}
- return (0);
+ return 0;
}
/*
for (i = 0; i < n; ++i) {
const dns_name_t *name = known_algs[i].name;
if (algorithm == name || dns_name_equal(algorithm, name)) {
- return (name);
+ return name;
}
}
- return (NULL);
+ return NULL;
}
/*
for (i = 0; i < n; ++i) {
const dns_name_t *name = known_algs[i].name;
if (algorithm == name) {
- return (false);
+ return false;
}
}
- return (true);
+ return true;
}
static isc_result_t
n = fscanf(fp, "%1023s %1023s %u %u %1023s %4095s\n", namestr,
creatorstr, &inception, &expire, algorithmstr, keystr);
if (n == EOF) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
if (n != 6) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (isc_serial_lt(expire, now)) {
- return (DNS_R_EXPIRED);
+ return DNS_R_EXPIRED;
}
name = dns_fixedname_initname(&fname);
isc_buffer_add(&b, strlen(namestr));
result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
creator = dns_fixedname_initname(&fcreator);
isc_buffer_add(&b, strlen(creatorstr));
result = dns_name_fromtext(creator, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
algorithm = dns_fixedname_initname(&falgorithm);
isc_buffer_add(&b, strlen(algorithmstr));
result = dns_name_fromtext(algorithm, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dstalg = dns__tsig_algfromname(algorithm);
if (dstalg == 0) {
- return (DNS_R_BADALG);
+ 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);
+ return result;
}
result = dns_tsigkey_createfromkey(name, algorithm, dstkey, true,
if (dstkey != NULL) {
dst_key_free(&dstkey);
}
- return (result);
+ return result;
}
static void
*ringp = NULL;
if (isc_refcount_decrement(&ring->references) > 1) {
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
isc_stdtime_get(&now);
destroy:
destroyring(ring);
- return (result);
+ return result;
}
const dns_name_t *
REQUIRE(tsigkey == NULL || VALID_TSIG_KEY(tsigkey));
if (tsigkey == NULL) {
- return (NULL);
+ return NULL;
}
if (tsigkey->generated) {
- return (tsigkey->creator);
+ return tsigkey->creator;
} else {
- return (&tsigkey->name);
+ return &tsigkey->name;
}
}
DNS_KEYPROTO_DNSSEC, dns_rdataclass_in, &b,
mctx, &dstkey);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
} else if (length > 0) {
- return (DNS_R_BADALG);
+ return DNS_R_BADALG;
}
result = dns_tsigkey_createfromkey(name, algorithm, dstkey, generated,
if (dstkey != NULL) {
dst_key_free(&dstkey);
}
- return (result);
+ return result;
}
void
response = is_response(msg);
if (response && msg->querytsig == NULL) {
if (msg->tkey != 1) {
- return (DNS_R_EXPECTEDTSIG);
+ return DNS_R_EXPECTEDTSIG;
}
}
ret = dst_context_create(key->key, mctx, DNS_LOGCATEGORY_DNSSEC,
true, 0, &ctx);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
/*
/* Windows does not like the tsig name being compressed. */
msg->tsigname->attributes |= DNS_NAMEATTR_NOCOMPRESS;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_rdatalist:
dns_message_puttemprdatalist(msg, &datalist);
if (ctx != NULL) {
dst_context_destroy(&ctx);
}
- return (ret);
+ return ret;
}
isc_result_t
if (msg->tcp_continuation) {
if (tsigkey == NULL || msg->querytsig == NULL) {
- return (DNS_R_UNEXPECTEDTSIG);
+ return DNS_R_UNEXPECTEDTSIG;
}
- return (tsig_verify_tcp(source, msg));
+ return tsig_verify_tcp(source, msg);
}
/*
* There should be a TSIG record...
*/
if (msg->tsig == NULL) {
- return (DNS_R_EXPECTEDTSIG);
+ return DNS_R_EXPECTEDTSIG;
}
/*
* shouldn't be one on the response.
*/
if (response && (tsigkey == NULL || msg->querytsig == NULL)) {
- return (DNS_R_UNEXPECTEDTSIG);
+ return DNS_R_UNEXPECTEDTSIG;
}
mctx = msg->mctx;
keyname = msg->tsigname;
ret = dns_rdataset_first(msg->tsig);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
dns_rdataset_current(msg->tsig, &rdata);
ret = dns_rdata_tostruct(&rdata, &tsig, NULL);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
dns_rdata_reset(&rdata);
if (response) {
ret = dns_rdataset_first(msg->querytsig);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
dns_rdataset_current(msg->querytsig, &rdata);
ret = dns_rdata_tostruct(&rdata, &querytsig, NULL);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
}
msg->tsigstatus = dns_tsigerror_badkey;
tsig_log(msg->tsigkey, 2,
"key name and algorithm do not match");
- return (DNS_R_TSIGVERIFYFAILURE);
+ return DNS_R_TSIGVERIFYFAILURE;
}
/*
0, false, NULL, now, now, mctx,
NULL, &msg->tsigkey);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
tsig_log(msg->tsigkey, 2, "unknown key");
- return (DNS_R_TSIGVERIFYFAILURE);
+ return DNS_R_TSIGVERIFYFAILURE;
}
msg->tsigkey = tsigkey;
}
alg = dst_key_alg(key);
ret = dst_key_sigsize(key, &siglen);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
if (dns__tsig_algvalid(alg)) {
if (tsig.siglen > siglen) {
tsig_log(msg->tsigkey, 2, "signature length too big");
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
if (tsig.siglen > 0 &&
(tsig.siglen < 10 || tsig.siglen < ((siglen + 1) / 2)))
{
tsig_log(msg->tsigkey, 2,
"signature length below minimum");
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
}
ret = dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC,
false, 0, &ctx);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
if (response) {
tsig.error != dns_tsigerror_badkey))
{
tsig_log(msg->tsigkey, 2, "signature was empty");
- return (DNS_R_TSIGVERIFYFAILURE);
+ return DNS_R_TSIGVERIFYFAILURE;
}
/*
dst_context_destroy(&ctx);
}
- return (ret);
+ return ret;
}
static isc_result_t
msg->tsigstatus = dns_tsigerror_badsig;
if (!is_response(msg)) {
- return (DNS_R_EXPECTEDRESPONSE);
+ return DNS_R_EXPECTEDRESPONSE;
}
mctx = msg->mctx;
*/
ret = dns_rdataset_first(msg->querytsig);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
dns_rdataset_current(msg->querytsig, &rdata);
ret = dns_rdata_tostruct(&rdata, &querytsig, NULL);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
dns_rdata_reset(&rdata);
cleanup_querystruct:
dns_rdata_freestruct(&querytsig);
- return (ret);
+ return ret;
}
isc_result_t
result = dns_rbt_findname(ring->keys, name, 0, NULL, (void *)&key);
if (result == DNS_R_PARTIALMATCH || result == ISC_R_NOTFOUND) {
RWUNLOCK(&ring->lock, locktype);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (algorithm != NULL && !dns_name_equal(key->algorithm, algorithm)) {
RWUNLOCK(&ring->lock, locktype);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (key->inception != key->expire && isc_serial_lt(key->expire, now)) {
/*
}
remove_fromring(key);
RWUNLOCK(&ring->lock, locktype);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
#if 0
/*
RWUNLOCK(&ring->lock, locktype);
adjust_lru(key);
*tsigkey = key;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
if (result != ISC_R_SUCCESS) {
isc_rwlock_destroy(&ring->lock);
isc_mem_put(mctx, ring, sizeof(dns_tsig_keyring_t));
- return (result);
+ return result;
}
ring->writecount = 0;
isc_refcount_init(&ring->references, 1);
*ringp = ring;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
isc_refcount_increment(&tkey->refs);
}
- return (result);
+ return result;
}
void
INSIST(len + 1 <= sizeof(tmp));
isc_buffer_availableregion(target, ®ion);
if (len > region.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, tmp, len);
isc_buffer_add(target, len);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
region.base[region.length - 1] =
toupper(region.base[region.length - 1]);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
dns_counter_fromtext(isc_textregion_t *source, uint32_t *ttl) {
- return (bind_ttl(source, ttl));
+ return bind_ttl(source, ttl);
}
isc_result_t
if (result != ISC_R_SUCCESS && result != ISC_R_RANGE) {
result = DNS_R_BADTTL;
}
- return (result);
+ return result;
}
static isc_result_t
* No legal counter / ttl is longer that 63 characters.
*/
if (source->length > sizeof(buf) - 1) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
/* Copy source->length bytes and NUL terminate. */
snprintf(buf, sizeof(buf), "%.*s", (int)source->length, source->base);
INSIST(np - nbuf <= (int)sizeof(nbuf));
result = isc_parse_uint32(&n, nbuf, 10);
if (result != ISC_R_SUCCESS) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
switch (*s) {
case 'w':
case '\0':
/* Plain number? */
if (tmp != 0ULL) {
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
tmp = n;
break;
default:
- return (DNS_R_SYNTAX);
+ return DNS_R_SYNTAX;
}
} while (*s != '\0');
if (tmp > 0xffffffffULL) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
*ttl = (uint32_t)(tmp & 0xffffffffUL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
ISC_LIST_UNLINK(temp_diff.tuples, *tuple, link);
if (result != ISC_R_SUCCESS) {
dns_difftuple_free(tuple);
- return (result);
+ return result;
}
/*
/*
* Do not clear temp_diff.
*/
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_result_t result;
result = dns_difftuple_create(diff->mctx, op, name, ttl, rdata, &tuple);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return (do_one_tuple(&tuple, db, ver, diff));
+ return do_one_tuple(&tuple, db, ver, diff);
}
/**************************************************************************/
rr.ttl = rdataset->ttl;
result = (*ctx->rr_action)(ctx->rr_action_data, &rr);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
if (result != ISC_R_NOMORE) {
- return (result);
+ return result;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
node = NULL;
result = dns_db_findnode(db, name, false, &node);
if (result == ISC_R_NOTFOUND) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
iter = NULL;
cleanup_node:
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
/*%
foreach_node_rr_ctx_t ctx;
ctx.rr_action = rr_action;
ctx.rr_action_data = rr_action_data;
- return (foreach_rrset(db, ver, name, foreach_node_rr_action, &ctx));
+ return foreach_rrset(db, ver, name, foreach_node_rr_action, &ctx);
}
/*%
dns_rdataset_t rdataset;
if (type == dns_rdatatype_any) {
- return (foreach_node_rr(db, ver, name, rr_action,
- rr_action_data));
+ return foreach_node_rr(db, ver, name, rr_action,
+ rr_action_data);
}
node = NULL;
result = dns_db_findnode(db, name, false, &node);
}
if (result == ISC_R_NOTFOUND) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_init(&rdataset);
cleanup_node:
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
/**************************************************************************/
rrset_exists_action(void *data, rr_t *rr) {
UNUSED(data);
UNUSED(rr);
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
/*%
*visible = false; /* silence false compiler warning */
break;
}
- return (result);
+ return result;
}
/*%
name_exists_action(void *data, dns_rdataset_t *rrset) {
UNUSED(data);
UNUSED(rrset);
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
/*%
int r;
r = dns_name_compare(&a->name, &b->name);
if (r != 0) {
- return (r);
+ return r;
}
r = (b->rdata.type - a->rdata.type);
if (r != 0) {
- return (r);
+ return r;
}
r = dns_rdata_casecompare(&a->rdata, &b->rdata);
- return (r);
+ return r;
}
/**************************************************************************/
true_p(dns_rdata_t *update_rr, dns_rdata_t *db_rr) {
UNUSED(update_rr);
UNUSED(db_rr);
- return (true);
+ return true;
}
/*%
static bool
rrsig_p(dns_rdata_t *update_rr, dns_rdata_t *db_rr) {
UNUSED(update_rr);
- return ((db_rr->type == dns_rdatatype_rrsig) ? true : false);
+ return (db_rr->type == dns_rdatatype_rrsig) ? true : false;
}
/*%
result = update_one_rr(ctx->db, ctx->ver, ctx->diff,
DNS_DIFFOP_DEL, ctx->name, rr->ttl,
&rr->rdata);
- return (result);
+ return result;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
ctx.diff = diff;
ctx.name = name;
ctx.update_rr = update_rr;
- return (foreach_rr(db, ver, name, type, covers, delete_if_action,
- &ctx));
+ return foreach_rr(db, ver, name, type, covers, delete_if_action, &ctx);
}
/**************************************************************************/
&dummy_rdata, &tuple));
dns_diff_append(list, &tuple);
failure:
- return (result);
+ return result;
}
static isc_result_t
if (dbit != NULL) {
dns_dbiterator_destroy(&dbit);
}
- return (result);
+ return result;
}
/*%
(rrset->covers == dns_rdatatype_nsec ||
rrset->covers == dns_rdatatype_nsec3))))
{
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
dns_difftuple_t const *const *bp = bv;
dns_difftuple_t const *a = *ap;
dns_difftuple_t const *b = *bp;
- return (dns_name_compare(&a->name, &b->name));
+ return dns_name_compare(&a->name, &b->name);
}
static isc_result_t
p = ISC_LIST_NEXT(p, link);
}
failure:
- return (result);
+ return result;
}
static isc_result_t
if (unsecure != NULL) {
*unsecure = false;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (result == DNS_R_ZONECUT) {
*flag = true;
*cut = true;
*unsecure = false;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (result == DNS_R_GLUE || result == DNS_R_DNAME ||
result == DNS_R_DELEGATION || result == DNS_R_NXDOMAIN)
{
if (unsecure != NULL) {
*unsecure = false;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
/*
* Silence compiler.
if (unsecure != NULL) {
*unsecure = false;
}
- return (result);
+ return result;
}
}
dns_dbiterator_destroy(&dbit);
}
- return (result);
+ return result;
}
/*%
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
/*%
&tuple));
CHECK(do_one_tuple(&tuple, db, ver, diff));
failure:
- return (result);
+ return result;
}
static isc_result_t
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
/*%
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
/*
result = dns_db_findnode(db, name, false, &node);
if (result == ISC_R_NOTFOUND) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
goto failure;
dns_db_detachnode(db, &node);
if (result == ISC_R_NOTFOUND) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
goto failure;
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
static isc_result_t
node = NULL;
result = dns_db_findnode(db, name, false, &node);
if (result == ISC_R_NOTFOUND) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
iter = NULL;
cleanup_node:
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
/*%
dns_update_signatures(dns_update_log_t *log, dns_zone_t *zone, dns_db_t *db,
dns_dbversion_t *oldver, dns_dbversion_t *newver,
dns_diff_t *diff, uint32_t sigvalidityinterval) {
- return (dns_update_signaturesinc(log, zone, db, oldver, newver, diff,
- sigvalidityinterval, NULL));
+ return dns_update_signaturesinc(log, zone, db, oldver, newver, diff,
+ sigvalidityinterval, NULL);
}
struct dns_update_state {
sigvalidity -= isc_random_uniform(1200);
}
}
- return (sigvalidity);
+ return sigvalidity;
}
isc_result_t
}
}
if (state != &mystate && sigs > maxsigs) {
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
}
ISC_LIST_APPENDLIST(diff->tuples, state->work.tuples, link);
ISC_LIST_UNLINK(state->affected.tuples, t, link);
ISC_LIST_APPEND(state->work.tuples, t, link);
if (state != &mystate && sigs > maxsigs) {
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
}
ISC_LIST_APPENDLIST(state->affected.tuples, state->work.tuples,
ISC_LIST_UNLINK(state->nsec_mindiff.tuples, t, link);
ISC_LIST_APPEND(state->work.tuples, t, link);
if (state != &mystate && sigs > maxsigs) {
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
}
ISC_LIST_APPENDLIST(state->nsec_mindiff.tuples,
ISC_LIST_UNLINK(state->affected.tuples, t, link);
ISC_LIST_APPEND(state->work.tuples, t, link);
if (state != &mystate && sigs > maxsigs) {
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
}
ISC_LIST_APPENDLIST(state->affected.tuples, state->work.tuples,
ISC_LIST_UNLINK(state->nsec_mindiff.tuples, t, link);
ISC_LIST_APPEND(state->work.tuples, t, link);
if (state != &mystate && sigs > maxsigs) {
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
}
ISC_LIST_APPENDLIST(state->nsec_mindiff.tuples,
isc_mem_put(diff->mctx, state, sizeof(*state));
}
- return (result);
+ return result;
}
static isc_stdtime_t
epoch_to_yyyymmdd(time_t when) {
struct tm t, *tm = localtime_r(&when, &t);
if (tm == NULL) {
- return (0);
+ return 0;
}
- return (((tm->tm_year + 1900) * 10000) + ((tm->tm_mon + 1) * 100) +
- tm->tm_mday);
+ return ((tm->tm_year + 1900) * 10000) + ((tm->tm_mon + 1) * 100) +
+ tm->tm_mday;
}
static uint32_t
switch (method) {
case dns_updatemethod_none:
- return (serial);
+ return serial;
case dns_updatemethod_unixtime:
isc_stdtime_get(&now);
- return (now);
+ return now;
case dns_updatemethod_date:
isc_stdtime_get(&now);
- return (epoch_to_yyyymmdd((time_t)now) * 100);
+ return epoch_to_yyyymmdd((time_t)now) * 100;
case dns_updatemethod_increment:
/* RFC1982 */
serial = (serial + 1) & 0xFFFFFFFF;
if (serial == 0) {
- return (1);
+ return 1;
}
- return (serial);
+ return serial;
default:
UNREACHABLE();
}
*used = method;
}
- return (new_serial);
+ return new_serial;
}
if (val->mustbesecure && mbstext != NULL) {
validator_log(val, ISC_LOG_WARNING,
"must be secure failure, %s", mbstext);
- return (DNS_R_MUSTBESECURE);
+ return DNS_R_MUSTBESECURE;
}
validator_log(val, ISC_LOG_DEBUG(3), "marking as answer (%s)", where);
dns_trust_answer);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
* Caller must be holding the lock.
*/
if (!SHUTDOWN(val)) {
- return (false);
+ return false;
}
INSIST(val->event == NULL);
if (val->fetch != NULL || val->subvalidator != NULL) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
/*%
goto trynsec3;
}
if (result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
}
dns_rdata_reset(&rdata);
}
dns_rdataset_disassociate(&set);
- return (found);
+ return found;
trynsec3:
/*
found = dns_nsec3_typepresent(&rdata,
dns_rdatatype_ns);
dns_rdataset_disassociate(&set);
- return (found);
+ return found;
}
if ((nsec3.flags & DNS_NSEC3FLAG_OPTOUT) == 0) {
continue;
memcmp(hash, nsec3.next, length) < 0)))
{
dns_rdataset_disassociate(&set);
- return (true);
+ return true;
}
}
dns_rdataset_disassociate(&set);
}
- return (found);
+ return found;
}
/*%
dns_rdatatype_format(type, typebuf, sizeof(typebuf));
validator_log(val, ISC_LOG_INFO, "bad cache hit (%s/%s)",
namebuf, typebuf);
- return (DNS_R_BROKENCHAIN);
+ return DNS_R_BROKENCHAIN;
}
options = DNS_DBFIND_PENDINGOK;
goto notfound;
}
- return (result);
+ return result;
notfound:
disassociate_rdatasets(val);
- return (result);
+ return result;
}
/*%
validator_log(val, ISC_LOG_DEBUG(3),
"continuing validation would lead to "
"deadlock: aborting validation");
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
/*%
if (check_deadlock(val, name, type, NULL, NULL)) {
validator_log(val, ISC_LOG_DEBUG(3),
"deadlock found (create_fetch)");
- return (DNS_R_NOVALIDSIG);
+ return DNS_R_NOVALIDSIG;
}
if ((val->options & DNS_VALIDATOR_NOCDFLAG) != 0) {
}
validator_logcreate(val, name, type, caller, "fetch");
- return (dns_resolver_createfetch(
+ return dns_resolver_createfetch(
val->view->resolver, name, type, NULL, NULL, NULL, NULL, 0,
fopts, 0, NULL, val->event->ev_sender, callback, val,
- &val->frdataset, &val->fsigrdataset, &val->fetch));
+ &val->frdataset, &val->fsigrdataset, &val->fetch);
}
/*%
if (check_deadlock(val, name, type, rdataset, sig)) {
validator_log(val, ISC_LOG_DEBUG(3),
"deadlock found (create_validator)");
- return (DNS_R_NOVALIDSIG);
+ return DNS_R_NOVALIDSIG;
}
/* OK to clear other options, but preserve NOCDFLAG and NONTA. */
val->subvalidator->parent = val;
val->subvalidator->depth = val->depth + 1;
}
- return (result);
+ return result;
}
/*%
result = ISC_R_NOTFOUND;
}
- return (result);
+ return result;
}
/*%
if (namereln != dns_namereln_subdomain &&
namereln != dns_namereln_equal)
{
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
if (namereln == dns_namereln_equal) {
* (since seek_dnskey is not called from validate_dnskey).
*/
if (val->event->rdataset->type == dns_rdatatype_dnskey) {
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
/*
* points cannot be self-signed.
*/
if (dns_rdatatype_atparent(val->event->rdataset->type)) {
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
} else {
/*
}
validator_log(val, ISC_LOG_DEBUG(3),
"%s signer mismatch", type);
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
}
&val->frdataset, &val->fsigrdataset,
validator_callback_dnskey, "seek_dnskey");
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return (DNS_R_WAIT);
+ return DNS_R_WAIT;
} else if (DNS_TRUST_PENDING(val->frdataset.trust)) {
/*
* Having a pending key with no signature means that
dns_rdatatype_dnskey,
fetch_callback_dnskey, "seek_dnskey");
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return (DNS_R_WAIT);
+ return DNS_R_WAIT;
case DNS_R_NCACHENXDOMAIN:
case DNS_R_NCACHENXRRSET:
break;
case DNS_R_BROKENCHAIN:
- return (result);
+ return result;
default:
break;
dns_rdataset_disassociate(&val->fsigrdataset);
}
- return (result);
+ return result;
}
/*
isc_region_t r;
dns_rdata_toregion(rdata, &r);
- return (dst_region_computeid(&r));
+ return dst_region_computeid(&r);
}
/*%
bool answer = false;
if (rdataset->type != dns_rdatatype_dnskey) {
- return (false);
+ return false;
}
for (result = dns_rdataset_first(rdataset); result == ISC_R_SUCCESS;
}
}
- return (answer);
+ return answer;
}
/*%
}
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
/*%
}
result = dns_rdata_tostruct(&rdata, val->siginfo, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
continue; /* Try the next SIG RR. */
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
validator_log(val, ISC_LOG_DEBUG(3),
"no message available "
"for noqname proof");
- return (DNS_R_NOVALIDSIG);
+ return DNS_R_NOVALIDSIG;
}
validator_log(val, ISC_LOG_DEBUG(3),
"looking for noqname proof");
- return (validate_nx(val, false));
+ return validate_nx(val, false);
} else if (vresult == ISC_R_SUCCESS) {
marksecure(event);
validator_log(val, ISC_LOG_DEBUG(3),
"marking as secure, "
"noqname proof not needed");
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
validator_log(val, ISC_LOG_DEBUG(3),
"verify failure: %s",
validator_log(val, ISC_LOG_DEBUG(3),
"failed to iterate signatures: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
validator_log(val, ISC_LOG_INFO, "no valid signature found");
- return (vresult);
+ return vresult;
}
/*%
dst_key_free(&dstkey);
}
- return (result);
+ return result;
}
/*
if (result != ISC_R_SUCCESS) {
*resp = result;
}
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
} else if (DNS_TRUST_PENDING(val->frdataset.trust)) {
/*
* There should never be an unsigned DS.
validator_log(val, ISC_LOG_DEBUG(2),
"unsigned DS record");
*resp = DNS_R_NOVALIDSIG;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
break;
if (result != ISC_R_SUCCESS) {
*resp = result;
}
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
case DNS_R_NCACHENXDOMAIN:
case DNS_R_NCACHENXRRSET:
disassociate_rdatasets(val);
validator_log(val, ISC_LOG_DEBUG(2), "no DS record");
*resp = DNS_R_NOVALIDSIG;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
case DNS_R_BROKENCHAIN:
*resp = result;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
default:
break;
}
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
/*%
dns_rdataset_disassociate(&val->fdsset);
}
- return (result);
+ return result;
}
/*%
if (message != NULL) {
result = dns_message_firstname(message, DNS_SECTION_AUTHORITY);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_message_currentname(message, DNS_SECTION_AUTHORITY, namep);
*rdatasetp = ISC_LIST_HEAD((*namep)->list);
*rdatasetp);
}
}
- return (result);
+ return result;
}
static isc_result_t
*rdatasetp);
}
}
- return (result);
+ return result;
}
/*%
if (dns_name_countlabels(wild) == 0) {
validator_log(val, ISC_LOG_DEBUG(3),
"in checkwildcard: no wildcard to check");
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_name_format(wild, namebuf, sizeof(namebuf));
if (dns_rdataset_isassociated(&trdataset)) {
dns_rdataset_disassociate(&trdataset);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (rdataset->type == dns_rdatatype_nsec3 &&
if (dns_rdataset_isassociated(&trdataset)) {
dns_rdataset_disassociate(&trdataset);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
if (result == ISC_R_NOMORE) {
if (dns_rdataset_isassociated(&trdataset)) {
dns_rdataset_disassociate(&trdataset);
}
- return (result);
+ return result;
}
/*
if (dns_rdataset_isassociated(&trdataset)) {
dns_rdataset_disassociate(&trdataset);
}
- return (result);
+ return result;
}
}
if (result != ISC_R_NOMORE) {
if (dns_rdataset_isassociated(&trdataset)) {
dns_rdataset_disassociate(&trdataset);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (dns_rdataset_isassociated(&trdataset)) {
dns_rdataset_disassociate(&trdataset);
}
- return (result);
+ return result;
}
if (result != ISC_R_SUCCESS) {
continue;
if (dns_rdataset_isassociated(&trdataset)) {
dns_rdataset_disassociate(&trdataset);
}
- return (result);
+ return result;
}
}
if (dns_rdataset_isassociated(&trdataset)) {
dns_rdataset_disassociate(&trdataset);
}
- return (result);
+ return result;
}
/*
result = dns_rdataset_first(rdataset);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_current(rdataset, &nsec);
if (dns_nsec_typepresent(&nsec, dns_rdatatype_soa)) {
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
}
sigrdataset, validator_callback_nsec,
"validate_neg_rrset");
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
val->authcount++;
- return (DNS_R_WAIT);
+ return DNS_R_WAIT;
}
/*%
result = validate_neg_rrset(val, name, rdataset,
sigrdataset);
if (result != DNS_R_CONTINUE) {
- return (result);
+ return result;
}
}
}
if (result == ISC_R_NOMORE) {
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
/*%
continue;
}
- return (result);
+ return result;
}
if (result == ISC_R_NOMORE) {
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
/*%
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
validator_log(val, ISC_LOG_DEBUG(3),
"too many iterations");
markanswer(val, "validate_nx (3)", NULL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
validator_log(val, ISC_LOG_DEBUG(3),
"marking as secure, noqname proof found");
marksecure(val->event);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (FOUNDOPTOUT(val) &&
dns_name_countlabels(
dns_fixedname_name(&val->wild)) != 0)
"optout proof found");
val->event->optout = true;
markanswer(val, "validate_nx (1)", NULL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if ((val->attributes & VALATTR_FOUNDUNKNOWN) != 0) {
validator_log(val, ISC_LOG_DEBUG(3),
"unknown NSEC3 hash algorithm found");
markanswer(val, "validate_nx (2)", NULL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
validator_log(val, ISC_LOG_DEBUG(3), "noqname proof not found");
- return (DNS_R_NOVALIDNSEC);
+ return DNS_R_NOVALIDNSEC;
}
if (!FOUNDNOQNAME(val) && !FOUNDNODATA(val)) {
validator_log(val, ISC_LOG_DEBUG(3),
"too many iterations");
markanswer(val, "validate_nx (4)", NULL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
{
result = checkwildcard(val, dns_rdatatype_nsec, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
} else {
val->event->secure = true;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (val->authfail != 0 && val->authcount == val->authfail) {
- return (DNS_R_BROKENCHAIN);
+ return DNS_R_BROKENCHAIN;
}
validator_log(val, ISC_LOG_DEBUG(3), "nonexistence proof(s) not found");
- return (proveunsecure(val, false, false));
+ return proveunsecure(val, false, false);
}
/*%
ds.algorithm))
{
dns_rdata_reset(&dsrdata);
- return (true);
+ return true;
}
dns_rdata_reset(&dsrdata);
}
- return (false);
+ return false;
}
/*%
*resp = markanswer(val, "proveunsecure (5)",
"no supported "
"algorithm/digest (DS)");
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
break;
*resp = DNS_R_NOVALIDSIG;
}
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
case ISC_R_NOTFOUND:
/*
if (result != ISC_R_SUCCESS) {
*resp = result;
}
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
case DNS_R_NXRRSET:
case DNS_R_NCACHENXRRSET:
if (result != ISC_R_SUCCESS) {
*resp = result;
}
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
/*
{
*resp = markanswer(val, "proveunsecure (3)",
"no DS at zone cut");
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
if (val->frdataset.trust < dns_trust_secure) {
"can't validate existing "
"negative responses (no DS)");
*resp = DNS_R_MUSTBESECURE;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
if (isdelegation(tname, &val->frdataset, result)) {
*resp = markanswer(val, "proveunsecure (4)",
"this is a delegation");
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
break;
* are still in a secure zone.
*/
*resp = DNS_R_NOVALIDNSEC;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
} else if (DNS_TRUST_PENDING(val->frdataset.trust) ||
DNS_TRUST_ANSWER(val->frdataset.trust))
{
if (result != ISC_R_SUCCESS) {
*resp = result;
}
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
} else if (val->frdataset.trust < dns_trust_secure) {
/*
* This shouldn't happen, since the negative
"negative responses "
"(not a zone cut)");
*resp = DNS_R_NOVALIDSIG;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
break;
if (result != ISC_R_SUCCESS) {
*resp = result;
}
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
break;
default:
*resp = result;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
/*
* No definite answer yet; continue walking down labels.
*/
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
/*%
result = dns_keytable_finddeepestmatch(val->keytable, secroot, secroot);
if (result == ISC_R_NOTFOUND) {
validator_log(val, ISC_LOG_DEBUG(3), "not beneath secure root");
- return (markanswer(val, "proveunsecure (1)",
- "not beneath secure root"));
+ return markanswer(val, "proveunsecure (1)",
+ "not beneath secure root");
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (!resume) {
/* Couldn't complete insecurity proof. */
validator_log(val, ISC_LOG_DEBUG(3), "insecurity proof failed: %s",
isc_result_totext(result));
- return (DNS_R_NOTINSECURE);
+ return DNS_R_NOTINSECURE;
out:
if (result != DNS_R_WAIT) {
disassociate_rdatasets(val);
}
- return (result);
+ return result;
}
/*%
"got insecure response; "
"parent indicates it should be secure");
}
- } else if ((val->event->rdataset == NULL &&
- val->event->sigrdataset == NULL))
+ } else if (val->event->rdataset == NULL &&
+ val->event->sigrdataset == NULL)
{
/*
* This is a validation of a negative response.
}
result = validate_nx(val, false);
- } else if ((val->event->rdataset != NULL &&
- NEGATIVE(val->event->rdataset)))
+ } else if (val->event->rdataset != NULL &&
+ NEGATIVE(val->event->rdataset))
{
/*
* This is a delayed validation of a negative cache entry.
*validatorp = val;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
isc_mutex_destroy(&val->lock);
dns_view_weakdetach(&val->view);
isc_mem_put(view->mctx, val, sizeof(*val));
- return (result);
+ return result;
}
void
*viewp = view;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_peerlist:
if (view->peers != NULL) {
isc_mem_free(mctx, view->name);
isc_mem_putanddetach(&view->mctx, view, sizeof(*view));
- return (result);
+ return result;
}
static void
dialup(dns_zone_t *zone, void *dummy) {
UNUSED(dummy);
dns_zone_dialup(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
REQUIRE(!view->frozen);
REQUIRE(view->zonetable == NULL);
- return (dns_zt_create(view->mctx, view->rdclass, &view->zonetable));
+ return dns_zt_create(view->mctx, view->rdclass, &view->zonetable);
}
isc_result_t
result = isc_task_create(taskmgr, 0, &view->task);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_task_setname(view->task, "view", view);
dispatchv6, &view->resolver);
if (result != ISC_R_SUCCESS) {
isc_task_detach(&view->task);
- return (result);
+ return result;
}
event = &view->resevent;
dns_resolver_whenshutdown(view->resolver, view->task, &event);
isc_mem_detach(&mctx);
if (result != ISC_R_SUCCESS) {
dns_resolver_shutdown(view->resolver);
- return (result);
+ return result;
}
event = &view->adbevent;
dns_adb_whenshutdown(view->adb, view->task, &event);
if (result != ISC_R_SUCCESS) {
dns_adb_shutdown(view->adb);
dns_resolver_shutdown(view->resolver);
- return (result);
+ return result;
}
event = &view->reqevent;
dns_requestmgr_whenshutdown(view->requestmgr, view->task, &event);
atomic_fetch_and(&view->attributes, ~DNS_VIEWATTR_REQSHUTDOWN);
isc_refcount_increment(&view->weakrefs);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
dns_view_iscacheshared(dns_view_t *view) {
REQUIRE(DNS_VIEW_VALID(view));
- return (view->cacheshared);
+ return view->cacheshared;
}
void
result = dns_zt_mount(view->zonetable, zone);
- return (result);
+ return result;
}
isc_result_t
}
UNLOCK(&view->lock);
- return (result);
+ return result;
}
isc_result_t
dns_zone_detach(&zone);
}
- return (result);
+ return result;
}
isc_result_t
result = ISC_R_NOTFOUND;
}
- return (result);
+ return result;
}
isc_result_t
dns_zone_detach(&zone);
}
- return (result);
+ return result;
}
isc_result_t
}
}
if (view == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
dns_view_attach(view, viewp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (zone2 != NULL) {
dns_zone_detach(&zone1);
dns_zone_detach(&zone2);
- return (ISC_R_MULTIPLE);
+ return ISC_R_MULTIPLE;
}
}
if (zone1 != NULL) {
dns_zone_attach(zone1, zonep);
dns_zone_detach(&zone1);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
isc_result_t
REQUIRE(DNS_VIEW_VALID(view));
REQUIRE(view->zonetable != NULL);
- return (dns_zt_load(view->zonetable, stop, newonly));
+ return dns_zt_load(view->zonetable, stop, newonly);
}
isc_result_t
REQUIRE(DNS_VIEW_VALID(view));
REQUIRE(view->zonetable != NULL);
- return (dns_zt_asyncload(view->zonetable, newonly, callback, arg));
+ return dns_zt_asyncload(view->zonetable, newonly, callback, arg);
}
isc_result_t
result = dns_tsigkey_find(keyp, keyname, NULL,
view->dynamickeys);
}
- return (result);
+ return result;
}
isc_result_t
dns_transport_t *transport = dns_transport_find(type, name,
view->transports);
if (transport == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
*transportp = transport;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
result = dns_peerlist_peerbyaddr(view->peers, peeraddr, &peer);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_peer_getkey(peer, &keyname);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_view_gettsig(view, keyname, keyp);
- return ((result == ISC_R_NOTFOUND) ? ISC_R_FAILURE : result);
+ return (result == ISC_R_NOTFOUND) ? ISC_R_FAILURE : result;
}
isc_result_t
REQUIRE(DNS_VIEW_VALID(view));
REQUIRE(source != NULL);
- return (dns_tsig_verify(source, msg, view->statickeys,
- view->dynamickeys));
+ return dns_tsig_verify(source, msg, view->statickeys,
+ view->dynamickeys);
}
isc_result_t
&dns_master_style_cache,
dns_masterformat_text, NULL, fp);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_adb_dump(view->adb, fp);
dns_resolver_printbadcache(view->resolver, fp);
dns_badcache_print(view->failcache, "SERVFAIL cache", fp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(DNS_VIEW_VALID(view));
if (view->cachedb == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (!fixuponly) {
result = dns_cache_flush(view->cache);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
dns_db_detach(&view->cachedb);
}
dns_adb_flush(view->adb);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
dns_view_flushname(dns_view_t *view, const dns_name_t *name) {
- return (dns_view_flushnode(view, name, false));
+ return dns_view_flushnode(view, name, false);
}
isc_result_t
result = dns_cache_flushnode(view->cache, name, tree);
}
- return (result);
+ return result;
}
void
REQUIRE(DNS_VIEW_VALID(view));
if (!view->rootdelonly && view->delonly == NULL) {
- return (false);
+ return false;
}
hash = dns_name_hash(name, false) % DNS_VIEW_DELONLYHASH;
if (view->rootdelonly && dns_name_countlabels(name) <= 2) {
if (view->rootexclude == NULL) {
- return (true);
+ return true;
}
item = ISC_LIST_HEAD(view->rootexclude[hash]);
while (item != NULL && !dns_name_equal(item, name)) {
item = ISC_LIST_NEXT(item, link);
}
if (item == NULL) {
- return (true);
+ return true;
}
}
if (view->delonly == NULL) {
- return (false);
+ return false;
}
item = ISC_LIST_HEAD(view->delonly[hash]);
item = ISC_LIST_NEXT(item, link);
}
if (item == NULL) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
void
bool
dns_view_getrootdelonly(dns_view_t *view) {
REQUIRE(DNS_VIEW_VALID(view));
- return (view->rootdelonly);
+ return view->rootdelonly;
}
isc_result_t
REQUIRE(DNS_VIEW_VALID(view));
REQUIRE(view->zonetable != NULL);
- return (dns_zt_freezezones(view->zonetable, view, value));
+ return dns_zt_freezezones(view->zonetable, view, value);
}
void
if (view->ntatable_priv != NULL) {
dns_ntatable_detach(&view->ntatable_priv);
}
- return (dns_ntatable_create(view, taskmgr, timermgr,
- &view->ntatable_priv));
+ return dns_ntatable_create(view, taskmgr, timermgr,
+ &view->ntatable_priv);
}
isc_result_t
REQUIRE(DNS_VIEW_VALID(view));
REQUIRE(ntp != NULL && *ntp == NULL);
if (view->ntatable_priv == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
dns_ntatable_attach(view->ntatable_priv, ntp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (view->secroots_priv != NULL) {
dns_keytable_detach(&view->secroots_priv);
}
- return (dns_keytable_create(mctx, &view->secroots_priv));
+ return dns_keytable_create(mctx, &view->secroots_priv);
}
isc_result_t
REQUIRE(DNS_VIEW_VALID(view));
REQUIRE(ktp != NULL && *ktp == NULL);
if (view->secroots_priv == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
dns_keytable_attach(view->secroots_priv, ktp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
bool
REQUIRE(DNS_VIEW_VALID(view));
if (view->ntatable_priv == NULL) {
- return (false);
+ return false;
}
- return (dns_ntatable_covered(view->ntatable_priv, now, name, anchor));
+ return dns_ntatable_covered(view->ntatable_priv, now, name, anchor);
}
isc_result_t
REQUIRE(DNS_VIEW_VALID(view));
if (view->secroots_priv == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
anchor = dns_fixedname_initname(&fn);
result = dns_keytable_issecuredomain(view->secroots_priv, name, anchor,
&secure);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (ntap != NULL) {
}
*secure_domain = secure;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
result = dns_view_getsecroots(view, &sr);
if (result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
dns_rdataset_init(&dsset);
dns_keytable_detachkeynode(sr, &knode);
}
dns_keytable_detach(&sr);
- return (answer);
+ return answer;
}
/*
result = isc_file_sanitize(directory, viewname, suffix, buffer, buflen);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
} else if (directory == NULL || isc_file_exists(buffer)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
/* Save buffer */
strlcpy(newbuf, buffer, sizeof(newbuf));
*/
result = isc_file_sanitize(NULL, viewname, suffix, buffer, buflen);
if (result != ISC_R_SUCCESS || isc_file_exists(buffer)) {
- return (result);
+ return result;
}
/*
* so use the path in 'directory'.
*/
strlcpy(buffer, newbuf, buflen);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
if (!allow) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
CHECK(nz_legacy(view->new_zone_dir, view->name, "nzf", buffer,
view->cfg_destroy = NULL;
}
- return (result);
+ return result;
}
void
dns_view_getnewzonedir(dns_view_t *view) {
REQUIRE(DNS_VIEW_VALID(view));
- return (view->new_zone_dir);
+ return view->new_zone_dir;
}
isc_result_t
if (best != NULL) {
dns_db_attach(best, dbp);
dns_db_detach(&best);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
uint32_t
dns_view_getfailttl(dns_view_t *view) {
REQUIRE(DNS_VIEW_VALID(view));
- return (view->fail_ttl);
+ return view->fail_ttl;
}
void
REQUIRE(DNS_VIEW_VALID(view));
if (view->nta_lifetime == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* Open NTA save file for overwrite. */
(void)isc_file_remove(view->nta_file);
}
- return (result);
+ return result;
}
#define TSTR(t) ((t).value.as_textregion.base)
REQUIRE(DNS_VIEW_VALID(view));
if (view->nta_lifetime == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
CHECK(isc_lex_create(view->mctx, 1025, &lex));
isc_lex_destroy(&lex);
}
- return (result);
+ return result;
}
void
if (dns_db_getservestalettl(view->cachedb, &stale_ttl) != ISC_R_SUCCESS)
{
- return (false);
+ return false;
}
if (stale_ttl > 0) {
if (view->staleanswersok == dns_stale_answer_yes) {
}
}
- return (result);
+ return result;
}
static void
CHECK(dns_db_beginload(xfr->db, &xfr->axfr));
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
static isc_result_t
dns_difftuple_t *tuple = NULL;
if (rdata->rdclass != xfr->rdclass) {
- return (DNS_R_BADCLASS);
+ return DNS_R_BADCLASS;
}
CHECK(dns_zone_checknames(xfr->zone, name, rdata));
}
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
/*
}
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
static isc_result_t
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
static isc_result_t
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
/**************************************************************************/
if (xfr->reqtype != dns_rdatatype_ixfr) {
xfrin_log(xfr, ISC_LOG_NOTICE,
"got incremental response to AXFR request");
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
xfr->is_ixfr = true;
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
static isc_result_t
dns_difftuple_t *tuple = NULL;
if (rdata->rdclass != xfr->rdclass) {
- return (DNS_R_BADCLASS);
+ return DNS_R_BADCLASS;
}
if (op == DNS_DIFFOP_ADD) {
}
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
/*
xfr->difflen = 0;
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
static isc_result_t
}
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
/**************************************************************************/
}
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
isc_result_t
"zone transfer setup failed");
}
- return (result);
+ return result;
}
static void
*pctx = found;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
if (tlsctx != NULL) {
isc_tls_cert_store_free(&store);
}
- return (result);
+ return result;
}
static isc_result_t
UNREACHABLE();
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
isc_refcount_decrement0(&xfr->connects);
dns_xfrin_detach(&connect_xfr);
- return (result);
+ return result;
}
/* XXX the resolver could use this, too */
if (cleanup_cctx) {
dns_compress_invalidate(&cctx);
}
- return (result);
+ return result;
}
/*
ISC_LIST_APPEND(name->list, rds, link);
*target = name;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
dns_message_puttemprdata(msg, &rdata);
}
- return (result);
+ return result;
}
/*
dns_db_closeversion(xfr->db, &ver, false);
}
- return (result);
+ return result;
}
static void
DNS_EVENT_ZONECONTROL, zone_shutdown, zone, zone, NULL,
NULL);
*zonep = zone;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
free_refs:
isc_refcount_decrement0(&zone->erefs);
ZONEDB_DESTROYLOCK(&zone->dblock);
isc_mutex_destroy(&zone->lock);
isc_mem_putanddetach(&zone->mctx, zone, sizeof(*zone));
- return (result);
+ return result;
}
static void
inline_secure(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
if (zone->raw != NULL) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
/*
inline_raw(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
if (zone->secure != NULL) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
/*
dns_zone_getclass(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->rdclass);
+ return zone->rdclass;
}
void
ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
UNLOCK_ZONE(zone);
- return (result);
+ return result;
}
/*
}
UNLOCK_ZONE(zone);
*argv = mem;
- return (result);
+ return result;
}
void
dns_zone_getview(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->view);
+ return zone->view;
}
void
result = dns_zone_setorigin(zone->raw, origin);
}
UNLOCK_ZONE(zone);
- return (result);
+ return result;
}
static isc_result_t
}
*field = copy;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
UNLOCK_ZONE(zone);
- return (result);
+ return result;
}
const char *
dns_zone_getfile(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->masterfile);
+ return zone->masterfile;
}
isc_result_t
result = default_journal(zone);
UNLOCK_ZONE(zone);
- return (result);
+ return result;
}
dns_ttl_t
dns_zone_getmaxttl(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->maxttl);
+ return zone->maxttl;
}
void
if (journal != NULL) {
isc_mem_free(zone->mctx, journal);
}
- return (result);
+ return result;
}
isc_result_t
result = dns_zone_setstring(zone, &zone->journal, myjournal);
UNLOCK_ZONE(zone);
- return (result);
+ return result;
}
char *
dns_zone_getjournal(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->journal);
+ return zone->journal;
}
/*
zone->type == dns_zone_stub || zone->type == dns_zone_key ||
(zone->type == dns_zone_redirect && zone->primaries != NULL))
{
- return (true);
+ return true;
}
/* Inline zones are always dynamic. */
if (zone->type == dns_zone_primary && zone->raw != NULL) {
- return (true);
+ return true;
}
/* If !ignore_freeze, we need check whether updates are disabled. */
((zone->ssutable != NULL) ||
(zone->update_acl != NULL && !dns_acl_isnone(zone->update_acl))))
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
/*
if (strcmp(zone->db_argv[0], "rbt") != 0 &&
strcmp(zone->db_argv[0], "rbt64") != 0)
{
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
/*
rpzs->defined |= DNS_RPZ_ZBIT(rpz_num);
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_rpz_num_t
dns_zone_get_rpz_num(dns_zone_t *zone) {
- return (zone->rpz_num);
+ return zone->rpz_num;
}
/*
dns_zone_catz_is_enabled(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->catzs != NULL);
+ return zone->catzs != NULL;
}
/*
dns_catz_zone_t *
dns_zone_get_parentcatz(const dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->parentcatz);
+ return zone->parentcatz;
}
static bool
if (result != ISC_R_SUCCESS ||
isc_time_compare(&modtime, &zone->loadtime) > 0)
{
- return (true);
+ return true;
}
for (include = ISC_LIST_HEAD(zone->includes); include != NULL;
if (result != ISC_R_SUCCESS ||
isc_time_compare(&modtime, &include->filetime) > 0)
{
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
/*
if (!locked) {
UNLOCK_ZONE(zone);
}
- return (result);
+ return result;
}
LOCK_ZONE(zone->raw);
}
if (db != NULL) {
dns_db_detach(&db);
}
- return (result);
+ return result;
}
isc_result_t
dns_zone_load(dns_zone_t *zone, bool newonly) {
- return (zone_load(zone, newonly ? DNS_ZONELOADFLAG_NOSTAT : 0, false));
+ return zone_load(zone, newonly ? DNS_ZONELOADFLAG_NOSTAT : 0, false);
}
static void
REQUIRE(DNS_ZONE_VALID(zone));
if (zone->zmgr == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* If we already have a load pending, stop now */
LOCK_ZONE(zone);
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADPENDING)) {
UNLOCK_ZONE(zone);
- return (ISC_R_ALREADYRUNNING);
+ return ISC_R_ALREADYRUNNING;
}
asl = isc_mem_get(zone->mctx, sizeof(*asl));
isc_task_send(zone->loadtask, &e);
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
bool
dns__zone_loadpending(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADPENDING));
+ return DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADPENDING);
}
isc_result_t
/* Error, remain in disabled state. */
break;
}
- return (result);
+ return result;
}
static unsigned int
options |= DNS_MASTER_CHECKTTL;
}
- return (options);
+ return options;
}
static void
result = dns_db_beginload(db, &callbacks);
if (result != ISC_R_SUCCESS) {
zone_idetach(&callbacks.zone);
- return (result);
+ return result;
}
if (zone->stream != NULL) {
zone_idetach(&callbacks.zone);
}
- return (result);
+ return result;
cleanup:
load->magic = 0;
zone_idetach(&load->callbacks.zone);
isc_mem_detach(&load->mctx);
isc_mem_put(zone->mctx, load, sizeof(*load));
- return (result);
+ return result;
}
static bool
* "." means the services does not exist.
*/
if (dns_name_equal(name, dns_rootname)) {
- return (true);
+ return true;
}
/*
*/
if (!dns_name_issubdomain(name, &zone->origin)) {
if (zone->checkmx != NULL) {
- return ((zone->checkmx)(zone, name, owner));
+ return (zone->checkmx)(zone, name, owner);
}
- return (true);
+ return true;
}
if (zone->type == dns_zone_primary) {
result = dns_db_find(db, name, NULL, dns_rdatatype_a, 0, 0, NULL,
foundname, NULL, NULL);
if (result == ISC_R_SUCCESS) {
- return (true);
+ return true;
}
if (result == DNS_R_NXRRSET) {
result = dns_db_find(db, name, NULL, dns_rdatatype_aaaa, 0, 0,
NULL, foundname, NULL, NULL);
if (result == ISC_R_SUCCESS) {
- return (true);
+ return true;
}
}
dns_zone_log(zone, level,
"%s/MX '%s' has no address records (A or AAAA)",
ownerbuf, namebuf);
- return ((level == ISC_LOG_WARNING) ? true : false);
+ return (level == ISC_LOG_WARNING) ? true : false;
}
if (result == DNS_R_CNAME) {
"%s/MX '%s' is a CNAME (illegal)",
ownerbuf, namebuf);
}
- return ((level == ISC_LOG_WARNING) ? true : false);
+ return (level == ISC_LOG_WARNING) ? true : false;
}
if (result == DNS_R_DNAME) {
" '%s' (illegal)",
ownerbuf, namebuf, altbuf);
}
- return ((level == ISC_LOG_WARNING) ? true : false);
+ return (level == ISC_LOG_WARNING) ? true : false;
}
if (zone->checkmx != NULL && result == DNS_R_DELEGATION) {
- return ((zone->checkmx)(zone, name, owner));
+ return (zone->checkmx)(zone, name, owner);
}
- return (true);
+ return true;
}
static bool
* "." means the services does not exist.
*/
if (dns_name_equal(name, dns_rootname)) {
- return (true);
+ return true;
}
/*
*/
if (!dns_name_issubdomain(name, &zone->origin)) {
if (zone->checksrv != NULL) {
- return ((zone->checksrv)(zone, name, owner));
+ return (zone->checksrv)(zone, name, owner);
}
- return (true);
+ return true;
}
if (zone->type == dns_zone_primary) {
result = dns_db_find(db, name, NULL, dns_rdatatype_a, 0, 0, NULL,
foundname, NULL, NULL);
if (result == ISC_R_SUCCESS) {
- return (true);
+ return true;
}
if (result == DNS_R_NXRRSET) {
result = dns_db_find(db, name, NULL, dns_rdatatype_aaaa, 0, 0,
NULL, foundname, NULL, NULL);
if (result == ISC_R_SUCCESS) {
- return (true);
+ return true;
}
}
"%s/SRV '%s' has no address records (A or AAAA)",
ownerbuf, namebuf);
/* XXX950 make fatal for 9.5.0. */
- return (true);
+ return true;
}
if (result == DNS_R_CNAME) {
"%s/SRV '%s' is a CNAME (illegal)",
ownerbuf, namebuf);
}
- return ((level == ISC_LOG_WARNING) ? true : false);
+ return (level == ISC_LOG_WARNING) ? true : false;
}
if (result == DNS_R_DNAME) {
"DNAME '%s' (illegal)",
ownerbuf, namebuf, altbuf);
}
- return ((level == ISC_LOG_WARNING) ? true : false);
+ return (level == ISC_LOG_WARNING) ? true : false;
}
if (zone->checksrv != NULL && result == DNS_R_DELEGATION) {
- return ((zone->checksrv)(zone, name, owner));
+ return (zone->checksrv)(zone, name, owner);
}
- return (true);
+ return true;
}
static bool
*/
if (!dns_name_issubdomain(name, &zone->origin)) {
if (zone->checkns != NULL) {
- return ((zone->checkns)(zone, name, owner, NULL, NULL));
+ return (zone->checkns)(zone, name, owner, NULL, NULL);
}
- return (true);
+ return true;
}
if (zone->type == dns_zone_primary) {
}
if (result == ISC_R_SUCCESS) {
dns_rdataset_disassociate(&a);
- return (true);
+ return true;
} else if (result == DNS_R_DELEGATION) {
dns_rdataset_disassociate(&a);
}
dns_rdataset_disassociate(&a);
}
dns_rdataset_disassociate(&aaaa);
- return (true);
+ return true;
}
if (tresult == DNS_R_DELEGATION || tresult == DNS_R_DNAME) {
dns_rdataset_disassociate(&aaaa);
if (dns_rdataset_isassociated(&aaaa)) {
dns_rdataset_disassociate(&aaaa);
}
- return (answer);
+ return answer;
}
}
if (dns_rdataset_isassociated(&aaaa)) {
dns_rdataset_disassociate(&aaaa);
}
- return (answer);
+ return answer;
}
static bool
break;
}
}
- return (answer);
+ return answer;
}
static bool
result = dns_db_createiterator(db, 0, &dbiterator);
if (result != ISC_R_SUCCESS) {
- return (true);
+ return true;
}
for (result = dns_dbiterator_first(dbiterator); result == ISC_R_SUCCESS;
}
dns_dbiterator_destroy(&dbiterator);
- return (ok);
+ return ok;
}
static bool
}
if (i < 6U) {
- return (false);
+ return false;
}
buf[i] = 0;
if (strncmp(buf, "v=spf1", 6) == 0 && (buf[6] == 0 || buf[6] == ' ')) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static bool
result = dns_db_createiterator(db, 0, &dbiterator);
if (result != ISC_R_SUCCESS) {
- return (true);
+ return true;
}
result = dns_dbiterator_first(dbiterator);
}
dns_dbiterator_destroy(&dbiterator);
- return (ok);
+ return ok;
}
/*
if (db != NULL) {
dns_db_detach(&db);
}
- return (result);
+ return result;
}
/*
dns_zone_log(zone, ISC_LOG_ERROR,
"nsec3param lookup failure: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
dns_db_currentversion(db, &version);
}
dns_db_closeversion(db, &version, false);
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
/*
* If the keynode has no trust anchor set, we shouldn't be here.
*/
if (!dns_keynode_dsset(keynode, NULL)) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
memset(&kd, 0, sizeof(kd));
/* Refresh new keys from the zone apex as soon as possible. */
set_refreshkeytimer(zone, &kd, now, true);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
/*
uresult = update_one_rr(db, ver, diff, DNS_DIFFOP_DEL, name, 0,
&rdata);
if (uresult != ISC_R_SUCCESS) {
- return (uresult);
+ return uresult;
}
}
if (result == ISC_R_NOMORE) {
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
/*
dst_key_free(&dstkey);
}
- return (result);
+ return result;
}
/*
ISC_LIST_UNLINK(temp_diff.tuples, *tuple, link);
if (result != ISC_R_SUCCESS) {
dns_difftuple_free(tuple);
- return (result);
+ return result;
}
/*
/*
* Do not clear temp_diff.
*/
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_result_t result;
result = dns_difftuple_create(diff->mctx, op, name, ttl, rdata, &tuple);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return (do_one_tuple(&tuple, db, ver, diff));
+ return do_one_tuple(&tuple, db, ver, diff);
}
static isc_result_t
if (deltuple != NULL) {
dns_difftuple_free(&deltuple);
}
- return (result);
+ return result;
}
/*
dns_zone_log(zone, ISC_LOG_ERROR,
"%s:dns_journal_open -> %s", caller,
isc_result_totext(result));
- return (result);
+ return result;
}
if (sourceserial != NULL) {
dns_journal_destroy(&journal);
}
- return (result);
+ return result;
}
/*
INSIST(ver == NULL);
- return (result);
+ return result;
}
struct addifmissing_arg {
INSIST(ver == NULL);
- return (result);
+ return result;
}
isc_result_t
dns_db_t *db = NULL;
if (zone->type != dns_zone_key) {
- return (DNS_R_BADZONE);
+ return DNS_R_BADZONE;
}
CHECK(dns_zone_getdb(zone, &db));
if (db != NULL) {
dns_db_detach(&db);
}
- return (result);
+ return result;
}
static void
answer = true;
}
dns_diff_clear(&diff);
- return (answer);
+ return answer;
}
/*
zone_debuglog(zone, "zone_postload", 99, "done");
- return (result);
+ return result;
}
static bool
* DNS_ZONEFLG_SHUTDOWN can only be set if erefs == 0.
*/
INSIST(isc_refcount_current(&zone->erefs) == 0);
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static bool
int level;
if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_NOCHECKNS)) {
- return (true);
+ return true;
}
if (zone->type == dns_zone_primary) {
result = dns_db_find(db, name, version, dns_rdatatype_a, 0, 0, NULL,
foundname, NULL, NULL);
if (result == ISC_R_SUCCESS) {
- return (true);
+ return true;
}
if (result == DNS_R_NXRRSET) {
result = dns_db_find(db, name, version, dns_rdatatype_aaaa, 0,
0, NULL, foundname, NULL, NULL);
if (result == ISC_R_SUCCESS) {
- return (true);
+ return true;
}
}
"records (A or AAAA)",
namebuf);
}
- return (false);
+ return false;
}
if (result == DNS_R_CNAME) {
"(illegal)",
namebuf);
}
- return (false);
+ return false;
}
if (result == DNS_R_DNAME) {
"'%s' (illegal)",
namebuf, altbuf);
}
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static isc_result_t
invalidate_rdataset:
dns_rdataset_invalidate(&rdataset);
- return (result);
+ return result;
}
#define SET_IF_NOT_NULL(obj, val) \
dns_rdataset_invalidate(&rdataset);
- return (result);
+ return result;
}
/*
closeversion:
dns_db_closeversion(db, &version, false);
- return (answer);
+ return answer;
}
void
dns_zone_getmctx(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->mctx);
+ return zone->mctx;
}
dns_zonemgr_t *
dns_zone_getmgr(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->zmgr);
+ return zone->zmgr;
}
void
dns_zone_getkasp(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->kasp);
+ return zone->kasp;
}
void
dns_zone_getoptions(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (atomic_load_relaxed(&zone->options));
+ return atomic_load_relaxed(&zone->options);
}
void
dns_zone_getkeyopts(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (atomic_load_relaxed(&zone->keyopts));
+ return atomic_load_relaxed(&zone->keyopts);
}
isc_result_t
zone->xfrsource4 = *xfrsource;
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_sockaddr_t *
dns_zone_getxfrsource4(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (&zone->xfrsource4);
+ return &zone->xfrsource4;
}
isc_result_t
zone->xfrsource6 = *xfrsource;
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_sockaddr_t *
dns_zone_getxfrsource6(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (&zone->xfrsource6);
+ return &zone->xfrsource6;
}
isc_result_t
zone->altxfrsource4 = *altxfrsource;
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_sockaddr_t *
dns_zone_getaltxfrsource4(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (&zone->altxfrsource4);
+ return &zone->altxfrsource4;
}
isc_result_t
zone->altxfrsource6 = *altxfrsource;
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_sockaddr_t *
dns_zone_getaltxfrsource6(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (&zone->altxfrsource6);
+ return &zone->altxfrsource6;
}
isc_result_t
zone->parentalsrc4 = *parentalsrc;
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_sockaddr_t *
dns_zone_getparentalsrc4(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (&zone->parentalsrc4);
+ return &zone->parentalsrc4;
}
isc_result_t
zone->parentalsrc6 = *parentalsrc;
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_sockaddr_t *
dns_zone_getparentalsrc6(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (&zone->parentalsrc6);
+ return &zone->parentalsrc6;
}
isc_result_t
zone->notifysrc4 = *notifysrc;
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_sockaddr_t *
dns_zone_getnotifysrc4(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (&zone->notifysrc4);
+ return &zone->notifysrc4;
}
isc_result_t
zone->notifysrc6 = *notifysrc;
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_sockaddr_t *
dns_zone_getnotifysrc6(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (&zone->notifysrc6);
+ return &zone->notifysrc6;
}
static bool
for (i = 0; i < count; i++) {
if (!isc_sockaddr_equal(&oldlist[i], &newlist[i])) {
- return (false);
+ return false;
}
}
- return (true);
+ return true;
}
static bool
unsigned int i;
if (oldlist == NULL && newlist == NULL) {
- return (true);
+ return true;
}
if (oldlist == NULL || newlist == NULL) {
- return (false);
+ return false;
}
for (i = 0; i < count; i++) {
if (oldlist[i] == NULL || newlist[i] == NULL ||
!dns_name_equal(oldlist[i], newlist[i]))
{
- return (false);
+ return false;
}
}
- return (true);
+ return true;
}
static void
has_pf(const isc_sockaddr_t *addresses, size_t count, int pf) {
for (size_t i = 0; i < count; i++) {
if (isc_sockaddr_pf(&addresses[i]) == pf) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static void
}
ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
- return (result);
+ return result;
}
void
REQUIRE(LOCKED_ZONE(zone));
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_DUMPING)) {
- return (true);
+ return true;
}
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_DUMPING);
DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NEEDDUMP);
isc_time_settoepoch(&zone->dumptime);
- return (false);
+ return false;
}
/*%
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
/*%
ISC_LIST_UNLINK(dnskeys, key, link);
dns_dnsseckey_destroy(dns_zone_getmctx(zone), &key);
}
- return (result);
+ return result;
}
static isc_result_t
isc_result_t result;
if ((rdata->flags & DNS_RDATA_OFFLINE) != 0) {
- return (ISC_R_SUCCESS);
+ 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);
+ return result;
}
rdata->flags |= DNS_RDATA_OFFLINE;
result = update_one_rr(db, ver, zonediff->diff, DNS_DIFFOP_ADDRESIGN,
name, ttl, rdata);
zonediff->offline = true;
- return (result);
+ return result;
}
static void
}
if (have_pksk && have_pzsk) {
- return (true);
+ return true;
}
/*
* Deleting the SOA RRSIG is always okay.
*/
if (rrsig_ptr->covered == dns_rdatatype_soa) {
- return (true);
+ return true;
}
/*
*/
if (have_pksk || have_pzsk) {
if (kasp && have_pzsk) {
- return (true);
+ return true;
}
- return (!kasp);
+ return !kasp;
}
/*
if ((rrsig_ptr->algorithm == dst_key_alg(keys[i])) &&
(rrsig_ptr->keyid == dst_key_id(keys[i])))
{
- return (false);
+ return false;
}
}
/*
* But if the key is gone, then go ahead.
*/
- return (true);
+ return true;
}
/*
result = dns_db_findnode(db, name, false, &node);
}
if (result == ISC_R_NOTFOUND) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
goto failure;
if (result == ISC_R_NOTFOUND) {
INSIST(!dns_rdataset_isassociated(&rdataset));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
INSIST(!dns_rdataset_isassociated(&rdataset));
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
static isc_result_t
result = dns_db_findnode(db, name, false, &node);
}
if (result == ISC_R_NOTFOUND) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
goto failure;
dns_db_detachnode(db, &node);
if (result == ISC_R_NOTFOUND) {
INSIST(!dns_rdataset_isassociated(&rdataset));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
INSIST(!dns_rdataset_isassociated(&rdataset));
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
static void
if (dbit != NULL) {
dns_dbiterator_destroy(&dbit);
}
- return (result);
+ return result;
}
static bool
type, 0, &rdataset, NULL);
if (result != ISC_R_SUCCESS) {
INSIST(!dns_rdataset_isassociated(&rdataset));
- return (false);
+ return false;
}
for (result = dns_rdataset_first(&rdataset); result == ISC_R_SUCCESS;
result = dns_rdataset_next(&rdataset))
rrsig.keyid == dst_key_id(key))
{
dns_rdataset_disassociate(&rdataset);
- return (true);
+ return true;
}
if (rrsig.algorithm == dst_key_alg(key)) {
count++;
}
dns_rdataset_disassociate(&rdataset);
- return (approved);
+ return approved;
}
dns_rdataset_disassociate(&rdataset);
- return (false);
+ return false;
}
static isc_result_t
CHECK(update_one_rr(db, version, diff, DNS_DIFFOP_ADD, name, ttl,
&rdata));
failure:
- return (result);
+ return result;
}
static isc_result_t
if (result == ISC_R_NOTFOUND) {
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
dns_rdataset_init(&rdataset);
failure:
dns_rdatasetiter_destroy(&iterator);
- return (result);
+ return result;
}
static isc_result_t
if (result == ISC_R_NOTFOUND) {
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
dns_rdataset_init(&rdataset);
if (iterator != NULL) {
dns_rdatasetiter_destroy(&iterator);
}
- return (result);
+ return result;
}
/*
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
static isc_result_t
if (node != NULL) {
dns_db_detachnode(signing->db, &node);
}
- return (result);
+ return result;
}
/*
if (dns_rdataset_isassociated(&rdataset)) {
dns_rdataset_disassociate(&rdataset);
}
- return (result);
+ return result;
}
static isc_result_t
result = dns_db_findrdataset(db, node, ver, dns_rdatatype_nsec, 0, 0,
&rdataset, NULL);
if (result == ISC_R_NOTFOUND) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (result = dns_rdataset_first(&rdataset); result == ISC_R_SUCCESS;
result = dns_rdataset_next(&rdataset))
}
failure:
dns_rdataset_disassociate(&rdataset);
- return (result);
+ return result;
}
static isc_result_t
result = dns_db_findrdataset(db, node, ver, dns_rdatatype_nsec3, 0, 0,
&rdataset, NULL);
if (result == ISC_R_NOTFOUND) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (result = dns_rdataset_first(&rdataset); result == ISC_R_SUCCESS;
}
failure:
dns_rdataset_disassociate(&rdataset);
- return (result);
+ return result;
}
static isc_result_t
if (result == ISC_R_SUCCESS) {
dns_rdataset_disassociate(&rdataset);
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
if (result != ISC_R_NOTFOUND) {
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
result = dns_db_findrdataset(db, node, ver, dns_rdatatype_nsec3param, 0,
if (result == ISC_R_NOTFOUND) {
*answer = true;
dns_db_detachnode(db, &node);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
for (result = dns_rdataset_first(&rdataset); result == ISC_R_SUCCESS;
dns_rdataset_disassociate(&rdataset);
}
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
/*%
if (cur->rdata.type == next->rdata.type &&
dns_name_equal(&cur->name, &next->name))
{
- return (next);
+ return next;
}
}
- return (NULL);
+ return NULL;
}
/*%
dns_zone_log(zone, ISC_LOG_ERROR,
"dns__zone_updatesigs:del_sigs -> %s",
isc_result_totext(result));
- return (result);
+ return result;
}
result = add_sigs(db, version, &tuple->name, zone,
tuple->rdata.type, zonediff->diff, zone_keys,
dns_zone_log(zone, ISC_LOG_ERROR,
"dns__zone_updatesigs:add_sigs -> %s",
isc_result_totext(result));
- return (result);
+ return result;
}
/*
*/
move_matching_tuples(tuple, diff, zonediff->diff);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (result == ISC_R_NOTFOUND) {
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
dns_rdataset_init(&rdataset);
dns_rdataset_disassociate(&rdataset);
}
dns_rdatasetiter_destroy(&iterator);
- return (result);
+ return result;
}
/*
goto failure;
}
- return (true);
+ return true;
failure:
- return (false);
+ return false;
}
/*
case dns_rdatatype_keydata:
result = dns_rdata_tostruct(rr, &keydata, NULL);
if (result == ISC_R_UNEXPECTEDEND) {
- return (result);
+ return result;
}
RUNTIME_CHECK(result == ISC_R_SUCCESS);
dns_keydata_todnskey(&keydata, &dnskey, NULL);
default:
UNREACHABLE();
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
result = normalize_key(rr, &rdata1, data1, sizeof(data1));
if (result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
for (result = dns_rdataset_first(rdset); result == ISC_R_SUCCESS;
continue;
}
if (dns_rdata_compare(&rdata1, &rdata2) == 0) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
/*
if (dns_rdataset_isassociated(&kfetch->dnskeysigset)) {
rdset = &kfetch->dnskeysigset;
} else {
- return (now + dns_zone_mkey_hour);
+ return now + dns_zone_mkey_hour;
}
result = dns_rdataset_first(rdset);
if (result != ISC_R_SUCCESS) {
- return (now + dns_zone_mkey_hour);
+ return now + dns_zone_mkey_hour;
}
dns_rdataset_current(rdset, &sigrr);
}
}
- return (now + t);
+ return now + t;
}
/*
}
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
/*
&dnskey, &keyb);
result = dns_dnssec_keyfromrdata(keyname, &rr, mctx, &dstkey);
if (result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
/* See if that key generated any of the signatures */
}
dst_key_free(&dstkey);
- return (answer);
+ return answer;
}
/*
if (result == ISC_R_NOTFOUND) {
dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(3),
"no journal file, but that's OK ");
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (result != ISC_R_SUCCESS) {
dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR,
"journal open failed: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
if (dns_journal_empty(journal)) {
dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(1),
"journal empty");
dns_journal_destroy(&journal);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = dns_journal_rollforward(journal, db, options);
}
dns_journal_destroy(&journal);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
case ISC_R_NOTFOUND:
case ISC_R_RANGE:
dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR,
"journal rollforward failed: journal out of sync "
"with zone");
dns_journal_destroy(&journal);
- return (result);
+ return result;
default:
dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR,
"journal rollforward failed: %s",
isc_result_totext(result));
dns_journal_destroy(&journal);
- return (result);
+ return result;
}
}
if (!dumping) {
result = zone_dump(zone, true); /* Unknown task. */
}
- return (result);
+ return result;
}
isc_result_t
if (!dumping) {
result = zone_dump(zone, false); /* Unknown task. */
}
- return (result);
+ return result;
}
static void
masterfile = NULL;
if (result == DNS_R_CONTINUE) {
- return (ISC_R_SUCCESS); /* XXXMPA */
+ return ISC_R_SUCCESS; /* XXXMPA */
}
again = false;
goto redo;
}
- return (result);
+ return result;
}
static isc_result_t
}
ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
if (db == NULL) {
- return (DNS_R_NOTLOADED);
+ return DNS_R_NOTLOADED;
}
dns_db_currentversion(db, &version);
&rawdata, fd);
dns_db_closeversion(db, &version, false);
dns_db_detach(&db);
- return (result);
+ return result;
}
isc_result_t
dns_zone_dumptostream(dns_zone_t *zone, FILE *fd, dns_masterformat_t format,
const dns_master_style_t *style,
const uint32_t rawversion) {
- return (dumptostream(zone, fd, style, format, rawversion));
+ return dumptostream(zone, fd, style, format, rawversion);
}
void
dns_zone_getmaxrecords(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->maxrecords);
+ return zone->maxrecords;
}
void
goto requeue;
}
}
- return (false);
+ return false;
requeue:
/*
result = isc_ratelimiter_dequeue(zmgr->startupnotifyrl,
notify->event);
if (result != ISC_R_SUCCESS) {
- return (true);
+ return true;
}
notify->flags &= ~DNS_NOTIFY_STARTUP;
¬ify->event);
if (result != ISC_R_SUCCESS) {
isc_event_free(¬ify->event);
- return (false);
+ return false;
}
}
- return (true);
+ return true;
}
static bool
isc_result_t result;
if (zone->view == NULL || zone->isself == NULL) {
- return (false);
+ return false;
}
switch (isc_sockaddr_pf(dst)) {
isc_sockaddr_any6(&any);
break;
default:
- return (false);
+ return false;
}
/*
isc_netaddr_fromsockaddr(&dstaddr, dst);
result = dns_view_getpeertsig(zone->view, &dstaddr, &key);
if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND) {
- return (false);
+ return false;
}
isself = (zone->isself)(zone->view, key, &src, dst, zone->rdclass,
zone->isselfarg);
if (key != NULL) {
dns_tsigkey_detach(&key);
}
- return (isself);
+ return isself;
}
static void
ISC_LINK_INIT(notify, link);
notify->magic = NOTIFY_MAGIC;
*notifyp = notify;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
isc_event_free(&e);
notify->event = NULL;
}
- return (result);
+ return result;
}
static void
dns_message_addname(message, qname, DNS_SECTION_QUESTION);
*messagep = message;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (qname != NULL) {
dns_message_puttemprdataset(message, &qrdataset);
}
dns_message_detach(&message);
- return (result);
+ return result;
}
static isc_result_t
result = dns_message_buildopt(message, &rdataset, 0, udpsize, 0,
ednsopts, count);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return (dns_message_setopt(message, rdataset));
+ return dns_message_setopt(message, rdataset);
}
/*
dns_message_detach(&message);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
fail:
dns_name_free(&request->name, zone->mctx);
dns_message_detach(&message);
}
- return (result);
+ return result;
}
static isc_result_t
dns_name_free(ns_name, cb_args->stub->mctx);
isc_mem_put(cb_args->stub->mctx, ns_name, sizeof(*ns_name));
}
- return (result);
+ return result;
}
static void
done:
*messagep = message;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (tempname != NULL) {
dns_message_puttemprdataset(message, &temprdataset);
}
dns_message_detach(&message);
- return (result);
+ return result;
}
isc_result_t
if (inline_secure(zone)) {
result = dns_zone_notifyreceive(zone->raw, from, to, msg);
UNLOCK_ZONE(zone);
- return (result);
+ return result;
}
/*
* We only handle NOTIFY (SOA) at the present.
"NOTIFY with no "
"question section from: %s",
fromtext);
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
dns_zone_log(zone, ISC_LOG_NOTICE,
"NOTIFY zone does not match");
- return (DNS_R_NOTIMP);
+ return DNS_R_NOTIMP;
}
/*
*/
if (zone->type == dns_zone_primary) {
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_netaddr_fromsockaddr(&netaddr, from);
dns_zone_log(zone, ISC_LOG_INFO,
"refused notify from non-primary: %s", fromtext);
inc_stats(zone, dns_zonestatscounter_notifyrej);
- return (DNS_R_REFUSED);
+ return DNS_R_REFUSED;
}
/*
"zone is up to date",
fromtext);
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
}
"refresh check queued",
fromtext);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (have_serial) {
dns_zone_log(zone, ISC_LOG_INFO, "notify from %s: serial %u",
dns_zonemgr_unreachabledel(zone->zmgr, from, to);
}
dns_zone_refresh(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
dns_zone_getnotifyacl(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->notify_acl);
+ return zone->notify_acl;
}
dns_acl_t *
dns_zone_getqueryacl(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->query_acl);
+ return zone->query_acl;
}
dns_acl_t *
dns_zone_getqueryonacl(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->queryon_acl);
+ return zone->queryon_acl;
}
dns_acl_t *
dns_zone_getupdateacl(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->update_acl);
+ return zone->update_acl;
}
dns_acl_t *
dns_zone_getforwardacl(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->forward_acl);
+ return zone->forward_acl;
}
dns_acl_t *
dns_zone_getxfracl(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->xfr_acl);
+ return zone->xfr_acl;
}
void
bool
dns_zone_getupdatedisabled(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->update_disabled);
+ return zone->update_disabled;
}
void
bool
dns_zone_getzeronosoattl(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->zero_no_soa_ttl);
+ return zone->zero_no_soa_ttl;
}
void
dns_zone_getchecknames(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->check_names);
+ return zone->check_names;
}
void
dns_zone_getjournalsize(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->journalsize);
+ return zone->journalsize;
}
static void
result = dns_message_nextname(msg, section);
}
- return (count);
+ return count;
}
void
dns_zone_getmaxxfrin(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->maxxfrin);
+ return zone->maxxfrin;
}
void
dns_zone_getmaxxfrout(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->maxxfrout);
+ return zone->maxxfrout;
}
dns_zonetype_t
dns_zone_gettype(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->type);
+ return zone->type;
}
const char *
dns_zonetype_name(dns_zonetype_t type) {
switch (type) {
case dns_zone_none:
- return ("none");
+ return "none";
case dns_zone_primary:
- return ("primary");
+ return "primary";
case dns_zone_secondary:
- return ("secondary");
+ return "secondary";
case dns_zone_mirror:
- return ("mirror");
+ return "mirror";
case dns_zone_stub:
- return ("stub");
+ return "stub";
case dns_zone_staticstub:
- return ("static-stub");
+ return "static-stub";
case dns_zone_key:
- return ("key");
+ return "key";
case dns_zone_dlz:
- return ("dlz");
+ return "dlz";
case dns_zone_redirect:
- return ("redirect");
+ return "redirect";
default:
- return ("unknown");
+ return "unknown";
}
}
REQUIRE(DNS_ZONE_VALID(zone));
REQUIRE(zone->type == dns_zone_redirect);
- return (zone->primaries == NULL ? dns_zone_primary
- : dns_zone_secondary);
+ return zone->primaries == NULL ? dns_zone_primary : dns_zone_secondary;
}
dns_name_t *
dns_zone_getorigin(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (&zone->origin);
+ return &zone->origin;
}
void
dns_zone_getidlein(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->idlein);
+ return zone->idlein;
}
void
dns_zone_getidleout(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->idleout);
+ return zone->idleout;
}
static void
dns_zone_log(zone, ISC_LOG_ERROR,
"dns_dnssec_keyfromrdata() failed: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
for (dns_dnsseckey_t *k = ISC_LIST_HEAD(*keylist); k != NULL;
}
dst_key_free(&dstkey);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_zone_log(zone, ISC_LOG_ERROR,
"dns_rdata_tostruct(cdnskey) failed: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
for (dns_dnsseckey_t *k = ISC_LIST_HEAD(*keylist); k != NULL;
dns_zone_log(zone, ISC_LOG_ERROR,
"dns_dnssec_make_dnskey() failed: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
cdnskeyrdata.type = dns_rdatatype_cdnskey;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_zone_log(zone, ISC_LOG_ERROR,
"dns_rdata_tostruct(cds) failed: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
for (dns_dnsseckey_t *k = ISC_LIST_HEAD(*keylist); k != NULL;
dns_zone_log(zone, ISC_LOG_ERROR,
"dns_dnssec_make_dnskey() failed: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
result = dns_ds_buildrdata(dns_zone_getorigin(zone), &dnskey,
cds.digest_type, cdsbuf, &cdsrdata);
cds.key_tag, cds.algorithm,
cds.digest_type,
isc_result_totext(result));
- return (result);
+ return result;
}
cdsrdata.type = dns_rdatatype_cds;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
now, mctx, &keylist);
dns_zone_unlock_keyfiles(zone);
if (result == ISC_R_NOTFOUND) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"dns_dnssec_findmatchingkeys() failed: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
switch (rdata->type) {
ISC_LIST_UNLINK(keylist, key, link);
dns_dnsseckey_destroy(mctx, &key);
}
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(soatuplep != NULL);
if (start == end) {
- return (DNS_R_UNCHANGED);
+ return DNS_R_UNCHANGED;
}
CHECK(dns_journal_iter_init(journal, start, end, NULL));
dns_zone_log(raw, ISC_LOG_ERROR,
"corrupt journal file: '%s'\n",
raw->journal);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (zone->privatetype != 0 && rdata->type == zone->privatetype)
}
failure:
- return (result);
+ return result;
}
/*
REQUIRE(soatuple != NULL && *soatuple == NULL);
if (!seczone->sourceserialset) {
- return (DNS_R_UNCHANGED);
+ return DNS_R_UNCHANGED;
}
dns_db_attach(raw->db, &rawdb);
dns_db_detach(&rawdb);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
ISC_LIST_APPENDLIST(diff->tuples, cdsadd, link);
if (ISC_LIST_EMPTY(diff->tuples)) {
- return (DNS_R_UNCHANGED);
+ return DNS_R_UNCHANGED;
}
/*
*soatuple = newtuple;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
isc_task_send(zone->secure->task, &e);
DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_SENDSECURE);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
RUNTIME_CHECK(result == ISC_R_SUCCESS);
if (isc_serial_gt(soa.serial, oldserial)) {
- return (dns_db_addrdataset(db, node, version, 0, rdataset, 0,
- NULL));
+ return dns_db_addrdataset(db, node, version, 0, rdataset, 0,
+ NULL);
}
/*
* Always bump the serial.
RUNTIME_CHECK(result == ISC_R_SUCCESS);
dns_rdataset_getownercase(rdataset, name);
dns_rdataset_setownercase(&temprdataset, name);
- return (dns_db_addrdataset(db, node, version, 0, &temprdataset, 0,
- NULL));
+ return dns_db_addrdataset(db, node, version, 0, &temprdataset, 0, NULL);
}
/*
if (dns_rdataset_isassociated(&prdataset)) {
dns_rdataset_disassociate(&prdataset);
}
- return (result);
+ return result;
}
/*
}
dns_diff_clear(&diff);
- return (result);
+ return result;
}
static isc_result_t
result = dns_dbiterator_current(dbiterator, &rawnode, name);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_dbiterator_pause(dbiterator);
if (node) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
static void
zone_iattach(zone->secure, &secure);
isc_task_send(zone->secure->task, &e);
DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_SENDSECURE);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
UNLOCK_ZONE(secure);
}
UNLOCK_ZONE(zone);
- return (result);
+ return result;
}
static isc_result_t
result = DNS_R_BADZONE;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
} else {
dns_zone_log(zone, ISC_LOG_ERROR,
"retrieving SOA and NS records failed: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
result = check_nsec3param(zone, db);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
ver = NULL;
dns_db_setmaxrrperset(zone->db, zone->maxrrperset);
dns_db_setmaxtypepername(zone->db, zone->maxtypepername);
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_LOADED | DNS_ZONEFLG_NEEDNOTIFY);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
fail:
dns_db_closeversion(db, &ver, false);
- return (result);
+ return result;
}
/* The caller must hold the dblock as a writer. */
dns_zone_getsigvalidityinterval(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->sigvalidityinterval);
+ return zone->sigvalidityinterval;
}
void
dns_zone_getkeyvalidityinterval(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->keyvalidityinterval);
+ return zone->keyvalidityinterval;
}
void
dns_zone_getsigresigninginterval(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->sigresigninginterval);
+ return zone->sigresigninginterval;
}
static void
if (DNS_ZONE_FLAG(forward->zone, DNS_ZONEFLG_EXITING)) {
UNLOCK_ZONE(forward->zone);
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
next:
if (forward->which >= forward->zone->primariescnt) {
UNLOCK_ZONE(forward->zone);
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
forward->addr = forward->zone->primaries[forward->which];
unlock:
UNLOCK_ZONE(forward->zone);
- return (result);
+ return result;
}
static void
if (result != ISC_R_SUCCESS) {
forward_destroy(forward);
}
- return (result);
+ return result;
}
isc_result_t
*next = ISC_LIST_NEXT(zone, link);
if (*next == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
*first = ISC_LIST_HEAD(zmgr->zones);
if (*first == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
static uint32_t
hash_index(uint32_t val, uint32_t bits) {
- return (val * GOLDEN_RATIO_32 >> (32 - bits));
+ return val * GOLDEN_RATIO_32 >> (32 - bits);
}
static uint32_t
while (count >= HASHSIZE(newbits) && newbits < KEYMGMT_BITS_MAX) {
newbits++;
}
- return (newbits);
+ return newbits;
}
static uint32_t
while (count <= HASHSIZE(newbits) && newbits > KEYMGMT_BITS_MIN) {
newbits--;
}
- return (newbits);
+ return newbits;
}
static void
zmgr->magic = ZONEMGR_MAGIC;
*zmgrp = zmgr;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#if 0
free_iolock:
isc_rwlock_destroy(&zmgr->rwlock);
isc_mem_put(zmgr->mctx, zmgr, sizeof(*zmgr));
isc_mem_detach(&mctx);
- return (result);
+ return result;
}
isc_result_t
REQUIRE(zonep != NULL && *zonep == NULL);
if (zmgr->mctxpool == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
item = isc_pool_get(zmgr->mctxpool);
if (item == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
isc_mem_attach((isc_mem_t *)item, &mctx);
*zonep = zone;
}
- return (result);
+ return result;
}
isc_result_t
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
if (zmgr->zonetasks == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
RWLOCK(&zmgr->rwlock, isc_rwlocktype_write);
unlock:
UNLOCK_ZONE(zone);
RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_write);
- return (result);
+ return result;
}
void
RWLOCK(&zmgr->rwlock, isc_rwlocktype_write);
zmgr_resume_xfrs(zmgr, true);
RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_write);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_mem_setname(mctx, "zonemgr-pool");
*target = mctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
zmgr->mctxpool = mctxpool;
}
- return (result);
+ return result;
}
static void
dns_zonemgr_gettransfersin(dns_zonemgr_t *zmgr) {
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
- return (zmgr->transfersin);
+ return zmgr->transfersin;
}
void
dns_zonemgr_gettransfersperns(dns_zonemgr_t *zmgr) {
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
- return (zmgr->transfersperns);
+ return zmgr->transfersperns;
}
isc_taskmgr_t *
dns_zonemgr_gettaskmgr(dns_zonemgr_t *zmgr) {
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
- return (zmgr->taskmgr);
+ return zmgr->taskmgr;
}
isc_timermgr_t *
dns_zonemgr_gettimermgr(dns_zonemgr_t *zmgr) {
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
- return (zmgr->timermgr);
+ return zmgr->timermgr;
}
/*
/* Enforce quota. */
if (nxfrsin >= maxtransfersin) {
- return (ISC_R_QUOTA);
+ return ISC_R_QUOTA;
}
if (nxfrsperns >= maxtransfersperns) {
- return (ISC_R_QUOTA);
+ return ISC_R_QUOTA;
}
gotquota:
"Transfer started.");
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
dns_zonemgr_getiolimit(dns_zonemgr_t *zmgr) {
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
- return (zmgr->iolimit);
+ return zmgr->iolimit;
}
/*
if (!queue) {
isc_task_send(io->task, &io->event);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
dns_zonemgr_getnotifyrate(dns_zonemgr_t *zmgr) {
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
- return (zmgr->notifyrate);
+ return zmgr->notifyrate;
}
unsigned int
dns_zonemgr_getstartupnotifyrate(dns_zonemgr_t *zmgr) {
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
- return (zmgr->startupnotifyrate);
+ return zmgr->startupnotifyrate;
}
unsigned int
dns_zonemgr_getserialqueryrate(dns_zonemgr_t *zmgr) {
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
- return (zmgr->serialqueryrate);
+ return zmgr->serialqueryrate;
}
bool
}
}
RWUNLOCK(&zmgr->urlock, isc_rwlocktype_read);
- return (i < UNREACH_CACHE_SIZE && count > 1U);
+ return i < UNREACH_CACHE_SIZE && count > 1U;
}
void
dns_zone_isforced(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_FORCEXFER));
+ return DNS_ZONE_FLAG(zone, DNS_ZONEFLG_FORCEXFER);
}
isc_result_t
*/
UNUSED(zone);
UNUSED(on);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
uint64_t *
* This function is obsoleted.
*/
UNUSED(zone);
- return (NULL);
+ return NULL;
}
void
dns_zone_getdnssecsignstats(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->dnssecsignstats);
+ return zone->dnssecsignstats;
}
isc_stats_t *
* installed, but it shouldn't matter much in practice.
*/
if (zone->requeststats_on) {
- return (zone->requeststats);
+ return zone->requeststats;
} else {
- return (NULL);
+ return NULL;
}
}
dns_stats_t *
dns_zone_getrcvquerystats(dns_zone_t *zone) {
if (zone->requeststats_on) {
- return (zone->rcvquerystats);
+ return zone->rcvquerystats;
} else {
- return (NULL);
+ return NULL;
}
}
result = dns_zone_setstring(zone, &zone->keydirectory, directory);
UNLOCK_ZONE(zone);
- return (result);
+ return result;
}
const char *
dns_zone_getkeydirectory(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->keydirectory);
+ return zone->keydirectory;
}
unsigned int
RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_read);
- return (count);
+ return count;
}
void
if (!DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKNAMES) &&
rdata->type != dns_rdatatype_nsec3)
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKNAMESFAIL) ||
dns_zone_log(zone, level, "%s/%s: %s", namebuf, typebuf,
isc_result_totext(DNS_R_BADOWNERNAME));
if (fail) {
- return (DNS_R_BADOWNERNAME);
+ return DNS_R_BADOWNERNAME;
}
}
dns_zone_log(zone, level, "%s/%s: %s: %s ", namebuf, typebuf,
namebuf2, isc_result_totext(DNS_R_BADNAME));
if (fail) {
- return (DNS_R_BADNAME);
+ return DNS_R_BADNAME;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
dns_zone_getnotifydelay(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->notifydelay);
+ return zone->notifydelay;
}
isc_result_t
result = zone_signwithkey(zone, algorithm, keyid, deleteit);
UNLOCK_ZONE(zone);
- return (result);
+ return result;
}
/*
result = zone_addnsec3chain(zone, nsec3param);
UNLOCK_ZONE(zone);
- return (result);
+ return result;
}
void
uint32_t
dns_zone_getsignatures(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->signatures);
+ return zone->signatures;
}
void
dns_rdatatype_t
dns_zone_getprivatetype(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->privatetype);
+ return zone->privatetype;
}
static isc_result_t
if (db != NULL) {
dns_db_detach(&db);
}
- return (result);
+ return result;
}
/* Called once; *timep should be set to the current time. */
if (then != 0) {
*timep = then;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
static isc_result_t
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
/*
INSIST(ISC_LIST_EMPTY(add));
INSIST(ISC_LIST_EMPTY(del));
INSIST(ISC_LIST_EMPTY(tuples));
- return (result);
+ return result;
}
/*
dnssec_log(zone, ISC_LOG_ERROR,
"sign_apex:del_sigs -> %s",
isc_result_totext(result));
- return (result);
+ return result;
}
result = add_sigs(db, ver, &zone->origin, zone, rrtype,
zonediff->diff, keys, nkeys, zone->mctx, now,
dnssec_log(zone, ISC_LOG_ERROR,
"sign_apex:add_sigs -> %s",
isc_result_totext(result));
- return (result);
+ return result;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dnssec_log(zone, ISC_LOG_ERROR,
"sign_apex:dns__zone_findkeys -> %s",
isc_result_totext(result));
- return (result);
+ return result;
}
inception = now - 3600; /* Allow for clock skew. */
for (i = 0; i < nkeys; i++) {
dst_key_free(&zone_keys[i]);
}
- return (result);
+ return result;
}
static isc_result_t
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
/*
REQUIRE(rdataset == NULL || rdataset->type == dns_rdatatype_rrsig);
if (rdataset == NULL || !dns_rdataset_isassociated(rdataset)) {
- return (false);
+ return false;
}
for (result = dns_rdataset_first(rdataset); result == ISC_R_SUCCESS;
RUNTIME_CHECK(result == ISC_R_SUCCESS);
dns_rdata_reset(&rdata);
if (rrsig.algorithm == alg) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static isc_result_t
CHECK(updatesecure(db, ver, origin, zone_nsecttl(zone), true, diff));
failure:
- return (result);
+ return result;
}
static void
isc_buffer_init(&b, buf, bufsize);
result = dst_key_todns(key, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdata_reset(target);
isc_buffer_usedregion(&b, &r);
dns_rdata_fromregion(target, dst_key_class(key), dns_rdatatype_dnskey,
&r);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
/* Validate DS RRset. */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
if (addr != NULL && isc_sockaddr_equal(addr, &checkds->dst) &&
checkds->key == key && checkds->transport == transport)
{
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static isc_result_t
ISC_LINK_INIT(checkds, link);
checkds->magic = CHECKDS_MAGIC;
*checkdsp = checkds;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
temprdataset = NULL;
*messagep = message;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (tempname != NULL) {
dns_message_puttemprdataset(message, &temprdataset);
}
dns_message_detach(&message);
- return (result);
+ return result;
}
static void
isc_event_free(&e);
checkds->event = NULL;
}
- return (result);
+ return result;
}
static void
result = dns_difftuple_create(diff->mctx, DNS_DIFFOP_DEL, name,
rdataset->ttl, &rdata, &tuple);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_diff_appendminimal(diff, &tuple);
}
if (result != ISC_R_NOMORE) {
- return (result);
+ return result;
}
/*
result = dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, name,
ttl, &rdata, &tuple);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_diff_appendminimal(diff, &tuple);
}
if (result != ISC_R_NOMORE) {
- return (result);
+ return result;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dnssec_log(zone, ISC_LOG_DEBUG(1),
"verifykeys: key %s - not available",
keystr);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
/* All good. */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
result = dns_db_getoriginnode(db, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = zone_count_ns_rr(zone, db, node, version, NULL, errors, false);
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
isc_result_t
result = dns_db_getoriginnode(db, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_init(&cds);
dns_rdataset_disassociate(&cdnskey);
}
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
void
bool
dns_zone_getautomatic(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->automatic);
+ return zone->automatic;
}
void
bool
dns_zone_getadded(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->added);
+ return zone->added;
}
isc_result_t
UNLOCK_ZONE(secure);
}
UNLOCK_ZONE(zone);
- return (result);
+ return result;
}
isc_result_t
dns_zone_setrefreshkeyinterval(dns_zone_t *zone, uint32_t interval) {
REQUIRE(DNS_ZONE_VALID(zone));
if (interval == 0) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
/* Maximum value: 24 hours (3600 minutes) */
if (interval > (24 * 60)) {
}
/* Multiply by 60 for seconds */
zone->refreshkeyinterval = interval * 60;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
bool
dns_zone_getrequestixfr(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->requestixfr);
+ return zone->requestixfr;
}
void
uint32_t
dns_zone_getixfrratio(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->ixfr_ratio);
+ return zone->ixfr_ratio;
}
void
bool
dns_zone_getrequestexpire(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->requestexpire);
+ return zone->requestexpire;
}
void
dns_updatemethod_t
dns_zone_getserialupdatemethod(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->updatemethod);
+ return zone->updatemethod;
}
/*
UNLOCK_ZONE(raw);
UNLOCK_ZONE(zone);
RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_write);
- return (result);
+ return result;
}
void
isc_event_free(&e);
}
UNLOCK_ZONE(zone);
- return (result);
+ return result;
}
/*
dns_db_detach(&db);
}
- return (result);
+ return result;
}
/*
saltbuf, resalt);
if (result == ISC_R_SUCCESS) {
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
* Schedule lookup if lookup above failed (may happen if zone
isc_event_free(&e);
}
UNLOCK_ZONE(zone);
- return (result);
+ return result;
}
isc_result_t
LOCK_ZONE(zone);
*loadtime = zone->loadtime;
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
LOCK_ZONE(zone);
*expiretime = zone->expiretime;
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
LOCK_ZONE(zone);
*refreshtime = zone->refreshtime;
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
LOCK_ZONE(zone);
*refreshkeytime = zone->refreshkeytime;
UNLOCK_ZONE(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
unsigned int
done:
UNLOCK_ZONE(zone);
- return (n);
+ return n;
}
void
dns_zone_getstatlevel(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->statlevel);
+ return zone->statlevel;
}
static void
isc_event_free(&e);
}
UNLOCK_ZONE(zone);
- return (result);
+ return result;
}
isc_stats_t *
dns_zone_getgluecachestats(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->gluecachestats);
+ return zone->gluecachestats;
}
bool
dns_zone_isloaded(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED));
+ return DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED);
}
isc_result_t
ENTER;
if (dns_zone_gettype(zone) != dns_zone_mirror) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (ver == NULL) {
result = DNS_R_VERIFYFAILURE;
}
- return (result);
+ return result;
}
static dns_ttl_t
zone_nsecttl(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (ISC_MIN(zone->minimum, zone->soattl));
+ return ISC_MIN(zone->minimum, zone->soattl);
}
void
: dns_dbtype_zone,
zone->rdclass, zone->db_argc - 1, zone->db_argv + 1, &db);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
switch (zone->type) {
}
if (result != ISC_R_SUCCESS) {
dns_db_detach(&db);
- return (result);
+ return result;
}
break;
default:
*dbp = db;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = dns_rdata_tostruct(keyrdata, &key, NULL);
if (result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
if ((key.flags & DNS_KEYTYPE_NOAUTH) != 0) {
iszonekey = false;
}
- return (iszonekey);
+ return iszonekey;
}
*/
static size_t
chain_length(struct nsec3_chain_fixed *chain) {
- return (chain->salt_length + 2 * chain->next_length);
+ return chain->salt_length + 2 * chain->next_length;
}
/*%
isc_result_t result;
if (dns_name_equal(name, vctx->origin)) {
- return (false);
+ return false;
}
dns_rdataset_init(&nsset);
dns_rdataset_disassociate(&nsset);
}
- return ((result == ISC_R_SUCCESS));
+ return result == ISC_R_SUCCESS;
}
/*%
dns_rdataset_disassociate(&dnameset);
}
- return ((result == ISC_R_SUCCESS));
+ return result == ISC_R_SUCCESS;
}
static bool
result = dns_dnssec_verify(name, rdataset, dstkeys[key], false,
0, vctx->mctx, sigrdata, NULL);
if (result == ISC_R_SUCCESS || result == DNS_R_FROMWILDCARD) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static bool
if (nsec->len != tmpnsec.len ||
memcmp(nsec->typebits, tmpnsec.typebits, nsec->len) != 0)
{
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static isc_result_t
dns_rdataset_disassociate(&rdataset);
}
- return (result);
+ return result;
}
static isc_result_t
if (result != ISC_R_SUCCESS) {
zoneverify_log_error(vctx, "dns_db_allrdatasets(): %s",
isc_result_totext(result));
- return (result);
+ return result;
}
for (result = dns_rdatasetiter_first(rdsiter); result == ISC_R_SUCCESS;
result = dns_rdatasetiter_next(rdsiter))
}
dns_rdatasetiter_destroy(&rdsiter);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
* Do each element in turn to get a stable sort.
*/
if (e1->hash < e2->hash) {
- return (true);
+ return true;
}
if (e1->hash > e2->hash) {
- return (false);
+ return false;
}
if (e1->iterations < e2->iterations) {
- return (true);
+ return true;
}
if (e1->iterations > e2->iterations) {
- return (false);
+ return false;
}
if (e1->salt_length < e2->salt_length) {
- return (true);
+ return true;
}
if (e1->salt_length > e2->salt_length) {
- return (false);
+ return false;
}
if (e1->next_length < e2->next_length) {
- return (true);
+ return true;
}
if (e1->next_length > e2->next_length) {
- return (false);
+ return false;
}
if (memcmp(e1 + 1, e2 + 1, chain_length(e1)) < 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static bool
chain_equal(const struct nsec3_chain_fixed *e1,
const struct nsec3_chain_fixed *e2, size_t data_length) {
if (e1->hash != e2->hash) {
- return (false);
+ return false;
}
if (e1->iterations != e2->iterations) {
- return (false);
+ return false;
}
if (e1->salt_length != e2->salt_length) {
- return (false);
+ return false;
}
if (e1->next_length != e2->next_length) {
- return (false);
+ return false;
}
- return (memcmp(e1 + 1, e2 + 1, data_length) == 0);
+ return memcmp(e1 + 1, e2 + 1, data_length) == 0;
}
static void
memcmp(nsec3_match->salt, nsec3param->salt,
nsec3param->salt_length) == 0)
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return (result);
+ return result;
}
static isc_result_t
zoneverify_log_error(vctx, "Missing NSEC3 record for %s",
namebuf);
*vresult = result;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
"mismatch",
namebuf);
*vresult = ISC_R_FAILURE;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
"same parameter set for %s",
namebuf);
*vresult = DNS_R_DUPLICATE;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
if (result != ISC_R_NOMORE) {
- return (result);
+ return result;
}
*vresult = ISC_R_SUCCESS;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
memcmp(nsec3param.salt, nsec3->salt, nsec3->salt_length) ==
0)
{
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static isc_result_t
if (nsec3paramset == NULL || !dns_rdataset_isassociated(nsec3paramset))
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_rdataset_init(&rdataset);
dns_rdatatype_nsec3, 0, 0, &rdataset,
NULL);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_name_getlabel(name, 0, &hashlabel);
cleanup:
dns_rdataset_disassociate(&rdataset);
- return (result);
+ return result;
}
static isc_result_t
if (result != ISC_R_SUCCESS) {
zoneverify_log_error(vctx, "dns_nsec3_hashname(): %s",
isc_result_totext(result));
- return (result);
+ return result;
}
dns_rdataset_init(&rdataset);
dns_db_detachnode(vctx->db, &node);
}
- return (result);
+ return result;
}
static isc_result_t
RUNTIME_CHECK(result == ISC_R_SUCCESS);
if (nsec3param.flags != 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (!dns_nsec3_supportedhash(nsec3param.hash)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (nsec3param.iterations > DNS_NSEC3_MAXITERATIONS) {
result = DNS_R_NSEC3ITERRANGE;
zoneverify_log_error(vctx, "verifynsec3: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
result = isoptout(vctx, &nsec3param, &optout);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_fixedname_init(&fixed);
if (result != ISC_R_SUCCESS) {
zoneverify_log_error(vctx, "dns_nsec3_hashname(): %s",
isc_result_totext(result));
- return (result);
+ return result;
}
/*
dns_db_detachnode(vctx->db, &node);
}
- return (result);
+ return result;
}
static isc_result_t
result = verifynsec3(vctx, name, &rdata, delegation, empty,
types, maxtype, vresult);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (*vresult != ISC_R_SUCCESS) {
break;
if (result == ISC_R_NOMORE) {
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
static isc_result_t
if (result != ISC_R_SUCCESS) {
zoneverify_log_error(vctx, "dns_db_allrdatasets(): %s",
isc_result_totext(result));
- return (result);
+ return result;
}
for (result = dns_rdatasetiter_first(rdsiter); result == ISC_R_SUCCESS;
result = dns_rdatasetiter_next(rdsiter))
}
dns_rdatasetiter_destroy(&rdsiter);
- return (result);
+ return result;
}
static isc_result_t
if (result != ISC_R_SUCCESS) {
zoneverify_log_error(vctx, "dns_db_allrdatasets(): %s",
isc_result_totext(result));
- return (result);
+ return result;
}
result = dns_rdatasetiter_first(rdsiter);
if (result != ISC_R_SUCCESS) {
dns_rdataset_disassociate(&rdataset);
dns_rdatasetiter_destroy(&rdsiter);
- return (result);
+ return result;
}
dns_nsec_setbit(types, rdataset.type, 1);
if (rdataset.type > maxtype) {
if (result != ISC_R_SUCCESS) {
dns_rdataset_disassociate(&rdataset);
dns_rdatasetiter_destroy(&rdsiter);
- return (result);
+ return result;
}
} else {
dns_nsec_setbit(types, rdataset.type, 1);
if (result != ISC_R_NOMORE) {
zoneverify_log_error(vctx, "rdataset iteration failed: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
if (vresult == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
*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);
+ return result;
}
*vresult = tvresult;
}
result = verifynsec3s(vctx, name, nsec3paramset, delegation,
false, types, maxtype, &tvresult);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (*vresult == ISC_R_SUCCESS) {
*vresult = tvresult;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
if (result != ISC_R_SUCCESS) {
zoneverify_log_error(vctx, "dns_db_allrdatasets(): %s",
isc_result_totext(result));
- return (result);
+ return result;
}
result = dns_rdatasetiter_first(rdsiter);
dns_rdatasetiter_destroy(&rdsiter);
*empty = (result == ISC_R_NOMORE);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdataset_disassociate(&rdataset);
}
- return (nsec_exists ? ISC_R_FAILURE : ISC_R_SUCCESS);
+ return nsec_exists ? ISC_R_FAILURE : ISC_R_SUCCESS;
}
static void
d2 += e->salt_length;
if (memcmp(d1, d2, first->next_length) == 0) {
- return (true);
+ return true;
}
DE_CONST(d1 - first->next_length, sr.base);
zoneverify_log_error(vctx, "Found: %.*s",
(int)isc_buffer_usedlength(&b), buf);
- return (false);
+ return false;
}
static bool
free_element(mctx, prev);
}
- return (result);
+ return result;
}
static bool
}
free_element(mctx, first);
- return (result);
+ return result;
}
static isc_result_t
}
} while (f != NULL);
- return (result);
+ return result;
}
static isc_result_t
reln = dns_name_fullcompare(prevname, name, &order, &labels);
if (order >= 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
nlabels = dns_name_countlabels(name);
vctx, &suffix, nsec3paramset,
isdelegation, true, NULL, 0, &tvresult);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (*vresult == ISC_R_SUCCESS) {
*vresult = tvresult;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
zoneverify_log_error(vctx,
"failed to find the zone's origin: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
result = dns_db_findrdataset(vctx->db, node, vctx->ver,
done:
dns_db_detachnode(vctx->db, &node);
- return (result);
+ return result;
}
/*%
zoneverify_log_error(
vctx, "dns_rdata_totext: %s",
isc_result_totext(result));
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
zoneverify_log_error(
vctx,
namebuf,
(int)isc_buffer_usedlength(&buf),
buffer);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if ((dnskey.flags & DNS_KEYFLAG_KSK) != 0 &&
vctx->revoked_ksk[dnskey.algorithm] !=
dns_rdata_reset(&rdata);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
if (result != ISC_R_SUCCESS) {
zoneverify_log_error(vctx, "dns_db_createiterator(): %s",
isc_result_totext(result));
- return (result);
+ return result;
}
for (result = dns_dbiterator_first(dbiter); result == ISC_R_SUCCESS;
dns_dbiterator_destroy(&dbiter);
}
- return (result);
+ return result;
}
static isc_result_t
report(".");
}
- return (first ? ISC_R_SUCCESS : ISC_R_FAILURE);
+ return first ? ISC_R_SUCCESS : ISC_R_FAILURE;
}
static void
done:
vctx_destroy(&vctx);
- return (result);
+ return result;
}
isc_refcount_init(&zt->loads_pending, 0);
*ztp = zt;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_zt:
isc_mem_put(mctx, zt, sizeof(*zt));
- return (result);
+ return result;
}
isc_result_t
RWUNLOCK(&zt->rwlock, isc_rwlocktype_write);
- return (result);
+ return result;
}
isc_result_t
RWUNLOCK(&zt->rwlock, isc_rwlocktype_write);
- return (result);
+ return result;
}
isc_result_t
RWUNLOCK(&zt->rwlock, isc_rwlocktype_read);
- return (result);
+ return result;
}
void
static isc_result_t
flush(dns_zone_t *zone, void *uap) {
UNUSED(uap);
- return (dns_zone_flush(zone));
+ return dns_zone_flush(zone);
}
static void
params.newonly = newonly;
result = dns_zt_apply(zt, isc_rwlocktype_read, stop, NULL, load,
¶ms);
- return (result);
+ return result;
}
static isc_result_t
{
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
static void
call_loaddone(zt);
}
- return (result);
+ return result;
}
/*
isc_refcount_decrement1(&zt->references);
isc_refcount_decrement1(&zt->loads_pending);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (tresult == ISC_R_NOTFOUND) {
tresult = ISC_R_SUCCESS;
}
- return ((result == ISC_R_SUCCESS) ? tresult : result);
+ return (result == ISC_R_SUCCESS) ? tresult : result;
}
static isc_result_t
if (raw != NULL) {
dns_zone_detach(&raw);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (dns_zone_gettype(zone) != dns_zone_primary) {
if (raw != NULL) {
dns_zone_detach(&raw);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (!dns_zone_isdynamic(zone, true)) {
if (raw != NULL) {
dns_zone_detach(&raw);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
frozen = dns_zone_getupdatedisabled(zone);
if (raw != NULL) {
dns_zone_detach(&raw);
}
- return (result);
+ return result;
}
void
RWUNLOCK(&zt->rwlock, lock);
}
- return (result);
+ return result;
}
/*
zt_destroy(zt);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/***
ch = fgetc(fp);
}
- return (ch);
+ return ch;
}
/*!
ch = eatline(fp);
}
- return (ch);
+ return ch;
}
/*!
ch = eatwhite(fp);
if (ch == EOF) {
- return (EOF);
+ return EOF;
}
do {
if (ch == EOF || isspace((unsigned char)ch)) {
break;
} else if ((size_t)(p - buffer) == size - 1) {
- return (EOF); /* Not enough space. */
+ return EOF; /* Not enough space. */
}
*p++ = (char)ch;
ch = fgetc(fp);
} while (1);
- return (ch);
+ return ch;
}
static isc_result_t
hints.ai_flags = AI_NUMERICHOST;
error = getaddrinfo(address_str, "53", &hints, &res);
if (error != 0) {
- return (ISC_R_BADADDRESSFORM);
+ return ISC_R_BADADDRESSFORM;
}
/* XXX: special case: treat all-0 IPv4 address as loopback */
cleanup:
freeaddrinfo(res);
- return (result);
+ return result;
}
static isc_result_t
memmove(&addr->type.in6, &v6, NS_IN6ADDRSZ);
addr->zone = 0;
} else {
- return (ISC_R_BADADDRESSFORM); /* Unrecognised format. */
+ return ISC_R_BADADDRESSFORM; /* Unrecognised format. */
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
cp = getword(fp, word, sizeof(word));
if (strlen(word) == 0U) {
- return (ISC_R_UNEXPECTEDEND); /* Nothing on line. */
+ return ISC_R_UNEXPECTEDEND; /* Nothing on line. */
} else if (cp == ' ' || cp == '\t') {
cp = eatwhite(fp);
}
if (cp != EOF && cp != '\n') {
- return (ISC_R_UNEXPECTEDTOKEN); /* Extra junk on line. */
+ return ISC_R_UNEXPECTEDTOKEN; /* Extra junk on line. */
}
if (conf->numns == RESCONFMAXNAMESERVERS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = add_server(conf->mctx, word, &conf->nameservers);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
conf->numns++;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
res = getword(fp, word, sizeof(word));
if (strlen(word) == 0U) {
- return (ISC_R_UNEXPECTEDEND); /* Nothing else on line. */
+ return ISC_R_UNEXPECTEDEND; /* Nothing else on line. */
} else if (res == ' ' || res == '\t') {
res = eatwhite(fp);
}
if (res != EOF && res != '\n') {
- return (ISC_R_UNEXPECTEDTOKEN); /* Extra junk on line. */
+ return ISC_R_UNEXPECTEDTOKEN; /* Extra junk on line. */
}
if (conf->domainname != NULL) {
conf->domainname = isc_mem_strdup(conf->mctx, word);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
delim = getword(fp, word, sizeof(word));
if (strlen(word) == 0U) {
- return (ISC_R_UNEXPECTEDEND); /* Nothing else on line. */
+ return ISC_R_UNEXPECTEDEND; /* Nothing else on line. */
}
idx = 0;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
delim = getword(fp, word, sizeof(word));
if (strlen(word) == 0U) {
- return (ISC_R_UNEXPECTEDEND); /* Empty line after keyword. */
+ return ISC_R_UNEXPECTEDEND; /* Empty line after keyword. */
}
while (strlen(word) > 0U) {
if (conf->sortlistnxt == RESCONFMAXSORTLIST) {
- return (ISC_R_QUOTA); /* Too many values. */
+ return ISC_R_QUOTA; /* Too many values. */
}
p = strchr(word, '/');
sizeof(conf->sortlist) / sizeof(conf->sortlist[0]));
res = create_addr(word, &conf->sortlist[idx].addr, 1);
if (res != ISC_R_SUCCESS) {
- return (res);
+ return res;
}
if (p != NULL) {
res = create_addr(p, &conf->sortlist[idx].mask, 0);
if (res != ISC_R_SUCCESS) {
- return (res);
+ return res;
}
} else {
/*
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
n = strtol(word, &p, 10);
if (*p != '\0') { /* Bad string. */
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
if (n < 0 || n > 0xff) { /* Out of range. */
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
*number = n;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
delim = getword(fp, word, sizeof(word));
if (strlen(word) == 0U) {
- return (ISC_R_UNEXPECTEDEND); /* Empty line after keyword. */
+ return ISC_R_UNEXPECTEDEND; /* Empty line after keyword. */
}
while (strlen(word) > 0U) {
}
cleanup:
- return (result);
+ return result;
}
static isc_result_t
ISC_LINK_INIT(entry, link);
ISC_LIST_APPEND(conf->searchlist, entry, link);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*% parses a file and fills in the data structure. */
break;
default:
isc_mem_put(mctx, conf, sizeof(*conf));
- return (ISC_R_INVALIDFILE);
+ return ISC_R_INVALIDFILE;
}
}
*confp = conf;
}
- return (ret);
+ return ret;
}
void
irs_resconf_getnameservers(irs_resconf_t *conf) {
REQUIRE(IRS_RESCONF_VALID(conf));
- return (&conf->nameservers);
+ return &conf->nameservers;
}
irs_resconf_searchlist_t *
irs_resconf_getsearchlist(irs_resconf_t *conf) {
REQUIRE(IRS_RESCONF_VALID(conf));
- return (&conf->searchlist);
+ return &conf->searchlist;
}
unsigned int
irs_resconf_getndots(irs_resconf_t *conf) {
REQUIRE(IRS_RESCONF_VALID(conf));
- return ((unsigned int)conf->ndots);
+ return (unsigned int)conf->ndots;
}
unsigned int
irs_resconf_getattempts(irs_resconf_t *conf) {
REQUIRE(IRS_RESCONF_VALID(conf));
- return ((unsigned int)conf->attempts);
+ return (unsigned int)conf->attempts;
}
unsigned int
irs_resconf_gettimeout(irs_resconf_t *conf) {
REQUIRE(IRS_RESCONF_VALID(conf));
- return ((unsigned int)conf->timeout);
+ return (unsigned int)conf->timeout;
}
FATAL_SYSERROR(presult, "pthread_sigmask()");
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
isc_g_appctx.mctx = NULL;
/* The remaining members will be initialized in ctxstart() */
- return (isc_app_ctxstart(&isc_g_appctx));
+ return isc_app_ctxstart(&isc_g_appctx);
}
isc_result_t
isc_app_onrun(isc_mem_t *mctx, isc_task_t *task, isc_taskaction_t action,
void *arg) {
- return (isc_app_ctxonrun(&isc_g_appctx, mctx, task, action, arg));
+ return isc_app_ctxonrun(&isc_g_appctx, mctx, task, action, arg);
}
isc_result_t
isc_task_t *cloned_task = NULL;
if (atomic_load_acquire(&ctx->running)) {
- return (ISC_R_ALREADYRUNNING);
+ return ISC_R_ALREADYRUNNING;
}
/*
ISC_LIST_APPEND(ctx->on_run, event, ev_link);
UNLOCK(&ctx->lock);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (atomic_compare_exchange_strong_acq_rel(
&ctx->want_reload, &(bool){ true }, false))
{
- return (ISC_R_RELOAD);
+ return ISC_R_RELOAD;
}
if (atomic_load_acquire(&ctx->want_shutdown) &&
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
result = isc_app_ctxrun(&isc_g_appctx);
atomic_store_release(&is_running, false);
- return (result);
+ return result;
}
bool
isc_app_isrunning(void) {
- return (atomic_load_acquire(&is_running));
+ return atomic_load_acquire(&is_running);
}
void
*ctxp = ctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
default:
result = "UNKNOWN";
}
- return (result);
+ return result;
}
/*
isc_mem_attach(mctx, &stack->mctx);
memset(stack->nodes, 0, size * sizeof(uintptr_t));
isc_mutex_init(&stack->lock);
- return (stack);
+ return stack;
}
bool
if (!isc_mutex_trylock(&stack->lock)) {
if (stack->pos >= stack->size) {
UNLOCK(&stack->lock);
- return (false);
+ return false;
}
stack->nodes[stack->pos++] = (uintptr_t)obj;
UNLOCK(&stack->lock);
- return (true);
+ return true;
} else {
- return (false);
+ return false;
}
}
rv = stack->nodes[--stack->pos];
}
UNLOCK(&stack->lock);
- return ((void *)rv);
+ return (void *)rv;
}
void
* See notes in backtrace.h.
*/
if (addrs == NULL || maxaddrs <= 0) {
- return (-1);
+ return -1;
}
/*
*/
n = backtrace(addrs, maxaddrs);
if (n < 2) {
- return (-1);
+ return -1;
}
n--;
memmove(addrs, &addrs[1], sizeof(addrs[0]) * n);
- return (n);
+ return n;
}
char **
isc_backtrace_symbols(void *const *buffer, int size) {
- return (backtrace_symbols(buffer, size));
+ return backtrace_symbols(buffer, size);
}
void
UNUSED(addrs);
UNUSED(maxaddrs);
- return (-1);
+ return -1;
}
char **
UNUSED(buffer);
UNUSED(size);
- return (NULL);
+ return NULL;
}
void
if (source->length > 0) {
isc_region_consume(source, source->length);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
isc_base32_totext(isc_region_t *source, int wordlength, const char *wordbreak,
isc_buffer_t *target) {
- return (base32_totext(source, wordlength, wordbreak, target, base32,
- '='));
+ return base32_totext(source, wordlength, wordbreak, target, base32,
+ '=');
}
isc_result_t
isc_base32hex_totext(isc_region_t *source, int wordlength,
const char *wordbreak, isc_buffer_t *target) {
- return (base32_totext(source, wordlength, wordbreak, target, base32hex,
- '='));
+ return base32_totext(source, wordlength, wordbreak, target, base32hex,
+ '=');
}
isc_result_t
isc_base32hexnp_totext(isc_region_t *source, int wordlength,
const char *wordbreak, isc_buffer_t *target) {
- return (base32_totext(source, wordlength, wordbreak, target, base32hex,
- 0));
+ return base32_totext(source, wordlength, wordbreak, target, base32hex,
+ 0);
}
/*%
unsigned int last;
if (ctx->seen_end) {
- return (ISC_R_BADBASE32);
+ return ISC_R_BADBASE32;
}
if ((s = strchr(ctx->base, c)) == NULL) {
- return (ISC_R_BADBASE32);
+ return ISC_R_BADBASE32;
}
last = (unsigned int)(s - ctx->base);
* Check that padding is contiguous.
*/
if (last != 32 && ctx->seen_32 != 0) {
- return (ISC_R_BADBASE32);
+ return ISC_R_BADBASE32;
}
/*
* If padding is not permitted flag padding as a error.
*/
if (last == 32 && !ctx->pad) {
- return (ISC_R_BADBASE32);
+ return ISC_R_BADBASE32;
}
/*
switch (ctx->digits) {
case 0:
case 1:
- return (ISC_R_BADBASE32);
+ return ISC_R_BADBASE32;
case 2:
if ((ctx->val[1] & 0x03) != 0) {
- return (ISC_R_BADBASE32);
+ return ISC_R_BADBASE32;
}
ctx->seen_32 = 1;
break;
case 3:
- return (ISC_R_BADBASE32);
+ return ISC_R_BADBASE32;
case 4:
if ((ctx->val[3] & 0x0f) != 0) {
- return (ISC_R_BADBASE32);
+ return ISC_R_BADBASE32;
}
ctx->seen_32 = 2;
break;
case 5:
if ((ctx->val[4] & 0x01) != 0) {
- return (ISC_R_BADBASE32);
+ return ISC_R_BADBASE32;
}
ctx->seen_32 = 3;
break;
case 6:
- return (ISC_R_BADBASE32);
+ return ISC_R_BADBASE32;
case 7:
if ((ctx->val[6] & 0x07) != 0) {
- return (ISC_R_BADBASE32);
+ return ISC_R_BADBASE32;
}
ctx->seen_32 = 4;
break;
RETERR(mem_tobuffer(ctx->target, buf, n));
if (ctx->length >= 0) {
if (n > ctx->length) {
- return (ISC_R_BADBASE32);
+ return ISC_R_BADBASE32;
} else {
ctx->length -= n;
}
}
ctx->digits = 0;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
base32_decode_finish(base32_decode_ctx_t *ctx) {
if (ctx->length > 0) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/*
* Add missing padding if required.
} while (ctx->digits != 0);
}
if (ctx->digits != 0) {
- return (ISC_R_BADBASE32);
+ return ISC_R_BADBASE32;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
}
RETERR(base32_decode_finish(&ctx));
if (length == -2 && before == after) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
isc_base32_tobuffer(isc_lex_t *lexer, isc_buffer_t *target, int length) {
- return (base32_tobuffer(lexer, base32, true, target, length));
+ return base32_tobuffer(lexer, base32, true, target, length);
}
isc_result_t
isc_base32hex_tobuffer(isc_lex_t *lexer, isc_buffer_t *target, int length) {
- return (base32_tobuffer(lexer, base32hex, true, target, length));
+ return base32_tobuffer(lexer, base32hex, true, target, length);
}
isc_result_t
isc_base32hexnp_tobuffer(isc_lex_t *lexer, isc_buffer_t *target, int length) {
- return (base32_tobuffer(lexer, base32hex, false, target, length));
+ return base32_tobuffer(lexer, base32hex, false, target, length);
}
static isc_result_t
RETERR(base32_decode_char(&ctx, c));
}
RETERR(base32_decode_finish(&ctx));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
isc_base32_decodestring(const char *cstr, isc_buffer_t *target) {
- return (base32_decodestring(cstr, base32, true, target));
+ return base32_decodestring(cstr, base32, true, target);
}
isc_result_t
isc_base32hex_decodestring(const char *cstr, isc_buffer_t *target) {
- return (base32_decodestring(cstr, base32hex, true, target));
+ return base32_decodestring(cstr, base32hex, true, target);
}
isc_result_t
isc_base32hexnp_decodestring(const char *cstr, isc_buffer_t *target) {
- return (base32_decodestring(cstr, base32hex, false, target));
+ return base32_decodestring(cstr, base32hex, false, target);
}
static isc_result_t
isc_region_consume(source, 1);
}
RETERR(base32_decode_finish(&ctx));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
isc_base32_decoderegion(isc_region_t *source, isc_buffer_t *target) {
- return (base32_decoderegion(source, base32, true, target));
+ return base32_decoderegion(source, base32, true, target);
}
isc_result_t
isc_base32hex_decoderegion(isc_region_t *source, isc_buffer_t *target) {
- return (base32_decoderegion(source, base32hex, true, target));
+ return base32_decoderegion(source, base32hex, true, target);
}
isc_result_t
isc_base32hexnp_decoderegion(isc_region_t *source, isc_buffer_t *target) {
- return (base32_decoderegion(source, base32hex, false, target));
+ return base32_decoderegion(source, base32hex, false, target);
}
static isc_result_t
l = strlen(source);
if (l > region.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, source, l);
isc_buffer_add(target, l);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_availableregion(target, &tr);
if (length > tr.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tr.base, base, length);
isc_buffer_add(target, length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
RETERR(str_totext(buf, target));
isc_region_consume(source, 1);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
const char *s;
if (ctx->seen_end) {
- return (ISC_R_BADBASE64);
+ return ISC_R_BADBASE64;
}
if ((s = strchr(base64, c)) == NULL) {
- return (ISC_R_BADBASE64);
+ return ISC_R_BADBASE64;
}
ctx->val[ctx->digits++] = (int)(s - base64);
if (ctx->digits == 4) {
int n;
unsigned char buf[3];
if (ctx->val[0] == 64 || ctx->val[1] == 64) {
- return (ISC_R_BADBASE64);
+ return ISC_R_BADBASE64;
}
if (ctx->val[2] == 64 && ctx->val[3] != 64) {
- return (ISC_R_BADBASE64);
+ return ISC_R_BADBASE64;
}
/*
* Check that bits that should be zero are.
*/
if (ctx->val[2] == 64 && (ctx->val[1] & 0xf) != 0) {
- return (ISC_R_BADBASE64);
+ return ISC_R_BADBASE64;
}
/*
* We don't need to test for ctx->val[2] != 64 as
* the bottom two bits of 64 are zero.
*/
if (ctx->val[3] == 64 && (ctx->val[2] & 0x3) != 0) {
- return (ISC_R_BADBASE64);
+ return ISC_R_BADBASE64;
}
n = (ctx->val[2] == 64) ? 1 : (ctx->val[3] == 64) ? 2 : 3;
if (n != 3) {
RETERR(mem_tobuffer(ctx->target, buf, n));
if (ctx->length >= 0) {
if (n > ctx->length) {
- return (ISC_R_BADBASE64);
+ return ISC_R_BADBASE64;
} else {
ctx->length -= n;
}
}
ctx->digits = 0;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
base64_decode_finish(base64_decode_ctx_t *ctx) {
if (ctx->length > 0) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (ctx->digits != 0) {
- return (ISC_R_BADBASE64);
+ return ISC_R_BADBASE64;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
RETERR(base64_decode_finish(&ctx));
if (length == -2 && before == after) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
RETERR(base64_decode_char(&ctx, c));
}
RETERR(base64_decode_finish(&ctx));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
l = strlen(source);
if (l > region.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, source, l);
isc_buffer_add(target, l);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_availableregion(target, &tr);
if (length > tr.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tr.base, base, length);
isc_buffer_add(target, length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
b->current += 1;
result = ((uint8_t)(cp[0]));
- return (result);
+ return result;
}
uint16_t
result = ((unsigned int)(cp[0])) << 8;
result |= ((unsigned int)(cp[1]));
- return (result);
+ return result;
}
uint32_t
result |= ((unsigned int)(cp[2])) << 8;
result |= ((unsigned int)(cp[3]));
- return (result);
+ return result;
}
uint64_t
result |= ((int64_t)(cp[4])) << 8;
result |= ((int64_t)(cp[5]));
- return (result);
+ return result;
}
void
result = isc_buffer_copyregion(dst, ®ion);
RUNTIME_CHECK(result == ISC_R_SUCCESS); /* NOSPACE is impossible */
*dstp = dst;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (b->autore) {
result = isc_buffer_reserve(&b, r->length);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
if (r->length > isc_buffer_availablelength(b)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
if (r->length > 0U) {
b->used += r->length;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
len = (*dynbuffer)->length;
if ((len - (*dynbuffer)->used) >= size) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if ((*dynbuffer)->mctx == NULL) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/* Round to nearest buffer size increment */
}
if ((len - (*dynbuffer)->used) < size) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
(*dynbuffer)->base = isc_mem_reget((*dynbuffer)->mctx,
(*dynbuffer)->length, len);
(*dynbuffer)->length = (unsigned int)len;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
va_end(ap);
if (n < 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (b->autore) {
result = isc_buffer_reserve(&b, n + 1);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
if (isc_buffer_availablelength(b) < (unsigned int)n + 1) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
va_start(ap, format);
va_end(ap);
if (n < 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
b->used += n;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
* Index out of range or points to non-option.
*/
place = ENDOPT;
- return (-1);
+ return -1;
}
if (place[1] != '\0' && *++place == '-' && place[1] == '\0') {
*/
isc_commandline_index++;
place = ENDOPT;
- return (-1);
+ return -1;
}
}
isc_commandline_option);
}
- return (BADOPT);
+ return BADOPT;
}
if (*++option != ':') {
* when ':' starts options string, per historical spec.
*/
if (*options == ':') {
- return (BADARG);
+ return BADARG;
}
if (isc_commandline_errprint) {
isc_commandline_option);
}
- return (BADOPT);
+ return BADOPT;
}
place = ENDOPT;
isc_commandline_index++;
}
- return (isc_commandline_option);
+ return isc_commandline_option;
}
isc_result_t
result = isc_commandline_strtoargv(mctx, p, argcp, argvp,
n + 1);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
(*argvp)[n] = s;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result == ISC_R_RANGE) {
ts.tv_sec = INT_MAX;
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*!
do {
presult = pthread_cond_timedwait(c, m, &ts);
if (presult == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (presult == ETIMEDOUT) {
- return (ISC_R_TIMEDOUT);
+ return ISC_R_TIMEDOUT;
}
} while (presult == EINTR);
UNEXPECTED_SYSERROR(presult, "pthread_cond_timedwait()");
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
counter->magic = COUNTER_MAGIC;
*counterp = counter;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
uint32_t limit = atomic_load_acquire(&counter->limit);
if (limit != 0 && used >= limit) {
- return (ISC_R_QUOTA);
+ return ISC_R_QUOTA;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
unsigned int
isc_counter_used(isc_counter_t *counter) {
REQUIRE(VALID_COUNTER(counter));
- return (atomic_load_acquire(&counter->used));
+ return atomic_load_acquire(&counter->used);
}
void
*/
if (strlen(dirname) + 3 > sizeof(dir->dirname)) {
/* XXXDCL ? */
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
strlcpy(dir->dirname, dirname, sizeof(dir->dirname));
dir->handle = opendir(dirname);
if (dir->handle == NULL) {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
- return (result);
+ return result;
}
/*!
entry = readdir(dir->handle);
if (entry == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
/*
* Make sure that the space for the name is long enough.
*/
if (sizeof(dir->entry.name) <= strlen(entry->d_name)) {
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
strlcpy(dir->entry.name, entry->d_name, sizeof(dir->entry.name));
*/
dir->entry.length = strlen(entry->d_name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*!
rewinddir(dir->handle);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(dirname != NULL);
if (chdir(dirname) < 0) {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
if (chroot(dirname) < 0 || chdir("/") < 0) {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#else /* ifdef HAVE_CHROOT */
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
#endif /* ifdef HAVE_CHROOT */
}
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
isc_result_t
isc_errno_toresult(int err) {
- return (isc___errno2result(err, false, 0, 0));
+ return isc___errno2result(err, false, 0, 0);
}
case EINVAL: /* XXX sometimes this is not for files */
case ENAMETOOLONG:
case EBADF:
- return (ISC_R_INVALIDFILE);
+ return ISC_R_INVALIDFILE;
case EISDIR:
- return (ISC_R_NOTFILE);
+ return ISC_R_NOTFILE;
case ENOENT:
- return (ISC_R_FILENOTFOUND);
+ return ISC_R_FILENOTFOUND;
case EACCES:
case EPERM:
case EROFS:
- return (ISC_R_NOPERM);
+ return ISC_R_NOPERM;
case EEXIST:
- return (ISC_R_FILEEXISTS);
+ return ISC_R_FILEEXISTS;
case EIO:
- return (ISC_R_IOERROR);
+ return ISC_R_IOERROR;
case ENOMEM:
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
case ENFILE:
case EMFILE:
- return (ISC_R_TOOMANYOPENFILES);
+ return ISC_R_TOOMANYOPENFILES;
#ifdef EDQUOT
case EDQUOT:
- return (ISC_R_DISCQUOTA);
+ return ISC_R_DISCQUOTA;
#endif /* ifdef EDQUOT */
case ENOSPC:
- return (ISC_R_DISCFULL);
+ return ISC_R_DISCFULL;
#ifdef EOVERFLOW
case EOVERFLOW:
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
#endif /* ifdef EOVERFLOW */
case EPIPE:
#ifdef ECONNRESET
#ifdef ECONNABORTED
case ECONNABORTED:
#endif /* ifdef ECONNABORTED */
- return (ISC_R_CONNECTIONRESET);
+ return ISC_R_CONNECTIONRESET;
#ifdef ENOTCONN
case ENOTCONN:
- return (ISC_R_NOTCONNECTED);
+ return ISC_R_NOTCONNECTED;
#endif /* ifdef ENOTCONN */
#ifdef ETIMEDOUT
case ETIMEDOUT:
- return (ISC_R_TIMEDOUT);
+ return ISC_R_TIMEDOUT;
#endif /* ifdef ETIMEDOUT */
#ifdef ENOBUFS
case ENOBUFS:
- return (ISC_R_NORESOURCES);
+ return ISC_R_NORESOURCES;
#endif /* ifdef ENOBUFS */
#ifdef EAFNOSUPPORT
case EAFNOSUPPORT:
- return (ISC_R_FAMILYNOSUPPORT);
+ return ISC_R_FAMILYNOSUPPORT;
#endif /* ifdef EAFNOSUPPORT */
#ifdef ENETDOWN
case ENETDOWN:
- return (ISC_R_NETDOWN);
+ return ISC_R_NETDOWN;
#endif /* ifdef ENETDOWN */
#ifdef EHOSTDOWN
case EHOSTDOWN:
- return (ISC_R_HOSTDOWN);
+ return ISC_R_HOSTDOWN;
#endif /* ifdef EHOSTDOWN */
#ifdef ENETUNREACH
case ENETUNREACH:
- return (ISC_R_NETUNREACH);
+ return ISC_R_NETUNREACH;
#endif /* ifdef ENETUNREACH */
#ifdef EHOSTUNREACH
case EHOSTUNREACH:
- return (ISC_R_HOSTUNREACH);
+ return ISC_R_HOSTUNREACH;
#endif /* ifdef EHOSTUNREACH */
#ifdef EADDRINUSE
case EADDRINUSE:
- return (ISC_R_ADDRINUSE);
+ return ISC_R_ADDRINUSE;
#endif /* ifdef EADDRINUSE */
case EADDRNOTAVAIL:
- return (ISC_R_ADDRNOTAVAIL);
+ return ISC_R_ADDRNOTAVAIL;
case ECONNREFUSED:
- return (ISC_R_CONNREFUSED);
+ return ISC_R_CONNREFUSED;
default:
if (dolog) {
strerror_r(posixerrno, strbuf, sizeof(strbuf));
* might have something more descriptive than "unexpected
* error" to log with.
*/
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
}
ISC_EVENT_INIT(event, size, 0, NULL, type, action, arg, sender, destroy,
mctx);
- return (event);
+ return event;
}
isc_event_t *
ISC_EVENT_INIT(event, size, 0, NULL, type, action, deconst_arg, sender,
destroy, mctx);
- return (event);
+ return event;
}
void
result = isc__errno2result(errno);
}
- return (result);
+ return result;
}
static isc_result_t
result = isc__errno2result(errno);
}
- return (result);
+ return result;
}
isc_result_t
*size = stats.st_size;
}
- return (result);
+ return result;
}
isc_result_t
*modep = (stats.st_mode & 07777);
}
- return (result);
+ return result;
}
isc_result_t
#endif /* if defined(HAVE_STAT_NSEC) */
}
- return (result);
+ return result;
}
isc_result_t
*size = stats.st_size;
}
- return (result);
+ return result;
}
isc_result_t
if ((times[0].tv_sec &
(1ULL << (sizeof(times[0].tv_sec) * CHAR_BIT - 1))) != 0)
{
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
/*
(int32_t)(isc_time_nanoseconds(when) / 1000);
if (utimes(file, times) < 0) {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#undef TEMPLATE
isc_result_t
isc_file_mktemplate(const char *path, char *buf, size_t buflen) {
- return (isc_file_template(path, TEMPLATE, buf, buflen));
+ return isc_file_template(path, TEMPLATE, buf, buflen);
}
isc_result_t
if (s != NULL) {
size_t prefixlen = s - path + 1;
if ((prefixlen + strlen(templet) + 1) > buflen) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/* Copy 'prefixlen' bytes and NUL terminate. */
strlcat(buf, templet, buflen);
} else {
if ((strlen(templet) + 1) > buflen) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
strlcpy(buf, templet, buflen);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static const char alphnum[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv"
cp++;
}
if (cp == templet) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
x = cp--;
}
while (link(file, templet) == -1) {
if (errno != EEXIST) {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
for (cp = x;;) {
const char *t;
if (*cp == '\0') {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
t = strchr(alphnum, *cp);
if (t == NULL || *++t == '\0') {
}
if (unlink(file) < 0) {
if (errno != ENOENT) {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
isc_file_openunique(char *templet, FILE **fp) {
int mode = S_IWUSR | S_IRUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
- return (isc_file_openuniquemode(templet, mode, fp));
+ return isc_file_openuniquemode(templet, mode, fp);
}
isc_result_t
isc_file_openuniqueprivate(char *templet, FILE **fp) {
int mode = S_IWUSR | S_IRUSR;
- return (isc_file_openuniquemode(templet, mode, fp));
+ return isc_file_openuniquemode(templet, mode, fp);
}
isc_result_t
cp++;
}
if (cp == templet) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
x = cp--;
while ((fd = open(templet, O_RDWR | O_CREAT | O_EXCL, mode)) == -1) {
if (errno != EEXIST) {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
for (cp = x;;) {
char *t;
if (*cp == '\0') {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
t = strchr(alphnum, *cp);
if (t == NULL || *++t == '\0') {
*fp = f;
}
- return (result);
+ return result;
}
isc_result_t
isc_file_bopenunique(char *templet, FILE **fp) {
int mode = S_IWUSR | S_IRUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
- return (isc_file_openuniquemode(templet, mode, fp));
+ return isc_file_openuniquemode(templet, mode, fp);
}
isc_result_t
isc_file_bopenuniqueprivate(char *templet, FILE **fp) {
int mode = S_IWUSR | S_IRUSR;
- return (isc_file_openuniquemode(templet, mode, fp));
+ return isc_file_openuniquemode(templet, mode, fp);
}
isc_result_t
isc_file_bopenuniquemode(char *templet, int mode, FILE **fp) {
- return (isc_file_openuniquemode(templet, mode, fp));
+ return isc_file_openuniquemode(templet, mode, fp);
}
isc_result_t
r = unlink(filename);
if (r == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
}
r = rename(oldname, newname);
if (r == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
}
REQUIRE(pathname != NULL);
- return (file_stats(pathname, &stats) == ISC_R_SUCCESS);
+ return file_stats(pathname, &stats) == ISC_R_SUCCESS;
}
isc_result_t
memset(&filestat, 0, sizeof(struct stat));
if ((stat(filename, &filestat)) == -1) {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
if (!S_ISREG(filestat.st_mode)) {
- return (ISC_R_INVALIDFILE);
+ return ISC_R_INVALIDFILE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
memset(&filestat, 0, sizeof(struct stat));
if ((fstat(fd, &filestat)) == -1) {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
if (!S_ISREG(filestat.st_mode)) {
- return (ISC_R_INVALIDFILE);
+ return ISC_R_INVALIDFILE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
memset(&filestat, 0, sizeof(struct stat));
if ((stat(filename, &filestat)) == -1) {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
if (!S_ISDIR(filestat.st_mode)) {
- return (ISC_R_INVALIDFILE);
+ return ISC_R_INVALIDFILE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
bool
isc_file_isabsolute(const char *filename) {
REQUIRE(filename != NULL);
- return (filename[0] == '/');
+ return filename[0] == '/';
}
bool
isc_file_iscurrentdir(const char *filename) {
REQUIRE(filename != NULL);
- return (filename[0] == '.' && filename[1] == '\0');
+ return filename[0] == '.' && filename[1] == '\0';
}
bool
isc_file_ischdiridempotent(const char *filename) {
REQUIRE(filename != NULL);
if (isc_file_isabsolute(filename)) {
- return (true);
+ return true;
}
if (isc_file_iscurrentdir(filename)) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
const char *
s = strrchr(filename, '/');
if (s == NULL) {
- return (filename);
+ return filename;
}
- return (s + 1);
+ return s + 1;
}
isc_result_t
len = strlen(base) + 1;
if (len > buflen) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(buf, base, len);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
}
}
- return (result);
+ return result;
}
isc_result_t
isc_result_t result;
result = dir_current(path, pathlen);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (strlen(path) + strlen(filename) + 1 > pathlen) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
strlcat(path, filename, pathlen);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (truncate(filename, size) < 0) {
result = isc__errno2result(errno);
}
- return (result);
+ return result;
}
isc_result_t
result = file_stats(filename, &sb);
if (result == ISC_R_SUCCESS) {
if ((sb.st_mode & S_IFREG) == 0) {
- return (ISC_R_INVALIDFILE);
+ return ISC_R_INVALIDFILE;
}
flags = O_WRONLY | O_TRUNC;
} else if (result == ISC_R_FILENOTFOUND) {
flags = O_WRONLY | O_CREAT | O_EXCL;
} else {
- return (result);
+ return result;
}
fd = open(filename, flags, S_IRUSR | S_IWUSR);
if (fd == -1) {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
f = fdopen(fd, "w");
if (f == NULL) {
result = isc__errno2result(errno);
close(fd);
- return (result);
+ return result;
}
*fp = f;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
const char *file, *slash;
if (path == NULL) {
- return (ISC_R_INVALIDFILE);
+ return ISC_R_INVALIDFILE;
}
slash = strrchr(path, '/');
}
if (dir == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (*file == '\0') {
isc_mem_free(mctx, dir);
- return (ISC_R_INVALIDFILE);
+ return ISC_R_INVALIDFILE;
}
*dirname = dir;
*bname = file;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#define DISALLOW "\\/ABCDEFGHIJKLMNOPQRSTUVWXYZ"
size_t left = hashlen - i * 2;
ret = snprintf(hash + i * 2, left, "%02x", digest[i]);
if (ret < 0 || (size_t)ret >= left) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
if (l > length || l > (unsigned)PATH_MAX) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/* 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);
+ return err;
}
err = digest2hex(digest, digestlen, hash, sizeof(hash));
if (err != ISC_R_SUCCESS) {
- return (err);
+ return err;
}
snprintf(buf, sizeof(buf), "%s%s%s%s%s", dir != NULL ? dir : "",
ext != NULL ? ext : "");
if (isc_file_exists(buf)) {
strlcpy(path, buf, length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* Check for a truncated SHA256 hash filename */
ext != NULL ? ext : "");
if (isc_file_exists(buf)) {
strlcpy(path, buf, length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
*/
if (strpbrk(base, DISALLOW) != NULL) {
strlcpy(path, buf, length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
snprintf(buf, sizeof(buf), "%s%s%s%s%s", dir != NULL ? dir : "",
dir != NULL ? "/" : "", base, ext != NULL ? "." : "",
ext != NULL ? ext : "");
strlcpy(path, buf, length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
bool
isc_file_isdirwritable(const char *path) {
- return (access(path, W_OK | X_OK) == 0);
+ return access(path, W_OK | X_OK) == 0;
}
switch (rc) {
case 0:
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
case GLOB_NOMATCH:
- return (ISC_R_FILENOTFOUND);
+ return ISC_R_FILENOTFOUND;
case GLOB_NOSPACE:
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
default:
- return (errno != 0 ? isc_errno_toresult(errno) : ISC_R_IOERROR);
+ return errno != 0 ? isc_errno_toresult(errno) : ISC_R_IOERROR;
}
}
ISC_R_SUCCESS);
}
- return (isc_hash_key);
+ return isc_hash_key;
}
void
isc_siphash24(isc_hash_key, input, length, (uint8_t *)&hval);
}
- return (hval);
+ return hval;
}
uint32_t
(uint8_t *)&hval);
}
- return (hval);
+ return hval;
}
heap_check(heap);
if (idx <= heap->last) {
- return (heap->array[idx]);
+ return heap->array[idx];
}
- return (NULL);
+ return NULL;
}
void
RETERR(str_totext(wordbreak, target));
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
const char *s;
if ((s = strchr(hex, toupper(c))) == NULL) {
- return (ISC_R_BADHEX);
+ return ISC_R_BADHEX;
}
ctx->val[ctx->digits++] = (int)(s - hex);
if (ctx->digits == 2) {
RETERR(mem_tobuffer(ctx->target, &num, 1));
if (ctx->length >= 0) {
if (ctx->length == 0) {
- return (ISC_R_BADHEX);
+ return ISC_R_BADHEX;
} else {
ctx->length -= 1;
}
}
ctx->digits = 0;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
hex_decode_finish(hex_decode_ctx_t *ctx) {
if (ctx->length > 0) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (ctx->digits != 0) {
- return (ISC_R_BADHEX);
+ return ISC_R_BADHEX;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
RETERR(hex_decode_finish(&ctx));
if (length == -2 && before == after) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
RETERR(hex_decode_char(&ctx, c));
}
RETERR(hex_decode_finish(&ctx));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
l = strlen(source);
if (l > region.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(region.base, source, l);
isc_buffer_add(target, l);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_availableregion(target, &tr);
if (length > tr.length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(tr.base, base, length);
isc_buffer_add(target, length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_hmac_new(void) {
EVP_MD_CTX *hmac_st = EVP_MD_CTX_new();
RUNTIME_CHECK(hmac_st != NULL);
- return ((isc_hmac_t *)hmac_st);
+ return (isc_hmac_t *)hmac_st;
}
void
REQUIRE(keylen <= INT_MAX);
if (md_type == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
pkey = EVP_PKEY_new_raw_private_key(EVP_PKEY_HMAC, NULL, key, keylen);
if (pkey == NULL) {
ERR_clear_error();
- return (ISC_R_CRYPTOFAILURE);
+ return ISC_R_CRYPTOFAILURE;
}
if (EVP_DigestSignInit(hmac_st, NULL, md_type, NULL, pkey) != 1) {
EVP_PKEY_free(pkey);
ERR_clear_error();
- return (ISC_R_CRYPTOFAILURE);
+ return ISC_R_CRYPTOFAILURE;
}
EVP_PKEY_free(pkey);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (EVP_MD_CTX_reset(hmac_st) != 1) {
ERR_clear_error();
- return (ISC_R_CRYPTOFAILURE);
+ return ISC_R_CRYPTOFAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(hmac_st != NULL);
if (buf == NULL || len == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (EVP_DigestSignUpdate(hmac_st, buf, len) != 1) {
ERR_clear_error();
- return (ISC_R_CRYPTOFAILURE);
+ return ISC_R_CRYPTOFAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (EVP_DigestSignFinal(hmac_st, digest, &len) != 1) {
ERR_clear_error();
- return (ISC_R_CRYPTOFAILURE);
+ return ISC_R_CRYPTOFAILURE;
}
*digestlen = (unsigned int)len;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
const isc_md_type_t *
isc_hmac_get_md_type(isc_hmac_t *hmac_st) {
REQUIRE(hmac_st != NULL);
- return (EVP_MD_CTX_get0_md(hmac_st));
+ return EVP_MD_CTX_get0_md(hmac_st);
}
size_t
isc_hmac_get_size(isc_hmac_t *hmac_st) {
REQUIRE(hmac_st != NULL);
- return ((size_t)EVP_MD_CTX_size(hmac_st));
+ return (size_t)EVP_MD_CTX_size(hmac_st);
}
int
isc_hmac_get_block_size(isc_hmac_t *hmac_st) {
REQUIRE(hmac_st != NULL);
- return (EVP_MD_CTX_block_size(hmac_st));
+ return EVP_MD_CTX_block_size(hmac_st);
}
isc_result_t
end:
isc_hmac_free(hmac_st);
- return (res);
+ return res;
}
static bool
isc__ht_node_match(isc_ht_node_t *node, const uint32_t hashval,
const uint8_t *key, uint32_t keysize, bool case_sensitive) {
- return (node->hashval == hashval && node->keysize == keysize &&
- (case_sensitive ? (memcmp(node->key, key, keysize) == 0)
- : (memcasecmp(node->key, key, keysize) == 0)));
+ return node->hashval == hashval && node->keysize == keysize &&
+ (case_sensitive ? (memcmp(node->key, key, keysize) == 0)
+ : (memcasecmp(node->key, key, keysize) == 0));
}
static uint32_t
hash_32(uint32_t val, unsigned int bits) {
REQUIRE(bits <= HT_MAX_BITS);
/* High bits are more random. */
- return (val * GOLDEN_RATIO_32 >> (32 - bits));
+ return val * GOLDEN_RATIO_32 >> (32 - bits);
}
static bool
rehashing_in_progress(const isc_ht_t *ht) {
- return (ht->table[HT_NEXTTABLE(ht->hindex)] != NULL);
+ return ht->table[HT_NEXTTABLE(ht->hindex)] != NULL;
}
static bool
hashtable_is_overcommited(isc_ht_t *ht) {
- return (ht->count >= (ht->size[ht->hindex] * HT_OVERCOMMIT));
+ return ht->count >= (ht->size[ht->hindex] * HT_OVERCOMMIT);
}
static uint32_t
newbits += 1;
}
- return (newbits);
+ return newbits;
}
/*
hashval = isc_hash32(key, keysize, ht->case_sensitive);
if (isc__ht_find(ht, key, keysize, hashval, ht->hindex) != NULL) {
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
isc__ht_add(ht, key, keysize, hashval, ht->hindex, value);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_ht_node_t *
if (isc__ht_node_match(node, hashval, key, keysize,
ht->case_sensitive))
{
- return (node);
+ return node;
}
}
if (TRY_NEXTTABLE(findex, ht)) {
goto nexttable;
}
- return (NULL);
+ return NULL;
}
isc_result_t
node = isc__ht_find(ht, key, keysize, hashval, ht->hindex);
if (node == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (valuep != NULL) {
*valuep = node->value;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
sizeof(*node) + node->keysize);
ht->count--;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
isc_result_t
goto nexttable;
}
- return (result);
+ return result;
}
void
it->hindex = ht->hindex;
it->i = 0;
- return (isc__ht_iter_next(it));
+ return isc__ht_iter_next(it);
}
static isc_result_t
if (it->i < ht->size[it->hindex]) {
it->cur = ht->table[it->hindex][it->i];
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (TRY_NEXTTABLE(it->hindex, ht)) {
it->hindex = HT_NEXTTABLE(it->hindex);
it->i = 0;
- return (isc__ht_iter_next(it));
+ return isc__ht_iter_next(it);
}
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
isc_result_t
it->cur = it->cur->next;
if (it->cur != NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
it->i++;
- return (isc__ht_iter_next(it));
+ return isc__ht_iter_next(it);
}
isc_result_t
dindex);
INSIST(dresult == ISC_R_SUCCESS);
- return (result);
+ return result;
}
void
isc_ht_count(const isc_ht_t *ht) {
REQUIRE(ISC_HT_VALID(ht));
- return (ht->count);
+ return ht->count;
}
httpdmgr->magic = HTTPDMGR_MAGIC;
*httpdmgrp = httpdmgr;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
httpdmgr->magic = 0;
isc_mutex_destroy(&httpdmgr->lock);
isc_mem_put(mctx, httpdmgr, sizeof(isc_httpdmgr_t));
- return (result);
+ return result;
}
static void
name_match(const struct phr_header *header, const char *match) {
size_t match_len = strlen(match);
if (match_len != header->name_len) {
- return (false);
+ return false;
}
- return (strncasecmp(header->name, match, match_len) == 0);
+ return strncasecmp(header->name, match, match_len) == 0;
}
static bool
size_t limit;
if (match_len > header->value_len) {
- return (false);
+ return false;
}
limit = header->value_len - match_len + 1;
if (i == header->value_len || header->value[i] == ',' ||
header->value[i] == ';')
{
- return (true);
+ return true;
}
}
i++;
}
}
- return (false);
+ return false;
}
static isc_result_t
if (pret == -1) {
/* Parse Error */
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
} else if (pret == -2) {
/* Need more data */
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
INSIST(pret > 0);
if (pret > HTTP_MAX_REQUEST_LEN) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
httpd->consume = pret;
} else if (strncmp(method, "POST ", method_len) == 0) {
httpd->method = METHOD_POST;
} else {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
/*
*/
result = isc_url_parse(path, path_len, 0, &httpd->up);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
httpd->path = path;
/* ensure we consumed all digits */
if ((header->value + header->value_len) != endptr) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
/* ensure there was no minus sign */
if (val < 0) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
/* ensure it did not overflow */
if (errno != 0) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
content_len = val;
} else if (name_match(header, "Connection")) {
* For a GET the length must be zero.
*/
if (httpd->method == METHOD_GET && content_len != 0) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
if (content_len >= HTTP_MAX_REQUEST_LEN) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
size_t consume = httpd->consume + content_len;
if (consume > httpd->recvlen) {
/* The request data isn't complete yet. */
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
/* Consume the request's data, which we do not use. */
break;
case 1:
if (!host_header) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
break;
default:
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
/*
* to the buffer.
*/
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
isc_buffer_initnull(&req->bodybuffer);
- return (req);
+ return req;
}
static void
REQUIRE(VALID_HTTPDMGR(httpdmgr));
if ((httpdmgr->flags & ISC_HTTPDMGR_SHUTTINGDOWN) != 0) {
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
} else if (result == ISC_R_CANCELED) {
isc_httpdmgr_shutdown(&httpdmgr);
- return (result);
+ return result;
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
peeraddr = isc_nmhandle_peeraddr(handle);
if (httpdmgr->client_ok != NULL &&
!(httpdmgr->client_ok)(&peeraddr, httpdmgr->cb_arg))
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
new_httpd(httpdmgr, handle);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*freecb = NULL;
*freecb_args = NULL;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*freecb = NULL;
*freecb_args = NULL;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#ifdef HAVE_ZLIB
*/
inputlen = isc_buffer_usedlength(&req->bodybuffer);
if (inputlen == 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
isc_buffer_allocate(req->mctx, &req->compbuffer, inputlen);
deflateEnd(&zstr);
if (ret == Z_STREAM_END) {
isc_buffer_add(req->compbuffer, zstr.total_out);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
isc_buffer_free(&req->compbuffer);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
#endif /* ifdef HAVE_ZLIB */
if (url == NULL) {
httpdmgr->render_404 = func;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
item = isc_mem_get(httpdmgr->mctx, sizeof(isc_httpdurl_t));
ISC_LIST_APPEND(httpdmgr->urls, item, link);
UNLOCK(&httpdmgr->lock);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
bool
isc_httpdurl_isstatic(const isc_httpdurl_t *url) {
- return (url->isstatic);
+ return url->isstatic;
}
const isc_time_t *
isc_httpdurl_loadtime(const isc_httpdurl_t *url) {
- return (&url->loadtime);
+ return &url->loadtime;
}
const isc_time_t *
isc_httpd_if_modified_since(const isc_httpd_t *httpd) {
- return ((const isc_time_t *)&httpd->if_modified_since);
+ return (const isc_time_t *)&httpd->if_modified_since;
}
if (j < nselected && selected[j].name == NULL) {
selected[j] = tests[i];
}
- return (true);
+ return true;
}
- return (false);
+ return false;
}
ISC_LANG_ENDDECLS
uint_fast32_t __v;
__v = (uint_fast32_t)atomic_fetch_add_relaxed(target, 1);
INSIST(__v < UINT32_MAX);
- return (__v);
+ return __v;
}
#else /* _MSC_VER */
#define isc_refcount_increment0(target) \
uint_fast32_t __v;
__v = (uint_fast32_t)atomic_fetch_add_relaxed(target, 1);
INSIST(__v > 0 && __v < UINT32_MAX);
- return (__v);
+ return __v;
}
#else /* _MSC_VER */
#define isc_refcount_increment(target) \
uint_fast32_t __v;
__v = (uint_fast32_t)atomic_fetch_sub_acq_rel(target, 1);
INSIST(__v > 0);
- return (__v);
+ return __v;
}
#else /* _MSC_VER */
#define isc_refcount_decrement(target) \
iter->magic = IFITER_MAGIC;
*iterp = iter;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
if (iter->ifaddrs != NULL) { /* just in case */
freeifaddrs(iter->ifaddrs);
}
isc_mem_put(mctx, iter, sizeof(*iter));
- return (result);
+ return result;
}
/*
INSIST(ifa->ifa_name != NULL);
if (ifa->ifa_addr == NULL) {
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
family = ifa->ifa_addr->sa_family;
if (family != AF_INET && family != AF_INET6) {
- return (ISC_R_IGNORE);
+ return ISC_R_IGNORE;
}
memset(&iter->current, 0, sizeof(iter->current));
ifa->ifa_name);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
iter->pos = iter->pos->ifa_next;
}
if (iter->pos == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
isc_interfaceiter_current(isc_interfaceiter_t *iter, isc_interface_t *ifdata) {
REQUIRE(iter->result == ISC_R_SUCCESS);
memmove(ifdata, &iter->current, sizeof(*ifdata));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
}
iter->result = result;
- return (result);
+ return result;
}
isc_result_t
}
}
iter->result = result;
- return (result);
+ return result;
}
void
SHA_CTX ctx;
if (hashalg != 1) {
- return (0);
+ return 0;
}
buf = in;
do {
if (SHA1_Init(&ctx) != 1) {
ERR_clear_error();
- return (0);
+ return 0;
}
if (SHA1_Update(&ctx, buf, len) != 1) {
ERR_clear_error();
- return (0);
+ return 0;
}
if (SHA1_Update(&ctx, salt, saltlength) != 1) {
ERR_clear_error();
- return (0);
+ return 0;
}
if (SHA1_Final(out, &ctx) != 1) {
ERR_clear_error();
- return (0);
+ return 0;
}
buf = out;
len = SHA_DIGEST_LENGTH;
} while (n++ < iterations);
- return (SHA_DIGEST_LENGTH);
+ return SHA_DIGEST_LENGTH;
}
#else
EVP_MD *md;
if (hashalg != 1) {
- return (0);
+ return 0;
}
ctx = EVP_MD_CTX_new();
EVP_MD_CTX_free(ctx);
EVP_MD_free(md);
- return (outlength);
+ return outlength;
fail:
EVP_MD_CTX_free(ctx);
EVP_MD_free(md);
ERR_clear_error();
- return (0);
+ return 0;
}
#endif
si->size = size;
ptr = &si[1];
- return (ptr);
+ return ptr;
}
static inline void
sallocx(void *ptr, int flags ISC_ATTR_UNUSED) {
size_info *si = &(((size_info *)ptr)[-1]);
- return (si[0].size);
+ return si[0].size;
}
static inline void *
si->size = size;
ptr = &si[1];
- return (ptr);
+ return ptr;
}
#endif /* !defined(HAVE_JEMALLOC) */
lex->data = tmp;
*remainingp += lex->max_token;
lex->max_token *= 2;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
*lexp = lex;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
REQUIRE(VALID_LEX(lex));
- return (lex->comments);
+ return lex->comments;
}
void
source->line = 1;
ISC_LIST_INITANDPREPEND(lex->sources, source, link);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
result = isc_stdio_open(filename, "r", &stream);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = new_source(lex, true, true, stream, filename);
if (result != ISC_R_SUCCESS) {
(void)fclose(stream);
}
- return (result);
+ return result;
}
isc_result_t
snprintf(name, sizeof(name), "stream-%p", stream);
- return (new_source(lex, true, false, stream, name));
+ return new_source(lex, true, false, stream, name);
}
isc_result_t
snprintf(name, sizeof(name), "buffer-%p", buffer);
- return (new_source(lex, false, false, buffer, name));
+ return new_source(lex, false, false, buffer, name);
}
isc_result_t
source = HEAD(lex->sources);
if (source == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
ISC_LIST_UNLINK(lex->sources, source, link);
isc_buffer_free(&source->pushback);
isc_mem_put(lex->mctx, source, sizeof(*source));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
typedef enum {
source->pushback = tbuf;
}
isc_buffer_putuint8(source->pushback, (uint8_t)c);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (source == NULL) {
if ((options & ISC_LEXOPT_NOMORE) != 0) {
tokenp->type = isc_tokentype_nomore;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
if (source->result != ISC_R_SUCCESS) {
- return (source->result);
+ return source->result;
}
lex->saved_paren_count = lex->paren_count;
lex->paren_count != 0)
{
lex->paren_count = 0;
- return (ISC_R_UNBALANCED);
+ return ISC_R_UNBALANCED;
}
if ((options & ISC_LEXOPT_BTEXT) != 0 && lex->brace_count != 0)
{
lex->brace_count = 0;
- return (ISC_R_UNBALANCED);
+ return ISC_R_UNBALANCED;
}
if ((options & ISC_LEXOPT_EOF) != 0) {
tokenp->type = isc_tokentype_eof;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_EOF);
+ return ISC_R_EOF;
}
isc_buffer_compact(source->pushback);
funlockfile(source->input);
}
#endif /* ifdef HAVE_FLOCKFILE */
- return (result);
+ return result;
}
isc_result_t
isc_lex_ungettoken(lex, token);
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (eol && ((token->type == isc_tokentype_eol) ||
(token->type == isc_tokentype_eof)))
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (token->type == isc_tokentype_string &&
(expect == isc_tokentype_qstring || expect == isc_tokentype_qvpair))
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (token->type == isc_tokentype_vpair &&
expect == isc_tokentype_qvpair)
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (token->type != expect) {
isc_lex_ungettoken(lex, token);
if (token->type == isc_tokentype_eol ||
token->type == isc_tokentype_eof)
{
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (expect == isc_tokentype_number) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
isc_lex_ungettoken(lex, token);
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (eol && ((token->type == isc_tokentype_eol) ||
(token->type == isc_tokentype_eof)))
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (token->type != isc_tokentype_number) {
isc_lex_ungettoken(lex, token);
if (token->type == isc_tokentype_eol ||
token->type == isc_tokentype_eof)
{
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
source = HEAD(lex->sources);
if (source == NULL) {
- return (NULL);
+ return NULL;
}
- return (source->name);
+ return source->name;
}
unsigned long
source = HEAD(lex->sources);
if (source == NULL) {
- return (0);
+ return 0;
}
- return (source->line);
+ return source->line;
}
isc_result_t
source = HEAD(lex->sources);
if (source == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
newname = isc_mem_strdup(lex->mctx, name);
isc_mem_free(lex->mctx, source->name);
source->name = newname;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
source = HEAD(lex->sources);
if (source == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
source->line = line;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
bool
source = HEAD(lex->sources);
if (source == NULL) {
- return (false);
+ return false;
}
- return (source->is_file);
+ return source->is_file;
}
DE_CONST(catp->name, catp);
} else {
if (strcmp(catp->name, name) == 0) {
- return (catp);
+ return catp;
}
catp++;
}
}
- return (NULL);
+ return NULL;
}
void
DE_CONST(modp->name, modp);
} else {
if (strcmp(modp->name, name) == 0) {
- return (modp);
+ return modp;
}
modp++;
}
}
- return (NULL);
+ return NULL;
}
void
}
if (channel == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (category != NULL) {
sync_highest_level(lctx, lcfg);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_log_getdebuglevel(isc_log_t *lctx) {
REQUIRE(VALID_CONTEXT(lctx));
- return (atomic_load_acquire(&lctx->debug_level));
+ return atomic_load_acquire(&lctx->debug_level);
}
void
isc_log_getduplicateinterval(isc_logconfig_t *lcfg) {
REQUIRE(VALID_CONTEXT(lcfg));
- return (lcfg->duplicate_interval);
+ return lcfg->duplicate_interval;
}
void
isc_log_gettag(isc_logconfig_t *lcfg) {
REQUIRE(VALID_CONFIG(lcfg));
- return (lcfg->tag);
+ return lcfg->tag;
}
/* XXXDCL NT -- This interface will assuredly be changing. */
result = ISC_R_NOSPACE;
syslog(LOG_ERR, "unable to remove log files: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
/*
* Return if the directory open failed.
*/
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
while (isc_dir_read(&dir) == ISC_R_SUCCESS) {
isc_dir_close(&dir);
*greatestp = greatest;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
int64_t version = 0;
if (versions <= 0) {
- return (INT64_MAX);
+ return INT64_MAX;
}
if (versions > ISC_LOG_MAX_VERSIONS) {
/*
* to_keep[versions - 1] is the last one we want to keep
*/
- return (to_keep[versions - 1]);
+ return to_keep[versions - 1];
}
static isc_result_t
result = ISC_R_NOSPACE;
syslog(LOG_ERR, "unable to remove log files: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
/*
* Return if the directory open failed.
*/
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
last = last_to_keep(versions, &dir, bname, bnamelen);
}
}
isc_dir_close(&dir);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*/
result = greatest_version(file, file->versions, &greatest);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
path, path, isc_result_totext(result));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
path, path, isc_result_totext(result));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
* files is desired.
*/
if (file->versions == ISC_LOG_ROLLNEVER) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (file->versions == 0) {
result = isc_file_remove(file->name);
if (result != ISC_R_SUCCESS && result != ISC_R_FILENOTFOUND) {
syslog(LOG_ERR, "unable to remove log file '%s': %s",
file->name, isc_result_totext(result));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
switch (file->suffix) {
case isc_log_rollsuffix_increment:
- return (roll_increment(file));
+ return roll_increment(file);
case isc_log_rollsuffix_timestamp:
- return (roll_timestamp(file));
+ return roll_timestamp(file);
default:
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
}
*/
if (result == ISC_R_SUCCESS && roll) {
if (FILE_VERSIONS(channel) == ISC_LOG_ROLLNEVER) {
- return (ISC_R_MAXSIZE);
+ return ISC_R_MAXSIZE;
}
result = isc_logfile_roll(&channel->destination.file);
if (result != ISC_R_SUCCESS) {
isc_result_totext(result));
channel->flags |= ISC_LOG_OPENERR;
}
- return (result);
+ return result;
}
}
result = isc_stdio_open(path, "a", &FILE_STREAM(channel));
- return (result);
+ return result;
}
ISC_NO_SANITIZE_THREAD bool
* entered to see if the message should really be output.
*/
if (lctx == NULL) {
- return (false);
+ return false;
}
if (forcelog) {
- return (true);
+ return true;
}
int highest_level = atomic_load_acquire(&lctx->highest_level);
if (level <= highest_level) {
- return (true);
+ return true;
}
if (atomic_load_acquire(&lctx->dynamic)) {
int debug_level = atomic_load_acquire(&lctx->debug_level);
if (level <= debug_level) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static void
*timermgrp = timermgr;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
fail:
isc_managers_destroy(netmgrp, taskmgrp, timermgrp);
- return (result);
+ return result;
}
void
isc_md_new(void) {
isc_md_t *md = EVP_MD_CTX_new();
RUNTIME_CHECK(md != NULL);
- return (md);
+ return md;
}
void
REQUIRE(md != NULL);
if (md_type == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
if (EVP_DigestInit_ex(md, md_type, NULL) != 1) {
ERR_clear_error();
- return (ISC_R_CRYPTOFAILURE);
+ return ISC_R_CRYPTOFAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (EVP_MD_CTX_reset(md) != 1) {
ERR_clear_error();
- return (ISC_R_CRYPTOFAILURE);
+ return ISC_R_CRYPTOFAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(md != NULL);
if (buf == NULL || len == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (EVP_DigestUpdate(md, buf, len) != 1) {
ERR_clear_error();
- return (ISC_R_CRYPTOFAILURE);
+ return ISC_R_CRYPTOFAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (EVP_DigestFinal_ex(md, digest, digestlen) != 1) {
ERR_clear_error();
- return (ISC_R_CRYPTOFAILURE);
+ return ISC_R_CRYPTOFAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
const isc_md_type_t *
isc_md_get_md_type(isc_md_t *md) {
REQUIRE(md != NULL);
- return (EVP_MD_CTX_get0_md(md));
+ return EVP_MD_CTX_get0_md(md);
}
size_t
isc_md_get_size(isc_md_t *md) {
REQUIRE(md != NULL);
- return (EVP_MD_CTX_size(md));
+ return EVP_MD_CTX_size(md);
}
size_t
isc_md_get_block_size(isc_md_t *md) {
REQUIRE(md != NULL);
- return (EVP_MD_CTX_block_size(md));
+ return EVP_MD_CTX_block_size(md);
}
size_t
"Change ISC_MAX_MD_SIZE to be greater than or equal to "
"EVP_MAX_MD_SIZE");
if (md_type != NULL) {
- return ((size_t)EVP_MD_size(md_type));
+ return (size_t)EVP_MD_size(md_type);
}
- return (ISC_MAX_MD_SIZE);
+ return ISC_MAX_MD_SIZE;
}
size_t
"Change ISC_MAX_MD_SIZE to be greater than or equal to "
"EVP_MAX_MD_SIZE");
if (md_type != NULL) {
- return ((size_t)EVP_MD_block_size(md_type));
+ return (size_t)EVP_MD_block_size(md_type);
}
- return (ISC_MAX_MD_SIZE);
+ return ISC_MAX_MD_SIZE;
}
isc_result_t
end:
isc_md_free(md);
- return (res);
+ return res;
}
#define md_register_algorithm(alg) \
malloced);
}
- return (malloced);
+ return malloced;
}
static size_t
decrement_malloced(isc_mem_t *ctx, size_t size) {
size_t malloced = atomic_fetch_sub_relaxed(&ctx->malloced, size) - size;
- return (malloced);
+ return malloced;
}
#if ISC_MEM_TRACKLINES
memset(ret, 0xbe, size); /* Mnemonic for "beef". */
}
- return (ret);
+ return ret;
}
/*!
}
}
- return (new_ptr);
+ return new_ptr;
}
#define stats_bucket(ctx, size) \
res = mallctl("arenas.create", &arenano, &len, NULL, 0);
if (res != 0) {
- return (false);
+ return false;
}
*pnew_arenano = arenano;
- return (true);
+ return true;
#else
*pnew_arenano = ISC_MEM_ILLEGAL_ARENA;
- return (true);
+ return true;
#endif /* defined(JEMALLOC_API_SUPPORTED) && JEMALLOC_VERSION_MAJOR >= 4 */
}
(void)snprintf(buf, sizeof(buf), "arena.%u.destroy", arenano);
res = mallctl(buf, NULL, NULL, NULL, 0);
if (res != 0) {
- return (false);
+ return false;
}
- return (true);
+ return true;
#else
UNUSED(arenano);
- return (true);
+ return true;
#endif /* defined(JEMALLOC_API_SUPPORTED) && JEMALLOC_VERSION_MAJOR >= 4 */
}
size_t hiwater = atomic_load_relaxed(&ctx->hi_water);
if (hiwater == 0) {
- return (false);
+ return false;
}
inuse = atomic_load_acquire(&ctx->inuse);
if (inuse <= hiwater) {
- return (false);
+ return false;
}
maxinuse = atomic_load_acquire(&ctx->maxinuse);
}
if (atomic_load_acquire(&ctx->hi_called)) {
- return (false);
+ return false;
}
/* We are over water (for the first time) */
atomic_store_release(&ctx->is_overmem, true);
- return (true);
+ return true;
}
static bool
size_t lowater = atomic_load_relaxed(&ctx->lo_water);
if (lowater == 0) {
- return (false);
+ return false;
}
inuse = atomic_load_acquire(&ctx->inuse);
if (inuse >= lowater) {
- return (false);
+ return false;
}
if (!atomic_load_acquire(&ctx->hi_called)) {
- return (false);
+ return false;
}
/* We are no longer overmem */
atomic_store_release(&ctx->is_overmem, false);
- return (true);
+ return true;
}
void *
CALL_HI_WATER(ctx);
- return (ptr);
+ return ptr;
}
void
CALL_HI_WATER(ctx);
- return (ptr);
+ return ptr;
}
void *
CALL_HI_WATER(ctx);
}
- return (new_ptr);
+ return new_ptr;
}
void *
CALL_HI_WATER(ctx);
}
- return (new_ptr);
+ return new_ptr;
}
void
strlcpy(ns, s, len);
- return (ns);
+ return ns;
}
char *
strlcpy(ns, s, len);
- return (ns);
+ return ns;
}
void
isc_mem_inuse(isc_mem_t *ctx) {
REQUIRE(VALID_CONTEXT(ctx));
- return (atomic_load_acquire(&ctx->inuse));
+ return atomic_load_acquire(&ctx->inuse);
}
size_t
isc_mem_maxinuse(isc_mem_t *ctx) {
REQUIRE(VALID_CONTEXT(ctx));
- return (atomic_load_acquire(&ctx->maxinuse));
+ return atomic_load_acquire(&ctx->maxinuse);
}
size_t
isc_mem_total(isc_mem_t *ctx) {
REQUIRE(VALID_CONTEXT(ctx));
- return (atomic_load_acquire(&ctx->total));
+ return atomic_load_acquire(&ctx->total);
}
size_t
isc_mem_malloced(isc_mem_t *ctx) {
REQUIRE(VALID_CONTEXT(ctx));
- return (atomic_load_acquire(&ctx->malloced));
+ return atomic_load_acquire(&ctx->malloced);
}
size_t
isc_mem_maxmalloced(isc_mem_t *ctx) {
REQUIRE(VALID_CONTEXT(ctx));
- return (atomic_load_acquire(&ctx->maxmalloced));
+ return atomic_load_acquire(&ctx->maxmalloced);
}
void
isc_mem_isovermem(isc_mem_t *ctx) {
REQUIRE(VALID_CONTEXT(ctx));
- return (atomic_load_relaxed(&ctx->is_overmem));
+ return atomic_load_relaxed(&ctx->is_overmem);
}
void
REQUIRE(VALID_CONTEXT(ctx));
if (ctx->name[0] == 0) {
- return ("");
+ return "";
}
- return (ctx->name);
+ return ctx->name;
}
/*
ADD_TRACE(mpctx->mctx, item, mpctx->size, file, line);
- return (item);
+ return item;
}
/* coverity[+free : arg-1] */
isc_mempool_getfreemax(isc_mempool_t *restrict mpctx) {
REQUIRE(VALID_MEMPOOL(mpctx));
- return (mpctx->freemax);
+ return mpctx->freemax;
}
unsigned int
isc_mempool_getfreecount(isc_mempool_t *restrict mpctx) {
REQUIRE(VALID_MEMPOOL(mpctx));
- return (mpctx->freecount);
+ return mpctx->freecount;
}
unsigned int
isc_mempool_getallocated(isc_mempool_t *restrict mpctx) {
REQUIRE(VALID_MEMPOOL(mpctx));
- return (mpctx->allocated);
+ return mpctx->allocated;
}
void
isc_mempool_getfillcount(isc_mempool_t *restrict mpctx) {
REQUIRE(VALID_MEMPOOL(mpctx));
- return (mpctx->fillcount);
+ return mpctx->fillcount;
}
/*
unsigned int
isc_mem_references(isc_mem_t *ctx) {
- return (isc_refcount_current(&ctx->references));
+ return isc_refcount_current(&ctx->references);
}
typedef struct summarystat {
error:
MCTXUNLOCK(ctx);
- return (xmlrc);
+ return xmlrc;
}
int
TRY0(xmlTextWriterEndElement(writer)); /* summary */
error:
- return (xmlrc);
+ return xmlrc;
}
#endif /* HAVE_LIBXML2 */
MCTXUNLOCK(ctx);
json_object_array_add(array, ctxobj);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
json_object_object_add(memobj, "Lost", obj);
json_object_object_add(memobj, "contexts", ctxarray);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
error:
if (ctxarray != NULL) {
json_object_put(ctxarray);
}
- return (result);
+ return result;
}
#endif /* HAVE_JSON_C */
int ret;
ret = mallctl(valname, NULL, NULL, &newval, sizeof(newval));
- return (ret == 0);
+ return ret == 0;
}
#endif /* defined(JEMALLOC_API_SUPPORTED) && JEMALLOC_VERSION_MAJOR >= 4 */
char buf[256] = { 0 };
if (mctx->jemalloc_arena == ISC_MEM_ILLEGAL_ARENA) {
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
(void)snprintf(buf, sizeof(buf), "arena.%u.%s", mctx->jemalloc_arena,
ret = jemalloc_set_ssize_value(buf, newval);
if (!ret) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#else
UNUSED(arena_valname);
UNUSED(newval);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
#endif /* defined(JEMALLOC_API_SUPPORTED) && JEMALLOC_VERSION_MAJOR >= 4 */
}
isc_result_t
isc_mem_arena_set_muzzy_decay_ms(isc_mem_t *mctx, const ssize_t decay_ms) {
- return (mem_set_arena_ssize_value(mctx, "muzzy_decay_ms", decay_ms));
+ return mem_set_arena_ssize_value(mctx, "muzzy_decay_ms", decay_ms);
}
isc_result_t
isc_mem_arena_set_dirty_decay_ms(isc_mem_t *mctx, const ssize_t decay_ms) {
- return (mem_set_arena_ssize_value(mctx, "dirty_decay_ms", decay_ms));
+ return mem_set_arena_ssize_value(mctx, "dirty_decay_ms", decay_ms);
}
void
uint64_t size = 0;
size_t len = sizeof(size);
if (sysctl(mib, 2, &size, &len, NULL, 0) == 0) {
- return (size);
+ return size;
}
#endif /* if defined(CTL_HW) && (defined(HW_PHYSMEM64) || defined(HW_MEMSIZE)) \
* */
long pagesize = sysconf(_SC_PAGESIZE);
if (pages < 0 || pagesize < 0) {
- return (0);
+ return 0;
}
- return ((uint64_t)pages * pagesize);
+ return (uint64_t)pages * pagesize;
#endif /* if defined(_SC_PHYS_PAGES) && defined(_SC_PAGESIZE) */
- return (0);
+ return 0;
}
result = isc_once_do(&once_attr, initialize_attr);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
- return (pthread_mutex_init(mp, &attr));
+ return pthread_mutex_init(mp, &attr);
#else /* HAVE_PTHREAD_MUTEX_ADAPTIVE_NP */
- return (pthread_mutex_init(mp, NULL));
+ return pthread_mutex_init(mp, NULL);
#endif /* HAVE_PTHREAD_MUTEX_ADAPTIVE_NP */
}
#ifdef EINVAL
case EINVAL:
#endif /* ifdef EINVAL */
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
default:
UNEXPECTED_SYSERROR(errno, "socket()");
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
}
(void)close(s);
- return (result);
+ return result;
}
static void
isc_result_t
isc_net_probeipv4(void) {
initialize();
- return (ipv4_result);
+ return ipv4_result;
}
isc_result_t
isc_net_probeipv6(void) {
initialize();
- return (ipv6_result);
+ return ipv6_result;
}
isc_result_t
isc_net_probeunix(void) {
initialize();
- return (unix_result);
+ return unix_result;
}
static void
isc_result_t
isc_net_probe_ipv6only(void) {
initialize_ipv6only();
- return (ipv6only_result);
+ return ipv6only_result;
}
isc_result_t
#ifdef __notyet__
initialize_ipv6pktinfo();
#endif /* ifdef __notyet__ */
- return (ipv6pktinfo_result);
+ return ipv6pktinfo_result;
}
#if defined(USE_SYSCTL_PORTRANGE)
portlen = sizeof(port_low);
if (sysctlbyname(sysctlname_lowport, &port_low, &portlen, NULL, 0) < 0)
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
portlen = sizeof(port_high);
if (sysctlbyname(sysctlname_hiport, &port_high, &portlen, NULL, 0) < 0)
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if ((port_low & ~0xffff) != 0 || (port_high & ~0xffff) != 0) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
*low = (in_port_t)port_low;
*high = (in_port_t)port_high;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#else /* !HAVE_SYSCTLBYNAME */
static isc_result_t
portlen = sizeof(port_low);
if (sysctl(mib_lo, miblen, &port_low, &portlen, NULL, 0) < 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
portlen = sizeof(port_high);
if (sysctl(mib_hi, miblen, &port_high, &portlen, NULL, 0) < 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if ((port_low & ~0xffff) != 0 || (port_high & ~0xffff) != 0) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
*low = (in_port_t)port_low;
*high = (in_port_t)port_high;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#endif /* HAVE_SYSCTLBYNAME */
#endif /* USE_SYSCTL_PORTRANGE */
*high = ISC_NET_PORTRANGEHIGH;
}
- return (ISC_R_SUCCESS); /* we currently never fail in this function */
+ return ISC_R_SUCCESS; /* we currently never fail in this function */
}
void
REQUIRE(a != NULL && b != NULL);
if (a->family != b->family) {
- return (false);
+ return false;
}
if (a->zone != b->zone) {
- return (false);
+ return false;
}
switch (a->family) {
case AF_INET:
if (a->type.in.s_addr != b->type.in.s_addr) {
- return (false);
+ return false;
}
break;
case AF_INET6:
0 ||
a->zone != b->zone)
{
- return (false);
+ return false;
}
break;
case AF_UNIX:
if (strcmp(a->type.un, b->type.un) != 0) {
- return (false);
+ return false;
}
break;
default:
- return (false);
+ return false;
}
- return (true);
+ return true;
}
bool
REQUIRE(a != NULL && b != NULL);
if (a->family != b->family) {
- return (false);
+ return false;
}
if (a->zone != b->zone && b->zone != 0) {
- return (false);
+ return false;
}
switch (a->family) {
ipabytes = 16;
break;
default:
- return (false);
+ return false;
}
/*
if (nbytes > 0) {
if (memcmp(pa, pb, nbytes) != 0) {
- return (false);
+ return false;
}
}
if (nbits > 0) {
byteb = pb[nbytes];
mask = (0xFF << (8 - nbits)) & 0xFF;
if ((bytea & mask) != (byteb & mask)) {
- return (false);
+ return false;
}
}
- return (true);
+ return true;
}
isc_result_t
case AF_UNIX:
alen = strlen(netaddr->type.un);
if (alen > isc_buffer_availablelength(target)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putmem(target,
(const unsigned char *)(netaddr->type.un),
alen);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
default:
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
r = inet_ntop(netaddr->family, type, abuf, sizeof(abuf));
if (r == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
alen = strlen(abuf);
if (netaddr->family == AF_INET6 && netaddr->zone != 0) {
zlen = snprintf(zbuf, sizeof(zbuf), "%%%u", netaddr->zone);
if (zlen < 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
INSIST((unsigned int)zlen < sizeof(zbuf));
}
if (alen + zlen > isc_buffer_availablelength(target)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putmem(target, (unsigned char *)abuf, alen);
isc_buffer_putmem(target, (unsigned char *)zbuf, (unsigned int)zlen);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
p = (const unsigned char *)&na->type.in;
ipbytes = 4;
if (prefixlen > 32) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
break;
case AF_INET6:
p = (const unsigned char *)&na->type.in6;
ipbytes = 16;
if (prefixlen > 128) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
break;
default:
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
nbytes = prefixlen / 8;
nbits = prefixlen % 8;
if (nbits != 0) {
INSIST(nbytes < ipbytes);
if ((p[nbytes] & (0xff >> nbits)) != 0U) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
nbytes++;
}
if (nbytes < ipbytes &&
memcmp(p + nbytes, zeros, ipbytes - nbytes) != 0)
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
ipbytes = 16;
break;
default:
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
for (i = 0; i < ipbytes; i++) {
if (p[i] != 0xFF) {
nbits++;
}
if ((c & 0xFF) != 0) {
- return (ISC_R_MASKNONCONTIG);
+ return ISC_R_MASKNONCONTIG;
}
i++;
}
for (; i < ipbytes; i++) {
if (p[i] != 0) {
- return (ISC_R_MASKNONCONTIG);
+ return ISC_R_MASKNONCONTIG;
}
}
*lenp = nbytes * 8 + nbits;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_result_t
isc_netaddr_frompath(isc_netaddr_t *netaddr, const char *path) {
if (strlen(path) > sizeof(netaddr->type.un) - 1) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memset(netaddr, 0, sizeof(*netaddr));
netaddr->family = AF_UNIX;
strlcpy(netaddr->type.un, path, sizeof(netaddr->type.un));
netaddr->zone = 0;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
uint32_t
isc_netaddr_getzone(const isc_netaddr_t *netaddr) {
- return (netaddr->zone);
+ return netaddr->zone;
}
void
isc_netaddr_ismulticast(const isc_netaddr_t *na) {
switch (na->family) {
case AF_INET:
- return (ISC_IPADDR_ISMULTICAST(na->type.in.s_addr));
+ return ISC_IPADDR_ISMULTICAST(na->type.in.s_addr);
case AF_INET6:
- return (IN6_IS_ADDR_MULTICAST(&na->type.in6));
+ return IN6_IS_ADDR_MULTICAST(&na->type.in6);
default:
- return (false); /* XXXMLG ? */
+ return false; /* XXXMLG ? */
}
}
isc_netaddr_isexperimental(const isc_netaddr_t *na) {
switch (na->family) {
case AF_INET:
- return (ISC_IPADDR_ISEXPERIMENTAL(na->type.in.s_addr));
+ return ISC_IPADDR_ISEXPERIMENTAL(na->type.in.s_addr);
default:
- return (false); /* XXXMLG ? */
+ return false; /* XXXMLG ? */
}
}
isc_netaddr_islinklocal(const isc_netaddr_t *na) {
switch (na->family) {
case AF_INET:
- return (false);
+ return false;
case AF_INET6:
- return (IN6_IS_ADDR_LINKLOCAL(&na->type.in6));
+ return IN6_IS_ADDR_LINKLOCAL(&na->type.in6);
default:
- return (false);
+ return false;
}
}
isc_netaddr_issitelocal(const isc_netaddr_t *na) {
switch (na->family) {
case AF_INET:
- return (false);
+ return false;
case AF_INET6:
- return (IN6_IS_ADDR_SITELOCAL(&na->type.in6));
+ return IN6_IS_ADDR_SITELOCAL(&na->type.in6);
default:
- return (false);
+ return false;
}
}
isc_netaddr_isnetzero(const isc_netaddr_t *na) {
switch (na->family) {
case AF_INET:
- return (ISC_IPADDR_ISNETZERO(na->type.in.s_addr));
+ return ISC_IPADDR_ISNETZERO(na->type.in.s_addr);
case AF_INET6:
- return (false);
+ return false;
default:
- return (false);
+ return false;
}
}
isc_netaddr_isloopback(const isc_netaddr_t *na) {
switch (na->family) {
case AF_INET:
- return (((ntohl(na->type.in.s_addr) & 0xff000000U) ==
- 0x7f000000U));
+ return (ntohl(na->type.in.s_addr) & 0xff000000U) == 0x7f000000U;
case AF_INET6:
- return (IN6_IS_ADDR_LOOPBACK(&na->type.in6));
+ return IN6_IS_ADDR_LOOPBACK(&na->type.in6);
default:
- return (false);
+ return false;
}
}
static bool
http_session_active(isc_nm_http_session_t *session) {
REQUIRE(VALID_HTTP2_SESSION(session));
- return (!session->closed && !session->closing);
+ return !session->closed && !session->closing;
}
static void *
http_malloc(size_t sz, isc_mem_t *mctx) {
- return (isc_mem_allocate(mctx, sz));
+ return isc_mem_allocate(mctx, sz);
}
static void *
void *data = isc_mem_allocate(mctx, msize);
memset(data, 0, msize);
- return (data);
+ return data;
}
static void *
http_realloc(void *p, size_t newsz, isc_mem_t *mctx) {
- return (isc_mem_reallocate(mctx, p, newsz));
+ return isc_mem_reallocate(mctx, p, newsz);
}
static void
REQUIRE(VALID_HTTP2_SESSION(session));
if (ISC_LIST_EMPTY(session->cstreams)) {
- return (NULL);
+ return NULL;
}
for (cstream = ISC_LIST_HEAD(session->cstreams); cstream != NULL;
ISC_LIST_PREPEND(session->cstreams, cstream, link);
}
- return (cstream);
+ return cstream;
}
static isc_result_t
if (result != ISC_R_SUCCESS) {
isc_mem_free(mctx, stream->uri);
isc_mem_put(mctx, stream, sizeof(http_cstream_t));
- return (result);
+ return result;
}
isc__nmsocket_attach(sock, &stream->httpsock);
ISC_LIST_PREPEND(sock->h2.session->cstreams, stream, link);
*streamp = stream;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
{
isc_buffer_putmem(cstream->rbuf, data, len);
} else {
- return (NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE);
+ return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
}
} else {
- return (NGHTTP2_ERR_CALLBACK_FAILURE);
+ return NGHTTP2_ERR_CALLBACK_FAILURE;
}
- return (0);
+ return 0;
}
static int
break;
}
- return (NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE);
+ return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
}
h2 = ISC_LIST_NEXT(h2, link);
}
if (h2 == NULL) {
- return (NGHTTP2_ERR_CALLBACK_FAILURE);
+ return NGHTTP2_ERR_CALLBACK_FAILURE;
}
- return (0);
+ return 0;
}
static int
session);
}
- return (rv);
+ return rv;
}
static void
rv = nghttp2_session_terminate_session(
session->ngsession, NGHTTP2_NO_ERROR);
if (rv != 0) {
- return (rv);
+ return rv;
}
/* Mark the session as closing one to finish it on a
* subsequent call to http_do_bio() */
session->closing = true;
}
} else {
- return (NGHTTP2_ERR_CALLBACK_FAILURE);
+ return NGHTTP2_ERR_CALLBACK_FAILURE;
}
- return (0);
+ return 0;
}
static int
*/
isc__nmsocket_prep_destroy(sock);
isc__nmsocket_detach(&sock);
- return (rv);
+ return rv;
}
static int
rv = on_server_stream_close_callback(stream_id, session);
}
- return (rv);
+ return rv;
}
static bool
cstream->response_status.code = strtoul(tmp, NULL, 10);
if (SUCCESSFUL_HTTP_STATUS(cstream->response_status.code)) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static bool
if (cstream->response_status.content_length == 0 ||
cstream->response_status.content_length > MAX_DNS_MESSAGE_SIZE)
{
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static bool
if (strncasecmp((const char *)value, type_dns_message, len) == 0) {
cstream->response_status.content_type_valid = true;
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static int
* - we closed the session prematurely before receiving all
* responses (i.e., because of a belated or partial response).
*/
- return (NGHTTP2_ERR_CALLBACK_FAILURE);
+ return NGHTTP2_ERR_CALLBACK_FAILURE;
}
INSIST(!ISC_LIST_EMPTY(session->cstreams));
}
if (!header_ok) {
- return (NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE);
+ return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
}
- return (0);
+ return 0;
}
static void
rv = nghttp2_submit_settings(session->ngsession, NGHTTP2_FLAG_NONE, iv,
sizeof(iv) / sizeof(iv[0]));
if (rv != 0) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
#define MAKE_NV(NAME, VALUE, VALUELEN) \
cstream = find_http_cstream(stream_id, session);
if (!cstream || cstream->stream_id != stream_id) {
/* We haven't found the stream, so we are not reading */
- return (NGHTTP2_ERR_CALLBACK_FAILURE);
+ return NGHTTP2_ERR_CALLBACK_FAILURE;
}
if (cstream->post) {
*data_flags |= NGHTTP2_DATA_FLAG_EOF;
}
- return (len);
+ return len;
} else {
*data_flags |= NGHTTP2_DATA_FLAG_EOF;
- return (0);
+ return 0;
}
- return (0);
+ return 0;
}
/*
sizeof(hdrs) / sizeof(hdrs[0]), &dp, stream);
}
if (stream_id < 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
stream->stream_id = stream_id;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
(!nghttp2_session_want_write(session->ngsession) &&
session->pending_write_data == NULL))
{
- return (false);
+ return false;
}
/* We need to attach to the session->handle earlier because as an
session->sending++;
isc_buffer_usedregion(send->pending_write_data, &send_data);
isc_nm_send(transphandle, &send_data, http_writecb, send);
- return (true);
+ return true;
nothing_to_send:
isc_nmhandle_detach(&transphandle);
- return (false);
+ return false;
}
static void
result = new_http_cstream(sock, &cstream);
if (result != ISC_R_SUCCESS) {
INSIST(cstream == NULL);
- return (result);
+ return result;
}
}
*streamp = cstream;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
REQUIRE(region->length <= MAX_DNS_MESSAGE_SIZE);
if (session->closed) {
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
INSIST(cstream != NULL);
}
error:
- return (result);
+ return result;
}
isc_result_t
isc__nm_http_read(handle, cb, cbarg);
if (!http_session_active(handle->sock->h2.session)) {
/* the callback was called by isc__nm_http_read() */
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
result = client_send(handle, region);
if (result != ISC_R_SUCCESS) {
goto error;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
error:
cstream = sock->h2.connect.cstream;
if (cstream->read_cb != NULL) {
cstream->read_cb(handle, result, NULL, cstream->read_cbarg);
}
- return (result);
+ return result;
}
static int
if (frame->hd.type != NGHTTP2_HEADERS ||
frame->headers.cat != NGHTTP2_HCAT_REQUEST)
{
- return (0);
+ return 0;
} else if (frame->hd.length > MAX_ALLOWED_DATA_IN_HEADERS) {
- return (NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE);
+ return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
}
if (session->nsstreams >= session->max_concurrent_streams) {
- return (NGHTTP2_ERR_CALLBACK_FAILURE);
+ return NGHTTP2_ERR_CALLBACK_FAILURE;
}
socket = isc_mem_get(session->mctx, sizeof(isc_nmsocket_t));
nghttp2_session_set_stream_user_data(ngsession, frame->hd.stream_id,
socket);
- return (0);
+ return 0;
}
static isc_http_error_responses_t
if (!isc_nm_http_path_isvalid(socket->h2.request_path)) {
isc_mem_free(socket->mgr->mctx, socket->h2.request_path);
socket->h2.request_path = NULL;
- return (ISC_HTTP_ERROR_BAD_REQUEST);
+ return ISC_HTTP_ERROR_BAD_REQUEST;
}
handler = http_endpoints_find(socket->h2.request_path,
} else {
isc_mem_free(socket->mgr->mctx, socket->h2.request_path);
socket->h2.request_path = NULL;
- return (ISC_HTTP_ERROR_NOT_FOUND);
+ return ISC_HTTP_ERROR_NOT_FOUND;
}
if (qstr != NULL) {
&socket->h2.query_data_len);
} else {
socket->h2.query_too_large = true;
- return (ISC_HTTP_ERROR_PAYLOAD_TOO_LARGE);
+ return ISC_HTTP_ERROR_PAYLOAD_TOO_LARGE;
}
} else {
- return (ISC_HTTP_ERROR_BAD_REQUEST);
+ return ISC_HTTP_ERROR_BAD_REQUEST;
}
}
- return (ISC_HTTP_ERROR_SUCCESS);
+ return ISC_HTTP_ERROR_SUCCESS;
}
static isc_http_error_responses_t
} else if (HEADER_MATCH(post, value, valuelen)) {
socket->h2.request_type = ISC_HTTP_REQ_POST;
} else {
- return (ISC_HTTP_ERROR_NOT_IMPLEMENTED);
+ return ISC_HTTP_ERROR_NOT_IMPLEMENTED;
}
- return (ISC_HTTP_ERROR_SUCCESS);
+ return ISC_HTTP_ERROR_SUCCESS;
}
static isc_http_error_responses_t
} else if (HEADER_MATCH(http, value, valuelen)) {
socket->h2.request_scheme = ISC_HTTP_SCHEME_HTTP;
} else {
- return (ISC_HTTP_ERROR_BAD_REQUEST);
+ return ISC_HTTP_ERROR_BAD_REQUEST;
}
- return (ISC_HTTP_ERROR_SUCCESS);
+ return ISC_HTTP_ERROR_SUCCESS;
}
static isc_http_error_responses_t
valuelen > tmplen ? tmplen : valuelen);
socket->h2.content_length = strtoul(tmp, NULL, 10);
if (socket->h2.content_length > MAX_DNS_MESSAGE_SIZE) {
- return (ISC_HTTP_ERROR_PAYLOAD_TOO_LARGE);
+ return ISC_HTTP_ERROR_PAYLOAD_TOO_LARGE;
} else if (socket->h2.content_length == 0) {
- return (ISC_HTTP_ERROR_BAD_REQUEST);
+ return ISC_HTTP_ERROR_BAD_REQUEST;
}
- return (ISC_HTTP_ERROR_SUCCESS);
+ return ISC_HTTP_ERROR_SUCCESS;
}
static isc_http_error_responses_t
if (!HEADER_MATCH(type_dns_message, value, valuelen)) {
resp = ISC_HTTP_ERROR_UNSUPPORTED_MEDIA_TYPE;
}
- return (resp);
+ return resp;
}
static isc_http_error_responses_t
valuelen);
}
- return (code);
+ return code;
}
static int
socket = nghttp2_session_get_stream_user_data(session,
frame->hd.stream_id);
if (socket == NULL) {
- return (NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE);
+ return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
}
socket->h2.headers_data_processed += (namelen + valuelen);
INSIST(socket != NULL);
if (socket->h2.headers_data_processed > MAX_ALLOWED_DATA_IN_HEADERS) {
- return (NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE);
+ return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
} else if (socket->h2.content_length > MAX_ALLOWED_DATA_IN_POST) {
- return (NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE);
+ return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
}
if (code == ISC_HTTP_ERROR_SUCCESS) {
- return (0);
+ return 0;
} else {
socket->h2.headers_error_code = code;
}
- return (0);
+ return 0;
}
static ssize_t
*data_flags |= NGHTTP2_DATA_FLAG_EOF;
}
- return (buflen);
+ return buflen;
}
static isc_result_t
* same HTTP/2 stream. Thus, we need to handle this case
* manually. We will return failure code so that it will be
* passed to the write callback. */
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
data_prd.source.ptr = socket;
rv = nghttp2_submit_response(ngsession, stream_id, nva, nvlen,
&data_prd);
if (rv != 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
socket->h2.response_submitted = true;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#define MAKE_ERROR_REPLY(tag, code, desc) \
{
if (error_responses[i].type == error) {
log_server_error_response(socket, &error_responses[i]);
- return (server_send_response(
+ return server_send_response(
ngsession, socket->h2.stream_id,
- &error_responses[i].header, 1, socket));
+ &error_responses[i].header, 1, socket);
}
}
- return (server_send_error_response(ISC_HTTP_ERROR_GENERIC, ngsession,
- socket));
+ return server_send_error_response(ISC_HTTP_ERROR_GENERIC, ngsession,
+ socket);
}
static void
server_call_cb(socket, ISC_R_SUCCESS, &data);
- return (0);
+ return 0;
error:
result = server_send_error_response(code, ngsession, socket);
if (result != ISC_R_SUCCESS) {
- return (NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE);
+ return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
}
- return (0);
+ return 0;
}
void
* the stream is still alive.
*/
if (socket == NULL) {
- return (0);
+ return 0;
}
- return (server_on_request_recv(ngsession, socket));
+ return server_on_request_recv(ngsession, socket);
}
break;
default:
break;
}
- return (0);
+ return 0;
}
static void
rv = nghttp2_submit_settings(session->ngsession, NGHTTP2_FLAG_NONE, iv,
1);
if (rv != 0) {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
/*
* detect this case.
*/
if (isc__nmsocket_closing(handle->sock) || httpserver == NULL) {
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
if (result != ISC_R_SUCCESS) {
/* XXXWPK do nothing? */
- return (result);
+ return result;
}
REQUIRE(VALID_NMSOCK(httplistensock));
if (isc__nmsocket_closing(httplistensock) ||
!atomic_load(&httplistensock->listening))
{
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
http_transpost_tcp_nodelay(handle);
/* TODO H2 */
http_do_bio(session, NULL, NULL, NULL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (result != ISC_R_SUCCESS) {
atomic_store(&sock->closed, true);
isc__nmsocket_detach(&sock);
- return (result);
+ return result;
}
isc__nmsocket_attach(sock, &sock->outer->h2.httpserver);
atomic_store(&sock->listening, true);
*sockp = sock;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_nm_http_endpoints_t *
REQUIRE(VALID_HTTP_ENDPOINTS(eps));
if (request_path == NULL || *request_path == '\0') {
- return (NULL);
+ return NULL;
}
for (handler = ISC_LIST_HEAD(eps->handlers); handler != NULL;
}
}
- return (handler);
+ return handler;
}
isc_result_t
ISC_LIST_APPEND(eps->handlers, handler, link);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
INSIST(VALID_HTTP2_SESSION(session));
if (session->handle == NULL) {
- return (false);
+ return false;
}
- return (isc_nm_socket_type(session->handle) == isc_nm_tlssocket);
+ return isc_nm_socket_type(session->handle) == isc_nm_tlssocket;
}
const char *
*/
if (session == NULL && sock->h2.connect.tls_peer_verify_string != NULL)
{
- return (sock->h2.connect.tls_peer_verify_string);
+ return sock->h2.connect.tls_peer_verify_string;
}
if (session == NULL) {
- return (NULL);
+ return NULL;
}
INSIST(VALID_HTTP2_SESSION(session));
if (session->handle == NULL) {
- return (NULL);
+ return NULL;
}
- return (isc_nm_verify_tls_peer_result_string(session->handle));
+ return isc_nm_verify_tls_peer_result_string(session->handle);
}
void
eps = listener->h2.listener_endpoints[tid];
INSIST(eps != NULL);
- return (eps);
+ return eps;
}
static const bool base64url_validation_table[256] = {
size_t i, k, len;
if (mem == NULL || base64url == NULL || base64url_len == 0) {
- return (NULL);
+ return NULL;
}
len = base64url_len % 4 ? base64url_len + (4 - base64url_len % 4)
res[i] = base64url[i];
} else {
isc_mem_free(mem, res);
- return (NULL);
+ return NULL;
}
break;
}
res[len] = '\0';
- return (res);
+ return res;
}
char *
size_t i;
if (mem == NULL || base64 == NULL || base64_len == 0) {
- return (NULL);
+ return NULL;
}
res = isc_mem_allocate(mem, base64_len + 1); /* '\0' */
res[i] = base64[i];
} else {
isc_mem_free(mem, res);
- return (NULL);
+ return NULL;
}
break;
}
res[i] = '\0';
- return (res);
+ return res;
}
void
REQUIRE(len != NULL);
if (query_string == NULL || query_string[0] == '\0') {
- return (false);
+ return false;
}
state = (isc_httpparser_state_t){ .str = query_string };
if (!rule_query_string(&state)) {
- return (false);
+ return false;
}
if (!state.query_found) {
- return (false);
+ return false;
}
*start = state.query;
*len = state.query_len;
- return (true);
+ return true;
}
static bool
}
if (!MATCH('\0')) {
- return (false);
+ return false;
}
ADVANCE();
- return (true);
+ return true;
}
static bool
rule_key_value_pair(isc_httpparser_state_t *st) {
if (!rule_key(st)) {
- return (false);
+ return false;
}
if (MATCH('=')) {
ADVANCE();
} else {
- return (false);
+ return false;
}
if (rule_value(st)) {
st->query_len = st->last_value_len;
}
} else {
- return (false);
+ return false;
}
if (MATCH('&')) {
ADVANCE();
}
- return (true);
+ return true;
}
static bool
st->last_key = GETP();
ADVANCE();
} else {
- return (false);
+ return false;
}
while (MATCH('_') || MATCH_ALNUM()) {
}
st->last_key_len = GETP() - st->last_key;
- return (true);
+ return true;
}
static bool
rule_value(isc_httpparser_state_t *st) {
const char *s = GETP();
if (!rule_value_char(st)) {
- return (false);
+ return false;
}
st->last_value = s;
/* skip */;
}
st->last_value_len = GETP() - st->last_value;
- return (true);
+ return true;
}
static bool
rule_value_char(isc_httpparser_state_t *st) {
if (rule_unreserved_char(st)) {
- return (true);
+ return true;
}
- return (rule_percent_charcode(st));
+ return rule_percent_charcode(st);
}
static bool
MATCH('~'))
{
ADVANCE();
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static bool
if (MATCH('%')) {
ADVANCE();
} else {
- return (false);
+ return false;
}
if (!MATCH_XDIGIT()) {
- return (false);
+ return false;
}
ADVANCE();
if (!MATCH_XDIGIT()) {
- return (false);
+ return false;
}
ADVANCE();
- return (true);
+ return true;
}
/*
if (MATCH('/')) {
ADVANCE();
} else {
- return (false);
+ return false;
}
(void)rule_loc_segments(st);
if (MATCH('\0')) {
ADVANCE();
} else {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static bool
rule_loc_segments(isc_http_location_parser_state_t *st) {
if (!rule_loc_segment_nz(st)) {
- return (false);
+ return false;
}
while (rule_loc_slash_segment(st)) {
/* zero or more */;
}
- return (true);
+ return true;
}
static bool
if (MATCH('/')) {
ADVANCE();
} else {
- return (false);
+ return false;
}
- return (rule_loc_segment(st));
+ return rule_loc_segment(st);
}
static bool
/* zero or more */;
}
- return (true);
+ return true;
}
static bool
rule_loc_segment_nz(isc_http_location_parser_state_t *st) {
if (!rule_loc_pchar(st)) {
- return (false);
+ return false;
}
while (rule_loc_pchar(st)) {
/* zero or more */;
}
- return (true);
+ return true;
}
static bool
rule_loc_pchar(isc_http_location_parser_state_t *st) {
if (rule_loc_unreserved(st)) {
- return (true);
+ return true;
} else if (rule_loc_pct_encoded(st)) {
- return (true);
+ return true;
} else if (rule_loc_sub_delims(st)) {
- return (true);
+ return true;
} else if (MATCH(':') || MATCH('@')) {
ADVANCE();
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static bool
MATCH('_') | MATCH('~'))
{
ADVANCE();
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static bool
rule_loc_pct_encoded(isc_http_location_parser_state_t *st) {
if (!MATCH('%')) {
- return (false);
+ return false;
}
ADVANCE();
if (!MATCH_XDIGIT()) {
- return (false);
+ return false;
}
ADVANCE();
if (!MATCH_XDIGIT()) {
- return (false);
+ return false;
}
ADVANCE();
- return (true);
+ return true;
}
static bool
MATCH('='))
{
ADVANCE();
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
state.str = path;
- return (rule_loc_path_absolute(&state));
+ return rule_loc_path_absolute(&state);
}
int
isc_nm_tid(void) {
- return (isc__nm_tid_v);
+ return isc__nm_tid_v;
}
bool
isc__nm_in_netthread(void) {
- return (isc__nm_tid_v >= 0);
+ return isc__nm_tid_v >= 0;
}
void
isc_nm_getloadbalancesockets(isc_nm_t *mgr) {
REQUIRE(VALID_NM(mgr));
- return (mgr->load_balance_sockets);
+ return mgr->load_balance_sockets;
}
void
SIGNAL(&mgr->wkstatecond);
UNLOCK(&mgr->lock);
- return ((isc_threadresult_t)0);
+ return (isc_threadresult_t)0;
}
static bool
}
}
- return (reschedule);
+ return reschedule;
}
/*
default:
UNREACHABLE();
}
- return (true);
+ return true;
}
static isc_result_t
ievent = ISC_LIST_HEAD(list);
if (ievent == NULL) {
/* There's nothing scheduled */
- return (ISC_R_EMPTY);
+ return ISC_R_EMPTY;
}
while (ievent != NULL) {
list, link);
UNLOCK(&worker->ievents[type].lock);
}
- return (ISC_R_SUSPEND);
+ return ISC_R_SUSPEND;
}
ievent = next;
}
/* We processed at least one */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void *
*event = (isc__netievent_storage_t){ .ni.type = type };
ISC_LINK_INIT(&(event->ni), link);
- return (event);
+ return event;
}
void
isc__nmsocket_active(isc_nmsocket_t *sock) {
REQUIRE(VALID_NMSOCK(sock));
if (sock->parent != NULL) {
- return (atomic_load(&sock->parent->active));
+ return atomic_load(&sock->parent->active);
}
- return (atomic_load(&sock->active));
+ return atomic_load(&sock->active);
}
bool
REQUIRE(VALID_NMSOCK(sock));
if (sock->parent != NULL) {
- return (atomic_compare_exchange_strong(&sock->parent->active,
- &(bool){ true }, false));
+ return atomic_compare_exchange_strong(&sock->parent->active,
+ &(bool){ true }, false);
}
- return (atomic_compare_exchange_strong(&sock->active, &(bool){ true },
- false));
+ return atomic_compare_exchange_strong(&sock->active, &(bool){ true },
+ false);
}
void
#endif
isc_refcount_init(&handle->references, 1);
- return (handle);
+ return handle;
}
isc_nmhandle_t *
}
#endif
- return (handle);
+ return handle;
}
void
isc_nmhandle_is_stream(isc_nmhandle_t *handle) {
REQUIRE(VALID_NMHANDLE(handle));
- return (handle->sock->type == isc_nm_tcpsocket ||
- handle->sock->type == isc_nm_tcpdnssocket ||
- handle->sock->type == isc_nm_tlssocket ||
- handle->sock->type == isc_nm_tlsdnssocket ||
- handle->sock->type == isc_nm_httpsocket);
+ return handle->sock->type == isc_nm_tcpsocket ||
+ handle->sock->type == isc_nm_tcpdnssocket ||
+ handle->sock->type == isc_nm_tlssocket ||
+ handle->sock->type == isc_nm_tlsdnssocket ||
+ handle->sock->type == isc_nm_httpsocket;
}
static void
isc_nmhandle_getdata(isc_nmhandle_t *handle) {
REQUIRE(VALID_NMHANDLE(handle));
- return (handle->opaque);
+ return handle->opaque;
}
void
isc__nmsocket_timer_running(isc_nmsocket_t *sock) {
REQUIRE(VALID_NMSOCK(sock));
- return (uv_is_active((uv_handle_t *)&sock->read_timer));
+ return uv_is_active((uv_handle_t *)&sock->read_timer);
}
void
break;
}
- return (req);
+ return req;
}
/*%<
int r;
if (atomic_load(&sock->reading)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
switch (sock->type) {
atomic_store(&sock->reading, true);
}
- return (result);
+ return result;
}
void
bool
isc__nm_closing(isc_nmsocket_t *sock) {
- return (atomic_load(&sock->mgr->closing));
+ return atomic_load(&sock->mgr->closing);
}
bool
isc__nmsocket_closing(isc_nmsocket_t *sock) {
- return (!isc__nmsocket_active(sock) || atomic_load(&sock->closing) ||
- isc__nm_closing(sock) ||
- (sock->server != NULL && !isc__nmsocket_active(sock->server)));
+ return !isc__nmsocket_active(sock) || atomic_load(&sock->closing) ||
+ isc__nm_closing(sock) ||
+ (sock->server != NULL && !isc__nmsocket_active(sock->server));
}
static isc_result_t
processbuffer(isc_nmsocket_t *sock) {
switch (sock->type) {
case isc_nm_tcpdnssocket:
- return (isc__nm_tcpdns_processbuffer(sock));
+ return isc__nm_tcpdns_processbuffer(sock);
case isc_nm_tlsdnssocket:
- return (isc__nm_tlsdns_processbuffer(sock));
+ return isc__nm_tlsdns_processbuffer(sock);
default:
UNREACHABLE();
}
}
result = isc__nm_start_reading(sock);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
/*
}
}
done:
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
REQUIRE(VALID_NMHANDLE(handle));
REQUIRE(VALID_NMSOCK(handle->sock));
- return (isc__nmsocket_timer_running(handle->sock));
+ return isc__nmsocket_timer_running(handle->sock);
}
void *
isc_nmhandle_getextra(isc_nmhandle_t *handle) {
REQUIRE(VALID_NMHANDLE(handle));
- return (handle->extra);
+ return handle->extra;
}
isc_sockaddr_t
isc_nmhandle_peeraddr(isc_nmhandle_t *handle) {
REQUIRE(VALID_NMHANDLE(handle));
- return (handle->peer);
+ return handle->peer;
}
isc_sockaddr_t
isc_nmhandle_localaddr(isc_nmhandle_t *handle) {
REQUIRE(VALID_NMHANDLE(handle));
- return (handle->local);
+ return handle->local;
}
isc_nm_t *
REQUIRE(VALID_NMHANDLE(handle));
REQUIRE(VALID_NMSOCK(handle->sock));
- return (handle->sock->mgr);
+ return handle->sock->mgr;
}
isc__nm_uvreq_t *
isc___nmsocket_attach(sock, &req->sock FLARG_PASS);
req->magic = UVREQ_MAGIC;
- return (req);
+ return req;
}
void
bool
isc__nm_acquire_interlocked(isc_nm_t *mgr) {
if (!isc__nm_in_netthread()) {
- return (false);
+ return false;
}
LOCK(&mgr->lock);
isc_nm_tid());
UNLOCK(&mgr->lock);
- return (success);
+ return success;
}
void
isc__nm_socket(int domain, int type, int protocol, uv_os_sock_t *sockp) {
int sock = socket(domain, type, protocol);
if (sock < 0) {
- return (isc_errno_toresult(errno));
+ return isc_errno_toresult(errno);
}
*sockp = (uv_os_sock_t)sock;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
#ifdef IP_FREEBIND
UNUSED(sa_family);
if (setsockopt_on(fd, IPPROTO_IP, IP_FREEBIND) == -1) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#elif defined(IP_BINDANY) || defined(IPV6_BINDANY)
if (sa_family == AF_INET) {
#if defined(IP_BINDANY)
if (setsockopt_on(fd, IPPROTO_IP, IP_BINDANY) == -1) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#endif
} else if (sa_family == AF_INET6) {
#if defined(IPV6_BINDANY)
if (setsockopt_on(fd, IPPROTO_IPV6, IPV6_BINDANY) == -1) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#endif
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
#elif defined(SO_BINDANY)
UNUSED(sa_family);
if (setsockopt_on(fd, SOL_SOCKET, SO_BINDANY) == -1) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#else
UNUSED(fd);
UNUSED(sa_family);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
#endif
}
#if defined(SO_REUSEPORT) && !defined(__linux__)
if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &val, sizeof(val)) == -1) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#elif defined(SO_REUSEADDR)
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) == -1) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#else
UNUSED(fd);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
#endif
}
*/
#if defined(SO_REUSEPORT_LB)
if (setsockopt_on(fd, SOL_SOCKET, SO_REUSEPORT_LB) == -1) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#elif defined(SO_REUSEPORT) && defined(__linux__)
if (setsockopt_on(fd, SOL_SOCKET, SO_REUSEPORT) == -1) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#else
UNUSED(fd);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
#endif
}
if (sa_family == AF_INET6) {
#if defined(IPV6_DONTFRAG)
if (setsockopt_off(fd, IPPROTO_IPV6, IPV6_DONTFRAG) == -1) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#elif defined(IPV6_MTU_DISCOVER) && defined(IP_PMTUDISC_OMIT)
if (setsockopt(fd, IPPROTO_IPV6, IPV6_MTU_DISCOVER,
&(int){ IP_PMTUDISC_OMIT }, sizeof(int)) == -1)
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#else
UNUSED(fd);
} else if (sa_family == AF_INET) {
#if defined(IP_DONTFRAG)
if (setsockopt_off(fd, IPPROTO_IP, IP_DONTFRAG) == -1) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#elif defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_OMIT)
if (setsockopt(fd, IPPROTO_IP, IP_MTU_DISCOVER,
&(int){ IP_PMTUDISC_OMIT }, sizeof(int)) == -1)
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#else
UNUSED(fd);
#endif
} else {
- return (ISC_R_FAMILYNOSUPPORT);
+ return ISC_R_FAMILYNOSUPPORT;
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
if (sa_family == AF_INET6) {
#if defined(IPV6_V6ONLY)
if (setsockopt_on(fd, IPPROTO_IPV6, IPV6_V6ONLY) == -1) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#else
UNUSED(fd);
#endif
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
proto = SOCK_DGRAM;
break;
default:
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
pf = isc_sockaddr_pf(addr);
fd = socket(pf, proto, 0);
if (fd < 0) {
- return (isc_errno_toresult(errno));
+ return isc_errno_toresult(errno);
}
r = bind(fd, (const struct sockaddr *)&addr->type.sa, addrlen);
if (r < 0) {
close(fd);
- return (isc_errno_toresult(errno));
+ return isc_errno_toresult(errno);
}
close(fd);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#if defined(TCP_CONNECTIONTIMEOUT)
if (setsockopt(fd, IPPROTO_TCP, TIMEOUT_OPTNAME, &timeout,
sizeof(timeout)) == -1)
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#else
UNUSED(fd);
UNUSED(timeout_ms);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#endif
}
isc__nm_socket_tcp_nodelay(uv_os_sock_t fd) {
#ifdef TCP_NODELAY
if (setsockopt_on(fd, IPPROTO_TCP, TCP_NODELAY) == -1) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#else
UNUSED(fd);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#endif
}
if (setsockopt(fd, IPPROTO_TCP, TCP_MAXSEG, (void *)&size,
sizeof(size)))
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#else
UNUSED(fd);
UNUSED(size);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#endif
}
isc_result_t
isc__nm_socket_min_mtu(uv_os_sock_t fd, sa_family_t sa_family) {
if (sa_family != AF_INET6) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#ifdef IPV6_USE_MIN_MTU
if (setsockopt_on(fd, IPPROTO_IPV6, IPV6_USE_MIN_MTU) == -1) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
#elif defined(IPV6_MTU)
if (setsockopt(fd, IPPROTO_IPV6, IPV6_MTU, &(int){ 1280 },
sizeof(int)) == -1)
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
#else
UNUSED(fd);
#endif
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
work->cb(work->data);
- return ((isc_threadresult_t)0);
+ return (isc_threadresult_t)0;
}
static void
break;
}
- return (result);
+ return result;
}
bool
REQUIRE(VALID_NMHANDLE(handle));
REQUIRE(VALID_NMSOCK(handle->sock));
- return (handle->sock->type == isc_nm_httpsocket);
+ return handle->sock->type == isc_nm_httpsocket;
}
void
REQUIRE(VALID_NMHANDLE(handle));
REQUIRE(VALID_NMSOCK(handle->sock));
- return (handle->sock->type);
+ return handle->sock->type;
}
bool
#if HAVE_LIBNGHTTP2
case isc_nm_tlssocket:
#endif /* HAVE_LIBNGHTTP2 */
- return (true);
+ return true;
#if HAVE_LIBNGHTTP2
case isc_nm_httpsocket:
- return (isc__nm_http_has_encryption(handle));
+ return isc__nm_http_has_encryption(handle);
#endif /* HAVE_LIBNGHTTP2 */
default:
- return (false);
+ return false;
};
- return (false);
+ return false;
}
void
sock = handle->sock;
switch (sock->type) {
case isc_nm_tlsdnssocket:
- return (isc__nm_tlsdns_verify_tls_peer_result_string(handle));
+ return isc__nm_tlsdns_verify_tls_peer_result_string(handle);
break;
#if HAVE_LIBNGHTTP2
case isc_nm_tlssocket:
- return (isc__nm_tls_verify_tls_peer_result_string(handle));
+ return isc__nm_tls_verify_tls_peer_result_string(handle);
break;
case isc_nm_httpsocket:
- return (isc__nm_http_verify_tls_peer_result_string(handle));
+ return isc__nm_http_verify_tls_peer_result_string(handle);
break;
#endif /* HAVE_LIBNGHTTP2 */
default:
break;
}
- return (NULL);
+ return NULL;
}
void
nmsocket_type_totext(isc_nmsocket_type type) {
switch (type) {
case isc_nm_udpsocket:
- return ("isc_nm_udpsocket");
+ return "isc_nm_udpsocket";
case isc_nm_udplistener:
- return ("isc_nm_udplistener");
+ return "isc_nm_udplistener";
case isc_nm_tcpsocket:
- return ("isc_nm_tcpsocket");
+ return "isc_nm_tcpsocket";
case isc_nm_tcplistener:
- return ("isc_nm_tcplistener");
+ return "isc_nm_tcplistener";
case isc_nm_tcpdnslistener:
- return ("isc_nm_tcpdnslistener");
+ return "isc_nm_tcpdnslistener";
case isc_nm_tcpdnssocket:
- return ("isc_nm_tcpdnssocket");
+ return "isc_nm_tcpdnssocket";
case isc_nm_tlssocket:
- return ("isc_nm_tlssocket");
+ return "isc_nm_tlssocket";
case isc_nm_tlslistener:
- return ("isc_nm_tlslistener");
+ return "isc_nm_tlslistener";
case isc_nm_tlsdnslistener:
- return ("isc_nm_tlsdnslistener");
+ return "isc_nm_tlsdnslistener";
case isc_nm_tlsdnssocket:
- return ("isc_nm_tlsdnssocket");
+ return "isc_nm_tlsdnssocket";
case isc_nm_httplistener:
- return ("isc_nm_httplistener");
+ return "isc_nm_httplistener";
case isc_nm_httpsocket:
- return ("isc_nm_httpsocket");
+ return "isc_nm_httpsocket";
default:
UNREACHABLE();
}
isc_stdtime_get(&now);
last = atomic_exchange_relaxed(&last_tcpquota_log, now);
if (now != last) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static isc_result_t
INSIST(atomic_load(&sock->active));
UNLOCK(&sock->lock);
- return (result);
+ return result;
}
void
RUNTIME_CHECK(result == ISC_R_SUCCESS);
}
- return (sock);
+ return sock;
}
static void
isc_nmsocket_close(&sock);
}
- return (result);
+ return result;
}
void
if (quota != NULL) {
isc_quota_detach("a);
}
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
csock = isc_mem_get(ssock->mgr->mctx, sizeof(isc_nmsocket_t));
*/
isc__nmsocket_detach(&csock);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
atomic_store(&csock->active, false);
isc__nmsocket_detach(&csock);
- return (result);
+ return result;
}
void
int r;
if (isc__nmsocket_closing(sock)) {
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
r = uv_write(&req->uv_req.write, &sock->uv_handle.stream, &req->uvbuf,
1, tcp_send_cb);
if (r < 0) {
- return (isc__nm_uverr2result(r));
+ return isc__nm_uverr2result(r);
}
isc_nm_timer_create(req->handle, isc__nmsocket_writetimeout_cb, req,
isc_nm_timer_start(req->timer, sock->write_timeout);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
nactive = atomic_load(&listener->active_child_connections);
INSIST(nactive >= 0);
- return (nactive);
+ return nactive;
}
isc_stdtime_get(&now);
last = atomic_exchange_relaxed(&last_tcpdnsquota_log, now);
if (now != last) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static isc_result_t
INSIST(atomic_load(&sock->active));
UNLOCK(&sock->lock);
- return (result);
+ return result;
}
void
RUNTIME_CHECK(result == ISC_R_SUCCESS);
}
- return (sock);
+ return sock;
}
static void
isc_nmsocket_close(&sock);
}
- return (result);
+ return result;
}
void
REQUIRE(sock->tid == isc_nm_tid());
if (isc__nmsocket_closing(sock)) {
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
/*
* anything.
*/
if (sock->buf_len < 2) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
/*
*/
len = ntohs(*(uint16_t *)sock->buf);
if (len > sock->buf_len - 2) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
if (sock->recv_cb == NULL) {
* recv_cb has been cleared - there is
* nothing to do
*/
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
} else if (sock->statichandle == NULL &&
atomic_load(&sock->connected) &&
!atomic_load(&sock->connecting))
* It seems that some unexpected data (a DNS message) has
* arrived while we are wrapping up.
*/
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
if (sock->client && !sock->recv_read) {
/*
* We are not reading data - stop here.
*/
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
req = isc__nm_get_read_req(sock, NULL);
isc_nmhandle_detach(&handle);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
if (quota != NULL) {
isc_quota_detach("a);
}
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
REQUIRE(ssock->accept_cb != NULL);
*/
isc__nmsocket_detach(&csock);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
isc__nmsocket_detach(&csock);
- return (result);
+ return result;
}
void
if (sock->tls.tls != NULL && sock->tls.state == TLS_STATE_HANDSHAKE &&
SSL_get_verify_result(sock->tls.tls) != X509_V_OK)
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static bool
isc_stdtime_get(&now);
last = atomic_exchange_relaxed(&last_tlsdnsquota_log, now);
if (now != last) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static isc_result_t
INSIST(atomic_load(&sock->active));
UNLOCK(&sock->lock);
- return (result);
+ return result;
}
void
RUNTIME_CHECK(result == ISC_R_SUCCESS);
}
- return (sock);
+ return sock;
}
static void
isc_nmsocket_close(&sock);
}
- return (result);
+ return result;
}
void
REQUIRE(sock->tid == isc_nm_tid());
if (isc__nmsocket_closing(sock)) {
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
/*
* anything.
*/
if (sock->buf_len < 2) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
/*
*/
len = ntohs(*(uint16_t *)sock->buf);
if (len > sock->buf_len - 2) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
if (sock->recv_cb == NULL) {
* recv_cb has been cleared - there is
* nothing to do
*/
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
} else if (sock->statichandle == NULL &&
sock->tls.state == TLS_STATE_IO &&
atomic_load(&sock->connected) &&
* It seems that some unexpected data (a DNS message) has
* arrived while we are wrapping up.
*/
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
if (sock->client && !sock->recv_read) {
/*
* We are not reading data - stop here.
*/
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
req = isc__nm_get_read_req(sock, NULL);
tlsdns_keep_client_tls_session(sock);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
/* Everything is ok, continue */
break;
case SSL_ERROR_ZERO_RETURN:
- return (ISC_R_EOF);
+ return ISC_R_EOF;
default:
- return (ISC_R_TLSERROR);
+ return ISC_R_TLSERROR;
}
/* Stop state after handshake */
async_tlsdns_cycle(sock);
}
failure:
- return (result);
+ return result;
}
static void
break;
}
- return (result);
+ return result;
}
static isc_result_t
isc_result_t result;
if (sock->tls.state != TLS_STATE_ERROR) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (sock->tls.pending_error == ISC_R_SUCCESS) {
- return (ISC_R_TLSERROR);
+ return ISC_R_TLSERROR;
}
result = sock->tls.pending_error;
sock->tls.pending_error = ISC_R_SUCCESS;
- return (result);
+ return result;
}
static isc_result_t
ERR_clear_error();
if (isc__nmsocket_closing(sock)) {
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
result = tls_pop_error(sock);
}
if (sock->tls.cycle) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
sock->tls.cycle = true;
done:
sock->tls.cycle = false;
- return (result);
+ return result;
}
static void
if (quota != NULL) {
isc_quota_detach("a);
}
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
REQUIRE(ssock->accept_cb != NULL);
*/
isc__nmsocket_detach(&csock);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
atomic_store(&csock->active, false);
isc__nmsocket_detach(&csock);
- return (result);
+ return result;
}
void
result = tls_pop_error(sock);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (isc__nmsocket_closing(sock)) {
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
/* Writes won't succeed until handshake end */
ISC_LIST_APPEND(sock->tls.sendreqs, req, link);
async_tlsdns_cycle(sock);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* Nothing was written, maybe enqueue? */
case 0:
UNREACHABLE();
default:
- return (ISC_R_TLSERROR);
+ return ISC_R_TLSERROR;
}
cycle:
result = tls_cycle(sock);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
requeue:
tlsdns_send_enqueue(sock, req);
- return (result);
+ return result;
}
static void
REQUIRE(sock->type == isc_nm_tlsdnssocket);
if (!sock->tls.alpn_negotiated) {
- return (ISC_R_DOTALPNERROR);
+ return ISC_R_DOTALPNERROR;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
const char *
sock = handle->sock;
if (sock->tls.tls == NULL) {
- return (sock->tls.tls_verify_errmsg);
+ return sock->tls.tls_verify_errmsg;
}
- return (isc_tls_verify_peer_result_string(sock->tls.tls));
+ return isc_tls_verify_peer_result_string(sock->tls.tls);
}
void
tls_error_to_result(const int tls_err, const int tls_state, isc_tls_t *tls) {
switch (tls_err) {
case SSL_ERROR_ZERO_RETURN:
- return (ISC_R_EOF);
+ return ISC_R_EOF;
case SSL_ERROR_SSL:
if (tls != NULL && tls_state < TLS_IO &&
SSL_get_verify_result(tls) != X509_V_OK)
{
- return (ISC_R_TLSBADPEERCERT);
+ return ISC_R_TLSBADPEERCERT;
}
- return (ISC_R_TLSERROR);
+ return ISC_R_TLSERROR;
default:
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
}
*/
static bool
inactive(isc_nmsocket_t *sock) {
- return (!isc__nmsocket_active(sock) || atomic_load(&sock->closing) ||
- sock->outerhandle == NULL ||
- !isc__nmsocket_active(sock->outerhandle->sock) ||
- atomic_load(&sock->outerhandle->sock->closing) ||
- (sock->listener != NULL &&
- !isc__nmsocket_active(sock->listener)) ||
- isc__nm_closing(sock));
+ return !isc__nmsocket_active(sock) || atomic_load(&sock->closing) ||
+ sock->outerhandle == NULL ||
+ !isc__nmsocket_active(sock->outerhandle->sock) ||
+ atomic_load(&sock->outerhandle->sock->closing) ||
+ (sock->listener != NULL &&
+ !isc__nmsocket_active(sock->listener)) ||
+ isc__nm_closing(sock);
}
static void
INSIST(VALID_NMHANDLE(tlshandle));
cb(tlshandle, ISC_R_CANCELED, cbarg);
}
- return (0);
+ return 0;
}
if (finish) {
pending = BIO_pending(sock->tlsstream.bio_out);
if (pending <= 0) {
- return (pending);
+ return pending;
}
/* TODO Should we keep track of these requests in a list? */
sock->tlsstream.nsending++;
isc_nm_send(sock->outerhandle, &send_req->data, tls_senddone, send_req);
- return (pending);
+ return pending;
}
static int
pending = tls_send_outgoing(sock, finish, NULL, NULL, NULL);
}
- return (pending);
+ return pending;
}
static int
REQUIRE(sock->tlsstream.state == TLS_HANDSHAKE);
if (SSL_is_init_finished(sock->tlsstream.tls) == 1) {
- return (0);
+ return 0;
}
rv = SSL_do_handshake(sock->tlsstream.tls);
}
}
- return (rv);
+ return rv;
}
static bool
* close the connection.
*/
isc__nmsocket_prep_destroy(sock);
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static void
sock->tlsstream.bio_in = BIO_new(BIO_s_mem());
if (sock->tlsstream.bio_in == NULL) {
isc_tls_free(&sock->tlsstream.tls);
- return (ISC_R_TLSERROR);
+ return ISC_R_TLSERROR;
}
sock->tlsstream.bio_out = BIO_new(BIO_s_mem());
if (sock->tlsstream.bio_out == NULL) {
BIO_free_all(sock->tlsstream.bio_in);
sock->tlsstream.bio_in = NULL;
isc_tls_free(&sock->tlsstream.tls);
- return (ISC_R_TLSERROR);
+ return ISC_R_TLSERROR;
}
if (BIO_set_mem_eof_return(sock->tlsstream.bio_in, EOF) != 1 ||
sock->tlsstream.server = server;
sock->tlsstream.nsending = 0;
sock->tlsstream.state = TLS_INIT;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
error:
isc_tls_free(&sock->tlsstream.tls);
sock->tlsstream.bio_out = sock->tlsstream.bio_in = NULL;
- return (ISC_R_TLSERROR);
+ return ISC_R_TLSERROR;
}
static isc_result_t
/* If accept() was unsuccessful we can't do anything */
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
REQUIRE(VALID_NMHANDLE(handle));
isc__nmsocket_closing(tlslistensock) ||
!atomic_load(&tlslistensock->listening))
{
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
/*
atomic_store(&tlssock->closed, true);
isc_tlsctx_free(&tlssock->tlsstream.ctx);
isc__nmsocket_detach(&tlssock);
- return (ISC_R_TLSERROR);
+ return ISC_R_TLSERROR;
}
tlssock->extrahandlesize = tlslistensock->extrahandlesize;
/* TODO: catch failure code, detach tlssock, and log the error */
tls_do_bio(tlssock, NULL, NULL, false);
- return (result);
+ return result;
}
isc_result_t
REQUIRE(VALID_NM(mgr));
if (atomic_load(&mgr->closing)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
tlssock = isc_mem_get(mgr->mctx, sizeof(*tlssock));
if (result != ISC_R_SUCCESS) {
atomic_store(&tlssock->closed, true);
isc__nmsocket_detach(&tlssock);
- return (result);
+ return result;
}
/* wait for listen result */
*sockp = tlssock;
}
- return (result);
+ return result;
}
void
sock = handle->sock;
if (sock->tlsstream.tls == NULL) {
- return (NULL);
+ return NULL;
}
- return (isc_tls_verify_peer_result_string(sock->tlsstream.tls));
+ return isc_tls_verify_peer_result_string(sock->tlsstream.tls);
}
static void
REQUIRE(tid >= 0);
if (listener->tlsstream.listener_tls_ctx == NULL) {
- return (NULL);
+ return NULL;
}
- return (listener->tlsstream.listener_tls_ctx[tid]);
+ return listener->tlsstream.listener_tls_ctx[tid];
}
void
RUNTIME_CHECK(result == ISC_R_SUCCESS);
}
- return (sock);
+ return sock;
}
static void
isc_nmsocket_close(&sock);
}
- return (result);
+ return result;
}
#ifdef USE_ROUTE_SOCKET
result = isc__nm_socket(ROUTE_SOCKET_PF, SOCK_RAW,
ROUTE_SOCKET_PROTOCOL, &fd);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
#ifdef USE_NETLINK
r = bind(fd, (struct sockaddr *)&sa, sizeof(sa));
if (r < 0) {
isc__nm_closesocket(fd);
- return (isc_errno_toresult(r));
+ return isc_errno_toresult(r);
}
#endif
*fdp = fd;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
INSIST(atomic_load(&sock->active));
UNLOCK(&sock->lock);
- return (result);
+ return result;
}
/*
isc__nm_connectcb(sock, req, result, true);
atomic_store(&sock->closed, true);
isc__nmsocket_detach(&sock);
- return (result);
+ return result;
}
event = isc__nm_get_netievent_routeconnect(mgr, sock, req);
BROADCAST(&sock->scond);
UNLOCK(&sock->lock);
- return (sock->result);
+ return sock->result;
#else /* USE_ROUTE_SOCKET */
UNUSED(mgr);
UNUSED(cb);
UNUSED(cbarg);
UNUSED(extrahandlesize);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
#endif /* USE_ROUTE_SOCKET */
}
* bigger than 'maxudp' bytes for testing purposes.
*/
maxudp = atomic_load(&sock->mgr->maxudp);
- if ((maxudp != 0 && (uint32_t)nrecv > maxudp)) {
+ if (maxudp != 0 && (uint32_t)nrecv > maxudp) {
/*
* We need to keep the read_cb intact in case, so the
* readtimeout_cb can trigger and not crash because of
isc_stdtime_get(&now);
isc_stdtime_t last = atomic_exchange_relaxed(&last_udpsends_log, now);
if (now != last) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
/*
REQUIRE(sock->type == isc_nm_udpsocket);
if (isc__nmsocket_closing(sock)) {
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
#if UV_VERSION_HEX >= UV_VERSION(1, 27, 0)
isc__nm_uverr2result(r)));
}
- return (isc__nm_uverr2result(r));
+ return isc__nm_uverr2result(r);
}
isc__nm_sendcb(sock, req, ISC_R_SUCCESS, true);
r = uv_udp_send(&req->uv_req.udp_send, &sock->uv_handle.udp,
&req->uvbuf, 1, sa, udp_send_cb);
if (r < 0) {
- return (isc__nm_uverr2result(r));
+ return isc__nm_uverr2result(r);
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
INSIST(atomic_load(&sock->active));
UNLOCK(&sock->lock);
- return (result);
+ return result;
}
/*
if (err) {
#if UV_VERSION_HEX >= UV_VERSION(1, 10, 0)
- return (uv_translate_sys_error(errno));
+ return uv_translate_sys_error(errno);
#else
- return (-errno);
+ return -errno;
#endif /* UV_VERSION_HEX >= UV_VERSION(1, 10, 0) */
}
- return (0);
+ return 0;
}
#endif /* UV_VERSION_HEX < UV_VERSION(1, 27, 0) */
&(struct linger){ 1, 0 }, sizeof(struct linger)) == -1)
{
#if UV_VERSION_HEX >= UV_VERSION(1, 10, 0)
- return (uv_translate_sys_error(errno));
+ return uv_translate_sys_error(errno);
#else
- return (-errno);
+ return -errno;
#endif /* UV_VERSION_HEX >= UV_VERSION(1, 10, 0) */
}
uv_close((uv_handle_t *)handle, close_cb);
- return (0);
+ return 0;
}
#endif /* UV_VERSION_HEX < UV_VERSION(1, 32, 0) */
r = uv_fileno((const uv_handle_t *)handle, (uv_os_fd_t *)&fd);
if (r < 0) {
- return (r);
+ return r;
}
r = uv_udp_bind(handle, addr, flags);
r = uv_udp_bind(handle, addr, flags);
}
- return (r);
+ return r;
}
static int
r = uv_tcp_bind(handle, addr, flags);
if (r < 0) {
- return (r);
+ return r;
}
/*
*/
r = uv_tcp_getsockname(handle, (struct sockaddr *)&sname, &snamelen);
if (r < 0) {
- return (r);
+ return r;
}
- return (0);
+ return 0;
}
int
r = uv_fileno((const uv_handle_t *)handle, (uv_os_fd_t *)&fd);
if (r < 0) {
- return (r);
+ return r;
}
r = isc__uv_tcp_bind_now(handle, addr, flags);
r = isc__uv_tcp_bind_now(handle, addr, flags);
}
- return (r);
+ return r;
}
#if UV_VERSION_HEX < UV_VERSION(1, 19, 0)
static inline void *
uv_handle_get_data(const uv_handle_t *handle) {
- return (handle->data);
+ return handle->data;
}
static inline void
static inline void *
uv_req_get_data(const uv_req_t *req) {
- return (req->data);
+ return req->data;
}
static inline void
char *buf = getenv(name);
if (buf == NULL) {
- return (UV_ENOENT);
+ return UV_ENOENT;
}
len = strlen(buf) + 1;
if (len > *size) {
*size = len;
- return (UV_ENOBUFS);
+ return UV_ENOBUFS;
}
*size = len;
memmove(buffer, buf, len);
- return (0);
+ return 0;
}
#define uv_os_setenv(name, value) setenv(name, value, 0)
unsigned int line, const char *func) {
switch (uverr) {
case 0:
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
case UV_ENOTDIR:
case UV_ELOOP:
case UV_EINVAL: /* XXX sometimes this is not for files */
case UV_ENAMETOOLONG:
case UV_EBADF:
- return (ISC_R_INVALIDFILE);
+ return ISC_R_INVALIDFILE;
case UV_ENOENT:
- return (ISC_R_FILENOTFOUND);
+ return ISC_R_FILENOTFOUND;
case UV_EAGAIN:
- return (ISC_R_NOCONN);
+ return ISC_R_NOCONN;
case UV_EACCES:
case UV_EPERM:
- return (ISC_R_NOPERM);
+ return ISC_R_NOPERM;
case UV_EEXIST:
- return (ISC_R_FILEEXISTS);
+ return ISC_R_FILEEXISTS;
case UV_EIO:
- return (ISC_R_IOERROR);
+ return ISC_R_IOERROR;
case UV_ENOMEM:
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
case UV_ENFILE:
case UV_EMFILE:
- return (ISC_R_TOOMANYOPENFILES);
+ return ISC_R_TOOMANYOPENFILES;
case UV_ENOSPC:
- return (ISC_R_DISCFULL);
+ return ISC_R_DISCFULL;
case UV_EPIPE:
case UV_ECONNRESET:
case UV_ECONNABORTED:
- return (ISC_R_CONNECTIONRESET);
+ return ISC_R_CONNECTIONRESET;
case UV_ENOTCONN:
- return (ISC_R_NOTCONNECTED);
+ return ISC_R_NOTCONNECTED;
case UV_ETIMEDOUT:
- return (ISC_R_TIMEDOUT);
+ return ISC_R_TIMEDOUT;
case UV_ENOBUFS:
- return (ISC_R_NORESOURCES);
+ return ISC_R_NORESOURCES;
case UV_EAFNOSUPPORT:
- return (ISC_R_FAMILYNOSUPPORT);
+ return ISC_R_FAMILYNOSUPPORT;
case UV_ENETDOWN:
- return (ISC_R_NETDOWN);
+ return ISC_R_NETDOWN;
case UV_EHOSTDOWN:
- return (ISC_R_HOSTDOWN);
+ return ISC_R_HOSTDOWN;
case UV_ENETUNREACH:
- return (ISC_R_NETUNREACH);
+ return ISC_R_NETUNREACH;
case UV_EHOSTUNREACH:
- return (ISC_R_HOSTUNREACH);
+ return ISC_R_HOSTUNREACH;
case UV_EADDRINUSE:
- return (ISC_R_ADDRINUSE);
+ return ISC_R_ADDRINUSE;
case UV_EADDRNOTAVAIL:
- return (ISC_R_ADDRNOTAVAIL);
+ return ISC_R_ADDRNOTAVAIL;
case UV_ECONNREFUSED:
- return (ISC_R_CONNREFUSED);
+ return ISC_R_CONNREFUSED;
case UV_ECANCELED:
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
case UV_EOF:
- return (ISC_R_EOF);
+ return ISC_R_EOF;
case UV_EMSGSIZE:
- return (ISC_R_MAXSIZE);
+ return ISC_R_MAXSIZE;
case UV_ENOTSUP:
- return (ISC_R_FAMILYNOSUPPORT);
+ return ISC_R_FAMILYNOSUPPORT;
case UV_ENOPROTOOPT:
case UV_EPROTONOSUPPORT:
- return (ISC_R_INVALIDPROTO);
+ return ISC_R_INVALIDPROTO;
default:
if (dolog) {
UNEXPECTED_ERROR("unable to convert libuv error code "
func, file, line, uverr,
uv_strerror(uverr));
}
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
}
/* at this moment, we only support AF_INET6 */
if (af != AF_INET6) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
#endif /* ifdef HAVE_IF_NAMETOINDEX */
llz = strtoull(scopename, &ep, 10);
if (ep == scopename) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* check overflow */
zone = (uint32_t)(llz & 0xffffffffUL);
if (zone != llz) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
#ifdef HAVE_IF_NAMETOINDEX
}
#endif /* ifdef HAVE_IF_NAMETOINDEX */
*zoneid = zone;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (ret != NULL) {
memset(ret, 0, num);
}
- return (ret);
+ return ret;
}
#endif /* if !HAVE_CRYPTO_ZALLOC */
EVP_CIPHER_CTX *
EVP_CIPHER_CTX_new(void) {
EVP_CIPHER_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
- return (ctx);
+ return ctx;
}
#endif /* if !HAVE_EVP_CIPHER_CTX_NEW */
#if !HAVE_EVP_MD_CTX_RESET
int
EVP_MD_CTX_reset(EVP_MD_CTX *ctx) {
- return (EVP_MD_CTX_cleanup(ctx));
+ return EVP_MD_CTX_cleanup(ctx);
}
#endif /* if !HAVE_EVP_MD_CTX_RESET */
rv = 1;
}
- return (rv);
+ return rv;
}
#endif
rv = 1;
}
- return (rv);
+ return rv;
}
#endif
rv = 1;
}
- return (rv);
+ return rv;
}
#endif
rv = 1;
}
- return (rv);
+ return rv;
}
#endif
rv = 1;
}
- return (rv);
+ return rv;
}
#endif
OpenSSL_add_all_ciphers();
}
- return (1);
+ return 1;
}
#endif
SSL_load_error_strings();
}
- return (1);
+ return 1;
}
#endif
#if !HAVE_SSL_CTX_UP_REF
int
SSL_CTX_up_ref(SSL_CTX *ctx) {
- return (CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX) > 0);
+ return CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX) > 0;
}
#endif /* !HAVE_SSL_CTX_UP_REF */
int
X509_STORE_up_ref(X509_STORE *store) {
- return (CRYPTO_add(&store->references, 1, CRYPTO_LOCK_X509_STORE) > 0);
+ return CRYPTO_add(&store->references, 1, CRYPTO_LOCK_X509_STORE) > 0;
}
#endif /* !HAVE_OPENSSL_CLEANUP */
static long
sysconf_ncpus(void) {
#if defined(_SC_NPROCESSORS_ONLN)
- return (sysconf((_SC_NPROCESSORS_ONLN)));
+ return sysconf(_SC_NPROCESSORS_ONLN);
#elif defined(_SC_NPROC_ONLN)
- return (sysconf((_SC_NPROC_ONLN)));
+ return sysconf(_SC_NPROC_ONLN);
#else /* if defined(_SC_NPROCESSORS_ONLN) */
- return (0);
+ return 0;
#endif /* if defined(_SC_NPROCESSORS_ONLN) */
}
#endif /* HAVE_SYSCONF */
len = sizeof(ncpu);
result = sysctlbyname("hw.ncpu", &ncpu, &len, 0, 0);
if (result != -1) {
- return (ncpu);
+ return ncpu;
}
- return (0);
+ return 0;
}
#endif /* if defined(HAVE_SYS_SYSCTL_H) && defined(HAVE_SYSCTLBYNAME) */
result = sched_getaffinity(0, sizeof(cpus), &cpus);
if (result != -1) {
#ifdef CPU_COUNT
- return (CPU_COUNT(&cpus));
+ return CPU_COUNT(&cpus);
#else
int i, n = 0;
if (CPU_ISSET(i, &cpus))
++n;
}
- return (n);
+ return n;
#endif
}
- return (0);
+ return 0;
}
#endif
if (CPU_ISSET(i, &cpus))
++n;
}
- return (n);
+ return n;
}
- return (0);
+ return 0;
}
#endif
unsigned int
isc_os_ncpus(void) {
- return (isc__os_ncpus);
+ return isc__os_ncpus;
}
unsigned long
isc_os_cacheline(void) {
- return (isc__os_cacheline);
+ return isc__os_cacheline;
}
mode_t
isc_os_umask(void) {
- return (isc__os_umask);
+ return isc__os_umask;
}
void
uint32_t r;
char *e;
if (!isalnum((unsigned char)(string[0]))) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
errno = 0;
n = strtoul(string, &e, base);
if (*e != '\0') {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
/*
* Where long is 64 bits we need to convert to 32 bits then test for
*/
r = (uint32_t)n;
if ((n == ULONG_MAX && errno == ERANGE) || (n != (unsigned long)r)) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
*uip = r;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
isc_result_t result;
result = isc_parse_uint32(&val, string, base);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (val > 0xFFFF) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
*uip = (uint16_t)val;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
isc_result_t result;
result = isc_parse_uint32(&val, string, base);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (val > 0xFF) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
*uip = (uint8_t)val;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
memset(pool->pool, 0, count * sizeof(void *));
*poolp = pool;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
/* Allocate the pool structure */
result = alloc_pool(mctx, count, &pool);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
pool->free = release;
result = init(&pool->pool[i], initarg);
if (result != ISC_R_SUCCESS) {
isc_pool_destroy(&pool);
- return (result);
+ return result;
}
}
*poolp = pool;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void *
isc_pool_get(isc_pool_t *pool) {
- return (pool->pool[isc_random_uniform(pool->count)]);
+ return pool->pool[isc_random_uniform(pool->count)];
}
int
isc_pool_count(isc_pool_t *pool) {
REQUIRE(pool != NULL);
- return (pool->count);
+ return pool->count;
}
isc_result_t
/* Allocate a new pool structure */
result = alloc_pool(pool->mctx, count, &newpool);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
newpool->free = pool->free;
newpool->initarg);
if (result != ISC_R_SUCCESS) {
isc_pool_destroy(&newpool);
- return (result);
+ return result;
}
}
}
*targetp = pool;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
static bool
portset_isset(isc_portset_t *portset, in_port_t port) {
- return ((portset->buf[port >> 5] & ((uint32_t)1 << (port & 31))) != 0);
+ return (portset->buf[port >> 5] & ((uint32_t)1 << (port & 31))) != 0;
}
static void
memset(portset, 0, sizeof(*portset));
*portsetp = portset;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_portset_isset(isc_portset_t *portset, in_port_t port) {
REQUIRE(portset != NULL);
- return (portset_isset(portset, port));
+ return portset_isset(portset, port);
}
unsigned int
isc_portset_nports(isc_portset_t *portset) {
REQUIRE(portset != NULL);
- return (portset->nports);
+ return portset->nports;
}
void
unsigned int
isc_quota_getmax(isc_quota_t *quota) {
REQUIRE(VALID_QUOTA(quota));
- return (atomic_load_relaxed("a->max));
+ return atomic_load_relaxed("a->max);
}
unsigned int
isc_quota_getsoft(isc_quota_t *quota) {
REQUIRE(VALID_QUOTA(quota));
- return (atomic_load_relaxed("a->soft));
+ return atomic_load_relaxed("a->soft);
}
unsigned int
isc_quota_getused(isc_quota_t *quota) {
REQUIRE(VALID_QUOTA(quota));
- return (atomic_load_relaxed("a->used));
+ return atomic_load_relaxed("a->used);
}
static isc_result_t
uint_fast32_t used = atomic_load_acquire("a->used);
do {
if (max != 0 && used >= max) {
- return (ISC_R_QUOTA);
+ return ISC_R_QUOTA;
}
if (soft != 0 && used >= soft) {
result = ISC_R_SOFTQUOTA;
}
} while (!atomic_compare_exchange_weak_acq_rel("a->used, &used,
used + 1));
- return (result);
+ return result;
}
/* Must be quota->cbslock locked */
INSIST(cb != NULL);
ISC_LIST_DEQUEUE(quota->cbs, cb, link);
atomic_fetch_sub_relaxed("a->waiting, 1);
- return (cb);
+ return cb;
}
static void
*p = quota;
}
- return (result);
+ return result;
}
isc_result_t
REQUIRE(VALID_QUOTA(quota));
REQUIRE(quotap != NULL && *quotap == NULL);
- return (isc_quota_attach_cb(quota, quotap, NULL));
+ return isc_quota_attach_cb(quota, quotap, NULL);
}
isc_result_t
enqueue(quota, cb);
UNLOCK("a->cblock);
}
- return (result);
+ return result;
}
void
REQUIRE(target != NULL);
if (family != AF_INET6 && family != AF_INET && family != AF_UNSPEC) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
prefix = isc_mem_get(mctx, sizeof(isc_prefix_t));
isc_refcount_init(&prefix->refcount, 1);
*target = prefix;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
isc_result_t ret;
ret = _new_prefix(mctx, target, prefix->family, &prefix->add,
prefix->bitlen);
- return (ret);
+ return ret;
}
isc_refcount_increment(&prefix->refcount);
*target = prefix;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static int
_comp_with_mask(void *addr, void *dest, u_int mask) {
/* Mask length of zero matches everything */
if (mask == 0) {
- return (1);
+ return 1;
}
if (memcmp(addr, dest, mask / 8) == 0) {
if ((mask % 8) == 0 ||
(((u_char *)addr)[n] & m) == (((u_char *)dest)[n] & m))
{
- return (1);
+ return 1;
}
}
- return (0);
+ return 0;
}
isc_result_t
RUNTIME_CHECK(maxbits <= RADIX_MAXBITS); /* XXX */
radix->magic = RADIX_TREE_MAGIC;
*target = radix;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
node = radix->head;
if (node == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
addr = isc_prefix_touchar(prefix);
}
if (*target == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
if (result != ISC_R_SUCCESS) {
isc_mem_put(radix->mctx, node,
sizeof(isc_radix_node_t));
- return (result);
+ return result;
}
node->parent = NULL;
node->l = node->r = NULL;
radix->head = node;
radix->num_active_node++;
*target = node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
addr = isc_prefix_touchar(prefix);
}
}
*target = node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
result = _ref_prefix(radix->mctx, &node->prefix,
prefix);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
INSIST(node->data[RADIX_V4] == NULL &&
}
}
*target = node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
new_node = isc_mem_get(radix->mctx, sizeof(isc_radix_node_t));
isc_mem_put(radix->mctx, glue,
sizeof(isc_radix_node_t));
}
- return (result);
+ return result;
}
new_node->parent = NULL;
new_node->l = new_node->r = NULL;
node->l = new_node;
}
*target = new_node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (bitlen == differ_bit) {
}
*target = new_node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
static uint32_t
rotl(const uint32_t x, int k) {
- return ((x << k) | (x >> (32 - k)));
+ return (x << k) | (x >> (32 - k));
}
static uint32_t
seed[3] = rotl(seed[3], 11);
- return (result_starstar);
+ return result_starstar;
}
static thread_local isc_once_t isc_random_once = ISC_ONCE_INIT;
isc_random8(void) {
RUNTIME_CHECK(isc_once_do(&isc_random_once, isc_random_initialize) ==
ISC_R_SUCCESS);
- return (next() & 0xff);
+ return next() & 0xff;
}
uint16_t
isc_random16(void) {
RUNTIME_CHECK(isc_once_do(&isc_random_once, isc_random_initialize) ==
ISC_R_SUCCESS);
- return (next() & 0xffff);
+ return next() & 0xffff;
}
uint32_t
isc_random32(void) {
RUNTIME_CHECK(isc_once_do(&isc_random_once, isc_random_initialize) ==
ISC_R_SUCCESS);
- return (next());
+ return next();
}
void
ISC_R_SUCCESS);
if (upper_bound < 2) {
- return (0);
+ return 0;
}
#if (ULONG_MAX > 0xffffffffUL)
}
}
- return (r % upper_bound);
+ return r % upper_bound;
}
ratelimiter_shutdowncomplete, rl, rl, NULL, NULL);
*ratelimiterp = rl;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
free_mutex:
isc_refcount_decrementz(&rl->references);
isc_refcount_destroy(&rl->references);
isc_mutex_destroy(&rl->lock);
isc_mem_put(mctx, rl, sizeof(*rl));
- return (result);
+ return result;
}
isc_result_t
&rl->interval, false);
}
UNLOCK(&rl->lock);
- return (result);
+ return result;
}
void
if (*eventp != NULL && result == ISC_R_SUCCESS) {
isc_task_send(task, eventp);
}
- return (result);
+ return result;
}
isc_result_t
result = ISC_R_NOTFOUND;
}
UNLOCK(&rl->lock);
- return (result);
+ return result;
}
static void
break;
}
UNLOCK(&rl->lock);
- return (result);
+ return result;
}
isc_result_t
break;
}
UNLOCK(&rl->lock);
- return (result);
+ return result;
}
if (!have_atom) {
FAIL("no atom");
}
- return (sub);
+ return sub;
error:
#if VALREGEX_REPORT_REASON
fprintf(stderr, "%s\n", reason);
#endif /* if VALREGEX_REPORT_REASON */
- return (-1);
+ return -1;
}
l = (r1->length < r2->length) ? r1->length : r2->length;
if ((result = memcmp(r1->base, r2->base, l)) != 0) {
- return ((result < 0) ? -1 : 1);
+ return (result < 0) ? -1 : 1;
} else {
- return ((r1->length == r2->length) ? 0
- : (r1->length < r2->length) ? -1
- : 1);
+ return (r1->length == r2->length) ? 0
+ : (r1->length < r2->length) ? -1
+ : 1;
}
}
break;
}
- return (result);
+ return result;
}
isc_result_t
result = resource2rlim(resource, &unixresource);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (value == ISC_RESOURCE_UNLIMITED) {
unixresult = setrlimit(unixresource, &rl);
if (unixresult == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#if defined(OPEN_MAX) && defined(__APPLE__)
rl.rlim_cur = OPEN_MAX;
unixresult = setrlimit(unixresource, &rl);
if (unixresult == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
#elif defined(__linux__)
rl.rlim_cur = rl.rlim_max = NR_OPEN;
unixresult = setrlimit(unixresource, &rl);
if (unixresult == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
#endif /* if defined(OPEN_MAX) && defined(__APPLE__) */
rl.rlim_cur = rl.rlim_max;
unixresult = setrlimit(unixresource, &rl);
if (unixresult == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
}
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
isc_result_t
result = resource2rlim(resource, &unixresource);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (getrlimit(unixresource, &rl) != 0) {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
*value = rl.rlim_max;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
result = resource2rlim(resource, &unixresource);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (getrlimit(unixresource, &rl) != 0) {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
*value = rl.rlim_cur;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
const char *
isc_result_totext(isc_result_t result) {
- return (description[result]);
+ return description[result];
}
const char *
isc_result_toid(isc_result_t result) {
- return (identifier[result]);
+ return identifier[result];
}
default:
UNREACHABLE();
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
ret = pthread_rwlock_trywrlock(&rwl->rwlock);
if ((ret == 0) && atomic_load_acquire(&rwl->downgrade)) {
isc_rwlock_unlock(rwl, type);
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
}
break;
default:
switch (ret) {
case 0:
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
case EBUSY:
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
case EAGAIN:
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
default:
UNREACHABLE();
}
isc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
UNUSED(type);
REQUIRE(pthread_rwlock_unlock(&rwl->rwlock) == 0);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
isc_rwlock_tryupgrade(isc_rwlock_t *rwl) {
UNUSED(rwl);
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
}
void
UNLOCK(&rwl->lock);
}
- INSIST((atomic_load_acquire(&rwl->cnt_and_flag) &
- WRITER_ACTIVE));
+ INSIST(atomic_load_acquire(&rwl->cnt_and_flag) & WRITER_ACTIVE);
atomic_fetch_add_release(&rwl->write_granted, 1);
}
print_lock("postlock", rwl, type);
#endif /* ifdef ISC_RWLOCK_TRACE */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
atomic_fetch_add_release(&rwl->spins, (cnt - spins) / 8);
- return (result);
+ return result;
}
isc_result_t
if (atomic_load_acquire(&rwl->write_requests) !=
atomic_load_acquire(&rwl->write_completions))
{
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
}
/* Otherwise, be ready for reading. */
UNLOCK(&rwl->lock);
}
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
}
} else {
/* Try locking without entering the waiting queue. */
if (!atomic_compare_exchange_strong_acq_rel(
&rwl->cnt_and_flag, &zero, WRITER_ACTIVE))
{
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
}
/*
print_lock("postlock", rwl, type);
#endif /* ifdef ISC_RWLOCK_TRACE */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
*/
atomic_fetch_sub_release(&rwl->write_completions, 1);
} else {
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
print_lock("postunlock", rwl, type);
#endif /* ifdef ISC_RWLOCK_TRACE */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#endif /* USE_PTHREAD_RWLOCK */
int
isc_safe_memequal(const void *s1, const void *s2, size_t len) {
- return (!CRYPTO_memcmp(s1, s2, len));
+ return !CRYPTO_memcmp(s1, s2, len);
}
void
* Undefined => false
*/
if (a == (b ^ 0x80000000U)) {
- return (false);
+ return false;
}
- return (((int32_t)(a - b) < 0) ? true : false);
+ return ((int32_t)(a - b) < 0) ? true : false;
}
bool
isc_serial_gt(uint32_t a, uint32_t b) {
- return (((int32_t)(a - b) > 0) ? true : false);
+ return ((int32_t)(a - b) > 0) ? true : false;
}
bool
isc_serial_le(uint32_t a, uint32_t b) {
- return ((a == b) ? true : isc_serial_lt(a, b));
+ return (a == b) ? true : isc_serial_lt(a, b);
}
bool
isc_serial_ge(uint32_t a, uint32_t b) {
- return ((a == b) ? true : isc_serial_gt(a, b));
+ return (a == b) ? true : isc_serial_gt(a, b);
}
bool
isc_serial_eq(uint32_t a, uint32_t b) {
- return ((a == b) ? true : false);
+ return (a == b) ? true : false;
}
bool
isc_serial_ne(uint32_t a, uint32_t b) {
- return ((a != b) ? true : false);
+ return (a != b) ? true : false;
}
bool
isc_sockaddr_equal(const isc_sockaddr_t *a, const isc_sockaddr_t *b) {
- return (isc_sockaddr_compare(a, b,
- ISC_SOCKADDR_CMPADDR |
- ISC_SOCKADDR_CMPPORT |
- ISC_SOCKADDR_CMPSCOPE));
+ return isc_sockaddr_compare(a, b,
+ ISC_SOCKADDR_CMPADDR |
+ ISC_SOCKADDR_CMPPORT |
+ ISC_SOCKADDR_CMPSCOPE);
}
bool
isc_sockaddr_eqaddr(const isc_sockaddr_t *a, const isc_sockaddr_t *b) {
- return (isc_sockaddr_compare(
- a, b, ISC_SOCKADDR_CMPADDR | ISC_SOCKADDR_CMPSCOPE));
+ return isc_sockaddr_compare(
+ a, b, ISC_SOCKADDR_CMPADDR | ISC_SOCKADDR_CMPSCOPE);
}
bool
REQUIRE(a != NULL && b != NULL);
if (a->length != b->length) {
- return (false);
+ return false;
}
/*
*/
if (a->type.sa.sa_family != b->type.sa.sa_family) {
- return (false);
+ return false;
}
switch (a->type.sa.sa_family) {
case AF_INET:
memcmp(&a->type.sin.sin_addr, &b->type.sin.sin_addr,
sizeof(a->type.sin.sin_addr)) != 0)
{
- return (false);
+ return false;
}
if ((flags & ISC_SOCKADDR_CMPPORT) != 0 &&
a->type.sin.sin_port != b->type.sin.sin_port)
{
- return (false);
+ return false;
}
break;
case AF_INET6:
memcmp(&a->type.sin6.sin6_addr, &b->type.sin6.sin6_addr,
sizeof(a->type.sin6.sin6_addr)) != 0)
{
- return (false);
+ return false;
}
/*
* If ISC_SOCKADDR_CMPSCOPEZERO is set then don't return
(a->type.sin6.sin6_scope_id != 0 &&
b->type.sin6.sin6_scope_id != 0)))
{
- return (false);
+ return false;
}
if ((flags & ISC_SOCKADDR_CMPPORT) != 0 &&
a->type.sin6.sin6_port != b->type.sin6.sin6_port)
{
- return (false);
+ return false;
}
break;
default:
if (memcmp(&a->type, &b->type, a->length) != 0) {
- return (false);
+ return false;
}
}
- return (true);
+ return true;
}
bool
isc_netaddr_t na, nb;
isc_netaddr_fromsockaddr(&na, a);
isc_netaddr_fromsockaddr(&nb, b);
- return (isc_netaddr_eqprefix(&na, &nb, prefixlen));
+ return isc_netaddr_eqprefix(&na, &nb, prefixlen);
}
isc_result_t
case AF_UNIX:
plen = strlen(sockaddr->type.sunix.sun_path);
if (plen >= isc_buffer_availablelength(target)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putmem(
INSIST(avail.length >= 1);
avail.base[0] = '\0';
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
default:
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
plen = strlen(pbuf);
isc_netaddr_fromsockaddr(&netaddr, sockaddr);
result = isc_netaddr_totext(&netaddr, target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (1 + plen + 1 > isc_buffer_availablelength(target)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putmem(target, (const unsigned char *)"#", 1);
INSIST(avail.length >= 1);
avail.base[0] = '\0';
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
h = isc_hash_function(buf, length, true);
}
- return (h);
+ return h;
}
void
/*
* Assume that PF_xxx == AF_xxx for all AF and PF.
*/
- return (sockaddr->type.sa.sa_family);
+ return sockaddr->type.sa.sa_family;
#else /* if (AF_INET == PF_INET && AF_INET6 == PF_INET6) */
switch (sockaddr->type.sa.sa_family) {
case AF_INET:
- return (PF_INET);
+ return PF_INET;
case AF_INET6:
- return (PF_INET6);
+ return PF_INET6;
default:
FATAL_ERROR("unknown address family: %d",
(int)sockaddr->type.sa.sa_family);
(int)sockaddr->type.sa.sa_family);
}
- return (port);
+ return port;
}
bool
sockaddr->type.sa.sa_family == AF_INET6)
{
isc_netaddr_fromsockaddr(&netaddr, sockaddr);
- return (isc_netaddr_ismulticast(&netaddr));
+ return isc_netaddr_ismulticast(&netaddr);
}
- return (false);
+ return false;
}
bool
if (sockaddr->type.sa.sa_family == AF_INET) {
isc_netaddr_fromsockaddr(&netaddr, sockaddr);
- return (isc_netaddr_isexperimental(&netaddr));
+ return isc_netaddr_isexperimental(&netaddr);
}
- return (false);
+ return false;
}
bool
if (sockaddr->type.sa.sa_family == AF_INET6) {
isc_netaddr_fromsockaddr(&netaddr, sockaddr);
- return (isc_netaddr_issitelocal(&netaddr));
+ return isc_netaddr_issitelocal(&netaddr);
}
- return (false);
+ return false;
}
bool
if (sockaddr->type.sa.sa_family == AF_INET6) {
isc_netaddr_fromsockaddr(&netaddr, sockaddr);
- return (isc_netaddr_islinklocal(&netaddr));
+ return isc_netaddr_islinklocal(&netaddr);
}
- return (false);
+ return false;
}
bool
if (sockaddr->type.sa.sa_family == AF_INET) {
isc_netaddr_fromsockaddr(&netaddr, sockaddr);
- return (isc_netaddr_isnetzero(&netaddr));
+ return isc_netaddr_isnetzero(&netaddr);
}
- return (false);
+ return false;
}
isc_result_t
isc_sockaddr_frompath(isc_sockaddr_t *sockaddr, const char *path) {
if (strlen(path) >= sizeof(sockaddr->type.sunix.sun_path)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memset(sockaddr, 0, sizeof(*sockaddr));
sockaddr->length = sizeof(sockaddr->type.sunix);
sockaddr->type.sunix.sun_family = AF_UNIX;
strlcpy(sockaddr->type.sunix.sun_path, path,
sizeof(sockaddr->type.sunix.sun_path));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
length = sizeof(isa->type.sunix);
break;
default:
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
memset(isa, 0, sizeof(isc_sockaddr_t));
memmove(isa, sa, length);
isa->length = length;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
bool
(sockaddr->type.sa.sa_family == AF_INET6 &&
isc_net_probeipv6() == ISC_R_DISABLED))
{
- return (true);
+ return true;
}
- return (false);
+ return false;
}
stats->magic = ISC_STATS_MAGIC;
*statsp = stats;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_stats_ncounters(isc_stats_t *stats) {
REQUIRE(ISC_STATS_VALID(stats));
- return (stats->ncounters);
+ return stats->ncounters;
}
isc_result_t
isc_stats_create(isc_mem_t *mctx, isc_stats_t **statsp, int ncounters) {
REQUIRE(statsp != NULL && *statsp == NULL);
- return (create_stats(mctx, ncounters, statsp));
+ return create_stats(mctx, ncounters, statsp);
}
void
REQUIRE(ISC_STATS_VALID(stats));
REQUIRE(counter < stats->ncounters);
- return (atomic_load_acquire(&stats->counters[counter]));
+ return atomic_load_acquire(&stats->counters[counter]);
}
void
f = fopen(filename, mode);
if (f == NULL) {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
*fp = f;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
r = fclose(f);
if (r == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
}
r = fseeko(f, offset, whence);
if (r == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
}
r = ftello(f);
if (r >= 0) {
*offsetp = r;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
}
if (nret != NULL) {
*nret = r;
}
- return (result);
+ return result;
}
isc_result_t
if (nret != NULL) {
*nret = r;
}
- return (result);
+ return result;
}
isc_result_t
r = fflush(f);
if (r == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
}
int r;
if (fstat(fileno(f), &buf) != 0) {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
/*
* Only call fsync() on regular files.
*/
if ((buf.st_mode & S_IFMT) != S_IFREG) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
r = fsync(fileno(f));
if (r == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (isc__errno2result(errno));
+ return isc__errno2result(errno);
}
}
/* time_t and isc_stdtime_t might be different sizes */
when = t;
- INSIST((ctime_r(&when, out) != NULL));
+ INSIST(ctime_r(&when, out) != NULL);
*(out + strlen(out) - 1) = '\0';
}
}
}
- return (s - src - 1); /* count does not include NUL */
+ return s - src - 1; /* count does not include NUL */
}
#endif /* !defined(HAVE_STRLCPY) */
n = size - dlen;
if (n == 0U) {
- return (dlen + strlen(s));
+ return dlen + strlen(s);
}
while (*s != '\0') {
if (n != 1U) {
}
*d = '\0';
- return (dlen + (s - src)); /* count does not include NUL */
+ return dlen + (s - src); /* count does not include NUL */
}
#endif /* !defined(HAVE_STRLCAT) */
do {
do {
if (slen-- < 1 || (sc = *s++) == '\0')
- return (NULL);
+ return NULL;
} while (sc != c);
if (len > slen)
- return (NULL);
+ return NULL;
} while (strncmp(s, find, len) != 0);
s--;
}
- return ((char *)s);
+ return (char *)s;
}
#endif
int
isc_string_strerror_r(int errnum, char *buf, size_t buflen) {
- return (strerror_r(errnum, buf, buflen));
+ return strerror_r(errnum, buf, buflen);
}
*symtabp = symtab;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
}
}
- return (h);
+ return h;
}
#define FIND(s, k, t, b, e) \
FIND(symtab, key, type, bucket, elt);
if (elt == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (value != NULL) {
*value = elt->value;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
if (exists_policy != isc_symexists_add && elt != NULL) {
if (exists_policy == isc_symexists_reject) {
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
INSIST(exists_policy == isc_symexists_replace);
UNLINK(symtab->table[bucket], elt, link);
grow_table(symtab);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
FIND(symtab, key, type, bucket, elt);
if (elt == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (symtab->undefine_action != NULL) {
isc_mem_put(symtab->mctx, elt, sizeof(*elt));
symtab->count--;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
unsigned int
isc_symtab_count(isc_symtab_t *symtab) {
REQUIRE(VALID_SYMTAB(symtab));
- return (symtab->count);
+ return symtab->count;
}
for (i = 0; facilities[i].strval != NULL; i++) {
if (strcasecmp(facilities[i].strval, str) == 0) {
*facilityp = facilities[i].val;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
isc_result_t
isc_task_create(isc_taskmgr_t *manager, unsigned int quantum,
isc_task_t **taskp) {
- return (isc_task_create_bound(manager, quantum, taskp, -1));
+ return isc_task_create_bound(manager, quantum, taskp, -1);
}
isc_result_t
isc_mutex_destroy(&task->lock);
isc_taskmgr_detach(&task->manager);
isc_mem_put(manager->mctx, task, sizeof(*task));
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
*taskp = task;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
}
}
- return (was_idle);
+ return was_idle;
}
/*
* loop to deal with shutting down and termination.
*/
task->state = task_state_ready;
- return (true);
+ return true;
}
- return (false);
+ return false;
}
void
ENQUEUE(task->events, event, ev_link);
task->nevents++;
- return (was_idle);
+ return was_idle;
}
void
UNLOCK(&task->lock);
- return (count);
+ return count;
}
unsigned int
* Note that purging never changes the state of the task.
*/
- return (count);
+ return count;
}
unsigned int
XTRACE("isc_task_purge");
- return (isc_task_purgerange(task, sender, type, type, tag));
+ return isc_task_purgerange(task, sender, type, type, tag);
}
/*
UNLOCK(&task->lock);
if (!found) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
unsigned int
XTRACE("isc_task_unsend");
- return (dequeue_events(task, sender, type, type, tag, events, false));
+ return dequeue_events(task, sender, type, type, tag, events, false);
}
isc_result_t
isc_mem_put(task->manager->mctx, event, sizeof(*event));
}
- return (result);
+ return result;
}
void
isc_task_getname(isc_task_t *task) {
REQUIRE(VALID_TASK(task));
- return (task->name);
+ return task->name;
}
void *
isc_task_gettag(isc_task_t *task) {
REQUIRE(VALID_TASK(task));
- return (task->tag);
+ return task->tag;
}
isc_nm_t *
isc_task_getnetmgr(isc_task_t *task) {
REQUIRE(VALID_TASK(task));
- return (task->manager->netmgr);
+ return task->manager->netmgr;
}
void
task_finished(task);
}
- return (result);
+ return result;
}
isc_result_t
isc_task_run(isc_task_t *task) {
- return (task_run(task));
+ return task_run(task);
}
static void
*managerp = manager;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
}
UNLOCK(&mgr->lock);
- return (result);
+ return result;
}
isc_result_t
if (!atomic_compare_exchange_strong(&manager->exclusive_req,
&(bool){ false }, true))
{
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
}
if (isc_log_wouldlog(isc_lctx, ISC_LOG_DEBUG(1))) {
"exclusive task mode: %s", "started");
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_taskmgrmode_t
isc_taskmgr_mode(isc_taskmgr_t *manager) {
- return (atomic_load(&manager->mode));
+ return atomic_load(&manager->mode);
}
void
isc_task_getprivilege(isc_task_t *task) {
REQUIRE(VALID_TASK(task));
- return (TASK_PRIVILEGED(task));
+ return TASK_PRIVILEGED(task);
}
bool
isc_task_privileged(isc_task_t *task) {
REQUIRE(VALID_TASK(task));
- return (isc_taskmgr_mode(task->manager) && TASK_PRIVILEGED(task));
+ return isc_taskmgr_mode(task->manager) && TASK_PRIVILEGED(task);
}
bool
isc_task_exiting(isc_task_t *task) {
REQUIRE(VALID_TASK(task));
- return (TASK_SHUTTINGDOWN(task));
+ return TASK_SHUTTINGDOWN(task);
}
#ifdef HAVE_LIBXML2
}
UNLOCK(&mgr->lock);
- return (xmlrc);
+ return xmlrc;
}
#endif /* HAVE_LIBXML2 */
}
UNLOCK(&mgr->lock);
- return (result);
+ return result;
}
#endif /* ifdef HAVE_JSON_C */
&pool->tasks[i], i);
if (result != ISC_R_SUCCESS) {
isc_taskpool_destroy(&pool);
- return (result);
+ return result;
}
isc_task_setprivilege(pool->tasks[i], priv);
isc_task_setname(pool->tasks[i], "taskpool", NULL);
}
*poolp = pool;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
int
isc_taskpool_size(isc_taskpool_t *pool) {
REQUIRE(pool != NULL);
- return (pool->ntasks);
+ return pool->ntasks;
}
isc_result_t
if (result != ISC_R_SUCCESS) {
*sourcep = pool;
isc_taskpool_destroy(&newpool);
- return (result);
+ return result;
}
isc_task_setprivilege(newpool->tasks[i], priv);
isc_task_setname(newpool->tasks[i], "taskpool", NULL);
}
*targetp = pool;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
INSIST(i->nanoseconds < NS_PER_SEC);
if (i->seconds == 0 && i->nanoseconds == 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
unsigned int
REQUIRE(i != NULL);
INSIST(i->nanoseconds < NS_PER_SEC);
- return ((i->seconds * MS_PER_SEC) + (i->nanoseconds / NS_PER_MS));
+ return (i->seconds * MS_PER_SEC) + (i->nanoseconds / NS_PER_MS);
}
/***
INSIST(t->nanoseconds < NS_PER_SEC);
if (t->seconds == 0 && t->nanoseconds == 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static isc_result_t
if (clock_gettime(clock, &ts) == -1) {
UNEXPECTED_SYSERROR(errno, "clock_gettime()");
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
if (ts.tv_sec < 0 || ts.tv_nsec < 0 || ts.tv_nsec >= (long)NS_PER_SEC) {
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
/*
if (sizeof(ts.tv_sec) > sizeof(t->seconds) &&
((ts.tv_sec | (unsigned int)-1) ^ (unsigned int)-1) != 0U)
{
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
t->seconds = ts.tv_sec;
t->nanoseconds = ts.tv_nsec;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (clock_gettime(CLOCKSOURCE, &ts) == -1) {
UNEXPECTED_SYSERROR(errno, "clock_gettime()");
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
if (ts.tv_sec < 0 || ts.tv_nsec < 0 || ts.tv_nsec >= (long)NS_PER_SEC) {
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
/*
if ((ts.tv_sec > INT_MAX || i->seconds > INT_MAX) &&
((long long)ts.tv_sec + i->seconds > UINT_MAX))
{
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
t->seconds = ts.tv_sec + i->seconds;
t->nanoseconds -= NS_PER_SEC;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
int
INSIST(t1->nanoseconds < NS_PER_SEC && t2->nanoseconds < NS_PER_SEC);
if (t1->seconds < t2->seconds) {
- return (-1);
+ return -1;
}
if (t1->seconds > t2->seconds) {
- return (1);
+ return 1;
}
if (t1->nanoseconds < t2->nanoseconds) {
- return (-1);
+ return -1;
}
if (t1->nanoseconds > t2->nanoseconds) {
- return (1);
+ return 1;
}
- return (0);
+ return 0;
}
isc_result_t
/* Seconds */
#if HAVE_BUILTIN_OVERFLOW
if (__builtin_uadd_overflow(t->seconds, i->seconds, &result->seconds)) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
#else
if (t->seconds > UINT_MAX - i->seconds) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
result->seconds = t->seconds + i->seconds;
#endif
result->nanoseconds = t->nanoseconds + i->nanoseconds;
if (result->nanoseconds >= NS_PER_SEC) {
if (result->seconds == UINT_MAX) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
result->nanoseconds -= NS_PER_SEC;
result->seconds++;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
/* Seconds */
#if HAVE_BUILTIN_OVERFLOW
if (__builtin_usub_overflow(t->seconds, i->seconds, &result->seconds)) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
#else
if (t->seconds < i->seconds) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
result->seconds = t->seconds - i->seconds;
#endif
result->nanoseconds = t->nanoseconds - i->nanoseconds;
} else {
if (result->seconds == 0) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
result->seconds--;
result->nanoseconds = NS_PER_SEC + t->nanoseconds -
i->nanoseconds;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
uint64_t
i2 = (uint64_t)t2->seconds * NS_PER_SEC + t2->nanoseconds;
if (i1 <= i2) {
- return (0);
+ return 0;
}
i3 = i1 - i2;
*/
i3 /= NS_PER_US;
- return (i3);
+ return i3;
}
uint32_t
REQUIRE(t != NULL);
INSIST(t->nanoseconds < NS_PER_SEC);
- return ((uint32_t)t->seconds);
+ return (uint32_t)t->seconds;
}
isc_result_t
INSIST(sizeof(time_t) >= sizeof(uint32_t));
if (t->seconds > (~0U >> 1) && seconds <= (time_t)(~0U >> 1)) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
*secondsp = seconds;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
uint32_t
ENSURE(t->nanoseconds < NS_PER_SEC);
- return ((uint32_t)t->nanoseconds);
+ return (uint32_t)t->nanoseconds;
}
void
p = isc_tm_strptime(buf, "%a, %d %b %Y %H:%M:%S", &t_tm);
if (p == NULL) {
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
when = isc_tm_timegm(&t_tm);
if (when == -1) {
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
isc_time_set(t, when, 0);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
if (timer->type != isc_timertype_once) {
isc_result_t result = isc_time_add(now, &timer->interval, &due);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (timer->type == isc_timertype_limited &&
isc_time_compare(&timer->expires, &due) < 0)
SIGNAL(&manager->wakeup);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static inline void
result = isc_time_add(&now, interval, &timer->idle);
if (result != ISC_R_SUCCESS) {
isc_mem_put(manager->mctx, timer, sizeof(*timer));
- return (result);
+ return result;
}
} else {
isc_time_settoepoch(&timer->idle);
isc_mutex_destroy(&timer->lock);
isc_task_detach(&timer->task);
isc_mem_put(manager->mctx, timer, sizeof(*timer));
- return (result);
+ return result;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
UNLOCK(&timer->lock);
UNLOCK(&manager->lock);
- return (result);
+ return result;
}
isc_timertype_t
t = timer->type;
UNLOCK(&timer->lock);
- return (t);
+ return t;
}
isc_result_t
UNLOCK(&timer->lock);
- return (result);
+ return result;
}
void
}
UNLOCK(&manager->lock);
- return ((isc_threadresult_t)0);
+ return (isc_threadresult_t)0;
}
static bool
REQUIRE(VALID_TIMER(t2));
if (isc_time_compare(&t1->due, &t2->due) < 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static void
*managerp = manager;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
*ctxp = ctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
ssl_error:
err = ERR_get_error();
ISC_LOG_ERROR, "Error initializing TLS context: %s",
errbuf);
- return (ISC_R_TLSERROR);
+ return ISC_R_TLSERROR;
}
isc_result_t
rv = SSL_CTX_use_certificate_chain_file(ctx, certfile);
if (rv != 1) {
- return (ISC_R_TLSERROR);
+ return ISC_R_TLSERROR;
}
rv = SSL_CTX_use_PrivateKey_file(ctx, keyfile, SSL_FILETYPE_PEM);
if (rv != 1) {
- return (ISC_R_TLSERROR);
+ return ISC_R_TLSERROR;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
sslkeylogfile_init(ctx);
*ctxp = ctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
ssl_error:
err = ERR_get_error();
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L */
- return (ISC_R_TLSERROR);
+ return ISC_R_TLSERROR;
}
static long
break;
};
- return (bit);
+ return bit;
}
bool
isc_tls_protocol_supported(const isc_tls_protocol_version_t tls_ver) {
- return (get_tls_version_disable_bit(tls_ver) != 0);
+ return get_tls_version_disable_bit(tls_ver) != 0;
}
isc_tls_protocol_version_t
REQUIRE(name != NULL);
if (strcasecmp(name, "TLSv1.2") == 0) {
- return (ISC_TLS_PROTO_VER_1_2);
+ return ISC_TLS_PROTO_VER_1_2;
} else if (strcasecmp(name, "TLSv1.3") == 0) {
- return (ISC_TLS_PROTO_VER_1_3);
+ return ISC_TLS_PROTO_VER_1_3;
}
- return (ISC_TLS_PROTO_VER_UNDEFINED);
+ return ISC_TLS_PROTO_VER_UNDEFINED;
}
void
fclose(paramfile);
if (dh == NULL) {
- return (false);
+ return false;
} else if (DH_check(dh, &check) != 1 || check != 0) {
DH_free(dh);
- return (false);
+ return false;
}
} else {
- return (false);
+ return false;
}
if (SSL_CTX_set_tmp_dh(ctx, dh) != 1) {
DH_free(dh);
- return (false);
+ return false;
}
DH_free(dh);
bio = BIO_new_file(dhparams_file, "r");
if (bio == NULL) {
- return (false);
+ return false;
}
dh = PEM_read_bio_Parameters(bio, NULL);
if (dh == NULL) {
BIO_free(bio);
- return (false);
+ return false;
}
if (SSL_CTX_set0_tmp_dh_pkey(ctx, dh) != 1) {
BIO_free(bio);
EVP_PKEY_free(dh);
- return (false);
+ return false;
}
/* No need to call EVP_PKEY_free(dh) as the "dh" is owned by the
BIO_free(bio);
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L */
- return (true);
+ return true;
}
bool
REQUIRE(cipherlist != NULL);
if (*cipherlist == '\0') {
- return (false);
+ return false;
}
method = TLS_server_method();
if (method == NULL) {
- return (false);
+ return false;
}
tmp_ctx = SSL_CTX_new(method);
if (tmp_ctx == NULL) {
- return (false);
+ return false;
}
result = SSL_CTX_set_cipher_list(tmp_ctx, cipherlist) == 1;
isc_tlsctx_free(&tmp_ctx);
- return (result);
+ return result;
}
void
errbuf);
}
- return (newctx);
+ return newctx;
}
void
isc_tls_verify_peer_result_string(isc_tls_t *tls) {
REQUIRE(tls != NULL);
- return (X509_verify_cert_error_string(SSL_get_verify_result(tls)));
+ return X509_verify_cert_error_string(SSL_get_verify_result(tls));
}
#if HAVE_LIBNGHTTP2
UNUSED(arg);
if (nghttp2_select_next_protocol(out, outlen, in, inlen) <= 0) {
- return (SSL_TLSEXT_ERR_NOACK);
+ return SSL_TLSEXT_ERR_NOACK;
}
- return (SSL_TLSEXT_ERR_OK);
+ return SSL_TLSEXT_ERR_OK;
}
#endif /* !OPENSSL_NO_NEXTPROTONEG */
*data = (const unsigned char *)NGHTTP2_PROTO_ALPN;
*len = (unsigned int)NGHTTP2_PROTO_ALPN_LEN;
- return (SSL_TLSEXT_ERR_OK);
+ return SSL_TLSEXT_ERR_OK;
}
#endif /* !OPENSSL_NO_NEXTPROTONEG */
outlen, in, inlen);
if (ret != 1) {
- return (SSL_TLSEXT_ERR_NOACK);
+ return SSL_TLSEXT_ERR_NOACK;
}
- return (SSL_TLSEXT_ERR_OK);
+ return SSL_TLSEXT_ERR_OK;
}
#endif /* OPENSSL_VERSION_NUMBER >= 0x10002000L */
if (memcmp(&in[i], key, key_len) == 0) {
*pout = (const uint8_t *)(&in[i + 1]);
*pout_len = in[i];
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
/* dot prepended by its length (3 bytes) */
static bool
dot_select_next_protocol(const uint8_t **pout, uint8_t *pout_len,
const uint8_t *in, size_t in_len) {
- return (protoneg_check_protocol(pout, pout_len, in, in_len,
- (const uint8_t *)DOT_PROTO_ALPN,
- DOT_PROTO_ALPN_LEN));
+ return protoneg_check_protocol(pout, pout_len, in, in_len,
+ (const uint8_t *)DOT_PROTO_ALPN,
+ DOT_PROTO_ALPN_LEN);
}
void
ret = dot_select_next_protocol(out, outlen, in, inlen);
if (!ret) {
- return (SSL_TLSEXT_ERR_NOACK);
+ return SSL_TLSEXT_ERR_NOACK;
}
- return (SSL_TLSEXT_ERR_OK);
+ return SSL_TLSEXT_ERR_OK;
}
#endif /* OPENSSL_VERSION_NUMBER >= 0x10002000L */
}
if (ret != 1) {
ERR_clear_error();
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
#ifdef X509_CHECK_FLAG_NEVER_CHECK_SUBJECT
SSL_CTX_set_verify(tlsctx, SSL_VERIFY_PEER, NULL);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
cert_names = SSL_load_client_CA_file(ca_bundle_file);
if (cert_names == NULL) {
ERR_clear_error();
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
SSL_CTX_set_client_CA_list(ctx, cert_names);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
*pstore = store;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
error:
ERR_clear_error();
if (store != NULL) {
X509_STORE_free(store);
}
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
void
RWUNLOCK(&cache->rwlock, isc_rwlocktype_write);
- return (result);
+ return result;
}
isc_result_t
RWUNLOCK(&cache->rwlock, isc_rwlocktype_read);
- return (result);
+ return result;
}
typedef struct client_session_cache_entry client_session_cache_entry_t;
* is expected to be available on OpenSSL >= 1.1.1 and its modern
* siblings.
*/
- return (SSL_SESSION_is_resumable(sess) != 0);
+ return SSL_SESSION_is_resumable(sess) != 0;
#elif (OPENSSL_VERSION_NUMBER >= 0x10100000L)
/*
* Taking into consideration that OpenSSL 1.1.0 uses opaque
*/
unsigned int session_id_len = 0;
(void)SSL_SESSION_get_id(sess, &session_id_len);
- return (SSL_SESSION_has_ticket(sess) || session_id_len > 0);
+ return SSL_SESSION_has_ticket(sess) || session_id_len > 0;
#else
- return (!sess->not_resumable &&
- (sess->session_id_length > 0 || sess->tlsext_ticklen > 0));
+ return !sess->not_resumable &&
+ (sess->session_id_length > 0 || sess->tlsext_ticklen > 0);
#endif
}
isc_tlsctx_client_session_cache_getctx(
isc_tlsctx_client_session_cache_t *cache) {
REQUIRE(VALID_TLSCTX_CLIENT_SESSION_CACHE(cache));
- return (cache->ctx);
+ return cache->ctx;
}
void
int rulim = ulim;
if (!isdigit((unsigned char)**buf)) {
- return (0);
+ return 0;
}
do {
**buf <= '9');
if (result < llim || result > ulim) {
- return (0);
+ return 0;
}
*dest = result;
- return (1);
+ return 1;
}
time_t
(86400 *
(yday + ((tm->tm_year - 70) * 365) + ((tm->tm_year - 69) / 4) -
((tm->tm_year - 1) / 100) + ((tm->tm_year + 299) / 400)));
- return (ret);
+ return ret;
}
char *
case '%': /* "%%" is converted to "%". */
literal:
if (c != *bp++) {
- return (0);
+ return 0;
}
break;
case 'c': /* Date and time, using the locale's format. */
LEGAL_ALT(ALT_E);
if (!(bp = isc_tm_strptime(bp, "%x %X", tm))) {
- return (0);
+ return 0;
}
break;
case 'D': /* The date as "%m/%d/%y". */
LEGAL_ALT(0);
if (!(bp = isc_tm_strptime(bp, "%m/%d/%y", tm))) {
- return (0);
+ return 0;
}
break;
case 'R': /* The time as "%H:%M". */
LEGAL_ALT(0);
if (!(bp = isc_tm_strptime(bp, "%H:%M", tm))) {
- return (0);
+ return 0;
}
break;
case 'r': /* The time in 12-hour clock representation. */
LEGAL_ALT(0);
if (!(bp = isc_tm_strptime(bp, "%I:%M:%S %p", tm))) {
- return (0);
+ return 0;
}
break;
case 'T': /* The time as "%H:%M:%S". */
LEGAL_ALT(0);
if (!(bp = isc_tm_strptime(bp, "%H:%M:%S", tm))) {
- return (0);
+ return 0;
}
break;
case 'X': /* The time, using the locale's format. */
LEGAL_ALT(ALT_E);
if (!(bp = isc_tm_strptime(bp, "%H:%M:%S", tm))) {
- return (0);
+ return 0;
}
break;
case 'x': /* The date, using the locale's format. */
LEGAL_ALT(ALT_E);
if (!(bp = isc_tm_strptime(bp, "%m/%d/%y", tm))) {
- return (0);
+ return 0;
}
break;
/* Nothing matched. */
if (i == 7) {
- return (0);
+ return 0;
}
tm->tm_wday = i;
/* Nothing matched. */
if (i == 12) {
- return (0);
+ return 0;
}
tm->tm_mon = i;
case 'C': /* The century number. */
LEGAL_ALT(ALT_E);
if (!(conv_num(&bp, &i, 0, 99))) {
- return (0);
+ return 0;
}
if (split_year) {
case 'e':
LEGAL_ALT(ALT_O);
if (!(conv_num(&bp, &tm->tm_mday, 1, 31))) {
- return (0);
+ return 0;
}
break;
case 'H':
LEGAL_ALT(ALT_O);
if (!(conv_num(&bp, &tm->tm_hour, 0, 23))) {
- return (0);
+ return 0;
}
break;
case 'I':
LEGAL_ALT(ALT_O);
if (!(conv_num(&bp, &tm->tm_hour, 1, 12))) {
- return (0);
+ return 0;
}
if (tm->tm_hour == 12) {
tm->tm_hour = 0;
case 'j': /* The day of year. */
LEGAL_ALT(0);
if (!(conv_num(&bp, &i, 1, 366))) {
- return (0);
+ return 0;
}
tm->tm_yday = i - 1;
break;
case 'M': /* The minute. */
LEGAL_ALT(ALT_O);
if (!(conv_num(&bp, &tm->tm_min, 0, 59))) {
- return (0);
+ return 0;
}
break;
case 'm': /* The month. */
LEGAL_ALT(ALT_O);
if (!(conv_num(&bp, &i, 1, 12))) {
- return (0);
+ return 0;
}
tm->tm_mon = i - 1;
break;
/* AM? */
if (strcasecmp(am_pm[0], bp) == 0) {
if (tm->tm_hour > 11) {
- return (0);
+ return 0;
}
bp += strlen(am_pm[0]);
else if (strcasecmp(am_pm[1], bp) == 0)
{
if (tm->tm_hour > 11) {
- return (0);
+ return 0;
}
tm->tm_hour += 12;
}
/* Nothing matched. */
- return (0);
+ return 0;
case 'S': /* The seconds. */
LEGAL_ALT(ALT_O);
if (!(conv_num(&bp, &tm->tm_sec, 0, 61))) {
- return (0);
+ return 0;
}
break;
* range for now.
*/
if (!(conv_num(&bp, &i, 0, 53))) {
- return (0);
+ return 0;
}
break;
case 'w': /* The day of week, beginning on sunday. */
LEGAL_ALT(ALT_O);
if (!(conv_num(&bp, &tm->tm_wday, 0, 6))) {
- return (0);
+ return 0;
}
break;
case 'Y': /* The year. */
LEGAL_ALT(ALT_E);
if (!(conv_num(&bp, &i, 0, 9999))) {
- return (0);
+ return 0;
}
tm->tm_year = i - TM_YEAR_BASE;
case 'y': /* The year within 100 years of the epoch. */
LEGAL_ALT(ALT_E | ALT_O);
if (!(conv_num(&bp, &i, 0, 99))) {
- return (0);
+ return 0;
}
if (split_year) {
break;
default: /* Unknown/unsupported conversion. */
- return (0);
+ return 0;
}
}
/* LINTED functional specification */
DE_CONST(bp, ret);
- return (ret);
+ return ret;
}
.self = ISC__TRAMPOLINE_UNUSED,
};
- return (trampoline);
+ return trampoline;
}
void
INSIST(trampoline != NULL);
uv_mutex_unlock(&isc__trampoline_lock);
- return (trampoline);
+ return trampoline;
}
void
isc__trampoline_detach(trampoline);
- return (result);
+ return result;
}
static state_t
parse_url_char(state_t s, const char ch) {
if (ch == ' ' || ch == '\r' || ch == '\n') {
- return (s_dead);
+ return s_dead;
}
#if HTTP_PARSER_STRICT
if (ch == '\t' || ch == '\f') {
- return (s_dead);
+ return s_dead;
}
#endif
*/
if (ch == '/' || ch == '*') {
- return (s_req_path);
+ return s_req_path;
}
if (isalpha((unsigned char)ch)) {
- return (s_req_schema);
+ return s_req_schema;
}
break;
case s_req_schema:
if (isalpha((unsigned char)ch)) {
- return (s);
+ return s;
}
if (ch == ':') {
- return (s_req_schema_slash);
+ return s_req_schema_slash;
}
break;
case s_req_schema_slash:
if (ch == '/') {
- return (s_req_schema_slash_slash);
+ return s_req_schema_slash_slash;
}
break;
case s_req_schema_slash_slash:
if (ch == '/') {
- return (s_req_server_start);
+ return s_req_server_start;
}
break;
case s_req_server_with_at:
if (ch == '@') {
- return (s_dead);
+ return s_dead;
}
FALLTHROUGH;
case s_req_server_start:
case s_req_server:
if (ch == '/') {
- return (s_req_path);
+ return s_req_path;
}
if (ch == '?') {
- return (s_req_query_string_start);
+ return s_req_query_string_start;
}
if (ch == '@') {
- return (s_req_server_with_at);
+ return s_req_server_with_at;
}
if (IS_USERINFO_CHAR(ch) || ch == '[' || ch == ']') {
- return (s_req_server);
+ return s_req_server;
}
break;
case s_req_path:
if (IS_URL_CHAR(ch)) {
- return (s);
+ return s;
}
switch (ch) {
case '?':
- return (s_req_query_string_start);
+ return s_req_query_string_start;
case '#':
- return (s_req_fragment_start);
+ return s_req_fragment_start;
}
break;
case s_req_query_string_start:
case s_req_query_string:
if (IS_URL_CHAR(ch)) {
- return (s_req_query_string);
+ return s_req_query_string;
}
switch (ch) {
case '?':
/* allow extra '?' in query string */
- return (s_req_query_string);
+ return s_req_query_string;
case '#':
- return (s_req_fragment_start);
+ return s_req_fragment_start;
}
break;
case s_req_fragment_start:
if (IS_URL_CHAR(ch)) {
- return (s_req_fragment);
+ return s_req_fragment;
}
switch (ch) {
case '?':
- return (s_req_fragment);
+ return s_req_fragment;
case '#':
- return (s);
+ return s;
}
break;
case s_req_fragment:
if (IS_URL_CHAR(ch)) {
- return (s);
+ return s;
}
switch (ch) {
case '?':
case '#':
- return (s);
+ return s;
}
break;
* We should never fall out of the switch above unless there's an
* error.
*/
- return (s_dead);
+ return s_dead;
}
static host_state_t
case s_http_userinfo:
case s_http_userinfo_start:
if (ch == '@') {
- return (s_http_host_start);
+ return s_http_host_start;
}
if (IS_USERINFO_CHAR(ch)) {
- return (s_http_userinfo);
+ return s_http_userinfo;
}
break;
case s_http_host_start:
if (ch == '[') {
- return (s_http_host_v6_start);
+ return s_http_host_v6_start;
}
if (IS_HOST_CHAR(ch)) {
- return (s_http_host);
+ return s_http_host;
}
break;
case s_http_host:
if (IS_HOST_CHAR(ch)) {
- return (s_http_host);
+ return s_http_host;
}
FALLTHROUGH;
case s_http_host_v6_end:
if (ch == ':') {
- return (s_http_host_port_start);
+ return s_http_host_port_start;
}
break;
case s_http_host_v6:
if (ch == ']') {
- return (s_http_host_v6_end);
+ return s_http_host_v6_end;
}
FALLTHROUGH;
case s_http_host_v6_start:
if (isxdigit((unsigned char)ch) || ch == ':' || ch == '.') {
- return (s_http_host_v6);
+ return s_http_host_v6;
}
if (s == s_http_host_v6 && ch == '%') {
- return (s_http_host_v6_zone_start);
+ return s_http_host_v6_zone_start;
}
break;
case s_http_host_v6_zone:
if (ch == ']') {
- return (s_http_host_v6_end);
+ return s_http_host_v6_end;
}
FALLTHROUGH;
if (isalnum((unsigned char)ch) || ch == '%' || ch == '.' ||
ch == '-' || ch == '_' || ch == '~')
{
- return (s_http_host_v6_zone);
+ return s_http_host_v6_zone;
}
break;
case s_http_host_port:
case s_http_host_port_start:
if (isdigit((unsigned char)ch)) {
- return (s_http_host_port);
+ return s_http_host_port;
}
break;
break;
}
- return (s_http_host_dead);
+ return s_http_host_dead;
}
static isc_result_t
host_state_t new_s = http_parse_host_char(s, *p);
if (new_s == s_http_host_dead) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
switch (new_s) {
case s_http_host_port_start:
case s_http_userinfo:
case s_http_userinfo_start:
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
default:
break;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
const char *p = NULL;
if (buflen == 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
up->port = up->field_set = 0;
/* Figure out the next field that we're operating on */
switch (s) {
case s_dead:
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
/* Skip delimiters */
case s_req_schema_slash:
if ((up->field_set & (1 << ISC_UF_SCHEMA)) &&
(up->field_set & (1 << ISC_UF_HOST)) == 0)
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (up->field_set & (1 << ISC_UF_HOST)) {
result = http_parse_host(buf, up, found_at);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
if (is_connect &&
up->field_set != ((1 << ISC_UF_HOST) | (1 << ISC_UF_PORT)))
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (up->field_set & (1 << ISC_UF_PORT)) {
/* Ports have a max value of 2^16 */
if (v > 0xffff) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
}
up->port = (uint16_t)v;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
w = (buf[i] & 0x1f) << 6;
w |= (buf[++i] & 0x3f);
if (w < 0x80) {
- return (false);
+ return false;
}
continue;
}
w |= (buf[++i] & 0x3f) << 6;
w |= (buf[++i] & 0x3f);
if (w < 0x0800) {
- return (false);
+ return false;
}
continue;
}
w |= (buf[++i] & 0x3f) << 6;
w |= (buf[++i] & 0x3f);
if (w < 0x10000 || w > 0x10FFFF) {
- return (false);
+ return false;
}
continue;
}
- return (false);
+ return false;
}
- return (true);
+ return true;
}
bool
REQUIRE(buf != NULL);
if (len >= 3U && !memcmp(buf, "\xef\xbb\xbf", 3)) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
tag = isccc_sexpr_fromstring(ALIST_TAG);
if (tag == NULL) {
- return (NULL);
+ return NULL;
}
alist = isccc_sexpr_cons(tag, NULL);
if (alist == NULL) {
isccc_sexpr_free(&tag);
- return (NULL);
+ return NULL;
}
- return (alist);
+ return alist;
}
bool
isccc_sexpr_t *car;
if (alist == NULL || alist->type != ISCCC_SEXPRTYPE_DOTTEDPAIR) {
- return (false);
+ return false;
}
car = CAR(alist);
if (car == NULL || car->type != ISCCC_SEXPRTYPE_STRING) {
- return (false);
+ return false;
}
if (strcmp(car->value.as_string, ALIST_TAG) != 0) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
bool
REQUIRE(isccc_alist_alistp(alist));
if (CDR(alist) == NULL) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
isccc_sexpr_t *
isccc_alist_first(isccc_sexpr_t *alist) {
REQUIRE(isccc_alist_alistp(alist));
- return (CDR(alist));
+ return CDR(alist);
}
isccc_sexpr_t *
if (caar->type == ISCCC_SEXPRTYPE_STRING &&
strcmp(caar->value.as_string, key) == 0)
{
- return (car);
+ return car;
}
alist = CDR(alist);
}
- return (NULL);
+ return NULL;
}
void
*/
k = isccc_sexpr_fromstring(key);
if (k == NULL) {
- return (NULL);
+ return NULL;
}
kv = isccc_sexpr_cons(k, value);
if (kv == NULL) {
isccc_sexpr_free(&kv);
- return (NULL);
+ return NULL;
}
elt = isccc_sexpr_addtolist(&alist, kv);
if (elt == NULL) {
isccc_sexpr_free(&kv);
- return (NULL);
+ return NULL;
}
} else {
/*
CDR(kv) = value;
}
- return (kv);
+ return kv;
}
isccc_sexpr_t *
v = isccc_sexpr_fromstring(str);
if (v == NULL) {
- return (NULL);
+ return NULL;
}
kv = isccc_alist_define(alist, key, v);
if (kv == NULL) {
isccc_sexpr_free(&v);
}
- return (kv);
+ return kv;
}
isccc_sexpr_t *
v = isccc_sexpr_frombinary(r);
if (v == NULL) {
- return (NULL);
+ return NULL;
}
kv = isccc_alist_define(alist, key, v);
if (kv == NULL) {
isccc_sexpr_free(&v);
}
- return (kv);
+ return kv;
}
isccc_sexpr_t *
kv = isccc_alist_assq(alist, key);
if (kv != NULL) {
- return (CDR(kv));
+ return CDR(kv);
}
- return (NULL);
+ return NULL;
}
isc_result_t
if (strp != NULL) {
*strp = isccc_sexpr_tostring(v);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
isc_result_t
if (r != NULL) {
*r = isccc_sexpr_tobinary(v);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
void
result = isc_base64_totext(&sr, wordlength, wordbreak, &tb);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
source->rstart = source->rend;
target->rstart = isc_buffer_used(&tb);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
(unsigned int)(target->rend - target->rstart));
result = isc_base64_decodestring(cstr, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
target->rstart = isc_buffer_used(&b);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
len = REGION_SIZE(*vr);
result = isc_buffer_reserve(buffer, 1 + 4);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint8(*buffer, ISCCC_CCMSGTYPE_BINARYDATA);
isc_buffer_putuint32(*buffer, len);
result = isc_buffer_reserve(buffer, len);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putmem(*buffer, vr->rstart, len);
} else if (isccc_alist_alistp(elt)) {
result = isc_buffer_reserve(buffer, 1 + 4);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint8(*buffer, ISCCC_CCMSGTYPE_TABLE);
/*
*/
result = table_towire(elt, buffer);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
len = (*buffer)->used - used;
result = isc_buffer_reserve(buffer, 1 + 4);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint8(*buffer, ISCCC_CCMSGTYPE_LIST);
/*
*/
result = list_towire(elt, buffer);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
len = (*buffer)->used - used;
isc_buffer_putuint32(&b, len);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*/
result = isc_buffer_reserve(buffer, 1 + len);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint8(*buffer, (uint8_t)len);
isc_buffer_putmem(*buffer, (const unsigned char *)ks, len);
*/
result = value_towire(v, buffer);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
while (list != NULL) {
result = value_towire(ISCCC_SEXPR_CAR(list), buffer);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
list = ISCCC_SEXPR_CDR(list);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
md_type = ISC_MD_SHA512;
break;
default:
- return (ISC_R_NOTIMPLEMENTED);
+ 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);
+ return result;
}
source.rend = digest + digestlen;
target.rend = digestb64 + sizeof(digestb64);
result = isccc_base64_encode(&source, 64, "", &target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (algorithm == ISCCC_ALG_HMACMD5) {
PUT_MEM(digestb64, HMD5_LENGTH, out);
} else {
PUT_MEM(digestb64, HSHA_LENGTH, out);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
? sizeof(auth_hmd5)
: sizeof(auth_hsha)));
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/*
*/
result = table_towire(alist, buffer);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (secret != NULL) {
- return (sign((unsigned char *)(*buffer)->base + signed_base,
- (*buffer)->used - signed_base,
- (unsigned char *)(*buffer)->base + hmac_base,
- algorithm, secret));
+ return sign((unsigned char *)(*buffer)->base + signed_base,
+ (*buffer)->used - signed_base,
+ (unsigned char *)(*buffer)->base + hmac_base,
+ algorithm, secret);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*/
_auth = isccc_alist_lookup(alist, "_auth");
if (!isccc_alist_alistp(_auth)) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (algorithm == ISCCC_ALG_HMACMD5) {
hmacvalue = isccc_alist_lookup(_auth, "hmd5");
hmacvalue = isccc_alist_lookup(_auth, "hsha");
}
if (!isccc_sexpr_binaryp(hmacvalue)) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
* Compute digest.
md_type = ISC_MD_SHA512;
break;
default:
- return (ISC_R_NOTIMPLEMENTED);
+ 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);
+ return result;
}
source.rend = digest + digestlen;
memset(digestb64, 0, sizeof(digestb64));
result = isccc_base64_encode(&source, 64, "", &target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
region = isccc_sexpr_tobinary(hmacvalue);
if ((region->rend - region->rstart) != HMD5_LENGTH) {
- return (ISCCC_R_BADAUTH);
+ return ISCCC_R_BADAUTH;
}
value = region->rstart;
if (!isc_safe_memequal(value, digestb64, HMD5_LENGTH)) {
- return (ISCCC_R_BADAUTH);
+ return ISCCC_R_BADAUTH;
}
} else {
isccc_region_t *region;
* to identify which algorithm is in use.
*/
if ((region->rend - region->rstart) != HSHA_LENGTH + 1) {
- return (ISCCC_R_BADAUTH);
+ return ISCCC_R_BADAUTH;
}
value = region->rstart;
GET8(valalg, value);
if ((valalg != algorithm) ||
!isc_safe_memequal(value, digestb64, HSHA_LENGTH))
{
- return (ISCCC_R_BADAUTH);
+ return ISCCC_R_BADAUTH;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_result_t result;
if (depth > ISCCC_MAXDEPTH) {
- return (ISCCC_R_MAXDEPTH);
+ return ISCCC_R_MAXDEPTH;
}
if (REGION_SIZE(*source) < 1 + 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
GET8(msgtype, source->rstart);
GET32(len, source->rstart);
if (REGION_SIZE(*source) < len) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
active.rstart = source->rstart;
active.rend = active.rstart + len;
result = ISCCC_R_SYNTAX;
}
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(alistp != NULL && *alistp == NULL);
if (depth > ISCCC_MAXDEPTH) {
- return (ISCCC_R_MAXDEPTH);
+ return ISCCC_R_MAXDEPTH;
}
checksum_rstart = NULL;
first_tag = true;
alist = isccc_alist_create();
if (alist == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
while (!REGION_EMPTY(*source)) {
isccc_sexpr_free(&alist);
}
- return (result);
+ return result;
}
static isc_result_t
isc_result_t result;
if (depth > ISCCC_MAXDEPTH) {
- return (ISCCC_R_MAXDEPTH);
+ return ISCCC_R_MAXDEPTH;
}
list = NULL;
result = value_fromwire(source, depth + 1, &value);
if (result != ISC_R_SUCCESS) {
isccc_sexpr_free(&list);
- return (result);
+ return result;
}
if (isccc_sexpr_addtolist(&list, value) == NULL) {
isccc_sexpr_free(&value);
isccc_sexpr_free(&list);
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
}
*listp = list;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
size = REGION_SIZE(*source);
if (size < 4) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
GET32(version, source->rstart);
if (version != 1) {
- return (ISCCC_R_UNKNOWNVERSION);
+ return ISCCC_R_UNKNOWNVERSION;
}
- return (table_fromwire(source, secret, algorithm, 0, alistp));
+ return table_fromwire(source, secret, algorithm, 0, alistp);
}
static isc_result_t
REQUIRE(alistp != NULL && *alistp == NULL);
if (version != 1) {
- return (ISCCC_R_UNKNOWNVERSION);
+ return ISCCC_R_UNKNOWNVERSION;
}
alist = isccc_alist_create();
if (alist == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
result = ISC_R_NOMEMORY;
*alistp = alist;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
bad:
isccc_sexpr_free(&alist);
- return (result);
+ return result;
}
isc_result_t
isccc_cc_createmessage(uint32_t version, const char *from, const char *to,
uint32_t serial, isccc_time_t now, isccc_time_t expires,
isccc_sexpr_t **alistp) {
- return (createmessage(version, from, to, serial, now, expires, alistp,
- true));
+ return createmessage(version, from, to, serial, now, expires, alistp,
+ true);
}
isc_result_t
isccc_cc_lookupuint32(_ctrl, "_ser", &serial) != ISC_R_SUCCESS ||
isccc_cc_lookupuint32(_ctrl, "_tim", &t) != ISC_R_SUCCESS)
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
* _frm and _to are optional.
ack = NULL;
result = createmessage(1, _to, _frm, serial, t, 0, &ack, false);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
_ctrl = isccc_alist_lookup(ack, "_ctrl");
*ackp = ack;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
bad:
isccc_sexpr_free(&ack);
- return (result);
+ return result;
}
bool
_ctrl = isccc_alist_lookup(message, "_ctrl");
if (!isccc_alist_alistp(_ctrl)) {
- return (false);
+ return false;
}
if (isccc_cc_lookupstring(_ctrl, "_ack", NULL) == ISC_R_SUCCESS) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
_ctrl = isccc_alist_lookup(message, "_ctrl");
if (!isccc_alist_alistp(_ctrl)) {
- return (false);
+ return false;
}
if (isccc_cc_lookupstring(_ctrl, "_rpl", NULL) == ISC_R_SUCCESS) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
isc_result_t
isccc_cc_lookupuint32(_ctrl, "_ser", &serial) != ISC_R_SUCCESS ||
isccc_cc_lookupstring(_data, "type", &type) != ISC_R_SUCCESS)
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
* _frm and _to are optional.
result = isccc_cc_createmessage(1, _to, _frm, serial, now, expires,
&alist);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
_ctrl = isccc_alist_lookup(alist, "_ctrl");
*alistp = alist;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
bad:
isccc_sexpr_free(&alist);
- return (result);
+ return result;
}
isccc_sexpr_t *
DE_CONST(str, r.rstart);
r.rend = r.rstart + len;
- return (isccc_alist_definebinary(alist, key, &r));
+ return isccc_alist_definebinary(alist, key, &r);
}
isccc_sexpr_t *
r.rstart = (unsigned char *)b;
r.rend = (unsigned char *)b + len;
- return (isccc_alist_definebinary(alist, key, &r));
+ return isccc_alist_definebinary(alist, key, &r);
}
isc_result_t
if (strp != NULL) {
*strp = isccc_sexpr_tostring(v);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
isc_result_t
*uintp = (uint32_t)strtoul(
isccc_sexpr_tostring(v), NULL, 10);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
static void
now = arg;
if (*now < value.as_uinteger) {
- return (false);
+ return false;
}
if ((*now - value.as_uinteger) < DUP_LIFETIME) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
isc_result_t
isccc_cc_createsymtab(isccc_symtab_t **symtabp) {
- return (isccc_symtab_create(11897, symtab_undefine, NULL, false,
- symtabp));
+ return isccc_symtab_create(11897, symtab_undefine, NULL, false,
+ symtabp);
}
void
char c;
if (str == NULL) {
- return (false);
+ return false;
}
while ((c = *str++) != '\0') {
if (c == ' ' || c == '\t' || c == '\n') {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
isc_result_t
isccc_cc_lookupstring(_ctrl, "_ser", &_ser) != ISC_R_SUCCESS ||
isccc_cc_lookupstring(_ctrl, "_tim", &_tim) != ISC_R_SUCCESS)
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
INSIST(_ser != NULL);
if (has_whitespace(_frm) || has_whitespace(_to) ||
has_whitespace(_ser) || has_whitespace(_tim))
{
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
len = strlen(_frm) + strlen(_to) + strlen(_ser) + strlen(_tim) + 4;
key = malloc(len);
if (key == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
snprintf(key, len, "%s;%s;%s;%s", _frm, _to, _ser, _tim);
value.as_uinteger = now;
isccc_symexists_reject);
if (result != ISC_R_SUCCESS) {
free(key);
- return (result);
+ return result;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
sexpr = malloc(sizeof(*sexpr));
if (sexpr == NULL) {
- return (NULL);
+ return NULL;
}
sexpr->type = ISCCC_SEXPRTYPE_DOTTEDPAIR;
CAR(sexpr) = car;
CDR(sexpr) = cdr;
- return (sexpr);
+ return sexpr;
}
isccc_sexpr_t *
isccc_sexpr_tconst(void) {
- return (&sexpr_t);
+ return &sexpr_t;
}
isccc_sexpr_t *
sexpr = malloc(sizeof(*sexpr));
if (sexpr == NULL) {
- return (NULL);
+ return NULL;
}
sexpr->type = ISCCC_SEXPRTYPE_STRING;
sexpr->value.as_string = strdup(str);
if (sexpr->value.as_string == NULL) {
free(sexpr);
- return (NULL);
+ return NULL;
}
- return (sexpr);
+ return sexpr;
}
isccc_sexpr_t *
sexpr = malloc(sizeof(*sexpr));
if (sexpr == NULL) {
- return (NULL);
+ return NULL;
}
sexpr->type = ISCCC_SEXPRTYPE_BINARY;
region_size = REGION_SIZE(*region);
sexpr->value.as_region.rstart = malloc(region_size + 1);
if (sexpr->value.as_region.rstart == NULL) {
free(sexpr);
- return (NULL);
+ return NULL;
}
sexpr->value.as_region.rend = sexpr->value.as_region.rstart +
region_size;
*/
sexpr->value.as_region.rstart[region_size] = '\0';
- return (sexpr);
+ return sexpr;
}
void
curr = r->rstart;
while (curr != r->rend) {
if (!isprint(*curr)) {
- return (false);
+ return false;
}
curr++;
}
- return (true);
+ return true;
}
void
isccc_sexpr_car(isccc_sexpr_t *list) {
REQUIRE(list->type == ISCCC_SEXPRTYPE_DOTTEDPAIR);
- return (CAR(list));
+ return CAR(list);
}
isccc_sexpr_t *
isccc_sexpr_cdr(isccc_sexpr_t *list) {
REQUIRE(list->type == ISCCC_SEXPRTYPE_DOTTEDPAIR);
- return (CDR(list));
+ return CDR(list);
}
void
elt = isccc_sexpr_cons(l2, NULL);
if (elt == NULL) {
- return (NULL);
+ return NULL;
}
if (l1 == NULL) {
*l1p = elt;
- return (elt);
+ return elt;
}
for (last = l1; CDR(last) != NULL; last = CDR(last)) {
/* Nothing */
}
CDR(last) = elt;
- return (elt);
+ return elt;
}
bool
isccc_sexpr_listp(isccc_sexpr_t *sexpr) {
if (sexpr == NULL || sexpr->type == ISCCC_SEXPRTYPE_DOTTEDPAIR) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
isccc_sexpr_emptyp(isccc_sexpr_t *sexpr) {
if (sexpr == NULL) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
isccc_sexpr_stringp(isccc_sexpr_t *sexpr) {
if (sexpr != NULL && sexpr->type == ISCCC_SEXPRTYPE_STRING) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
isccc_sexpr_binaryp(isccc_sexpr_t *sexpr) {
if (sexpr != NULL && sexpr->type == ISCCC_SEXPRTYPE_BINARY) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
char *
sexpr->type == ISCCC_SEXPRTYPE_BINARY));
if (sexpr->type == ISCCC_SEXPRTYPE_BINARY) {
- return ((char *)sexpr->value.as_region.rstart);
+ return (char *)sexpr->value.as_region.rstart;
}
- return (sexpr->value.as_string);
+ return sexpr->value.as_string;
}
isccc_region_t *
isccc_sexpr_tobinary(isccc_sexpr_t *sexpr) {
REQUIRE(sexpr != NULL && sexpr->type == ISCCC_SEXPRTYPE_BINARY);
- return (&sexpr->value.as_region);
+ return &sexpr->value.as_region;
}
symtab = malloc(sizeof(*symtab));
if (symtab == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
symtab->table = malloc(size * sizeof(eltlist_t));
if (symtab->table == NULL) {
free(symtab);
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
for (i = 0; i < size; i++) {
ISC_LIST_INIT(symtab->table[i]);
*symtabp = symtab;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
}
}
- return (h);
+ return h;
}
#define FIND(s, k, t, b, e) \
FIND(symtab, key, type, bucket, elt);
if (elt == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (value != NULL) {
*value = elt->value;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (exists_policy != isccc_symexists_add && elt != NULL) {
if (exists_policy == isccc_symexists_reject) {
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
INSIST(exists_policy == isccc_symexists_replace);
ISC_LIST_UNLINK(symtab->table[bucket], elt, link);
} else {
elt = malloc(sizeof(*elt));
if (elt == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
ISC_LINK_INIT(elt, link);
}
*/
ISC_LIST_PREPEND(symtab->table[bucket], elt, link);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
FIND(symtab, key, type, bucket, elt);
if (elt == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
free_elt(symtab, bucket, elt);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
#endif /* if defined(HAVE_GEOIP2) */
*ret = actx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
result = cfg_map_get(cctx, "acl", &acls);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
for (elt = cfg_list_first(acls); elt != NULL; elt = cfg_list_next(elt))
{
if (ret != NULL) {
*ret = cfg_tuple_get(acl, "value");
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
static isc_result_t
if (ISC_MAGIC_VALID(dacl, LOOP_MAGIC)) {
cfg_obj_log(nameobj, lctx, ISC_LOG_ERROR,
"acl loop detected: %s", aclname);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
dns_acl_attach(dacl, target);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
/* Not yet converted. Convert now. */
if (result != ISC_R_SUCCESS) {
cfg_obj_log(nameobj, lctx, ISC_LOG_WARNING,
"undefined ACL '%s'", aclname);
- return (result);
+ return result;
}
/*
* Add a loop detection element.
loop.magic = 0;
loop.name = NULL;
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dacl->name = isc_mem_strdup(dacl->mctx, aclname);
ISC_LIST_APPEND(ctx->named_acl_cache, dacl, nextincache);
dns_acl_attach(dacl, target);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
cfg_obj_log(keyobj, lctx, ISC_LOG_WARNING,
"key name '%s' is not a valid domain name",
txtname);
- return (result);
+ return result;
}
dns_name_dup(dns_fixedname_name(&fixname), mctx, dnsname);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
result = count_acl_elements(ce, cctx, lctx, ctx, mctx,
&sub, &negative);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
n += sub;
if (negative) {
}
dns_acl_detach(&inneracl);
} else {
- return (result);
+ return result;
}
}
}
}
*count = n;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#if defined(HAVE_GEOIP2)
get_subtype(const cfg_obj_t *obj, isc_log_t *lctx, dns_geoip_subtype_t subtype,
const char *dbname) {
if (dbname == NULL) {
- return (subtype);
+ return subtype;
}
switch (subtype) {
case dns_geoip_countrycode:
if (strcasecmp(dbname, "city") == 0) {
- return (dns_geoip_city_countrycode);
+ return dns_geoip_city_countrycode;
} else if (strcasecmp(dbname, "country") == 0) {
- return (dns_geoip_country_code);
+ return dns_geoip_country_code;
}
cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
"invalid database specified for "
"country search: ignored");
- return (subtype);
+ return subtype;
case dns_geoip_countryname:
if (strcasecmp(dbname, "city") == 0) {
- return (dns_geoip_city_countryname);
+ return dns_geoip_city_countryname;
} else if (strcasecmp(dbname, "country") == 0) {
- return (dns_geoip_country_name);
+ return dns_geoip_country_name;
}
cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
"invalid database specified for "
"country search: ignored");
- return (subtype);
+ return subtype;
case dns_geoip_continentcode:
if (strcasecmp(dbname, "city") == 0) {
- return (dns_geoip_city_continentcode);
+ return dns_geoip_city_continentcode;
} else if (strcasecmp(dbname, "country") == 0) {
- return (dns_geoip_country_continentcode);
+ return dns_geoip_country_continentcode;
}
cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
"invalid database specified for "
"continent search: ignored");
- return (subtype);
+ return subtype;
case dns_geoip_continent:
if (strcasecmp(dbname, "city") == 0) {
- return (dns_geoip_city_continent);
+ return dns_geoip_city_continent;
} else if (strcasecmp(dbname, "country") == 0) {
- return (dns_geoip_country_continent);
+ return dns_geoip_country_continent;
}
cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
"invalid database specified for "
"continent search: ignored");
- return (subtype);
+ return subtype;
case dns_geoip_region:
if (strcasecmp(dbname, "city") == 0) {
- return (dns_geoip_city_region);
+ return dns_geoip_city_region;
}
cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
"invalid database specified for "
"region/subdivision search: ignored");
- return (subtype);
+ return subtype;
case dns_geoip_regionname:
if (strcasecmp(dbname, "city") == 0) {
- return (dns_geoip_city_regionname);
+ return dns_geoip_city_regionname;
}
cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
"invalid database specified for "
"region/subdivision search: ignored");
- return (subtype);
+ return subtype;
/*
* Log a warning if the wrong database was specified
"invalid database specified for "
"a 'city'-only search type: ignoring");
}
- return (subtype);
+ return subtype;
case dns_geoip_isp_name:
if (strcasecmp(dbname, "isp") != 0) {
cfg_obj_log(obj, lctx, ISC_LOG_WARNING,
"invalid database specified for "
"an 'isp' search: ignoring");
}
- return (subtype);
+ return subtype;
case dns_geoip_org_name:
if (strcasecmp(dbname, "org") != 0) {
cfg_obj_log(obj, lctx, ISC_LOG_WARNING,
"invalid database specified for "
"an 'org' search: ignoring");
}
- return (subtype);
+ return subtype;
case dns_geoip_as_asnum:
if (strcasecmp(dbname, "asnum") != 0) {
cfg_obj_log(obj, lctx, ISC_LOG_WARNING,
"invalid database specified for "
"an 'asnum' search: ignoring");
}
- return (subtype);
+ return subtype;
case dns_geoip_domain_name:
if (strcasecmp(dbname, "domain") != 0) {
cfg_obj_log(obj, lctx, ISC_LOG_WARNING,
"invalid database specified for "
"a 'domain' search: ignoring");
}
- return (subtype);
+ return subtype;
case dns_geoip_netspeed_id:
if (strcasecmp(dbname, "netspeed") != 0) {
cfg_obj_log(obj, lctx, ISC_LOG_WARNING,
"invalid database specified for "
"a 'netspeed' search: ignoring");
}
- return (subtype);
+ return subtype;
default:
UNREACHABLE();
}
static bool
geoip_can_answer(dns_aclelement_t *elt, cfg_aclconfctx_t *ctx) {
if (ctx->geoip == NULL) {
- return (true);
+ return true;
}
switch (elt->geoip_elem.subtype) {
case dns_geoip_continentcode:
case dns_geoip_continent:
if (ctx->geoip->country != NULL || ctx->geoip->city != NULL) {
- return (true);
+ return true;
}
break;
case dns_geoip_country_code:
case dns_geoip_country_continentcode:
case dns_geoip_country_continent:
if (ctx->geoip->country != NULL) {
- return (true);
+ return true;
}
/* city db can answer these too, so: */
FALLTHROUGH;
case dns_geoip_city_continent:
case dns_geoip_city_timezonecode:
if (ctx->geoip->city != NULL) {
- return (true);
+ return true;
}
break;
case dns_geoip_isp_name:
if (ctx->geoip->isp != NULL) {
- return (true);
+ return true;
}
break;
case dns_geoip_as_asnum:
case dns_geoip_org_name:
if (ctx->geoip->as != NULL) {
- return (true);
+ return true;
}
break;
case dns_geoip_domain_name:
if (ctx->geoip->domain != NULL) {
- return (true);
+ return true;
}
break;
default:
break;
}
- return (false);
+ return false;
}
static isc_result_t
cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
"database '%s' is not defined for GeoIP2",
dbname);
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
}
if (len == 0) {
cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
"zero-length geoip search field");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (strcasecmp(stype, "country") == 0 && len == 2) {
cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
"three-letter country codes are unavailable "
"in GeoIP2 databases");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
} else if (strcasecmp(stype, "country") == 0) {
/* Country name */
subtype = dns_geoip_countryname;
} else {
cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
"geoiop postal code (%s) too long", search);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
} else if (strcasecmp(stype, "metro") == 0 ||
strcasecmp(stype, "metrocode") == 0)
"type '%s' is unavailable "
"in GeoIP2 databases",
stype);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
de.geoip_elem.subtype = get_subtype(obj, lctx, subtype, dbname);
"no GeoIP2 database installed which can answer "
"queries of type '%s'",
stype);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
*dep = de;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#endif /* HAVE_GEOIP2 */
cfg_acl_fromconfig(const cfg_obj_t *caml, const cfg_obj_t *cctx,
isc_log_t *lctx, cfg_aclconfctx_t *ctx, isc_mem_t *mctx,
unsigned int nest_level, dns_acl_t **target) {
- return (cfg_acl_fromconfig2(caml, cctx, lctx, ctx, mctx, nest_level, 0,
- target));
+ return cfg_acl_fromconfig2(caml, cctx, lctx, ctx, mctx, nest_level, 0,
+ target);
}
isc_result_t
result = count_acl_elements(caml, cctx, lctx, ctx, mctx,
&nelem, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
} else {
nelem = cfg_list_length(caml, false);
result = dns_acl_create(mctx, nelem, &dacl);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
dns_acl_detach(&inneracl);
}
dns_acl_detach(&dacl);
- return (result);
+ return result;
}
* Copy the buffer as it may not be NULL terminated.
*/
if (source->length > sizeof(buf) - 1) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
/* Copy source->length bytes and NULL terminate. */
snprintf(buf, sizeof(buf), "%.*s", (int)source->length, source->base);
/* Every duration starts with 'P' */
if (toupper((unsigned char)str[0]) != 'P') {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
P = str;
endptr = NULL;
lli = strtoll(str + 1, &endptr, 10);
if (*endptr != *X) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
if (errno != 0 || lli < 0 || lli > UINT32_MAX) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
duration->parts[0] = (uint32_t)lli;
str = X;
errno = 0;
lli = strtoll(str + 1, &endptr, 10);
if (*endptr != *X) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
if (errno != 0 || lli < 0 || lli > UINT32_MAX) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
duration->parts[1] = (uint32_t)lli;
str = X;
errno = 0;
lli = strtoll(str + 1, &endptr, 10);
if (*endptr != *X) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
if (errno != 0 || lli < 0 || lli > UINT32_MAX) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
duration->parts[3] = (uint32_t)lli;
str = X;
errno = 0;
lli = strtoll(str + 1, &endptr, 10);
if (*endptr != *X) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
if (errno != 0 || lli < 0 || lli > UINT32_MAX) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
duration->parts[4] = (uint32_t)lli;
str = X;
errno = 0;
lli = strtoll(str + 1, &endptr, 10);
if (*endptr != *X) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
if (errno != 0 || lli < 0 || lli > UINT32_MAX) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
duration->parts[5] = (uint32_t)lli;
str = X;
errno = 0;
lli = strtoll(str + 1, &endptr, 10);
if (*endptr != *X) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
if (errno != 0 || lli < 0 || lli > UINT32_MAX) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
duration->parts[6] = (uint32_t)lli;
str = X;
if (W != NULL) {
if (not_weeks) {
/* Mix of weeks and other indicators is not allowed */
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
} else {
errno = 0;
lli = strtoll(str + 1, &endptr, 10);
if (*endptr != *W) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
if (errno != 0 || lli < 0 || lli > UINT32_MAX) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
duration->parts[2] = (uint32_t)lli;
str = W;
/* Deal with trailing garbage. */
if (str[1] != '\0') {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
duration->iso8601 = true;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
}
- return (result);
+ return result;
}
uint32_t
seconds += (uint64_t)duration->parts[1] * 86400 * 31; /* Months */
seconds += (uint64_t)duration->parts[0] * 86400 * 365; /* Years */
- return (seconds > UINT32_MAX ? UINT32_MAX : (uint32_t)seconds);
+ return seconds > UINT32_MAX ? UINT32_MAX : (uint32_t)seconds;
}
confget(cfg_obj_t const *const *maps, const char *name, const cfg_obj_t **obj) {
for (size_t i = 0;; i++) {
if (maps[i] == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (cfg_map_get(maps[i], name, obj) == ISC_R_SUCCESS) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
}
if (result == ISC_R_SUCCESS) {
time = isccfg_duration_toseconds(&duration);
}
- return (time);
+ return time;
}
/*
result = confget(maps, option, &obj);
if (result == ISC_R_NOTFOUND) {
- return (parse_duration(dfl));
+ return parse_duration(dfl);
}
INSIST(result == ISC_R_SUCCESS);
- return (cfg_obj_asduration(obj));
+ return cfg_obj_asduration(obj);
}
/*
/* Create a new key reference. */
result = dns_kasp_key_create(kasp, &key);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (config == NULL) {
}
dns_kasp_addkey(kasp, key);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_kasp_key_destroy(key);
- return (result);
+ return result;
}
static isc_result_t
obj, logctx, ISC_LOG_ERROR,
"dnssec-policy: cannot use nsec3 with algorithm '%s'",
algstr);
- return (DNS_R_NSEC3BADALG);
+ return DNS_R_NSEC3BADALG;
}
if (iter > dns_nsec3_maxiterations()) {
"dnssec-policy: nsec3 iterations value %u "
"out of range",
iter);
- return (ret);
+ return ret;
}
/* Opt-out? */
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"dnssec-policy: nsec3 salt length %u too high",
saltlen);
- return (DNS_R_NSEC3SALTRANGE);
+ return DNS_R_NSEC3SALTRANGE;
}
dns_kasp_setnsec3param(kasp, iter, optout, saltlen);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
"dnssec-policy: duplicately named policy found '%s'",
kaspname);
dns_kasp_detach(&kasp);
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
if (result != ISC_R_NOTFOUND) {
- return (result);
+ return result;
}
/* No kasp with configured name was found in list, create new one. */
INSIST(kasp == NULL);
result = dns_kasp_create(mctx, kaspname, &kasp);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
INSIST(kasp != NULL);
dns_kasp_attach(kasp, kaspp);
/* Don't detach as kasp is on '*kasplist' */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
/* Something bad happened, detach (destroys kasp) and return error. */
dns_kasp_detach(&kasp);
- return (result);
+ return result;
}
{
pctx->flags |= CFG_PCTX_SKIP;
}
- return (cfg_parse_enum(pctx, type, ret));
+ return cfg_parse_enum(pctx, type, ret);
cleanup:
- return (result);
+ return result;
}
static isc_result_t
*ret = obj;
cleanup:
- return (result);
+ return result;
}
static void
pctx->token.value.as_char == '{')
{
cfg_ungettoken(pctx);
- return (cfg_parse_bracketed_list(pctx, type, ret));
+ return cfg_parse_bracketed_list(pctx, type, ret);
}
if (pctx->token.type == isc_tokentype_string &&
memmove(obj->value.string.base, "local", 5);
obj->value.string.base[5] = '\0';
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
cfg_ungettoken(pctx);
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
cleanup:
- return (result);
+ return result;
}
static void
static isc_result_t
parse_maxduration(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
- return (cfg_parse_enum_or_other(pctx, type, &cfg_type_duration, ret));
+ return cfg_parse_enum_or_other(pctx, type, &cfg_type_duration, ret);
}
static void
static isc_result_t
parse_optional_enum(cfg_parser_t *pctx, const cfg_type_t *type,
cfg_obj_t **ret) {
- return (cfg_parse_enum_or_other(pctx, type, &cfg_type_void, ret));
+ return cfg_parse_enum_or_other(pctx, type, &cfg_type_void, ret);
}
static void
static const char *zonestat_enums[] = { "full", "terse", "none", NULL };
static isc_result_t
parse_zonestat(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
- return (cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret));
+ return cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret);
}
static void
doc_zonestat(cfg_printer_t *pctx, const cfg_type_t *type) {
if (pctx->token.type == isc_tokentype_string &&
strcasecmp(TOKEN_STRING(pctx), "none") == 0)
{
- return (cfg_create_obj(pctx, &cfg_type_none, ret));
+ return cfg_create_obj(pctx, &cfg_type_none, ret);
}
cfg_ungettoken(pctx);
- return (cfg_parse_qstring(pctx, type, ret));
+ return cfg_parse_qstring(pctx, type, ret);
cleanup:
- return (result);
+ return result;
}
static void
if (pctx->token.type == isc_tokentype_string &&
strcasecmp(TOKEN_STRING(pctx), "auto") == 0)
{
- return (cfg_create_obj(pctx, &cfg_type_auto, ret));
+ return cfg_create_obj(pctx, &cfg_type_auto, ret);
}
cfg_ungettoken(pctx);
- return (cfg_parse_boolean(pctx, type, ret));
+ return cfg_parse_boolean(pctx, type, ret);
cleanup:
- return (result);
+ return result;
}
static void
if (pctx->token.type == isc_tokentype_string &&
strcasecmp(TOKEN_STRING(pctx), "none") == 0)
{
- return (cfg_create_obj(pctx, &cfg_type_none, ret));
+ return cfg_create_obj(pctx, &cfg_type_none, ret);
}
if (pctx->token.type == isc_tokentype_string &&
strcasecmp(TOKEN_STRING(pctx), "hostname") == 0)
if (result == ISC_R_SUCCESS) {
(*ret)->value.boolean = true;
}
- return (result);
+ return result;
}
cfg_ungettoken(pctx);
- return (cfg_parse_qstring(pctx, type, ret));
+ return cfg_parse_qstring(pctx, type, ret);
cleanup:
- return (result);
+ return result;
}
static void
}
cleanup:
- return (result);
+ return result;
}
static isc_result_t
{
cfg_parser_error(pctx, CFG_LOG_NEAR,
"expected integer or 'range'");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
CHECK(cfg_create_tuple(pctx, &cfg_type_porttuple, &obj));
CHECK(parse_port(pctx, &obj->value.tuple[0]));
if (obj != NULL) {
cfg_obj_destroy(pctx, &obj);
}
- return (result);
+ return result;
}
static cfg_type_t cfg_type_portrange = { "portrange", parse_portrange,
}
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
CLEANUP_OBJ(obj);
- return (result);
+ return result;
}
static void
}
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
CLEANUP_OBJ(obj);
- return (result);
+ return result;
}
/*
}
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
CLEANUP_OBJ(obj);
- return (result);
+ return result;
}
static void
CHECK(cfg_parse_obj(pctx, &cfg_type_void, ret));
}
cleanup:
- return (result);
+ return result;
}
static void
static isc_result_t
parse_staleanswerclienttimeout(cfg_parser_t *pctx, const cfg_type_t *type,
cfg_obj_t **ret) {
- return (cfg_parse_enum_or_other(pctx, type, &cfg_type_uint32, ret));
+ return cfg_parse_enum_or_other(pctx, type, &cfg_type_uint32, ret);
}
static void
NULL };
static isc_result_t
parse_printtime(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
- return (cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret));
+ return cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret);
}
static void
doc_printtime(cfg_printer_t *pctx, const cfg_type_t *type) {
value = strtoull(str, &endp, 10);
if (*endp == 0) {
*valuep = value;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
len = strlen(str);
if (len < 2 || endp[1] != '\0') {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
switch (str[len - 1]) {
unit = 1024 * 1024 * 1024;
break;
default:
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (value > ((uint64_t)UINT64_MAX / unit)) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
*valuep = value * unit;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
CHECK(cfg_create_obj(pctx, &cfg_type_uint64, &obj));
obj->value.uint64 = val;
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
cfg_parser_error(pctx, CFG_LOG_NEAR,
"expected integer and optional unit");
- return (result);
+ return result;
}
static isc_result_t
CHECK(cfg_create_obj(pctx, &cfg_type_percentage, &obj));
obj->value.uint32 = (uint32_t)percent;
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
CHECK(parse_unitstring(TOKEN_STRING(pctx), &val));
CHECK(cfg_create_obj(pctx, &cfg_type_uint64, &obj));
obj->value.uint64 = val;
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
cleanup:
cfg_parser_error(pctx, CFG_LOG_NEAR,
"expected integer and optional unit or percent");
- return (result);
+ return result;
}
static void
static isc_result_t
parse_size(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
- return (cfg_parse_enum_or_other(pctx, type, &cfg_type_sizeval, ret));
+ return cfg_parse_enum_or_other(pctx, type, &cfg_type_sizeval, ret);
}
static void
static isc_result_t
parse_size_or_percent(cfg_parser_t *pctx, const cfg_type_t *type,
cfg_obj_t **ret) {
- return (cfg_parse_enum_or_other(pctx, type, &cfg_type_sizeval_percent,
- ret));
+ return cfg_parse_enum_or_other(pctx, type, &cfg_type_sizeval_percent,
+ ret);
}
static void
static isc_result_t
parse_ixfrratio(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
- return (cfg_parse_enum_or_other(pctx, type, &cfg_type_percentage, ret));
+ return cfg_parse_enum_or_other(pctx, type, &cfg_type_percentage, ret);
}
static void
}
*ret = obj;
cleanup:
- return (result);
+ return result;
}
static isc_result_t
parse_keyvalue(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
- return (parse_maybe_optional_keyvalue(pctx, type, false, ret));
+ return parse_maybe_optional_keyvalue(pctx, type, false, ret);
}
static isc_result_t
parse_optional_keyvalue(cfg_parser_t *pctx, const cfg_type_t *type,
cfg_obj_t **ret) {
- return (parse_maybe_optional_keyvalue(pctx, type, true, ret));
+ return parse_maybe_optional_keyvalue(pctx, type, true, ret);
}
static void
"refresh", NULL };
static isc_result_t
parse_dialup_type(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
- return (cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret));
+ return cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret);
}
static void
doc_dialup_type(cfg_printer_t *pctx, const cfg_type_t *type) {
NULL };
static isc_result_t
parse_notify_type(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
- return (cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret));
+ return cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret);
}
static void
doc_notify_type(cfg_printer_t *pctx, const cfg_type_t *type) {
static const char *minimal_enums[] = { "no-auth", "no-auth-recursive", NULL };
static isc_result_t
parse_minimal(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
- return (cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret));
+ return cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret);
}
static void
doc_minimal(cfg_printer_t *pctx, const cfg_type_t *type) {
static isc_result_t
parse_ixfrdiff_type(cfg_parser_t *pctx, const cfg_type_t *type,
cfg_obj_t **ret) {
- return (cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret));
+ return cfg_parse_enum_or_other(pctx, type, &cfg_type_boolean, ret);
}
static void
doc_ixfrdiff_type(cfg_printer_t *pctx, const cfg_type_t *type) {
CHECK(cfg_parse_obj(pctx, &cfg_type_void, ret));
}
cleanup:
- return (result);
+ return result;
}
static void
} else if (have_port == 0 && have_dscp == 0 &&
have_address == 0)
{
- return (cfg_parse_sockaddr(pctx, type, ret));
+ return cfg_parse_sockaddr(pctx, type, ret);
} else {
cfg_parser_error(pctx, CFG_LOG_NEAR,
"expected 'address' "
"or 'port'");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
} else {
break;
if (have_address > 1 || have_port > 1 || have_address + have_port == 0)
{
cfg_parser_error(pctx, 0, "expected one address and/or port");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
if (have_dscp > 1) {
cfg_parser_error(pctx, 0, "expected at most one dscp");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
CHECK(cfg_create_obj(pctx, &cfg_type_querysource, &obj));
isc_sockaddr_fromnetaddr(&obj->value.sockaddr, &netaddr, port);
obj->value.sockaddrdscp.dscp = dscp;
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
cfg_parser_error(pctx, CFG_LOG_NEAR, "invalid query source");
CLEANUP_OBJ(obj);
- return (result);
+ return result;
}
static void
CHECK(cfg_parse_special(pctx, '}'));
}
cleanup:
- return (result);
+ return result;
}
static cfg_type_t cfg_type_server_key_kludge = {
"server_key", parse_server_key_kludge, NULL, cfg_doc_terminal, NULL,
CHECK(cfg_parse_obj(pctx, &cfg_type_void, ret));
}
cleanup:
- return (result);
+ return result;
}
static void
CHECK(cfg_parse_obj(pctx, &cfg_type_loglevel, ret));
}
cleanup:
- return (result);
+ return result;
}
static cfg_type_t cfg_type_logseverity = { "log_severity", parse_logseverity,
static const char *logversions_enums[] = { "unlimited", NULL };
static isc_result_t
parse_logversions(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
- return (cfg_parse_enum_or_other(pctx, type, &cfg_type_uint32, ret));
+ return cfg_parse_enum_or_other(pctx, type, &cfg_type_uint32, ret);
}
static void
}
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
CLEANUP_OBJ(obj);
- return (result);
+ return result;
}
static void
} else {
cfg_parser_error(pctx, CFG_LOG_NEAR,
"expected IP address or hostname");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
cleanup:
CLEANUP_OBJ(obj);
- return (result);
+ return result;
}
static cfg_type_t cfg_type_sockaddrnameport = { "sockaddrnameport_element",
cfg_parser_error(pctx, CFG_LOG_NEAR,
"expected IP address or remote servers list "
"name");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
cleanup:
CLEANUP_OBJ(obj);
- return (result);
+ return result;
}
static cfg_type_t cfg_type_remoteselement = { "remotes_element",
cmp_clause(const void *ap, const void *bp) {
const cfg_clausedef_t *a = (const cfg_clausedef_t *)ap;
const cfg_clausedef_t *b = (const cfg_clausedef_t *)bp;
- return (strcmp(a->name, b->name));
+ return strcmp(a->name, b->name);
}
bool
valid = true;
}
- return (valid);
+ return valid;
}
void
result = type->parse(pctx, type, ret);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
ENSURE(*ret != NULL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
obj->value.tuple[i] = NULL;
}
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (obj != NULL) {
isc_mem_put(pctx->mctx, obj, sizeof(*obj));
}
- return (result);
+ return result;
}
isc_result_t
}
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
CLEANUP_OBJ(obj);
- return (result);
+ return result;
}
void
bool
cfg_obj_istuple(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->type->rep == &cfg_rep_tuple);
+ return obj->type->rep == &cfg_rep_tuple;
}
const cfg_obj_t *
fields = tupleobj->type->of;
for (f = fields, i = 0; f->name != NULL; f++, i++) {
if (strcmp(f->name, name) == 0) {
- return (tupleobj->value.tuple[i]);
+ return tupleobj->value.tuple[i];
}
}
UNREACHABLE();
if (pctx->token.type == isc_tokentype_special &&
pctx->token.value.as_char == special)
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
cfg_parser_error(pctx, CFG_LOG_NEAR, "'%c' expected", special);
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
cleanup:
- return (result);
+ return result;
}
/*
if (pctx->token.type == isc_tokentype_special &&
pctx->token.value.as_char == ';')
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
cfg_parser_error(pctx, CFG_LOG_BEFORE, "missing ';'");
cfg_ungettoken(pctx);
cleanup:
- return (result);
+ return result;
}
/*
CHECK(cfg_gettoken(pctx, 0));
if (pctx->token.type == isc_tokentype_eof) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
cfg_parser_error(pctx, CFG_LOG_NEAR, "syntax error");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
cleanup:
- return (result);
+ return result;
}
/* A list of files, used internally for pctx->files. */
CHECK(cfg_create_list(pctx, &cfg_type_filelist, &pctx->closed_files));
*ret = pctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (pctx->lexer != NULL) {
CLEANUP_OBJ(pctx->open_files);
CLEANUP_OBJ(pctx->closed_files);
isc_mem_putanddetach(&pctx->mctx, pctx, sizeof(*pctx));
- return (result);
+ return result;
}
void
elt->obj = stringobj;
ISC_LIST_APPEND(pctx->open_files->value.list, elt, link);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
CLEANUP_OBJ(stringobj);
- return (result);
+ return result;
}
void
CHECK(parse_eof(pctx));
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
CLEANUP_OBJ(obj);
- return (result);
+ return result;
}
isc_result_t
ISC_LIST_APPEND(pctx->closed_files->value.list, elt, link);
cleanup:
- return (result);
+ return result;
}
isc_result_t
pctx->buf_name = NULL;
cleanup:
- return (result);
+ return result;
}
void
UNUSED(type);
- return (cfg_create_obj(pctx, &cfg_type_void, ret));
+ return cfg_create_obj(pctx, &cfg_type_void, ret);
}
void
bool
cfg_obj_isvoid(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->type->rep == &cfg_rep_void);
+ return obj->type->rep == &cfg_rep_void;
}
cfg_type_t cfg_type_void = { "void", cfg_parse_void, cfg_print_void,
CHECK(cfg_gettoken(pctx, 0));
if (pctx->token.type != isc_tokentype_string) {
cfg_parser_error(pctx, CFG_LOG_NEAR, "expected percentage");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
percent = strtoull(TOKEN_STRING(pctx), &endp, 10);
if (*endp != '%' || *(endp + 1) != 0) {
cfg_parser_error(pctx, CFG_LOG_NEAR, "expected percentage");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
CHECK(cfg_create_obj(pctx, &cfg_type_percentage, &obj));
*ret = obj;
cleanup:
- return (result);
+ return result;
}
void
uint32_t
cfg_obj_aspercentage(const cfg_obj_t *obj) {
REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_percentage);
- return (obj->value.uint32);
+ return obj->value.uint32;
}
cfg_type_t cfg_type_percentage = { "percentage", cfg_parse_percentage,
bool
cfg_obj_ispercentage(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->type->rep == &cfg_rep_percentage);
+ return obj->type->rep == &cfg_rep_percentage;
}
/*
if (pctx->token.type != isc_tokentype_string) {
cfg_parser_error(pctx, CFG_LOG_NEAR,
"expected fixed point number");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
p = TOKEN_STRING(pctx);
{
cfg_parser_error(pctx, CFG_LOG_NEAR,
"expected fixed point number");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
CHECK(cfg_create_obj(pctx, &cfg_type_fixedpoint, &obj));
*ret = obj;
cleanup:
- return (result);
+ return result;
}
void
uint32_t
cfg_obj_asfixedpoint(const cfg_obj_t *obj) {
REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_fixedpoint);
- return (obj->value.uint32);
+ return obj->value.uint32;
}
cfg_type_t cfg_type_fixedpoint = { "fixedpoint", cfg_parse_fixedpoint,
bool
cfg_obj_isfixedpoint(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->type->rep == &cfg_rep_fixedpoint);
+ return obj->type->rep == &cfg_rep_fixedpoint;
}
/*
CHECK(cfg_gettoken(pctx, ISC_LEXOPT_NUMBER | ISC_LEXOPT_CNUMBER));
if (pctx->token.type != isc_tokentype_number) {
cfg_parser_error(pctx, CFG_LOG_NEAR, "expected number");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
CHECK(cfg_create_obj(pctx, &cfg_type_uint32, &obj));
obj->value.uint32 = pctx->token.value.as_ulong;
*ret = obj;
cleanup:
- return (result);
+ return result;
}
void
bool
cfg_obj_isuint32(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->type->rep == &cfg_rep_uint32);
+ return obj->type->rep == &cfg_rep_uint32;
}
uint32_t
cfg_obj_asuint32(const cfg_obj_t *obj) {
REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_uint32);
- return (obj->value.uint32);
+ return obj->value.uint32;
}
cfg_type_t cfg_type_uint32 = { "integer", cfg_parse_uint32,
bool
cfg_obj_isuint64(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->type->rep == &cfg_rep_uint64);
+ return obj->type->rep == &cfg_rep_uint64;
}
uint64_t
cfg_obj_asuint64(const cfg_obj_t *obj) {
REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_uint64);
- return (obj->value.uint64);
+ return obj->value.uint64;
}
void
size_t count = 0;
if (period == 0) {
- return (1);
+ return 1;
}
while (period > 0) {
count++;
period /= 10;
}
- return (count);
+ return count;
}
/*
bool
cfg_obj_isduration(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->type->rep == &cfg_rep_duration);
+ return obj->type->rep == &cfg_rep_duration;
}
uint32_t
if (result == ISC_R_RANGE) {
cfg_parser_error(pctx, CFG_LOG_NEAR,
"duration or TTL out of range");
- return (result);
+ return result;
} else if (result != ISC_R_SUCCESS) {
goto cleanup;
}
obj->value.duration = duration;
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
cfg_parser_error(pctx, CFG_LOG_NEAR,
"expected ISO 8601 duration or TTL value");
- return (result);
+ return result;
}
isc_result_t
goto cleanup;
}
- return (parse_duration(pctx, ret));
+ return parse_duration(pctx, ret);
cleanup:
cfg_parser_error(pctx, CFG_LOG_NEAR,
"expected ISO 8601 duration or TTL value");
- return (result);
+ return result;
}
isc_result_t
CHECK(cfg_create_obj(pctx, &cfg_type_duration, &obj));
obj->value.duration = duration;
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (parse_duration(pctx, ret));
+ return parse_duration(pctx, ret);
cleanup:
cfg_parser_error(pctx, CFG_LOG_NEAR,
"expected ISO 8601 duration, TTL value, or unlimited");
- return (result);
+ return result;
}
/*%
obj->value.string.base = isc_mem_get(pctx->mctx, len + 1);
if (obj->value.string.base == 0) {
isc_mem_put(pctx->mctx, obj, sizeof(*obj));
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
memmove(obj->value.string.base, contents, len);
obj->value.string.base[len] = '\0';
*ret = obj;
cleanup:
- return (result);
+ return result;
}
isc_result_t
CHECK(cfg_gettoken(pctx, CFG_LEXOPT_QSTRING));
if (pctx->token.type != isc_tokentype_qstring) {
cfg_parser_error(pctx, CFG_LOG_NEAR, "expected quoted string");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
- return (create_string(pctx, TOKEN_STRING(pctx), &cfg_type_qstring,
- ret));
+ return create_string(pctx, TOKEN_STRING(pctx), &cfg_type_qstring, ret);
cleanup:
- return (result);
+ return result;
}
static isc_result_t
if (pctx->token.type != isc_tokentype_string) {
cfg_parser_error(pctx, CFG_LOG_NEAR,
"expected unquoted string");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
- return (create_string(pctx, TOKEN_STRING(pctx), &cfg_type_ustring,
- ret));
+ return create_string(pctx, TOKEN_STRING(pctx), &cfg_type_ustring, ret);
cleanup:
- return (result);
+ return result;
}
isc_result_t
UNUSED(type);
CHECK(cfg_getstringtoken(pctx));
- return (create_string(pctx, TOKEN_STRING(pctx), &cfg_type_qstring,
- ret));
+ return create_string(pctx, TOKEN_STRING(pctx), &cfg_type_qstring, ret);
cleanup:
- return (result);
+ return result;
}
isc_result_t
UNUSED(type);
CHECK(cfg_getstringtoken(pctx));
- return (create_string(pctx, TOKEN_STRING(pctx), &cfg_type_sstring,
- ret));
+ return create_string(pctx, TOKEN_STRING(pctx), &cfg_type_sstring, ret);
cleanup:
- return (result);
+ return result;
}
static isc_result_t
CHECK(cfg_gettoken(pctx, ISC_LEXOPT_BTEXT));
if (pctx->token.type != isc_tokentype_btext) {
cfg_parser_error(pctx, CFG_LOG_NEAR, "expected bracketed text");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
- return (create_string(pctx, TOKEN_STRING(pctx),
- &cfg_type_bracketed_text, ret));
+ return create_string(pctx, TOKEN_STRING(pctx), &cfg_type_bracketed_text,
+ ret);
cleanup:
- return (result);
+ return result;
}
static void
for (p = enums; *p != NULL; p++) {
if (strcasecmp(*p, s) == 0) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static isc_result_t
const char *s = obj->value.string.base;
if (cfg_is_enum(s, enums)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
cfg_parser_error(pctx, 0, "'%s' unexpected", s);
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
isc_result_t
CHECK(parse_ustring(pctx, NULL, &obj));
CHECK(check_enum(pctx, obj, type->of));
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
CLEANUP_OBJ(obj);
- return (result);
+ return result;
}
void
CHECK(cfg_parse_obj(pctx, othertype, ret));
}
cleanup:
- return (result);
+ return result;
}
void
bool
cfg_obj_isstring(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->type->rep == &cfg_rep_string);
+ return obj->type->rep == &cfg_rep_string;
}
const char *
cfg_obj_asstring(const cfg_obj_t *obj) {
REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_string);
- return (obj->value.string.base);
+ return obj->value.string.base;
}
/* Quoted string only */
CHECK(cfg_parse_obj(pctx, fields[3].type, &obj->value.tuple[3]));
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
CLEANUP_OBJ(obj);
- return (result);
+ return result;
}
static void
cfg_parser_error(pctx, CFG_LOG_NEAR,
"'geoip' "
"not supported in this build");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
#endif /* if defined(HAVE_GEOIP2) */
} else {
if (cfg_lookingat_netaddr(
bad:
cfg_parser_error(pctx, CFG_LOG_NEAR,
"expected IP match list element");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
cleanup:
- return (result);
+ return result;
}
/*%
CHECK(cfg_parse_obj(pctx, &cfg_type_void, ret));
}
cleanup:
- return (result);
+ return result;
}
static void
bool
cfg_obj_isboolean(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->type->rep == &cfg_rep_boolean);
+ return obj->type->rep == &cfg_rep_boolean;
}
bool
cfg_obj_asboolean(const cfg_obj_t *obj) {
REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_boolean);
- return (obj->value.boolean);
+ return obj->value.boolean;
}
isc_result_t
result = cfg_gettoken(pctx, 0);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (pctx->token.type != isc_tokentype_string) {
CHECK(cfg_create_obj(pctx, &cfg_type_boolean, &obj));
obj->value.boolean = value;
*ret = obj;
- return (result);
+ return result;
bad_boolean:
cfg_parser_error(pctx, CFG_LOG_NEAR, "boolean expected");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
cleanup:
- return (result);
+ return result;
}
void
CHECK(cfg_create_obj(pctx, type, obj));
ISC_LIST_INIT((*obj)->value.list);
cleanup:
- return (result);
+ return result;
}
static isc_result_t
elt->obj = NULL;
ISC_LINK_INIT(elt, link);
*eltp = elt;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
elt->obj = value;
*ret = elt;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
isc_mem_put(pctx->mctx, elt, sizeof(*elt));
- return (result);
+ return result;
}
/*
elt = NULL;
}
*ret = listobj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (elt != NULL) {
free_listelt(pctx, elt);
}
CLEANUP_OBJ(listobj);
- return (result);
+ return result;
}
static void
CHECK(parse_list(pctx, type, ret));
CHECK(cfg_parse_special(pctx, '}'));
cleanup:
- return (result);
+ return result;
}
void
ISC_LIST_APPEND(listobj->value.list, elt, link);
}
*ret = listobj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
CLEANUP_OBJ(listobj);
- return (result);
+ return result;
}
void
bool
cfg_obj_islist(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->type->rep == &cfg_rep_list);
+ return obj->type->rep == &cfg_rep_list;
}
const cfg_listelt_t *
cfg_list_first(const cfg_obj_t *obj) {
REQUIRE(obj == NULL || obj->type->rep == &cfg_rep_list);
if (obj == NULL) {
- return (NULL);
+ return NULL;
}
- return (ISC_LIST_HEAD(obj->value.list));
+ return ISC_LIST_HEAD(obj->value.list);
}
const cfg_listelt_t *
cfg_list_next(const cfg_listelt_t *elt) {
REQUIRE(elt != NULL);
- return (ISC_LIST_NEXT(elt, link));
+ return ISC_LIST_NEXT(elt, link);
}
/*
unsigned int count = 0;
if (obj == NULL || !cfg_obj_islist(obj)) {
- return (0U);
+ return 0U;
}
for (elt = cfg_list_first(obj); elt != NULL; elt = cfg_list_next(elt)) {
if (recurse && cfg_obj_islist(elt->obj)) {
count++;
}
}
- return (count);
+ return count;
}
cfg_obj_t *
cfg_listelt_value(const cfg_listelt_t *elt) {
REQUIRE(elt != NULL);
- return (elt->obj);
+ return elt->obj;
}
/*
}
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
CLEANUP_OBJ(value);
CLEANUP_OBJ(obj);
CLEANUP_OBJ(eltobj);
CLEANUP_OBJ(includename);
- return (result);
+ return result;
}
static isc_result_t
symval.as_pointer = obj;
CHECK(isc_symtab_define(symtab, name, 1, symval, isc_symexists_reject));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
CLEANUP_OBJ(obj);
- return (result);
+ return result;
}
/*
CHECK(cfg_parse_mapbody(pctx, type, ret));
CHECK(cfg_parse_special(pctx, '}'));
cleanup:
- return (result);
+ return result;
}
/*
CHECK(cfg_parse_map(pctx, type, &mapobj));
mapobj->value.map.id = idobj;
*ret = mapobj;
- return (result);
+ return result;
cleanup:
CLEANUP_OBJ(idobj);
CLEANUP_OBJ(mapobj);
- return (result);
+ return result;
}
/*
isc_result_t
cfg_parse_named_map(cfg_parser_t *pctx, const cfg_type_t *type,
cfg_obj_t **ret) {
- return (parse_any_named_map(pctx, &cfg_type_astring, type, ret));
+ return parse_any_named_map(pctx, &cfg_type_astring, type, ret);
}
/*
isc_result_t
cfg_parse_addressed_map(cfg_parser_t *pctx, const cfg_type_t *type,
cfg_obj_t **ret) {
- return (parse_any_named_map(pctx, &cfg_type_netaddr, type, ret));
+ return parse_any_named_map(pctx, &cfg_type_netaddr, type, ret);
}
/*
isc_result_t
cfg_parse_netprefix_map(cfg_parser_t *pctx, const cfg_type_t *type,
cfg_obj_t **ret) {
- return (parse_any_named_map(pctx, &cfg_type_netprefix, type, ret));
+ return parse_any_named_map(pctx, &cfg_type_netprefix, type, ret);
}
static void
bool
cfg_obj_ismap(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->type->rep == &cfg_rep_map);
+ return obj->type->rep == &cfg_rep_map;
}
isc_result_t
result = isc_symtab_lookup(map->symtab, name, MAP_SYM, &val);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
*obj = val.as_pointer;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
const cfg_obj_t *
cfg_map_getname(const cfg_obj_t *mapobj) {
REQUIRE(mapobj != NULL && mapobj->type->rep == &cfg_rep_map);
- return (mapobj->value.map.id);
+ return mapobj->value.map.id;
}
unsigned int
REQUIRE(mapobj != NULL && mapobj->type->rep == &cfg_rep_map);
map = &mapobj->value.map;
- return (isc_symtab_count(map->symtab));
+ return isc_symtab_count(map->symtab);
}
const char *
clauseset = map->of;
if (*clauseset == NULL) {
- return (NULL);
+ return NULL;
}
*clauses = *clauseset;
*idx = 0;
while ((*clauseset)[*idx].name == NULL) {
*clauses = (*++clauseset);
if (*clauses == NULL) {
- return (NULL);
+ return NULL;
}
}
- return ((*clauseset)[*idx].name);
+ return (*clauseset)[*idx].name;
}
const char *
*idx = 0;
*clauses = (*++clauseset);
if (*clauses == NULL) {
- return (NULL);
+ return NULL;
}
}
- return ((*clauseset)[*idx].name);
+ return (*clauseset)[*idx].name;
}
/* Parse an arbitrary token, storing its raw text representation. */
memmove(obj->value.string.base, r.base, r.length);
obj->value.string.base[r.length] = '\0';
*ret = obj;
- return (result);
+ return result;
cleanup:
if (obj != NULL) {
isc_mem_put(pctx->mctx, obj, sizeof(*obj));
}
- return (result);
+ return result;
}
cfg_type_t cfg_type_token = { "token", parse_token,
}
INSIST(braces == 0);
*ret = listobj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
CLEANUP_OBJ(listobj);
- return (result);
+ return result;
}
cfg_type_t cfg_type_unsupported = { "unsupported", parse_unsupported,
struct in6_addr in6a;
if (pctx->token.type != isc_tokentype_string) {
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
s = TOKEN_STRING(pctx);
if ((flags & CFG_ADDR_WILDOK) != 0 && strcmp(s, "*") == 0) {
if ((flags & CFG_ADDR_V4OK) != 0) {
isc_netaddr_any(na);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if ((flags & CFG_ADDR_V6OK) != 0) {
isc_netaddr_any6(na);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
UNREACHABLE();
}
if ((flags & (CFG_ADDR_V4OK | CFG_ADDR_V4PREFIXOK)) != 0) {
if (inet_pton(AF_INET, s, &in4a) == 1) {
isc_netaddr_fromin(na, &in4a);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
if ((flags & CFG_ADDR_V4PREFIXOK) != 0 && strlen(s) <= 15U) {
strlcat(buf, ".0", sizeof(buf));
if (inet_pton(AF_INET, buf, &in4a) == 1) {
isc_netaddr_fromin(na, &in4a);
- return (ISC_R_IPV4PREFIX);
+ return ISC_R_IPV4PREFIX;
}
}
}
result = isc_netscope_pton(
AF_INET6, d + 1, &in6a, &zone);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
isc_netaddr_fromin6(na, &in6a);
isc_netaddr_setzone(na, zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
}
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
isc_result_t
}
}
cleanup:
- return (result);
+ return result;
}
bool
REQUIRE(pctx != NULL);
result = token_addr(pctx, flags, &na_dummy);
- return (result == ISC_R_SUCCESS || result == ISC_R_IPV4PREFIX);
+ return result == ISC_R_SUCCESS || result == ISC_R_IPV4PREFIX;
}
isc_result_t
strcmp(TOKEN_STRING(pctx), "*") == 0)
{
*port = 0;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (pctx->token.type != isc_tokentype_number) {
cfg_parser_error(pctx, CFG_LOG_NEAR,
"expected port number or '*'");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
if (pctx->token.value.as_ulong >= 65536U) {
cfg_parser_error(pctx, CFG_LOG_NEAR,
"port number out of range");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
*port = (in_port_t)(pctx->token.value.as_ulong);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
- return (result);
+ return result;
}
void
isc_sockaddr_fromnetaddr(&obj->value.sockaddr, &netaddr, 0);
obj->value.sockaddrdscp.dscp = -1;
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
CLEANUP_OBJ(obj);
- return (result);
+ return result;
}
static void
if (pctx->token.type != isc_tokentype_number) {
cfg_parser_error(pctx, CFG_LOG_NEAR,
"expected prefix length");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
prefixlen = pctx->token.value.as_ulong;
if (prefixlen > addrlen) {
cfg_parser_error(pctx, CFG_LOG_NOPREP,
"invalid prefix length");
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
result = isc_netaddr_prefixok(&netaddr, prefixlen);
if (result != ISC_R_SUCCESS) {
"'%s/%u': address/prefix length "
"mismatch",
buf, prefixlen);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
} else {
if (expectprefix) {
cfg_parser_error(pctx, CFG_LOG_NEAR,
"incomplete IPv4 address or prefix");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
prefixlen = addrlen;
}
obj->value.netprefix.address = netaddr;
obj->value.netprefix.prefixlen = prefixlen;
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
cfg_parser_error(pctx, CFG_LOG_NEAR, "expected network prefix");
- return (result);
+ return result;
}
static void
bool
cfg_obj_isnetprefix(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->type->rep == &cfg_rep_netprefix);
+ return obj->type->rep == &cfg_rep_netprefix;
}
void
}
isc_sockaddr_fromnetaddr(&obj->value.sockaddr, &netaddr, port);
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
CLEANUP_OBJ(obj);
- return (result);
+ return result;
}
static unsigned int sockaddr_flags = CFG_ADDR_V4OK | CFG_ADDR_V6OK |
flagp = type->of;
- return (parse_sockaddrsub(pctx, &cfg_type_sockaddr, *flagp, ret));
+ return parse_sockaddrsub(pctx, &cfg_type_sockaddr, *flagp, ret);
}
void
bool
cfg_obj_issockaddr(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->type->rep == &cfg_rep_sockaddr);
+ return obj->type->rep == &cfg_rep_sockaddr;
}
const isc_sockaddr_t *
cfg_obj_assockaddr(const cfg_obj_t *obj) {
REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_sockaddr);
- return (&obj->value.sockaddr);
+ return &obj->value.sockaddr;
}
isc_result_t
REQUIRE(pctx != NULL);
if (pctx->seen_eof) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
options |= (ISC_LEXOPT_EOF | ISC_LEXOPT_NOMORE);
isc_result_totext(result));
break;
}
- return (result);
+ return result;
}
void
CHECK(cfg_gettoken(pctx, options));
cfg_ungettoken(pctx);
cleanup:
- return (result);
+ return result;
}
/*
result = cfg_gettoken(pctx, CFG_LEXOPT_QSTRING);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (pctx->token.type != isc_tokentype_string &&
pctx->token.type != isc_tokentype_qstring)
{
cfg_parser_error(pctx, CFG_LOG_NEAR, "expected string");
- return (ISC_R_UNEXPECTEDTOKEN);
+ return ISC_R_UNEXPECTEDTOKEN;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
have_current_file(cfg_parser_t *pctx) {
cfg_listelt_t *elt;
if (pctx->open_files == NULL) {
- return (false);
+ return false;
}
elt = ISC_LIST_TAIL(pctx->open_files->value.list);
if (elt == NULL) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static char *
cfg_obj_t *fileobj;
if (!have_current_file(pctx)) {
- return (none);
+ return none;
}
elt = ISC_LIST_TAIL(pctx->open_files->value.list);
if (elt == NULL) { /* shouldn't be possible, but... */
- return (none);
+ return none;
}
fileobj = elt->obj;
INSIST(fileobj->type == &cfg_type_qstring);
- return (fileobj->value.string.base);
+ return fileobj->value.string.base;
}
static void
cfg_obj_file(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->file);
+ return obj->file;
}
unsigned int
cfg_obj_line(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->line);
+ return obj->line;
}
isc_result_t
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
obj->value.map.id = NULL;
*ret = obj;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (obj != NULL) {
isc_mem_put(pctx->mctx, obj, sizeof(*obj));
}
- return (result);
+ return result;
}
static void
REQUIRE(obj != NULL);
REQUIRE(type != NULL);
- return (obj->type == type);
+ return obj->type == type;
}
/*
breakout:
if (clause == NULL || clause->name == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
result = isc_symtab_lookup(map->symtab, clausename, 0, &symval);
}
CLEANUP_OBJ(destobj);
- return (result);
+ return result;
}
isc_result_t
if (strcasecmp(type, "query") != 0) {
cfg_obj_log(obj, lctx, ISC_LOG_ERROR,
"unsupported plugin type");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
library = cfg_obj_asstring(cfg_tuple_get(plugin, "library"));
}
}
- return (result);
+ return result;
}
case 13: /* daytime */
case 19: /* chargen */
case 37: /* time */
- return (DROPPORT_REQUEST);
+ return DROPPORT_REQUEST;
case 464: /* kpasswd */
- return (DROPPORT_RESPONSE);
+ return DROPPORT_RESPONSE;
}
- return (DROPPORT_NO);
+ return DROPPORT_NO;
}
#endif /* if NS_CLIENT_DROPPORT */
result = dns_message_buildopt(message, opt, 0, udpsize, flags, ednsopts,
count);
- return (result);
+ return result;
}
static void
*/
if ((client->attributes & NS_CLIENTATTR_HAVEECS) != 0) {
isc_buffer_forward(buf, (unsigned int)optlen);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
ns_client_log(client, NS_LOGCATEGORY_CLIENT,
NS_LOGMODULE_CLIENT, ISC_LOG_DEBUG(2),
"EDNS client-subnet option too short");
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
family = isc_buffer_getuint16(buf);
ns_client_log(client, NS_LOGCATEGORY_CLIENT,
NS_LOGMODULE_CLIENT, ISC_LOG_DEBUG(2),
"EDNS client-subnet option: invalid scope");
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
memset(&caddr, 0, sizeof(caddr));
"EDNS client-subnet option: invalid "
"address length (%u) for FAMILY=0",
addrlen);
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
caddr.family = AF_UNSPEC;
break;
"EDNS client-subnet option: invalid "
"address length (%u) for IPv4",
addrlen);
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
caddr.family = AF_INET;
break;
"EDNS client-subnet option: invalid "
"address length (%u) for IPv6",
addrlen);
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
caddr.family = AF_INET6;
break;
ns_client_log(client, NS_LOGCATEGORY_CLIENT,
NS_LOGMODULE_CLIENT, ISC_LOG_DEBUG(2),
"EDNS client-subnet option: invalid family");
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
addrbytes = (addrlen + 7) / 8;
ns_client_log(client, NS_LOGCATEGORY_CLIENT,
NS_LOGMODULE_CLIENT, ISC_LOG_DEBUG(2),
"EDNS client-subnet option: address too short");
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
paddr = (uint8_t *)&caddr.type;
uint8_t bits = ~0U << (8 - (addrlen % 8));
bits &= paddr[addrbytes - 1];
if (bits != paddr[addrbytes - 1]) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
}
}
client->attributes |= NS_CLIENTATTR_HAVEECS;
isc_buffer_forward(buf, (unsigned int)optlen);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
process_keytag(ns_client_t *client, isc_buffer_t *buf, size_t optlen) {
if (optlen == 0 || (optlen % 2) != 0) {
isc_buffer_forward(buf, (unsigned int)optlen);
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
/* Silently drop additional keytag options. */
if (client->keytag != NULL) {
isc_buffer_forward(buf, (unsigned int)optlen);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
client->keytag = isc_mem_get(client->mctx, optlen);
memmove(client->keytag, isc_buffer_current(buf), optlen);
}
isc_buffer_forward(buf, (unsigned int)optlen);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
result = DNS_R_BADVERS;
}
ns_client_error(client, result);
- return (result);
+ return result;
}
/* Check for NSID request */
result = process_ecs(client, &optbuf, optlen);
if (result != ISC_R_SUCCESS) {
ns_client_error(client, result);
- return (result);
+ return result;
}
ns_stats_increment(client->sctx->nsstats,
ns_statscounter_ecsopt);
optlen);
if (result != ISC_R_SUCCESS) {
ns_client_error(client, result);
- return (result);
+ return result;
}
ns_stats_increment(client->sctx->nsstats,
ns_statscounter_keytagopt);
ns_stats_increment(client->sctx->nsstats, ns_statscounter_edns0in);
client->attributes |= NS_CLIENTATTR_WANTOPT;
- return (result);
+ return result;
}
void
int match;
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (handle != NULL) {
&match, NULL) == ISC_R_SUCCESS) &&
match > 0)
{
- return (ISC_R_CONNREFUSED);
+ return ISC_R_CONNREFUSED;
}
}
ns_stats_update_if_greater(sctx->nsstats, ns_statscounter_tcphighwater,
tcpquota);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
CTRACE("client_setup");
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_message_detach(&client->message);
isc_mem_detach(&client->mctx);
ns_server_detach(&client->sctx);
- return (result);
+ return result;
}
bool
ns_client_shuttingdown(ns_client_t *client) {
- return (client->shuttingdown);
+ return client->shuttingdown;
}
/***
*managerp = manager;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_sockaddr_t *
ns_client_getsockaddr(ns_client_t *client) {
- return (&client->peeraddr);
+ return &client->peeraddr;
}
isc_sockaddr_t *
ns_client_getdestaddr(ns_client_t *client) {
- return (&client->destsockaddr);
+ return &client->destsockaddr;
}
isc_result_t
goto deny; /* Negative match or no match. */
allow:
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
deny:
- return (DNS_R_REFUSED);
+ return DNS_R_REFUSED;
}
isc_result_t
NS_LOGMODULE_CLIENT, log_level, "%s denied",
opname);
}
- return (result);
+ return result;
}
static void
REQUIRE(addrp != NULL);
*addrp = &client->peeraddr;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_rdataset_t *
rdataset = NULL;
result = dns_message_gettemprdataset(client->message, &rdataset);
if (result != ISC_R_SUCCESS) {
- return (NULL);
+ return NULL;
}
- return (rdataset);
+ return rdataset;
}
void
ISC_LIST_APPEND(client->query.namebufs, dbuf, link);
CTRACE("ns_client_newnamebuf: done");
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_name_t *
if (result != ISC_R_SUCCESS) {
CTRACE("ns_client_newname: "
"dns_message_gettempname failed: done");
- return (NULL);
+ return NULL;
}
isc_buffer_availableregion(dbuf, &r);
isc_buffer_init(nbuf, r.base, r.length);
client->query.attributes |= NS_QUERYATTR_NAMEBUFUSED;
CTRACE("ns_client_newname: done");
- return (name);
+ return name;
}
isc_buffer_t *
INSIST(r.length >= 255);
}
CTRACE("ns_client_getnamebuf: done");
- return (dbuf);
+ return dbuf;
}
void
link);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static ns_dbversion_t *
INSIST(dbversion != NULL);
ISC_LIST_UNLINK(client->query.freeversions, dbversion, link);
- return (dbversion);
+ return dbversion;
}
ns_dbversion_t *
*/
dbversion = client_getdbversion(client);
if (dbversion == NULL) {
- return (NULL);
+ return NULL;
}
dns_db_attach(db, &dbversion->db);
dns_db_currentversion(db, &dbversion->version);
ISC_LIST_APPEND(client->query.activeversions, dbversion, link);
}
- return (dbversion);
+ return dbversion;
}
}
if (result < 0) {
- return (isc_errno_toresult(errno));
+ return isc_errno_toresult(errno);
} else if ((size_t)result >= dstsize) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
"failed to look up symbol %s in "
"plugin '%s': %s",
symbol_name, modpath, errmsg);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
*symbolp = symbol;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
*pluginp = plugin;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
unload_plugin(&plugin);
- return (result);
+ return result;
}
static void
unload_plugin(&plugin);
}
- return (result);
+ return result;
}
isc_result_t
unload_plugin(&plugin);
}
- return (result);
+ return result;
}
void
*tablep = hooktable;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
static bool
need_rescan(ns_interfacemgr_t *mgr, struct MSGHDR *rtm, size_t len) {
if (rtm->MSGTYPE != RTM_NEWADDR && rtm->MSGTYPE != RTM_DELADDR) {
- return (false);
+ return false;
}
#ifndef LINUX_NETLINK_AVAILABLE
UNUSED(mgr);
UNUSED(len);
/* On most systems, any NEWADDR or DELADDR means we rescan */
- return (true);
+ return true;
#else /* LINUX_NETLINK_AVAILABLE */
/* ...but on linux we need to check the messages more carefully */
for (struct MSGHDR *nlh = rtm;
(existed && was_listening &&
rtm->MSGTYPE == RTM_DELADDR))
{
- return (true);
+ return true;
}
} else if (rth->rta_type == IFA_ADDRESS &&
ifa->ifa_family == AF_INET)
* It seems that the IPv4 P2P link state
* has changed.
*/
- return (true);
+ return true;
} else if (rth->rta_type == IFA_LOCAL) {
/*
* Local address state has changed - do
* rescan.
*/
- return (true);
+ return true;
}
rth = RTA_NEXT(rth, rtl);
}
}
#endif /* LINUX_NETLINK_AVAILABLE */
- return (false);
+ return false;
}
static void
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_listenon:
ns_listenlist_detach(&mgr->listenon4);
isc_mutex_destroy(&mgr->lock);
ns_server_detach(&mgr->sctx);
isc_mem_putanddetach(&mgr->mctx, mgr, sizeof(*mgr));
- return (result);
+ return result;
}
static void
aclenv = mgr->aclenv;
UNLOCK(&mgr->lock);
- return (aclenv);
+ return aclenv;
}
void
result = isc_nm_listenudp(ifp->mgr->nm, &ifp->addr, ns__client_request,
ifp, sizeof(ns_client_t),
&ifp->udplistensocket);
- return (result);
+ return result;
}
static isc_result_t
isc_result_totext(result));
}
- return (result);
+ return result;
}
/*
isc_log_write(IFMGR_COMMON_LOGARGS, ISC_LOG_ERROR,
"creating TLS socket: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
/*
isc_result_totext(result));
}
- return (result);
+ return result;
}
#ifdef HAVE_LIBNGHTTP2
}
}
- return (result);
+ return result;
}
#endif /* HAVE_LIBNGHTTP2 */
"creating %s socket: %s",
sslctx ? "HTTPS" : "HTTP",
isc_result_totext(result));
- return (result);
+ return result;
}
if (sslctx) {
isc_result_totext(result));
}
- return (result);
+ return result;
#else
UNUSED(ifp);
UNUSED(sslctx);
UNUSED(neps);
UNUSED(max_clients);
UNUSED(max_concurrent_streams);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
#endif
}
goto cleanup_interface;
}
*ifpret = ifp;
- return (result);
+ return result;
}
if (elt->sslctx != NULL) {
goto cleanup_interface;
}
*ifpret = ifp;
- return (result);
+ return result;
}
result = ns_interface_listenudp(ifp);
goto cleanup_interface;
}
- if (((mgr->sctx->options & NS_SERVER_NOTCP) == 0)) {
+ if ((mgr->sctx->options & NS_SERVER_NOTCP) == 0) {
result = ns_interface_listentcp(ifp);
if (result != ISC_R_SUCCESS) {
if ((result == ISC_R_ADDRINUSE) &&
}
}
*ifpret = ifp;
- return (result);
+ return result;
cleanup_interface:
ns_interface_shutdown(ifp);
- return (result);
+ return result;
}
void
}
}
UNLOCK(&mgr->lock);
- return (ifp);
+ return ifp;
}
static void
static bool
listenon_is_ip6_any(ns_listenelt_t *elt) {
REQUIRE(elt && elt->acl);
- return (dns_acl_isany(elt->acl));
+ return dns_acl_isany(elt->acl);
}
static isc_result_t
result = dns_iptable_addprefix(localhost->iptable, netaddr, prefixlen,
true);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/* Then add localnets prefix */
/* Non contiguous netmasks not allowed by IPv6 arch. */
if (result != ISC_R_SUCCESS && netaddr->family == AF_INET6) {
- return (result);
+ return result;
}
if (result != ISC_R_SUCCESS) {
"omitting IPv4 interface %s from "
"localnets ACL: %s",
interface->name, isc_result_totext(result));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (prefixlen == 0U) {
"zero prefix length detected",
(netaddr->family == AF_INET) ? "IPv4" : "IPv6",
interface->name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = dns_iptable_addprefix(localnets->iptable, netaddr, prefixlen,
true);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
same_transport_type = true;
}
- return (same_transport_type);
+ return same_transport_type;
}
static bool
if (config) {
update_listener_configuration(mgr, ifp, le);
}
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static isc_result_t
result = isc_interfaceiter_create(mgr->mctx, &iter);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_acl_create(mgr->mctx, 0, &localhost);
cleanup_iter:
isc_interfaceiter_destroy(&iter);
- return (result);
+ return result;
}
isc_result_t
"not listening on any interfaces");
}
- return (result);
+ return result;
}
bool
ns_interfacemgr_islistening(ns_interfacemgr_t *mgr) {
REQUIRE(NS_INTERFACEMGR_VALID(mgr));
- return (ISC_LIST_EMPTY(mgr->interfaces) ? false : true);
+ return ISC_LIST_EMPTY(mgr->interfaces) ? false : true;
}
void
* return true.
*/
if (atomic_load(&mgr->shuttingdown)) {
- return (true);
+ return true;
}
LOCK(&mgr->lock);
for (old = ISC_LIST_HEAD(mgr->listenon); old != NULL;
}
UNLOCK(&mgr->lock);
- return (result);
+ return result;
}
ns_server_t *
ns_interfacemgr_getserver(ns_interfacemgr_t *mgr) {
REQUIRE(NS_INTERFACEMGR_VALID(mgr));
- return (mgr->sctx);
+ return mgr->sctx;
}
ns_clientmgr_t *
REQUIRE(tid >= 0);
REQUIRE(tid < mgr->ncpus);
- return (mgr->clientmgrs[tid]);
+ return mgr->clientmgrs[tid];
}
elt->max_concurrent_streams = 0;
*target = elt;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
tls_error:
if (sslctx != NULL) {
isc_tlsctx_free(&sslctx);
if (store != NULL && store != found_store) {
isc_tls_cert_store_free(&store);
}
- return (result);
+ return result;
}
isc_result_t
}
isc_mem_free(mctx, endpoints);
}
- return (result);
+ return result;
}
void
list->refcount = 1;
ISC_LIST_INIT(list->elts);
*target = list;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
ISC_LIST_APPEND(list->elts, elt, link);
*target = list;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_listenelt:
ns_listenelt_destroy(elt);
cleanup_acl:
dns_acl_detach(&acl);
cleanup:
- return (result);
+ return result;
}
get_hooktab(query_ctx_t *qctx) {
if (qctx == NULL || qctx->view == NULL || qctx->view->hooktable == NULL)
{
- return (ns__hook_table);
+ return ns__hook_table;
}
- return (qctx->view->hooktable);
+ return qctx->view->hooktable;
}
/*
ns_client_newdbversion(client, 3);
ns_client_newnamebuf(client);
- return (result);
+ return result;
}
/*%
client->query.attributes |= NS_QUERYATTR_CACHEACLOKVALID;
}
- return ((client->query.attributes & NS_QUERYATTR_CACHEACLOK) != 0
- ? ISC_R_SUCCESS
- : DNS_R_REFUSED);
+ return (client->query.attributes & NS_QUERYATTR_CACHEACLOK) != 0
+ ? ISC_R_SUCCESS
+ : DNS_R_REFUSED;
}
static isc_result_t
* Mirror zone data is treated as cache data.
*/
if (dns_zone_gettype(zone) == dns_zone_mirror) {
- return (query_checkcacheaccess(client, name, qtype, options));
+ return query_checkcacheaccess(client, name, qtype, options);
}
/*
!(WANTRECURSION(client) && RECURSIONOK(client)) &&
client->query.authdbset && db != client->query.authdb)
{
- return (DNS_R_REFUSED);
+ return DNS_R_REFUSED;
}
/*
if (dns_zone_gettype(zone) == dns_zone_staticstub &&
!RECURSIONOK(client))
{
- return (DNS_R_REFUSED);
+ return DNS_R_REFUSED;
}
/*
dbversion = ns_client_findversion(client, db);
if (dbversion == NULL) {
CTRACE(ISC_LOG_ERROR, "unable to get db version");
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
if ((options & DNS_GETDB_IGNOREACL) != 0) {
}
if (dbversion->acl_checked) {
if (!dbversion->queryok) {
- return (DNS_R_REFUSED);
+ return DNS_R_REFUSED;
}
goto approved;
}
0)
{
dbversion->queryok = false;
- return (DNS_R_REFUSED);
+ return DNS_R_REFUSED;
}
dbversion->queryok = true;
goto approved;
dbversion->acl_checked = true;
if (result != ISC_R_SUCCESS) {
dbversion->queryok = false;
- return (DNS_R_REFUSED);
+ return DNS_R_REFUSED;
}
dbversion->queryok = true;
if (versionp != NULL) {
*versionp = dbversion->version;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*dbp = db;
if (partial && (options & DNS_GETDB_PARTIAL) != 0) {
- return (DNS_R_PARTIALMATCH);
+ return DNS_R_PARTIALMATCH;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
fail:
if (zone != NULL) {
dns_db_detach(&db);
}
- return (result);
+ return result;
}
static void
p_namebuf);
}
*versionp = rpz_version;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
rpz_log_fail(client, DNS_RPZ_ERROR_LEVEL, p_name, rpz_type,
"query_getzonedb()", result);
- return (result);
+ return result;
}
/*%
REQUIRE(dbp != NULL && *dbp == NULL);
if (!USECACHE(client)) {
- return (DNS_R_REFUSED);
+ return DNS_R_REFUSED;
}
dns_db_attach(client->view->cachedb, &db);
*/
*dbp = db;
- return (result);
+ return result;
}
static isc_result_t
}
*is_zonep = false;
}
- return (result);
+ return result;
}
static bool
*/
CTRACE(ISC_LOG_DEBUG(3), "query_isduplicate: true: "
"done");
- return (true);
+ return true;
} else if (result == DNS_R_NXRRSET) {
/*
* The name exists, but the rdataset does not.
}
CTRACE(ISC_LOG_DEBUG(3), "query_isduplicate: false: done");
- return (false);
+ return false;
}
/*
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
/*
*nodep = node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
* additional data.
*/
if (!client->query.authdbset || client->query.authdb == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
dbversion = ns_client_findversion(client, client->query.authdb);
if (dbversion == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
dns_db_attach(client->query.authdb, &db);
result = query_getzonedb(client, name, type, DNS_GETDB_NOLOG,
&zone, &db, &version);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_zone_detach(&zone);
db = NULL;
}
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(qtype != dns_rdatatype_any);
if (!WANTDNSSEC(client) && dns_rdatatype_isdnssec(qtype)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
CTRACE(ISC_LOG_DEBUG(3), "query_additional_cb");
}
CTRACE(ISC_LOG_DEBUG(3), "query_additional_cb: done");
- return (eresult);
+ return eresult;
}
/*
result = dns_db_findnodeext(db, &rrsig->signer, false, &cm, &ci,
&node);
if (result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
result = dns_db_findrdataset(db, node, NULL,
client->now, keyrdataset, NULL);
dns_db_detachnode(db, &node);
if (result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
if (keyrdataset->trust != dns_trust_secure) {
- return (false);
+ return false;
}
result = dns_rdataset_first(keyrdataset);
}
dst_key_free(keyp);
}
- return (secure);
+ return secure;
}
static bool
goto again;
}
if (result == ISC_R_SUCCESS || result == DNS_R_FROMWILDCARD) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
/*
dns_rdataset_t keyrdataset;
if (sigrdataset == NULL || !dns_rdataset_isassociated(sigrdataset)) {
- return (false);
+ return false;
}
for (result = dns_rdataset_first(sigrdataset); result == ISC_R_SUCCESS;
dns_rdataset_disassociate(&keyrdataset);
mark_secure(client, db, name, &rrsig, rdataset,
sigrdataset);
- return (true);
+ return true;
}
dst_key_free(&key);
} while (1);
dns_rdataset_disassociate(&keyrdataset);
}
}
- return (false);
+ return false;
}
static void
if (*rdatasetp == NULL) {
CTRACE(ISC_LOG_ERROR, "rpz_ready: "
"ns_client_newrdataset failed");
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
} else if (dns_rdataset_isassociated(*rdatasetp)) {
dns_rdataset_disassociate(*rdatasetp);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
ip_type == dns_rdatatype_aaaa,
((rpsdb_t *)st->rpsdb)->rsp))
{
- return (DNS_RPZ_ALL_ZBITS);
+ return DNS_RPZ_ALL_ZBITS;
}
- return (0);
+ return 0;
}
#endif /* ifdef USE_DNSRPS */
zbits &= st->popt.no_rd_ok;
}
- return (zbits);
+ return zbits;
}
static void
st->m.policy = DNS_RPZ_POLICY_ERROR;
result = DNS_R_SERVFAIL;
}
- return (result);
+ return result;
}
result = rpz_ready(client, rdatasetp);
if (result != ISC_R_SUCCESS) {
st->m.policy = DNS_RPZ_POLICY_ERROR;
- return (result);
+ return result;
}
if (*dbp != NULL) {
is_zone = false;
if (zone != NULL) {
dns_zone_detach(&zone);
}
- return (result);
+ return result;
}
if (zone != NULL) {
dns_zone_detach(&zone);
}
}
}
- return (result);
+ return result;
}
/*
if (labels - first < 2) {
rpz_log_fail(client, DNS_RPZ_ERROR_LEVEL, suffix,
rpz_type, "concatenate()", result);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/*
* Complain once about trimming the trigger name.
}
++first;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
result = rpz_ready(client, rdatasetp);
if (result != ISC_R_SUCCESS) {
CTRACE(ISC_LOG_ERROR, "rpz_ready() failed");
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
*versionp = NULL;
result = rpz_getdb(client, p_name, rpz_type, zonep, dbp, versionp);
if (result != ISC_R_SUCCESS) {
- return (DNS_R_NXDOMAIN);
+ return DNS_R_NXDOMAIN;
}
found = dns_fixedname_initname(&foundf);
rpz_type, "allrdatasets()", result);
CTRACE(ISC_LOG_ERROR,
"rpz_find_p: allrdatasets failed");
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
if (qtype == dns_rdatatype_aaaa &&
!ISC_LIST_EMPTY(client->view->dns64))
result);
CTRACE(ISC_LOG_ERROR, "rpz_find_p: "
"rdatasetiter failed");
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
/*
* Ask again to get the right DNS_R_DNAME/NXRRSET/...
qtype != dns_rdatatype_cname &&
qtype != dns_rdatatype_any)
{
- return (DNS_R_CNAME);
+ return DNS_R_CNAME;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
case DNS_R_NXRRSET:
if (found_a) {
*policyp = DNS_RPZ_POLICY_DNS64;
} else {
*policyp = DNS_RPZ_POLICY_NODATA;
}
- return (result);
+ return result;
case DNS_R_DNAME:
/*
* DNAME policy RRs have very few if any uses that are not
*/
case DNS_R_NXDOMAIN:
case DNS_R_EMPTYNAME:
- return (DNS_R_NXDOMAIN);
+ return DNS_R_NXDOMAIN;
default:
rpz_log_fail(client, DNS_RPZ_ERROR_LEVEL, p_name, rpz_type, "",
result);
CTRACE(ISC_LOG_ERROR, "rpz_find_p: unexpected result");
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
}
librpz_domain_buf_t pname_buf;
if (!librpz->rsp_result(emsg, &rpsdb->result, recursed, rpsdb->rsp)) {
- return (-1);
+ return -1;
}
/*
rpsdb->result.policy != LIBRPZ_POLICY_DISABLED)
{
if (!librpz->rsp_pop_discard(emsg, rpsdb->rsp)) {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
/*
* Forget the zone to not try it again, and restore the pre-hit state.
*/
if (!librpz->rsp_domain(emsg, &pname_buf, rpsdb->rsp)) {
- return (-1);
+ return -1;
}
region.base = pname_buf.d;
region.length = pname_buf.size;
if (!librpz->rsp_forget_zone(emsg, rpsdb->result.cznum, rpsdb->rsp) ||
!librpz->rsp_pop(emsg, &rpsdb->result, rpsdb->rsp))
{
- return (-1);
+ return -1;
}
- return (1);
+ return 1;
}
/*
rpsdb = (rpsdb_t *)st->rpsdb;
if (!librpz->rsp_result(emsg, &rpsdb->result, recursed, rpsdb->rsp)) {
- return (false);
+ return false;
}
if (rpsdb->result.policy == LIBRPZ_POLICY_UNDEFINED) {
- return (true);
+ return true;
}
/*
if (!librpz->rsp_soa(emsg, NULL, NULL, &rpsdb->origin_buf,
&rpsdb->result, rpsdb->rsp))
{
- return (false);
+ return false;
}
region.base = rpsdb->origin_buf.d;
region.length = rpsdb->origin_buf.size;
dns_name_fromregion(&rpsdb->common.origin, ®ion);
if (!librpz->rsp_domain(emsg, &pname_buf, rpsdb->rsp)) {
- return (false);
+ return false;
}
region.base = pname_buf.d;
region.length = pname_buf.size;
&rpsdb->result, rpsdb->qname->ndata,
rpsdb->qname->length, rpsdb->rsp))
{
- return (false);
+ return false;
}
if (foundtype == dns_rdatatype_cname) {
searchtype = dns_rdatatype_cname;
} else {
snprintf(emsg->c, sizeof(emsg->c), "dns_db_find(): %s",
isc_result_totext(result));
- return (false);
+ return false;
}
}
rpz_clean(NULL, NULL, NULL, p_rdatasetp);
- return (true);
+ return true;
}
static isc_result_t
result = rpz_ready(client, p_rdatasetp);
if (result != ISC_R_SUCCESS) {
st->m.policy = DNS_RPZ_POLICY_ERROR;
- return (result);
+ return result;
}
switch (rpz_type) {
rpz_log_fail(client, DNS_RPZ_ERROR_LEVEL, NULL,
rpz_type, emsg.c, DNS_R_SERVFAIL);
st->m.policy = DNS_RPZ_POLICY_ERROR;
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
} while (res != 0);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
result = rpz_ready(client, p_rdatasetp);
if (result != ISC_R_SUCCESS) {
st->m.policy = DNS_RPZ_POLICY_ERROR;
- return (result);
+ return result;
}
switch (rpz_type) {
rpz_log_fail(client, DNS_RPZ_ERROR_LEVEL, NULL,
rpz_type, emsg.c, DNS_R_SERVFAIL);
st->m.policy = DNS_RPZ_POLICY_ERROR;
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
} while (res != 0);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#endif /* USE_DNSRPS */
st = client->query.rpz_st;
#ifdef USE_DNSRPS
if (st->popt.dnsrps_enabled) {
- return (dnsrps_rewrite_ip(client, netaddr, rpz_type,
- p_rdatasetp));
+ return dnsrps_rewrite_ip(client, netaddr, rpz_type,
+ p_rdatasetp);
}
#endif /* ifdef USE_DNSRPS */
case DNS_R_SERVFAIL:
rpz_clean(&p_zone, &p_db, &p_node, p_rdatasetp);
st->m.policy = DNS_RPZ_POLICY_ERROR;
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
default:
/*
* Forget this policy if it is not preferable
}
rpz_clean(&p_zone, &p_db, &p_node, p_rdatasetp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
do {
zbits = rpz_get_zbits(client, ip_type, rpz_type);
if (zbits == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
case DNS_R_NXRRSET:
case DNS_R_NCACHENXRRSET:
case ISC_R_NOTFOUND:
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
case DNS_R_DELEGATION:
case DNS_R_DUPLICATE:
case DNS_R_DROP:
- return (result);
+ return result;
case DNS_R_CNAME:
case DNS_R_DNAME:
rpz_log_fail(client, DNS_RPZ_DEBUG_LEVEL1, name,
rpz_type, "NS address rewrite rrset",
result);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
default:
if (client->query.rpz_st->m.policy !=
DNS_RPZ_POLICY_ERROR)
CTRACE(ISC_LOG_ERROR,
"rpz_rewrite_ip_rrset: unexpected "
"result");
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
/*
result = rpz_rewrite_ip(client, &netaddr, qtype,
rpz_type, zbits, p_rdatasetp);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
} while (!done &&
client->query.rpz_st->m.policy == DNS_RPZ_POLICY_MISS);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
dns_db_detach(&ip_db);
}
ns_client_putrdataset(client, &p_rdataset);
- return (result);
+ return result;
}
/*
#ifdef USE_DNSRPS
if (st->popt.dnsrps_enabled) {
- return (dnsrps_rewrite_name(client, trig_name, recursed,
- rpz_type, rdatasetp));
+ return dnsrps_rewrite_name(client, trig_name, recursed,
+ rpz_type, rdatasetp);
}
#endif /* ifdef USE_DNSRPS */
zbits = rpz_get_zbits(client, qtype, rpz_type);
zbits &= allowed_zbits;
if (zbits == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
*/
zbits = dns_rpz_find_name(rpzs, rpz_type, zbits, trig_name);
if (zbits == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
p_name = dns_fixedname_initname(&p_namef);
case DNS_R_SERVFAIL:
rpz_clean(&p_zone, &p_db, &p_node, rdatasetp);
st->m.policy = DNS_RPZ_POLICY_ERROR;
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
default:
/*
* With more than one applicable policy, prefer
* are irrelevant
*/
rpz_clean(&p_zone, &p_db, &p_node, rdatasetp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
* Log DNS_RPZ_POLICY_DISABLED zones
}
rpz_clean(&p_zone, &p_db, &p_node, rdatasetp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
st = client->query.rpz_st;
if (rpzs == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (st != NULL && (st->state & DNS_RPZ_REWRITTEN) != 0) {
- return (DNS_R_DISALLOWED);
+ return DNS_R_DISALLOWED;
}
if (RECURSING(client)) {
- return (DNS_R_DISALLOWED);
+ return DNS_R_DISALLOWED;
}
RWLOCK(&rpzs->search_lock, isc_rwlocktype_read);
!rpz_ck_dnssec(client, qresult, ordataset, osigset))
{
RWUNLOCK(&rpzs->search_lock, isc_rwlocktype_read);
- return (DNS_R_DISALLOWED);
+ return DNS_R_DISALLOWED;
}
have = rpzs->have;
popt = rpzs->p;
DNS_RPZ_TYPE_QNAME, emsg.c,
result);
st->m.policy = DNS_RPZ_POLICY_ERROR;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
#endif /* ifdef USE_DNSRPS */
rpz_log_fail(client, DNS_RPZ_DEBUG_LEVEL3, NULL,
DNS_RPZ_TYPE_QNAME,
"stop on qresult in rpz_rewrite()", qresult);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
default:
rpz_log_fail(client, DNS_RPZ_DEBUG_LEVEL1, NULL,
DNS_RPZ_TYPE_QNAME,
"stop on unrecognized qresult in rpz_rewrite()",
qresult);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
rdataset = NULL;
*/
allowed = st->have.qname_skip_recurse;
if (allowed == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
} else {
allowed = DNS_RPZ_ALL_ZBITS;
rpz_clean(NULL, &st->r.db, NULL, &st->r.ns_rdataset);
}
- return (result);
+ return result;
}
/*
CTRACE(ISC_LOG_DEBUG(3), "rpz_ck_dnssec");
if (client->view->rpzs->p.break_dnssec || !WANTDNSSEC(client)) {
- return (true);
+ return true;
}
/*
* for them.
*/
if (qresult == DNS_R_DELEGATION || qresult == ISC_R_NOTFOUND) {
- return (false);
+ return false;
}
if (sigrdataset == NULL) {
- return (true);
+ return true;
}
if (dns_rdataset_isassociated(sigrdataset)) {
- return (false);
+ return false;
}
/*
* We are happy to rewrite nothing.
*/
if (rdataset == NULL || !dns_rdataset_isassociated(rdataset)) {
- return (true);
+ return true;
}
/*
* Do not rewrite if there is any sign of signatures.
rdataset->type == dns_rdatatype_nsec3 ||
rdataset->type == dns_rdatatype_rrsig)
{
- return (false);
+ return false;
}
/*
* Look for a signature in a negative cache rdataset.
*/
if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) == 0) {
- return (true);
+ return true;
}
found = dns_fixedname_initname(&fixed);
dns_rdataset_init(&trdataset);
if (type == dns_rdatatype_nsec || type == dns_rdatatype_nsec3 ||
type == dns_rdatatype_rrsig)
{
- return (false);
+ return false;
}
}
- return (true);
+ return true;
}
/*
INSIST(rdata->length == 4);
memmove(&ina.s_addr, rdata->data, 4);
isc_netaddr_fromin(netaddr, &ina);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
case dns_rdatatype_aaaa:
INSIST(rdata->length == 16);
memmove(in6a.s6_addr, rdata->data, 16);
isc_netaddr_fromin6(netaddr, &in6a);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
default:
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
}
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (ttl);
+ return ttl;
}
static bool
INSIST(client->query.dns64_sigaaaa == NULL);
if (dns64 == NULL) {
- return (true);
+ return true;
}
if (RECURSIONOK(client)) {
if (aaaaok != NULL) {
isc_mem_put(client->mctx, aaaaok, sizeof(bool) * count);
}
- return (true);
+ return true;
}
if (aaaaok != NULL) {
isc_mem_put(client->mctx, aaaaok, sizeof(bool) * count);
}
- return (false);
+ return false;
}
/*
CTRACE(ISC_LOG_DEBUG(3), "redirect");
if (client->view->redirect == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
found = dns_fixedname_initname(&fixed);
if (WANTDNSSEC(client) && dns_db_iszone(*dbp) && dns_db_issecure(*dbp))
{
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (WANTDNSSEC(client) && dns_rdataset_isassociated(rdataset)) {
if (rdataset->trust == dns_trust_secure) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (rdataset->trust == dns_trust_ultimate &&
(rdataset->type == dns_rdatatype_nsec ||
rdataset->type == dns_rdatatype_nsec3))
{
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0) {
for (result = dns_rdataset_first(rdataset);
type == dns_rdatatype_nsec3 ||
type == dns_rdatatype_rrsig)
{
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
}
client, NULL, dns_zone_getqueryacl(client->view->redirect),
true);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
result = dns_zone_getdb(client->view->redirect, &db);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
dbversion = ns_client_findversion(client, db);
if (dbversion == NULL) {
dns_db_detach(&db);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
dns_db_detachnode(db, &node);
}
dns_db_detach(&db);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
CTRACE(ISC_LOG_DEBUG(3), "redirect: found data: done");
client->query.attributes |= (NS_QUERYATTR_NOAUTHORITY |
NS_QUERYATTR_NOADDITIONAL);
- return (result);
+ return result;
}
static isc_result_t
CTRACE(ISC_LOG_DEBUG(3), "redirect2");
if (client->view->redirectzone == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (dns_name_issubdomain(name, client->view->redirectzone)) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
found = dns_fixedname_initname(&fixed);
if (WANTDNSSEC(client) && dns_db_iszone(*dbp) && dns_db_issecure(*dbp))
{
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (WANTDNSSEC(client) && dns_rdataset_isassociated(rdataset)) {
if (rdataset->trust == dns_trust_secure) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (rdataset->trust == dns_trust_ultimate &&
(rdataset->type == dns_rdatatype_nsec ||
rdataset->type == dns_rdatatype_nsec3))
{
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0) {
for (result = dns_rdataset_first(rdataset);
type == dns_rdatatype_nsec3 ||
type == dns_rdatatype_rrsig)
{
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
}
client->view->redirectzone,
redirectname, NULL);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
} else {
dns_name_copy(redirectname, client->view->redirectzone);
result = query_getdb(client, redirectname, qtype, options, &zone, &db,
&version, &is_zone);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (zone != NULL) {
dns_zone_detach(&zone);
NS_QUERYATTR_RECURSING;
client->query.attributes |=
NS_QUERYATTR_REDIRECT;
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
} else if (result != ISC_R_SUCCESS) {
if (dns_rdataset_isassociated(&trdataset)) {
dns_rdataset_disassociate(&trdataset);
dns_db_detachnode(db, &node);
}
dns_db_detach(&db);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
CTRACE(ISC_LOG_DEBUG(3), "redirect2: found data: done");
client->query.attributes |= (NS_QUERYATTR_NOAUTHORITY |
NS_QUERYATTR_NOADDITIONAL);
- return (result);
+ return result;
}
/*%
result = ns__query_sfcache(&qctx);
if (result != ISC_R_COMPLETE) {
qctx_destroy(&qctx);
- return (result);
+ return result;
}
result = ns__query_start(&qctx);
cleanup:
qctx_destroy(&qctx);
- return (result);
+ return result;
}
static bool
for (i = 0; i < 5; i++) {
if (!isdigit((unsigned char)ndata[i])) {
- return (false);
+ return false;
}
v *= 10;
v += ndata[i] - '0';
}
if (v > 65535U) {
- return (false);
+ return false;
}
qctx->client->query.root_key_sentinel_keyid = v;
- return (true);
+ return true;
}
/*%
qctx->client->message->flags &= ~DNS_MESSAGEFLAG_AA;
qctx->client->message->flags &= ~DNS_MESSAGEFLAG_AD;
qctx->client->message->rcode = dns_rcode_badcookie;
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
if (qctx->view->checknames &&
"check-names failure %s/%s/%s", namebuf, typebuf,
classbuf);
QUERY_ERROR(qctx, DNS_R_REFUSED);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
/*
"failed");
QUERY_ERROR(qctx, result);
}
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
/*
qctx->options &= ~DNS_GETDB_STALEFIRST;
cleanup:
- return (result);
+ return result;
}
/*
CCTRACE(ISC_LOG_ERROR,
"qctx_prepare_buffers: ns_client_getnamebuf "
"failed");
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
qctx->fname = ns_client_newname(qctx->client, qctx->dbuf, buffer);
CCTRACE(ISC_LOG_ERROR,
"qctx_prepare_buffers: ns_client_newname failed");
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
qctx->rdataset = ns_client_newrdataset(qctx->client);
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
error:
if (qctx->fname != NULL) {
ns_client_putrdataset(qctx->client, &qctx->rdataset);
}
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
/*
case DNS_R_NCACHENXRRSET:
case DNS_R_CNAME:
case DNS_R_DNAME:
- return (true);
+ return true;
default:
- return (false);
+ return false;
}
UNREACHABLE();
result = qctx_prepare_buffers(qctx, &buffer);
if (result != ISC_R_SUCCESS) {
QUERY_ERROR(qctx, result);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
/*
* can do, return SERVFAIL.
*/
QUERY_ERROR(qctx, DNS_R_SERVFAIL);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
} else if (stale_refresh_window) {
/*
* to refresh the data, because a recent lookup failed.
*/
QUERY_ERROR(qctx, DNS_R_SERVFAIL);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
} else if (stale_timeout) {
if ((qctx->options & DNS_GETDB_STALEFIRST) != 0) {
dns_resolver_destroyfetch(
&qctx->client->query.fetch);
}
- return (query_lookup(qctx));
+ return query_lookup(qctx);
} else if (stale_client_answer(result)) {
/*
* Immediately return the stale answer, start a
ns_client_extendederror(qctx->client, ede,
"client timeout");
} else if (!answer_found) {
- return (result);
+ return result;
}
if (!stale_client_answer(result)) {
- return (result);
+ return result;
}
/*
result = query_gotanswer(qctx, result);
cleanup:
- return (result);
+ return result;
}
/*
const dns_name_t *qname, const dns_name_t *qdomain) {
REQUIRE(param != NULL);
- return (param->qtype == qtype && param->qname != NULL &&
- qname != NULL && param->qdomain != NULL && qdomain != NULL &&
- dns_name_equal(param->qname, qname) &&
- dns_name_equal(param->qdomain, qdomain));
+ return param->qtype == qtype && param->qname != NULL && qname != NULL &&
+ param->qdomain != NULL && qdomain != NULL &&
+ dns_name_equal(param->qname, qname) &&
+ dns_name_equal(param->qdomain, qdomain);
}
/*%
ns_client_killoldestquery(client);
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_message_clonebuffer(client->message);
ns_client_recursing(client);
}
- return (result);
+ return result;
}
isc_result_t
if (recparam_match(&client->query.recparam, qtype, qname, qdomain)) {
ns_client_log(client, NS_LOGCATEGORY_CLIENT, NS_LOGMODULE_QUERY,
ISC_LOG_INFO, "recursion loop detected");
- return (ISC_R_ALREADYRUNNING);
+ return ISC_R_ALREADYRUNNING;
}
recparam_update(&client->query.recparam, qtype, qname, qdomain);
result = check_recursionquota(client);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
rdataset = ns_client_newrdataset(client);
if (rdataset == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (WANTDNSSEC(client)) {
sigrdataset = ns_client_newrdataset(client);
if (sigrdataset == NULL) {
ns_client_putrdataset(client, &rdataset);
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
} else {
sigrdataset = NULL;
* have been received.
*/
- return (result);
+ return result;
}
/*%
qctx->view->rpzs->rpz_ver,
qctx->rpz_st->rpz_ver);
QUERY_ERROR(qctx, DNS_R_SERVFAIL);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
}
CCTRACE(ISC_LOG_ERROR, "query_resume: ns_client_getnamebuf "
"failed (1)");
QUERY_ERROR(qctx, ISC_R_NOMEMORY);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
qctx->fname = ns_client_newname(qctx->client, qctx->dbuf, &b);
CCTRACE(ISC_LOG_ERROR, "query_resume: ns_client_newname failed "
"(1)");
QUERY_ERROR(qctx, ISC_R_NOMEMORY);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
if (qctx->rpz_st != NULL &&
qctx->resuming = true;
- return (query_gotanswer(qctx, result));
+ return query_gotanswer(qctx, result);
cleanup:
- return (result);
+ return result;
}
static void
* task or pausing it.
*/
isc_nmhandle_attach(client->handle, &client->fetchhandle);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
/*
isc_mem_put(client->mctx, saved_qctx, sizeof(*saved_qctx));
}
qctx->detach_client = true;
- return (result);
+ return result;
}
/*%
* The SERVFAIL cache doesn't apply to authoritative queries.
*/
if (!RECURSIONOK(qctx->client)) {
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
flags = 0;
qctx->client->attributes |= NS_CLIENTATTR_NOSETFC;
QUERY_ERROR(qctx, DNS_R_SERVFAIL);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
/*%
}
}
}
- return (DNS_R_DROP);
+ return DNS_R_DROP;
}
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
break;
case ISC_R_NOTFOUND:
case DNS_R_DISALLOWED:
- return (result);
+ return result;
case DNS_R_DELEGATION:
/*
* recursing for NS names or addresses,
dns_name_copy(qctx->fname, qctx->rpz_st->fname);
qctx->rpz_st->q.result = result;
qctx->client->query.attributes |= NS_QUERYATTR_RECURSING;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
default:
QUERY_ERROR(qctx, rresult);
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
if (qctx->rpz_st->m.policy != DNS_RPZ_POLICY_MISS) {
DNS_SECTION_ADDITIONAL);
if (rresult != ISC_R_SUCCESS) {
QUERY_ERROR(qctx, result);
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
}
qctx->rpz_st->m.type, qctx->zone,
qctx->rpz_st->p_name, NULL,
qctx->rpz_st->m.rpz->num);
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
case DNS_RPZ_POLICY_DROP:
QUERY_ERROR(qctx, DNS_R_DROP);
rpz_log_rewrite(qctx->client, false,
qctx->rpz_st->m.type, qctx->zone,
qctx->rpz_st->p_name, NULL,
qctx->rpz_st->m.rpz->num);
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
case DNS_RPZ_POLICY_NXDOMAIN:
result = DNS_R_NXDOMAIN;
qctx->nxrewrite = true;
dns_rdata_reset(&rdata);
result = query_rpzcname(qctx, &cname.cname);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
qctx->fname = NULL;
qctx->want_restart = true;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
case DNS_RPZ_POLICY_CNAME:
/*
result = query_rpzcname(qctx,
&qctx->rpz_st->m.rpz->cname);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
qctx->fname = NULL;
qctx->want_restart = true;
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
default:
UNREACHABLE();
}
qctx->rpz_st->m.rpz->num);
}
- return (result);
+ return result;
}
/*%
if (result == DNS_R_NAMETOOLONG) {
client->message->rcode = dns_rcode_yxdomain;
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
} else {
dns_name_copy(cname, qctx->fname);
result = query_addcname(qctx, dns_trust_authanswer,
qctx->rpz_st->m.ttl);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
rpz_log_rewrite(client, false, qctx->rpz_st->m.policy,
client->attributes &= ~(NS_CLIENTATTR_WANTDNSSEC |
NS_CLIENTATTR_WANTAD);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
result = dns_view_getsecroots(qctx->view, &keytable);
if (result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
result = dns_keytable_find(keytable, dns_rootname, &keynode);
dns_keytable_detachkeynode(keytable, &keynode);
}
dns_keytable_detach(&keytable);
- return (false);
+ return false;
}
dns_rdataset_init(&dsset);
dns_keytable_detachkeynode(keytable, &keynode);
dns_keytable_detach(&keytable);
dns_rdataset_disassociate(&dsset);
- return (true);
+ return true;
}
}
dns_rdataset_disassociate(&dsset);
dns_keytable_detach(&keytable);
- return (false);
+ return false;
}
/*%
if (!qctx->client->query.root_key_sentinel_is_ta &&
!qctx->client->query.root_key_sentinel_not_ta)
{
- return (false);
+ return false;
}
/*
case DNS_R_NCACHENXRRSET:
break;
default:
- return (false);
+ return false;
}
/*
((qctx->client->query.root_key_sentinel_is_ta && !has_ta(qctx)) ||
(qctx->client->query.root_key_sentinel_not_ta && has_ta(qctx))))
{
- return (true);
+ return true;
}
/*
qctx->client->query.root_key_sentinel_is_ta = false;
qctx->client->query.root_key_sentinel_not_ta = false;
- return (false);
+ return false;
}
/*%
* Query was already using stale, if that didn't work the
* last time, it won't work this time either.
*/
- return (false);
+ return false;
}
if (qctx->refresh_rrset) {
* This is a refreshing query, we have already prioritized
* stale data, so don't enable serve-stale again.
*/
- return (false);
+ return false;
}
if (result == DNS_R_DUPLICATE || result == DNS_R_DROP ||
* query or a query that is being dropped or can't proceed
* because of a recursion loop.
*/
- return (false);
+ return false;
}
qctx_clean(qctx);
* Failed to get the database, unexpected, but let us
* at least abandon serve-stale.
*/
- return (false);
+ return false;
}
qctx->client->query.dboptions |= DNS_DBFIND_STALEOK;
if (qctx->resuming && result == ISC_R_TIMEDOUT) {
qctx->client->query.dboptions |= DNS_DBFIND_STALESTART;
}
- return (true);
+ return true;
}
- return (false);
+ return false;
}
/*%
CALL_HOOK(NS_QUERY_GOT_ANSWER_BEGIN, qctx);
if (query_checkrrl(qctx, result) != ISC_R_SUCCESS) {
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
if (!dns_name_equal(qctx->client->query.qname, dns_rootname)) {
* bail out and wait for recursion to complete, as we
* we can't perform the RPZ rewrite rules.
*/
- return (result);
+ return result;
}
if (result == ISC_R_COMPLETE) {
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
}
*/
qctx->client->attributes |= NS_CLIENTATTR_NOSETFC;
QUERY_ERROR(qctx, DNS_R_SERVFAIL);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
switch (result) {
case ISC_R_SUCCESS:
- return (query_prepresponse(qctx));
+ return query_prepresponse(qctx);
case DNS_R_GLUE:
case DNS_R_ZONECUT:
INSIST(qctx->is_zone);
qctx->authoritative = false;
- return (query_prepresponse(qctx));
+ return query_prepresponse(qctx);
case ISC_R_NOTFOUND:
- return (query_notfound(qctx));
+ return query_notfound(qctx);
case DNS_R_DELEGATION:
- return (query_delegation(qctx));
+ return query_delegation(qctx);
case DNS_R_EMPTYNAME:
case DNS_R_NXRRSET:
- return (query_nodata(qctx, result));
+ return query_nodata(qctx, result);
case DNS_R_EMPTYWILD:
case DNS_R_NXDOMAIN:
- return (query_nxdomain(qctx, result));
+ return query_nxdomain(qctx, result);
case DNS_R_COVERINGNSEC:
- return (query_coveringnsec(qctx));
+ return query_coveringnsec(qctx);
case DNS_R_NCACHENXDOMAIN:
result = query_redirect(qctx, result);
if (result != ISC_R_COMPLETE) {
- return (result);
+ return result;
}
- return (query_ncache(qctx, DNS_R_NCACHENXDOMAIN));
+ return query_ncache(qctx, DNS_R_NCACHENXDOMAIN);
case DNS_R_NCACHENXRRSET:
- return (query_ncache(qctx, DNS_R_NCACHENXRRSET));
+ return query_ncache(qctx, DNS_R_NCACHENXRRSET);
case DNS_R_CNAME:
- return (query_cname(qctx));
+ return query_cname(qctx);
case DNS_R_DNAME:
- return (query_dname(qctx));
+ return query_dname(qctx);
default:
/*
* If serve-stale is enabled, query_usestale() already
* set up 'qctx' for looking up a stale response.
*/
- return (query_lookup(qctx));
+ return query_lookup(qctx);
}
/*
qctx->client->rcode_override = dns_rcode_servfail;
QUERY_ERROR(qctx, result);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
cleanup:
- return (result);
+ return result;
}
static void
CCTRACE(ISC_LOG_ERROR, "query_respond_any: allrdatasets "
"failed");
QUERY_ERROR(qctx, result);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
/*
CCTRACE(ISC_LOG_ERROR, "query_respond_any: rdataset iterator "
"failed");
QUERY_ERROR(qctx, DNS_R_SERVFAIL);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
if (found) {
qctx->authoritative = false;
qctx->client->attributes &= ~NS_CLIENTATTR_RA;
query_addauth(qctx);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
if (qctx->qtype == dns_rdatatype_rrsig &&
}
qctx->fname = ns_client_newname(qctx->client, qctx->dbuf, &b);
- return (query_sign_nodata(qctx));
+ return query_sign_nodata(qctx);
} else if (!hidden) {
/*
* No matching rdatasets were found and nothing was
QUERY_ERROR(qctx, DNS_R_SERVFAIL);
}
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
cleanup:
- return (result);
+ return result;
}
/*
#ifndef dns64_bis_return_excluded_addresses
if (qctx->dns64_exclude) {
if (!qctx->is_zone) {
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
/*
* Add a fake SOA record.
*/
(void)query_addsoa(qctx, 600,
DNS_SECTION_AUTHORITY);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
#endif /* ifndef dns64_bis_return_excluded_addresses */
if (qctx->is_zone) {
- return (query_nodata(qctx, DNS_R_NXDOMAIN));
+ return query_nodata(qctx, DNS_R_NXDOMAIN);
} else {
- return (query_ncache(qctx, DNS_R_NXDOMAIN));
+ return query_ncache(qctx, DNS_R_NXDOMAIN);
}
} else if (result != ISC_R_SUCCESS) {
qctx->result = result;
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
} else if (qctx->client->query.dns64_aaaaok != NULL) {
query_filter64(qctx);
sigrdatasetp, qctx->dbuf, DNS_SECTION_ANSWER);
}
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
cleanup:
- return (result);
+ return result;
}
/*%
qctx->type = qctx->qtype = dns_rdatatype_a;
qctx->dns64_exclude = qctx->dns64 = true;
- return (query_lookup(qctx));
+ return query_lookup(qctx);
}
/*
result = query_addanswer(qctx);
if (result != ISC_R_COMPLETE) {
- return (result);
+ return result;
}
query_addnoqnameproof(qctx);
query_addauth(qctx);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
cleanup:
- return (result);
+ return result;
}
static isc_result_t
if (qctx->dbuf != NULL) {
ns_client_releasename(client, &qctx->fname);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (result == DNS_R_NXDOMAIN) {
/*
* The name doesn't exist.
}
CTRACE(ISC_LOG_DEBUG(3), "query_dns64: done");
- return (result);
+ return result;
}
static void
* already set up 'qctx' for looking up a
* stale response.
*/
- return (query_lookup(qctx));
+ return query_lookup(qctx);
} else {
QUERY_ERROR(qctx, result);
}
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
} else {
/* Unable to give root server referral. */
CCTRACE(ISC_LOG_ERROR, "unable to give root server "
"referral");
QUERY_ERROR(qctx, result);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
}
- return (query_delegation(qctx));
+ return query_delegation(qctx);
cleanup:
- return (result);
+ return result;
}
/*%
*/
query_addds(qctx);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
cleanup:
- return (result);
+ return result;
}
/*%
RESTORE(qctx->zone, tzone);
qctx->authoritative = true;
- return (query_lookup(qctx));
+ return query_lookup(qctx);
}
}
dns_db_attach(qctx->view->cachedb, &qctx->db);
qctx->is_zone = false;
- return (query_lookup(qctx));
+ return query_lookup(qctx);
}
- return (query_prepare_delegation_response(qctx));
+ return query_prepare_delegation_response(qctx);
cleanup:
- return (result);
+ return result;
}
/*%
qctx->authoritative = false;
if (qctx->is_zone) {
- return (query_zone_delegation(qctx));
+ return query_zone_delegation(qctx);
}
if (qctx->zfname != NULL &&
result = query_delegation_recurse(qctx);
if (result != ISC_R_COMPLETE) {
- return (result);
+ return result;
}
- return (query_prepare_delegation_response(qctx));
+ return query_prepare_delegation_response(qctx);
cleanup:
- return (result);
+ return result;
}
/*%
CCTRACE(ISC_LOG_DEBUG(3), "query_delegation_recurse");
if (!RECURSIONOK(qctx->client)) {
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
CALL_HOOK(NS_QUERY_DELEGATION_RECURSE_BEGIN, qctx);
* If serve-stale is enabled, query_usestale() already set up
* 'qctx' for looking up a stale response.
*/
- return (query_lookup(qctx));
+ return query_lookup(qctx);
} else {
QUERY_ERROR(qctx, result);
}
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
cleanup:
- return (result);
+ return result;
}
/*%
"ns_client_getnamebuf "
"failed (3)");
QUERY_ERROR(qctx, ISC_R_NOMEMORY);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
qctx->fname = ns_client_newname(qctx->client,
qctx->dbuf, &b);
"ns_client_newname "
"failed (3)");
QUERY_ERROR(qctx, ISC_R_NOMEMORY);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
}
dns_name_copy(qctx->client->query.qname, qctx->fname);
* Resume the diverted processing of the AAAA response?
*/
if (qctx->dns64_exclude) {
- return (query_prepresponse(qctx));
+ return query_prepresponse(qctx);
}
#endif /* ifdef dns64_bis_return_excluded_addresses */
} else if ((result == DNS_R_NXRRSET || result == DNS_R_NCACHENXRRSET) &&
dns_db_detachnode(qctx->db, &qctx->node);
qctx->type = qctx->qtype = dns_rdatatype_a;
qctx->dns64 = true;
- return (query_lookup(qctx));
+ return query_lookup(qctx);
}
if (qctx->is_zone) {
- return (query_sign_nodata(qctx));
+ return query_sign_nodata(qctx);
} else {
/*
* We don't call query_addrrset() because we don't need any
}
}
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
cleanup:
- return (result);
+ return result;
}
/*%
* Look for a NSEC3 record if we don't have a NSEC record.
*/
if (qctx->redirected) {
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
if (!dns_rdataset_isassociated(qctx->rdataset) &&
WANTDNSSEC(qctx->client))
"closest "
"encloser");
QUERY_ERROR(qctx, ISC_R_NOMEMORY);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
/*
* 'nearest' doesn't exist so
result = query_addsoa(qctx, UINT32_MAX, DNS_SECTION_AUTHORITY);
if (result != ISC_R_SUCCESS) {
QUERY_ERROR(qctx, result);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
}
query_addnxrrsetnsec(qctx);
}
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
static void
if (!empty_wild) {
result = query_redirect(qctx, result);
if (result != ISC_R_COMPLETE) {
- return (result);
+ return result;
}
}
result = query_addsoa(qctx, ttl, section);
if (result != ISC_R_SUCCESS) {
QUERY_ERROR(qctx, result);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
}
qctx->client->message->rcode = dns_rcode_nxdomain;
}
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
cleanup:
- return (result);
+ return result;
}
/*
switch (result) {
case ISC_R_SUCCESS:
inc_stats(qctx->client, ns_statscounter_nxdomainredirect);
- return (query_prepresponse(qctx));
+ return query_prepresponse(qctx);
case DNS_R_NXRRSET:
qctx->redirected = true;
qctx->is_zone = true;
- return (query_nodata(qctx, DNS_R_NXRRSET));
+ return query_nodata(qctx, DNS_R_NXRRSET);
case DNS_R_NCACHENXRRSET:
qctx->redirected = true;
qctx->is_zone = false;
- return (query_ncache(qctx, DNS_R_NCACHENXRRSET));
+ return query_ncache(qctx, DNS_R_NCACHENXRRSET);
default:
break;
}
switch (result) {
case ISC_R_SUCCESS:
inc_stats(qctx->client, ns_statscounter_nxdomainredirect);
- return (query_prepresponse(qctx));
+ return query_prepresponse(qctx);
case DNS_R_CONTINUE:
inc_stats(qctx->client,
ns_statscounter_nxdomainredirect_rlookup);
qctx->client->query.redirect.authoritative =
qctx->authoritative;
qctx->client->query.redirect.is_zone = qctx->is_zone;
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
case DNS_R_NXRRSET:
qctx->redirected = true;
qctx->is_zone = true;
- return (query_nodata(qctx, DNS_R_NXRRSET));
+ return query_nodata(qctx, DNS_R_NXRRSET);
case DNS_R_NCACHENXRRSET:
qctx->redirected = true;
qctx->is_zone = false;
- return (query_ncache(qctx, DNS_R_NCACHENXRRSET));
+ return query_ncache(qctx, DNS_R_NCACHENXRRSET);
default:
break;
}
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
/*%
ttl = ISC_MIN(ttl, sigp2rdataset->ttl);
}
- return (ttl);
+ return ttl;
}
/*
if (name != NULL) {
ns_client_releasename(qctx->client, &name);
}
- return (result);
+ return result;
}
/*
if (clonesigset != NULL) {
ns_client_putrdataset(qctx->client, &clonesigset);
}
- return (result);
+ return result;
}
/*
result = query_synthwildcard(qctx, rdataset, sigrdataset);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
qctx->client->query.attributes |= NS_QUERYATTR_PARTIALANSWER;
*/
result = dns_message_gettempname(qctx->client->message, &tname);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_rdataset_first(rdataset);
if (result != ISC_R_SUCCESS) {
dns_message_puttempname(qctx->client->message, &tname);
- return (result);
+ return result;
}
dns_rdataset_current(rdataset, &rdata);
if (dns_name_equal(qctx->client->query.qname, &cname.cname)) {
dns_message_puttempname(qctx->client->message, &tname);
dns_rdata_freestruct(&cname);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_name_copy(&cname.cname, tname);
qctx->options |= DNS_GETDB_NOLOG;
}
- return (result);
+ return result;
}
/*
if (clonesigset != NULL) {
ns_client_putrdataset(qctx->client, &clonesigset);
}
- return (result);
+ return result;
}
/*
if (dns_name_countlabels(signer) == 0) {
dns_name_copy(&rrsig.signer, signer);
} else if (!dns_name_equal(signer, &rrsig.signer)) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
}
if (redirected) {
- return (result);
+ return result;
}
if (!done) {
if (qctx->sigrdataset != NULL) {
ns_client_putrdataset(qctx->client, &qctx->sigrdataset);
}
- return (query_lookup(qctx));
+ return query_lookup(qctx);
}
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
/*%
}
}
- return (query_nodata(qctx, result));
+ return query_nodata(qctx, result);
cleanup:
- return (result);
+ return result;
}
/*
if (qctx->is_zone || qctx->resuming || STALE(qctx->rdataset) ||
qctx->rdataset->ttl != 0 || !RECURSIONOK(qctx->client))
{
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
qctx_clean(qctx);
QUERY_ERROR(qctx, result);
}
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
cleanup:
- return (result);
+ return result;
}
/*
result = query_zerottl_refetch(qctx);
if (result != ISC_R_COMPLETE) {
- return (result);
+ return result;
}
/*
*/
result = dns_message_gettempname(qctx->client->message, &tname);
if (result != ISC_R_SUCCESS) {
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
result = dns_rdataset_first(trdataset);
if (result != ISC_R_SUCCESS) {
dns_message_puttempname(qctx->client->message, &tname);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
dns_rdataset_current(trdataset, &rdata);
query_addauth(qctx);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
cleanup:
- return (result);
+ return result;
}
/*
tname = NULL;
result = dns_message_gettempname(qctx->client->message, &tname);
if (result != ISC_R_SUCCESS) {
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
result = dns_rdataset_first(trdataset);
if (result != ISC_R_SUCCESS) {
dns_message_puttempname(qctx->client->message, &tname);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
dns_rdataset_current(trdataset, &rdata);
qctx->dbuf = ns_client_getnamebuf(qctx->client);
if (qctx->dbuf == NULL) {
dns_message_puttempname(qctx->client->message, &tname);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
qctx->fname = ns_client_newname(qctx->client, qctx->dbuf, &b);
if (qctx->fname == NULL) {
dns_message_puttempname(qctx->client->message, &tname);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
result = dns_name_concatenate(prefix, tname, qctx->fname, NULL);
dns_message_puttempname(qctx->client->message, &tname);
qctx->client->message->rcode = dns_rcode_yxdomain;
}
if (result != ISC_R_SUCCESS) {
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
ns_client_keepname(qctx->client, qctx->fname, qctx->dbuf);
*/
result = query_addcname(qctx, trdataset->trust, trdataset->ttl);
if (result != ISC_R_SUCCESS) {
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
/*
query_addauth(qctx);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
cleanup:
- return (result);
+ return result;
}
/*%
result = dns_message_gettempname(client->message, &aname);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_name_copy(client->query.qname, aname);
result = dns_message_gettemprdatalist(client->message, &rdatalist);
if (result != ISC_R_SUCCESS) {
dns_message_puttempname(client->message, &aname);
- return (result);
+ return result;
}
result = dns_message_gettemprdata(client->message, &rdata);
if (result != ISC_R_SUCCESS) {
dns_message_puttempname(client->message, &aname);
dns_message_puttemprdatalist(client->message, &rdatalist);
- return (result);
+ return result;
}
result = dns_message_gettemprdataset(client->message, &rdataset);
dns_message_puttempname(client->message, &aname);
dns_message_puttemprdatalist(client->message, &rdatalist);
dns_message_puttemprdata(client->message, &rdata);
- return (result);
+ return result;
}
rdatalist->type = dns_rdatatype_cname;
dns_message_puttempname(client->message, &aname);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
}
if (qctx->type == dns_rdatatype_any) {
- return (query_respond_any(qctx));
+ return query_respond_any(qctx);
}
result = query_zerottl_refetch(qctx);
if (result != ISC_R_COMPLETE) {
- return (result);
+ return result;
}
- return (query_respond(qctx));
+ return query_respond(qctx);
cleanup:
- return (result);
+ return result;
}
/*%
if (((client->sctx->options & NS_SERVER_NOSOA) != 0) &&
(!WANTDNSSEC(client) || !dns_rdataset_isassociated(qctx->rdataset)))
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
*/
result = dns_message_gettempname(client->message, &name);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
dns_db_detachnode(qctx->db, &node);
}
- return (eresult);
+ return eresult;
}
/*%
if (result != ISC_R_SUCCESS) {
CTRACE(ISC_LOG_DEBUG(3), "query_addns: dns_message_gettempname "
"failed: done");
- return (result);
+ return result;
}
dns_name_clone(dns_db_origin(qctx->db), name);
rdataset = ns_client_newrdataset(client);
}
CTRACE(ISC_LOG_DEBUG(3), "query_addns: done");
- return (eresult);
+ return eresult;
}
/*%
isc_netaddr_t netaddr;
if (rdata_tonetaddr(rdata, &netaddr) != ISC_R_SUCCESS) {
- return (INT_MAX);
+ return INT_MAX;
}
- return (ns_sortlist_addrorder2(&netaddr, arg));
+ return ns_sortlist_addrorder2(&netaddr, arg);
}
/*
isc_netaddr_t netaddr;
if (rdata_tonetaddr(rdata, &netaddr) != ISC_R_SUCCESS) {
- return (INT_MAX);
+ return INT_MAX;
}
- return (ns_sortlist_addrorder1(&netaddr, arg));
+ return ns_sortlist_addrorder1(&netaddr, arg);
}
/*
qctx->client->view->max_restarts)
{
qctx->client->query.restarts++;
- return (ns__query_start(qctx));
+ return ns__query_start(qctx);
} else {
/*
* This is e.g. a long CNAME chain which we cut short.
}
qctx->detach_client = true;
- return (qctx->result);
+ return qctx->result;
}
/*
(!QUERY_STALETIMEOUT(&qctx->client->query) ||
((qctx->options & DNS_GETDB_STALEFIRST) != 0)))
{
- return (qctx->result);
+ return qctx->result;
}
/*
if (!nodetach) {
qctx->detach_client = true;
}
- return (qctx->result);
+ return qctx->result;
cleanup:
- return (result);
+ return result;
}
static void
sctx->magic = SCTX_MAGIC;
*sctxp = sctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
sctx->server_id = isc_mem_strdup(sctx->mctx, serverid);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
ns_server_getoption(ns_server_t *sctx, unsigned int option) {
REQUIRE(SCTX_VALID(sctx));
- return ((sctx->options & option) != 0);
+ return (sctx->options & option) != 0;
}
void
if (order_elt == NULL) {
INSIST(matched_elt != NULL);
*argp = matched_elt;
- return (NS_SORTLISTTYPE_1ELEMENT);
+ return NS_SORTLISTTYPE_1ELEMENT;
}
if (order_elt->type == dns_aclelementtype_nestedacl) {
dns_acl_t *inner = NULL;
dns_acl_attach(order_elt->nestedacl, &inner);
*argp = inner;
- return (NS_SORTLISTTYPE_2ELEMENT);
+ return NS_SORTLISTTYPE_2ELEMENT;
}
if (order_elt->type == dns_aclelementtype_localhost) {
if (inner != NULL) {
*argp = inner;
- return (NS_SORTLISTTYPE_2ELEMENT);
+ return NS_SORTLISTTYPE_2ELEMENT;
}
}
RWUNLOCK(&env->rwlock, isc_rwlocktype_read);
if (inner != NULL) {
*argp = inner;
- return (NS_SORTLISTTYPE_2ELEMENT);
+ return NS_SORTLISTTYPE_2ELEMENT;
}
}
* sortlist statement.
*/
*argp = order_elt;
- return (NS_SORTLISTTYPE_1ELEMENT);
+ return NS_SORTLISTTYPE_1ELEMENT;
}
dont_sort:
*argp = NULL;
- return (NS_SORTLISTTYPE_NONE);
+ return NS_SORTLISTTYPE_NONE;
}
int
(void)dns_acl_match(addr, NULL, sortacl, env, &match, NULL);
if (match > 0) {
- return (match);
+ return match;
} else if (match < 0) {
- return (INT_MAX - (-match));
+ return INT_MAX - (-match);
} else {
- return (INT_MAX / 2);
+ return INT_MAX / 2;
}
}
const dns_aclelement_t *element = sla->element;
if (dns_aclelement_match(addr, NULL, element, env, NULL)) {
- return (0);
+ return 0;
}
- return (INT_MAX);
+ return INT_MAX;
}
void
isc_mem_attach(mctx, &stats->mctx);
*statsp = stats;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
clean_mem:
isc_mem_put(mctx, stats, sizeof(*stats));
- return (result);
+ return result;
}
/*%
ns_stats_get(ns_stats_t *stats) {
REQUIRE(NS_STATS_VALID(stats));
- return (stats->counters);
+ return stats->counters;
}
void
ns_stats_get_counter(ns_stats_t *stats, isc_statscounter_t counter) {
REQUIRE(NS_STATS_VALID(stats));
- return (isc_stats_get_counter(stats->counters, counter));
+ return isc_stats_get_counter(stats->counters, counter);
}
NS_LOGMODULE_UPDATE, ISC_LOG_INFO,
"update '%s/%s' denied", namebuf, classbuf);
}
- return (result);
+ return result;
}
/*%
ns_client_log(client, NS_LOGCATEGORY_UPDATE_SECURITY,
NS_LOGMODULE_UPDATE, level, "%s '%s/%s' %s", message,
namebuf, classbuf, msg);
- return (result);
+ return result;
}
/*%
ISC_LIST_UNLINK(temp_diff.tuples, *tuple, link);
if (result != ISC_R_SUCCESS) {
dns_difftuple_free(tuple);
- return (result);
+ return result;
}
/*
/*
* Do not clear temp_diff.
*/
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
ISC_LIST_UNLINK(updates->tuples, t, link);
CHECK(do_one_tuple(&t, db, ver, diff));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
dns_diff_clear(diff);
- return (result);
+ return result;
}
static isc_result_t
isc_result_t result;
result = dns_difftuple_create(diff->mctx, op, name, ttl, rdata, &tuple);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return (do_one_tuple(&tuple, db, ver, diff));
+ return do_one_tuple(&tuple, db, ver, diff);
}
/**************************************************************************/
rr.ttl = rdataset->ttl;
result = (*ctx->rr_action)(ctx->rr_action_data, &rr);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
if (result != ISC_R_NOMORE) {
- return (result);
+ return result;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
node = NULL;
result = dns_db_findnodeext(db, name, false, &cm, &ci, &node);
if (result == ISC_R_NOTFOUND) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
iter = NULL;
cleanup_node:
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
/*%
foreach_node_rr_ctx_t ctx;
ctx.rr_action = rr_action;
ctx.rr_action_data = rr_action_data;
- return (foreach_rrset(db, ver, name, foreach_node_rr_action, &ctx));
+ return foreach_rrset(db, ver, name, foreach_node_rr_action, &ctx);
}
/*%
dns_db_closeversion(db, &oldver, false);
if (type == dns_rdatatype_any) {
- return (foreach_node_rr(db, ver, name, rr_action,
- rr_action_data));
+ return foreach_node_rr(db, ver, name, rr_action,
+ rr_action_data);
}
node = NULL;
result = dns_db_findnodeext(db, name, false, &cm, &ci, &node);
}
if (result == ISC_R_NOTFOUND) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_init(&rdataset);
cleanup_node:
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
/**************************************************************************/
(*ui)++;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
rrset_exists_action(void *data, rr_t *rr) {
UNUSED(data);
UNUSED(rr);
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
/*%
if (rrset->type != dns_rdatatype_cname &&
!dns_rdatatype_atcname(rrset->type))
{
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
int *countp = data;
UNUSED(rr);
(*countp)++;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
rr_count(dns_db_t *db, dns_dbversion_t *ver, dns_name_t *name,
dns_rdatatype_t type, dns_rdatatype_t covers, int *countp) {
*countp = 0;
- return (foreach_rr(db, ver, name, type, covers, count_rr_action,
- countp));
+ return foreach_rr(db, ver, name, type, covers, count_rr_action, countp);
}
/*%
name_exists_action(void *data, dns_rdataset_t *rrset) {
UNUSED(data);
UNUSED(rrset);
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
/*%
if (rrset->type == dns_rdatatype_rrsig ||
rrset->type == dns_rdatatype_nsec)
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
ssuinfo->addr, ssuinfo->tcp, ssuinfo->aclenv,
rrset->type, NULL, ssuinfo->key, NULL);
}
- return (rule_ok ? ISC_R_SUCCESS : ISC_R_FAILURE);
+ return rule_ok ? ISC_R_SUCCESS : ISC_R_FAILURE;
}
static bool
ssuinfo.tcp = tcp;
ssuinfo.key = key;
result = foreach_rrset(db, ver, name, ssu_checkrule, &ssuinfo);
- return (result == ISC_R_SUCCESS);
+ return result == ISC_R_SUCCESS;
}
static isc_result_t
ssuinfo->table, ssuinfo->signer, ssuinfo->name, ssuinfo->addr,
ssuinfo->tcp, ssuinfo->aclenv, rr->rdata.type, target,
ssuinfo->key, NULL);
- return (answer ? ISC_R_SUCCESS : ISC_R_FAILURE);
+ return answer ? ISC_R_SUCCESS : ISC_R_FAILURE;
}
/**************************************************************************/
rdata, &tuple));
ISC_LIST_APPEND(diff->tuples, tuple, link);
failure:
- return (result);
+ return result;
}
/*%
INSIST(a->rdata.type == b->rdata.type);
INSIST(dns_name_equal(&a->name, &b->name));
if (dns_rdata_casecompare(&a->rdata, &b->rdata) != 0) {
- return (DNS_R_NXRRSET);
+ return DNS_R_NXRRSET;
}
a = ISC_LIST_NEXT(a, link);
b = ISC_LIST_NEXT(b, link);
}
if (a != NULL || b != NULL) {
- return (DNS_R_NXRRSET);
+ return DNS_R_NXRRSET;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
int r;
r = dns_name_compare(&a->name, &b->name);
if (r != 0) {
- return (r);
+ return r;
}
r = (b->rdata.type - a->rdata.type);
if (r != 0) {
- return (r);
+ return r;
}
r = dns_rdata_casecompare(&a->rdata, &b->rdata);
- return (r);
+ return r;
}
/*%
result = dns_db_findnode(db, name, false, &node);
if (result == ISC_R_NOTFOUND) {
dns_diff_clear(&trash);
- return (DNS_R_NXRRSET);
+ return DNS_R_NXRRSET;
}
if (result != ISC_R_SUCCESS) {
dns_diff_clear(&trash);
- return (result);
+ return result;
}
/* A new unique type begins here. */
} else if (type == dns_rdatatype_any) {
dns_db_detachnode(db, &node);
dns_diff_clear(&trash);
- return (DNS_R_NXRRSET);
+ return DNS_R_NXRRSET;
} else {
covers = 0;
}
if (result != ISC_R_SUCCESS) {
dns_db_detachnode(db, &node);
dns_diff_clear(&trash);
- return (DNS_R_NXRRSET);
+ return DNS_R_NXRRSET;
}
dns_diff_init(mctx, &d_rrs);
dns_diff_clear(&trash);
dns_rdataset_disassociate(&rdataset);
dns_db_detachnode(db, &node);
- return (result);
+ return result;
}
dns_db_detachnode(db, &node);
}
dns_diff_clear(&trash);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/**************************************************************************/
static bool
type_not_soa_nor_ns_p(dns_rdata_t *update_rr, dns_rdata_t *db_rr) {
UNUSED(update_rr);
- return ((db_rr->type != dns_rdatatype_soa &&
- db_rr->type != dns_rdatatype_ns &&
- db_rr->type != dns_rdatatype_nsec3param &&
- db_rr->type != dns_rdatatype_rrsig &&
- db_rr->type != dns_rdatatype_nsec)
- ? true
- : false);
+ return (db_rr->type != dns_rdatatype_soa &&
+ db_rr->type != dns_rdatatype_ns &&
+ db_rr->type != dns_rdatatype_nsec3param &&
+ db_rr->type != dns_rdatatype_rrsig &&
+ db_rr->type != dns_rdatatype_nsec)
+ ? true
+ : false;
}
/*%
static bool
type_not_dnssec(dns_rdata_t *update_rr, dns_rdata_t *db_rr) {
UNUSED(update_rr);
- return ((db_rr->type != dns_rdatatype_rrsig &&
- db_rr->type != dns_rdatatype_nsec)
- ? true
- : false);
+ return (db_rr->type != dns_rdatatype_rrsig &&
+ db_rr->type != dns_rdatatype_nsec)
+ ? true
+ : false;
}
/*%
true_p(dns_rdata_t *update_rr, dns_rdata_t *db_rr) {
UNUSED(update_rr);
UNUSED(db_rr);
- return (true);
+ return true;
}
/*%
* dns_rdata_equal() (that used dns_name_equal()), since it
* would be faster. Not a priority.
*/
- return (dns_rdata_casecompare(update_rr, db_rr) == 0 ? true : false);
+ return dns_rdata_casecompare(update_rr, db_rr) == 0 ? true : false;
}
/*%
isc_result_t result;
if (db_rr->type != update_rr->type) {
- return (false);
+ return false;
}
if (db_rr->type == dns_rdatatype_cname) {
- return (true);
+ return true;
}
if (db_rr->type == dns_rdatatype_dname) {
- return (true);
+ return true;
}
if (db_rr->type == dns_rdatatype_soa) {
- return (true);
+ return true;
}
if (db_rr->type == dns_rdatatype_nsec) {
- return (true);
+ return true;
}
if (db_rr->type == dns_rdatatype_rrsig) {
/*
dbsig.covered == updatesig.covered &&
dbsig.algorithm == updatesig.algorithm)
{
- return (true);
+ return true;
}
}
if (db_rr->type == dns_rdatatype_wks) {
* dns_rdata_tostruct() might be cleaner in some ways.
*/
INSIST(db_rr->length >= 5 && update_rr->length >= 5);
- return (memcmp(db_rr->data, update_rr->data, 5) == 0 ? true
- : false);
+ return memcmp(db_rr->data, update_rr->data, 5) == 0 ? true
+ : false;
}
if (db_rr->type == dns_rdatatype_nsec3param) {
if (db_rr->length != update_rr->length) {
- return (false);
+ return false;
}
INSIST(db_rr->length >= 4 && update_rr->length >= 4);
/*
memcmp(db_rr->data + 2, update_rr->data + 2,
update_rr->length - 2) == 0)
{
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
/*%
result = update_one_rr(ctx->db, ctx->ver, ctx->diff,
DNS_DIFFOP_DEL, ctx->name, rr->ttl,
&rr->rdata);
- return (result);
+ return result;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
ctx.diff = diff;
ctx.name = name;
ctx.update_rr = update_rr;
- return (foreach_rr(db, ver, name, type, covers, delete_if_action,
- &ctx));
+ return foreach_rr(db, ver, name, type, covers, delete_if_action, &ctx);
}
/**************************************************************************/
equal = (dns_rdata_casecompare(&rr->rdata, ctx->update_rr) == 0);
if (equal && case_equal && ttl_equal) {
ctx->ignore_add = true;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
ctx->oldname, rr->ttl, &rr->rdata,
&tuple));
dns_diff_append(&ctx->del_diff, &tuple);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
}
}
failure:
- return (result);
+ return result;
}
/**************************************************************************/
if (deltuple != NULL) {
dns_difftuple_free(&deltuple);
}
- return (result);
+ return result;
}
/*%
result = dns_db_getsoaserial(db, ver, &db_serial);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (DNS_SERIAL_GE(db_serial, update_serial)) {
*ok = true;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/**************************************************************************/
dns_ssutable_detach(&ssutable);
}
- return (result);
+ return result;
}
static void
ISC_LIST_UNLINK(temp_diff.tuples, tuple, link);
dns_diff_appendminimal(diff, &tuple);
}
- return (result);
+ return result;
}
/*
ok = false;
}
}
- return (ok ? ISC_R_SUCCESS : DNS_R_REFUSED);
+ return ok ? ISC_R_SUCCESS : DNS_R_REFUSED;
}
static isc_result_t
if (node != NULL) {
dns_db_detachnode(db, &node);
}
- return (result);
+ return result;
}
static isc_result_t
result = dns_db_getoriginnode(db, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_findrdataset(db, node, ver, dns_rdatatype_nsec3param, 0,
(isc_stdtime_t)0, &rdataset, NULL);
if (dns_rdataset_isassociated(&rdataset)) {
dns_rdataset_disassociate(&rdataset);
}
- return (result);
+ return result;
}
/*
}
failure:
- return (result);
+ return result;
}
/*
result = ISC_R_SUCCESS;
failure:
dns_diff_clear(&temp_diff);
- return (result);
+ return result;
}
static isc_result_t
isc_result_t result;
if (privatetype == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_diff_init(mctx, &temp_diff);
failure:
dns_diff_clear(&temp_diff);
- return (result);
+ return result;
}
/*
failure:
dns_diff_clear(&temp_diff);
- return (result);
+ return result;
}
static bool
bool build_nsec, build_nsec3;
if (dns_db_issecure(db)) {
- return (true);
+ return true;
}
result = dns_private_chains(db, ver, privatetype, &build_nsec,
&build_nsec3);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
- return (build_nsec || build_nsec3);
+ return build_nsec || build_nsec3;
}
static void
"update forwarding", dns_zone_getorigin(zone),
true, false);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = isc_quota_attach(&client->manager->sctx->updquota,
isc_result_totext(result));
ns_stats_increment(client->manager->sctx->nsstats,
ns_statscounter_updatequota);
- return (DNS_R_DROP);
+ return DNS_R_DROP;
}
event = (update_event_t *)isc_event_allocate(
if (event != NULL) {
isc_event_free(ISC_EVENT_PTR(&event));
}
- return (result);
+ return result;
}
sizep));
*sp = (rrstream_t *)s;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
ixfr_rrstream_destroy((rrstream_t **)(void *)&s);
- return (result);
+ return result;
}
static isc_result_t
ixfr_rrstream_first(rrstream_t *rs) {
ixfr_rrstream_t *s = (ixfr_rrstream_t *)rs;
- return (dns_journal_first_rr(s->journal));
+ return dns_journal_first_rr(s->journal);
}
static isc_result_t
ixfr_rrstream_next(rrstream_t *rs) {
ixfr_rrstream_t *s = (ixfr_rrstream_t *)rs;
- return (dns_journal_next_rr(s->journal));
+ return dns_journal_next_rr(s->journal);
}
static void
s->it_valid = true;
*sp = (rrstream_t *)s;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
axfr_rrstream_destroy((rrstream_t **)(void *)&s);
- return (result);
+ return result;
}
static isc_result_t
isc_result_t result;
result = dns_rriterator_first(&s->it);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/* Skip SOA records. */
for (;;) {
break;
}
}
- return (result);
+ return result;
}
static isc_result_t
break;
}
}
- return (result);
+ return result;
}
static void
&s->soa_tuple));
*sp = (rrstream_t *)s;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
soa_rrstream_destroy((rrstream_t **)(void *)&s);
- return (result);
+ return result;
}
static isc_result_t
soa_rrstream_first(rrstream_t *rs) {
UNUSED(rs);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
soa_rrstream_next(rrstream_t *rs) {
UNUSED(rs);
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
static void
*data_stream = NULL;
*soa_stream = NULL;
*sp = (rrstream_t *)s;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
rrstream_t *curstream = s->components[s->state];
s->result = curstream->methods->first(curstream);
} while (s->result == ISC_R_NOMORE && s->state < 2);
- return (s->result);
+ return s->result;
}
static isc_result_t
*/
curstream->methods->pause(curstream);
if (s->state == 2) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
s->state++;
curstream = s->components[s->state];
s->result = curstream->methods->first(curstream);
}
- return (s->result);
+ return s->result;
}
static void
isc_buffer_t b;
isc_buffer_constinit(&b, src, strlen(src));
isc_buffer_add(&b, strlen(src));
- return (dns_name_fromtext(name, &b, dns_rootname, 0, NULL));
+ return dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
}
/* create: make sure we can create a dbiterator */
dns_db_newversion(db2, &v2);
assert_non_null(v1);
- return (0);
+ return 0;
}
static int
assert_null(db2);
}
- return (0);
+ return 0;
}
/*
result = dst_lib_init(mctx, NULL);
if (result != ISC_R_SUCCESS) {
- return (1);
+ return 1;
}
- return (0);
+ return 0;
}
static int
dst_lib_destroy();
- return (0);
+ return 0;
}
/* OpenSSL DH_compute_key() failure */
fd = socket(AF_INET6, family, 0);
if (fd < 0) {
perror("setup_ephemeral_port: socket()");
- return (-1);
+ return -1;
}
r = bind(fd, (const struct sockaddr *)&addr->type.sa,
if (r != 0) {
perror("setup_ephemeral_port: bind()");
close(fd);
- return (r);
+ return r;
}
r = getsockname(fd, (struct sockaddr *)&addr->type.sa, &addrlen);
if (r != 0) {
perror("setup_ephemeral_port: getsockname()");
close(fd);
- return (r);
+ return r;
}
#if IPV6_RECVERR
if (r != 0) {
perror("setup_ephemeral_port");
close(fd);
- return (r);
+ return r;
}
#endif
- return (fd);
+ return fd;
}
static void
udp_server_addr = (isc_sockaddr_t){ .length = 0 };
sock = setup_ephemeral_port(&udp_server_addr, SOCK_DGRAM);
if (sock < 0) {
- return (-1);
+ return -1;
}
close(sock);
tcp_server_addr = (isc_sockaddr_t){ .length = 0 };
sock = setup_ephemeral_port(&tcp_server_addr, SOCK_STREAM);
if (sock < 0) {
- return (-1);
+ return -1;
}
close(sock);
reset_testdata();
- return (0);
+ return 0;
}
static int
teardown_managers(state);
- return (0);
+ return 0;
}
static isc_result_t
result = dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_sockaddr_any(&any);
result = dns_dispatch_createudp(dispatchmgr, &any, &disp);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_dispatchset_create(mctx, disp, &dset, ndisps);
dns_dispatch_detach(&disp);
- return (result);
+ return result;
}
static void
UNUSED(handle);
UNUSED(cbarg);
- return (eresult);
+ return eresult;
}
static void
(void)isc_file_remove(TAPFILE);
(void)isc_file_remove(TAPSOCK);
- return (0);
+ return 0;
}
static int
* the testdata was originally generated.
*/
setenv("TZ", "PDT8", 1);
- return (0);
+ return 0;
}
/* set up dnstap environment */
dst_lib_init(mctx, NULL);
- return (0);
+ return 0;
}
static int
dst_lib_destroy();
- return (0);
+ return 0;
}
/* Read sig in file at path to buf. Check signature ineffability */
err:
isc_mem_put(mctx, data, size + 1);
- return (result);
+ return result;
}
static void
/* Use databases from the geoip system test */
load_geoip(TEST_GEOIP_DATA);
- return (0);
+ return 0;
}
static int
close_geoip();
- return (0);
+ return 0;
}
static MMDB_s *
snprintf(pathbuf, sizeof(pathbuf), "%s/%s", dir, dbfile);
ret = MMDB_open(pathbuf, MMDB_MODE_MMAP, mmdb);
if (ret == MMDB_SUCCESS) {
- return (mmdb);
+ return mmdb;
}
- return (NULL);
+ return NULL;
}
static void
db = geoip2_database(&geoip, fix_subtype(&geoip, subtype));
- return (db != NULL && get_entry_for(db, &na) != NULL);
+ return db != NULL && get_entry_for(db, &na) != NULL;
}
/*
elt.subtype = subtype;
strlcpy(elt.as_string, string, sizeof(elt.as_string));
- return (dns_geoip_match(&na, &geoip, &elt));
+ return dns_geoip_match(&na, &geoip, &elt);
}
static bool
elt.subtype = subtype;
strlcpy(elt.as_string, string, sizeof(elt.as_string));
- return (dns_geoip_match(&na, &geoip, &elt));
+ return dns_geoip_match(&na, &geoip, &elt);
}
/* GeoIP country matching */
dns_name_fromtext(name, &namebuf, dns_rootname, 0, NULL),
ISC_R_SUCCESS);
- return (name);
+ return name;
}
static void
isc_buffer_init(&target, buf, BIGBUFLEN);
result = dns_rdataset_totext(dataset, owner, false, false, &target);
- return (result);
+ return result;
}
static void
result = dns_name_fromtext(&dns_origin, &source, dns_rootname, 0,
&target);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdatacallbacks_init_stdio(&callbacks);
callbacks.error = error;
}
headerset = false;
- return (result);
+ return result;
}
static isc_result_t
result = setup_master(warn, error);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdatacallbacks_init_stdio(&callbacks);
if (workdir != NULL) {
result = isc_dir_chdir(workdir);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
dns_rdataclass_in, true, 0, &callbacks,
NULL, NULL, mctx, format, 0);
- return (result);
+ return result;
}
static void
(void)dns_name_fromwire(&name, &source, &dctx, 0, &target);
}
- return (NULL);
+ return NULL;
}
ISC_RUN_TEST_IMPL(benchmark) {
nsec3param.iterations = iter;
nsec3param.salt_length = saltlen;
nsec3param.salt = salt;
- return (nsec3param);
+ return nsec3param;
}
/*%
result = dst_lib_init(mctx, NULL);
if (result != ISC_R_SUCCESS) {
- return (1);
+ return 1;
}
- return (0);
+ return 0;
}
static int
dst_lib_destroy();
- return (0);
+ return 0;
}
typedef struct {
assert_int_equal(result, ISC_R_SUCCESS);
}
- return (ctx);
+ return ctx;
}
static void
dns_test_namefromstring(namestr, &fname);
name = dns_fixedname_name(&fname);
- return (dns_rbt_addnode(rbt, name, node));
+ return dns_rbt_addnode(rbt, name, node);
}
static bool
isc_mem_free(mctx, nodestr);
- return (is_equal);
+ return is_equal;
}
/* Test insertion into a tree */
}
}
- return (NULL);
+ return NULL;
}
/* Benchmark RBT implementation */
NODE_DESTROYLOCK(&rbtdb.node_locks[0].lock);
- return (dns_name_caseequal(name1, name2));
+ return dns_name_caseequal(name1, name2);
}
ISC_RUN_TEST_IMPL(ownercase) {
dns_decompress_invalidate(&dctx);
detect_uncleared_libcrypto_error();
- return (result);
+ return result;
}
/*
*length = isc_buffer_usedlength(&target);
- return (result);
+ return result;
}
static isc_result_t
UNUSED(name);
UNUSED(qtype);
UNUSED(found);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
*/
static isc_result_t
rdata_additionadata(dns_rdata_t *rdata) {
- return (dns_rdata_additionaldata(rdata, dns_rootname, additionaldata_cb,
- NULL));
+ return dns_rdata_additionaldata(rdata, dns_rootname, additionaldata_cb,
+ NULL);
}
/*
result = dns_dispatch_createudp(dispatchmgr, &local, &dispatch);
assert_int_equal(result, ISC_R_SUCCESS);
- return (0);
+ return 0;
}
static int
teardown_managers(state);
- return (0);
+ return 0;
}
static void
result = dst_lib_init(mctx, NULL);
if (result != ISC_R_SUCCESS) {
- return (1);
+ return 1;
}
- return (0);
+ return 0;
}
static int
dst_lib_destroy();
- return (0);
+ return 0;
}
static unsigned char d[10] = { 0xa, 0x10, 0xbb, 0, 0xfe,
result = dst_lib_init(mctx, NULL);
if (result != ISC_R_SUCCESS) {
- return (1);
+ return 1;
}
- return (0);
+ return 0;
}
static int
dst_lib_destroy();
- return (0);
+ return 0;
}
/*%
result = dst_lib_init(mctx, NULL);
if (result != ISC_R_SUCCESS) {
- return (1);
+ return 1;
}
- return (0);
+ return 0;
}
static int
dst_lib_destroy();
- return (0);
+ return 0;
}
static isc_result_t
result = dst_context_adddata(tsigctx, &r);
dns_rdata_freestruct(&tsig);
cleanup:
- return (result);
+ return result;
}
static isc_result_t
dns_compress_invalidate(&cctx);
}
- return (result);
+ return result;
}
static void
setenv("TZ", "", 1);
- return (0);
+ return 0;
}
static uint32_t mystdtime;
isc_app_start();
setup_managers(state);
- return (0);
+ return 0;
}
static int
teardown_managers(state);
isc_app_finish();
- return (0);
+ return 0;
}
struct args {
UNUSED(zone);
*nzones += 1;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
atomic_store(done, true);
isc_app_shutdown();
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
atomic_store(done, true);
isc_app_shutdown();
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
static isc_result_t
check_number(unsigned int n, unsigned int expected) {
- return ((n == expected) ? ISC_R_SUCCESS : ISC_R_BADNUMBER);
+ return (n == expected) ? ISC_R_SUCCESS : ISC_R_BADNUMBER;
}
static isc_result_t
check_attempts(irs_resconf_t *resconf) {
- return (check_number(irs_resconf_getattempts(resconf), 4));
+ return check_number(irs_resconf_getattempts(resconf), 4);
}
static isc_result_t
check_timeout(irs_resconf_t *resconf) {
- return (check_number(irs_resconf_gettimeout(resconf), 1));
+ return check_number(irs_resconf_gettimeout(resconf), 1);
}
static isc_result_t
check_ndots(irs_resconf_t *resconf) {
- return (check_number(irs_resconf_getndots(resconf), 2));
+ return check_number(irs_resconf_getndots(resconf), 2);
}
static isc_result_t
return ISC_R_BADNUMBER;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* test irs_resconf_load() */
cmocka_unit_test(irs_resconf_load_test),
};
- return (cmocka_run_group_tests(tests, NULL, NULL));
+ return cmocka_run_group_tests(tests, NULL, NULL);
}
#else /* HAVE_CMOCKA */
int
main(void) {
printf("1..0 # Skipped: cmocka not available\n");
- return (SKIPPED_TEST_EXIT_CODE);
+ return SKIPPED_TEST_EXIT_CODE;
}
#endif /* if HAVE_CMOCKA */
isc_buffer_init(&b, out, 2 * ISC_AES_BLOCK_LENGTH + 1);
r.base = d;
r.length = ISC_AES_BLOCK_LENGTH;
- return (isc_hex_totext(&r, 0, "", &b));
+ return isc_hex_totext(&r, 0, "", &b);
}
size_t
isc_buffer_init(&b, d, ISC_AES256_KEYLENGTH + 1);
ret = isc_hex_decodestring(in, &b);
if (ret != ISC_R_SUCCESS) {
- return (0);
+ return 0;
}
- return (isc_buffer_usedlength(&b));
+ return isc_buffer_usedlength(&b);
}
typedef struct aes_testcase {
fd = socket(AF_INET6, family, 0);
if (fd < 0) {
perror("setup_ephemeral_port: socket()");
- return (-1);
+ return -1;
}
r = bind(fd, (const struct sockaddr *)&addr->type.sa,
if (r != 0) {
perror("setup_ephemeral_port: bind()");
isc__nm_closesocket(fd);
- return (r);
+ return r;
}
r = getsockname(fd, (struct sockaddr *)&addr->type.sa, &addrlen);
if (r != 0) {
perror("setup_ephemeral_port: getsockname()");
isc__nm_closesocket(fd);
- return (r);
+ return r;
}
result = isc__nm_socket_reuse(fd, 1);
"setup_ephemeral_port: isc__nm_socket_reuse(): %s",
isc_result_totext(result));
close(fd);
- return (-1);
+ return -1;
}
result = isc__nm_socket_reuse_lb(fd);
"setup_ephemeral_port: isc__nm_socket_reuse_lb(): %s",
isc_result_totext(result));
close(fd);
- return (-1);
+ return -1;
}
if (result == ISC_R_NOTIMPLEMENTED) {
reuse_supported = false;
if (r != 0) {
perror("setup_ephemeral_port");
close(fd);
- return (r);
+ return r;
}
#endif
- return (fd);
+ return fd;
}
/* Generic */
tcp_listen_addr = (isc_sockaddr_t){ .length = 0 };
tcp_listen_sock = setup_ephemeral_port(&tcp_listen_addr, SOCK_STREAM);
if (tcp_listen_sock < 0) {
- return (-1);
+ return -1;
}
close(tcp_listen_sock);
tcp_listen_sock = -1;
isc_nonce_buf(&send_magic, sizeof(send_magic));
isc_nonce_buf(&stop_magic, sizeof(stop_magic));
if (send_magic == stop_magic) {
- return (-1);
+ return -1;
}
nm = isc_mem_get(mctx, MAX_NM * sizeof(nm[0]));
*state = nm;
- return (0);
+ return 0;
}
static int
isc_nm_http_endpoints_detach(&endpoints);
- return (0);
+ return 0;
}
thread_local size_t nwrites = NWRITES;
isc_quota_max(&listener_quota, max_quota);
quotap = &listener_quota;
}
- return (quotap);
+ return quotap;
}
static void
sends = atomic_load(&nsends);
}
- return ((isc_threadresult_t)0);
+ return (isc_threadresult_t)0;
}
static void
struct e *e1 = p1;
struct e *e2 = p2;
- return (e1->value < e2->value);
+ return e1->value < e2->value;
}
static void
_setup(void **state) {
isc_hmac_t *hmac_st = isc_hmac_new();
if (hmac_st == NULL) {
- return (-1);
+ return -1;
}
*state = hmac_st;
- return (0);
+ return 0;
}
static int
_teardown(void **state) {
if (*state == NULL) {
- return (-1);
+ return -1;
}
isc_hmac_free(*state);
- return (0);
+ return 0;
}
static int
_reset(void **state) {
if (*state == NULL) {
- return (-1);
+ return -1;
}
if (isc_hmac_reset(*state) != ISC_R_SUCCESS) {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
ISC_RUN_TEST_IMPL(isc_hmac_new) {
_setup(void **state) {
isc_md_t *md = isc_md_new();
if (md == NULL) {
- return (-1);
+ return -1;
}
*state = md;
- return (0);
+ return 0;
}
static int
_teardown(void **state) {
if (*state == NULL) {
- return (-1);
+ return -1;
}
isc_md_free(*state);
- return (0);
+ return 0;
}
static int
_reset(void **state) {
if (*state == NULL) {
- return (-1);
+ return -1;
}
if (isc_md_reset(*state) != ISC_R_SUCCESS) {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
ISC_RUN_TEST_IMPL(isc_md_new) {
}
}
- return ((isc_threadresult_t)0);
+ return (isc_threadresult_t)0;
}
ISC_RUN_TEST_IMPL(isc_mem_benchmark) {
fd = socket(AF_INET6, family, 0);
if (fd < 0) {
perror("setup_ephemeral_port: socket()");
- return (-1);
+ return -1;
}
r = bind(fd, (const struct sockaddr *)&addr->type.sa,
if (r != 0) {
perror("setup_ephemeral_port: bind()");
isc__nm_closesocket(fd);
- return (r);
+ return r;
}
r = getsockname(fd, (struct sockaddr *)&addr->type.sa, &addrlen);
if (r != 0) {
perror("setup_ephemeral_port: getsockname()");
isc__nm_closesocket(fd);
- return (r);
+ return r;
}
#if IPV6_RECVERR
if (r != 0) {
perror("setup_ephemeral_port");
isc__nm_closesocket(fd);
- return (r);
+ return r;
}
#endif
- return (fd);
+ return fd;
}
static int
udp_listen_addr = (isc_sockaddr_t){ .length = 0 };
udp_listen_sock = setup_ephemeral_port(&udp_listen_addr, SOCK_DGRAM);
if (udp_listen_sock < 0) {
- return (-1);
+ return -1;
}
isc__nm_closesocket(udp_listen_sock);
udp_listen_sock = -1;
tcp_listen_addr = (isc_sockaddr_t){ .length = 0 };
tcp_listen_sock = setup_ephemeral_port(&tcp_listen_addr, SOCK_STREAM);
if (tcp_listen_sock < 0) {
- return (-1);
+ return -1;
}
isc__nm_closesocket(tcp_listen_sock);
tcp_listen_sock = -1;
isc_nonce_buf(&send_magic, sizeof(send_magic));
isc_nonce_buf(&stop_magic, sizeof(stop_magic));
if (send_magic == stop_magic) {
- return (-1);
+ return -1;
}
isc__netmgr_create(mctx, nworkers, &listen_nm);
if (isc_tlsctx_createserver(NULL, NULL, &tcp_listen_tlsctx) !=
ISC_R_SUCCESS)
{
- return (-1);
+ return -1;
}
if (isc_tlsctx_createclient(&tcp_connect_tlsctx) != ISC_R_SUCCESS) {
- return (-1);
+ return -1;
}
isc_tlsctx_enable_dot_client_alpn(tcp_connect_tlsctx);
ISC_TLSCTX_CLIENT_SESSION_CACHE_DEFAULT_SIZE,
&tcp_tlsctx_client_sess_cache);
- return (0);
+ return 0;
}
static int
isc_tlsctx_client_session_cache_detach(&tcp_tlsctx_client_sess_cache);
- return (0);
+ return 0;
}
/* Callbacks */
(void)atomic_fetch_add(&saccepts, 1);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
F();
- return (eresult);
+ return eresult;
}
static isc_result_t
F();
if (eresult != ISC_R_SUCCESS) {
- return (eresult);
+ return eresult;
}
atomic_fetch_add(&saccepts, 1);
isc_nmhandle_attach(handle, &readhandle);
isc_nm_read(handle, listen_read_cb, readhandle);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
typedef void (*connect_func)(isc_nm_t *);
connect(connect_nm);
}
- return ((isc_threadresult_t)0);
+ return (isc_threadresult_t)0;
}
/* UDP */
isc_quota_max(&listener_quota, max_quota);
quotap = &listener_quota;
}
- return (quotap);
+ return quotap;
}
static void
get_stream_connect_function(void) {
#if HAVE_LIBNGHTTP2
if (stream_use_TLS) {
- return (tls_connect);
+ return tls_connect;
}
#endif
- return (tcp_connect);
+ return tcp_connect;
}
static isc_result_t
accept_cb, accept_cbarg,
extrahandlesize, backlog, quota,
tcp_listen_tlsctx, sockp);
- return (result);
+ return result;
}
#endif
result = isc_nm_listentcp(listen_nm, &tcp_listen_addr, accept_cb,
accept_cbarg, extrahandlesize, backlog, quota,
sockp);
- return (result);
+ return result;
}
static void
F();
if (eresult != ISC_R_SUCCESS) {
- return (eresult);
+ return eresult;
}
atomic_fetch_add(&saccepts, 1);
isc_nmhandle_attach(handle, &readhandle);
isc_nm_read(handle, tlsdns_many_listen_read_cb, cbarg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
F();
if (eresult != ISC_R_SUCCESS) {
- return (eresult);
+ return eresult;
}
atomic_fetch_add(&saccepts, 1);
if (isc_nm_xfr_checkperm(handle) != ISC_R_SUCCESS) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (stream_accept_cb(handle, eresult, cbarg));
+ return stream_accept_cb(handle, eresult, cbarg);
}
ISC_RUN_TEST_IMPL(tlsdns_listen_noalpn) {
isc_task_t *task = NULL;
result = isc_task_create(mgr, 0, &task);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
*target = (void *)task;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
isc_quota_t *quota = (isc_quota_t *)quotap;
uv_sleep(10);
isc_quota_detach("a);
- return ((isc_threadresult_t)0);
+ return (isc_threadresult_t)0;
}
static void
&g_threads[tnum]);
}
}
- return ((isc_threadresult_t)0);
+ return (isc_threadresult_t)0;
}
ISC_RUN_TEST_IMPL(isc_quota_callback_mt) {
double pkm1, pkm2, qkm1, qkm2;
if ((x <= 0) || (a <= 0)) {
- return (1.0);
+ return 1.0;
}
if ((x < 1.0) || (x < a)) {
- return (1.0 - igam(a, x));
+ return 1.0 - igam(a, x);
}
ax = a * log(x) - x - lgamma(a);
if (ax < -MAXLOG) {
print_error("# igamc: UNDERFLOW, ax=%f\n", ax);
- return (0.0);
+ return 0.0;
}
ax = exp(ax);
}
} while (t > MACHEP);
- return (ans * ax);
+ return ans * ax;
}
static double
double ans, ax, c, r;
if ((x <= 0) || (a <= 0)) {
- return (0.0);
+ return 0.0;
}
if ((x > 1.0) && (x > a)) {
- return (1.0 - igamc(a, x));
+ return 1.0 - igamc(a, x);
}
/* Compute x**a * exp(-x) / md_gamma(a) */
ax = a * log(x) - x - lgamma(a);
if (ax < -MAXLOG) {
print_error("# igam: UNDERFLOW, ax=%f\n", ax);
- return (0.0);
+ return 0.0;
}
ax = exp(ax);
ans += c;
} while (c / ans > MACHEP);
- return (ans * ax / a);
+ return ans * ax / a;
}
static int8_t scounts_table[65536];
n >>= 1;
}
- return (sc);
+ return sc;
}
static uint8_t
n >>= 1;
}
- return (bc);
+ return bc;
}
static void
}
}
- return (rank);
+ return rank;
}
rank++;
rt++;
}
- return (rank);
+ return rank;
}
static void
s_obs = abs(scount) / sqrt(numbits);
p_value = erfc(s_obs / sqrt(2.0));
- return (p_value);
+ return p_value;
}
/*
* cases.
*/
if (fabs(pi - 0.5) >= tau) {
- return (0.0);
+ return 0.0;
}
/* Compute v_obs */
p_value = erfc(numer / denom);
- return (p_value);
+ return p_value;
}
/*
p_value = igamc(numblocks * 0.5, chi_square * 0.5);
- return (p_value);
+ return p_value;
}
/*
p_value = exp(-chi_square * 0.5);
- return (p_value);
+ return p_value;
}
/***
workers = 0;
setup_managers(state);
- return (0);
+ return 0;
}
static int
workers = 2;
setup_managers(state);
- return (0);
+ return 0;
}
static int
workers = 4;
setup_managers(state);
- return (0);
+ return 0;
}
static int
isc_condition_destroy(&cv);
isc_mutex_destroy(&lock);
- return (0);
+ return 0;
}
static void
r = 0;
}
}
- return (r);
+ return r;
}
static void
setup_managers(state);
- return (0);
+ return 0;
}
static int
_teardown(void **state) {
teardown_managers(state);
- return (0);
+ return 0;
}
static void
int
__wrap_uv_udp_open(uv_udp_t *handle, uv_os_sock_t sock) {
if (atomic_load(&__state_uv_udp_open) == 0) {
- return (uv_udp_open(handle, sock));
+ return uv_udp_open(handle, sock);
}
- return (atomic_load(&__state_uv_udp_open));
+ return atomic_load(&__state_uv_udp_open);
}
static atomic_int __state_uv_udp_bind = 0;
__wrap_uv_udp_bind(uv_udp_t *handle, const struct sockaddr *addr,
unsigned int flags) {
if (atomic_load(&__state_uv_udp_bind) == 0) {
- return (uv_udp_bind(handle, addr, flags));
+ return uv_udp_bind(handle, addr, flags);
}
- return (atomic_load(&__state_uv_udp_bind));
+ return atomic_load(&__state_uv_udp_bind);
}
static atomic_int __state_uv_udp_connect __attribute__((unused)) = 0;
int
__wrap_uv_udp_connect(uv_udp_t *handle, const struct sockaddr *addr) {
if (atomic_load(&__state_uv_udp_connect) == 0) {
- return (uv_udp_connect(handle, addr));
+ return uv_udp_connect(handle, addr);
}
- return (atomic_load(&__state_uv_udp_connect));
+ return atomic_load(&__state_uv_udp_connect);
}
#endif /* UV_VERSION_HEX >= UV_VERSION(1, 27, 0) */
__wrap_uv_udp_getpeername(const uv_udp_t *handle, struct sockaddr *name,
int *namelen) {
if (atomic_load(&__state_uv_udp_getpeername) == 0) {
- return (uv_udp_getpeername(handle, name, namelen));
+ return uv_udp_getpeername(handle, name, namelen);
}
- return (atomic_load(&__state_uv_udp_getpeername));
+ return atomic_load(&__state_uv_udp_getpeername);
}
#endif /* UV_VERSION_HEX >= UV_VERSION(1, 27, 0) */
__wrap_uv_udp_getsockname(const uv_udp_t *handle, struct sockaddr *name,
int *namelen) {
if (atomic_load(&__state_uv_udp_getsockname) == 0) {
- return (uv_udp_getsockname(handle, name, namelen));
+ return uv_udp_getsockname(handle, name, namelen);
}
- return (atomic_load(&__state_uv_udp_getsockname));
+ return atomic_load(&__state_uv_udp_getsockname);
}
static atomic_int __state_uv_udp_send = 0;
unsigned int nbufs, const struct sockaddr *addr,
uv_udp_send_cb send_cb) {
if (atomic_load(&__state_uv_udp_send) == 0) {
- return (uv_udp_send(req, handle, bufs, nbufs, addr, send_cb));
+ return uv_udp_send(req, handle, bufs, nbufs, addr, send_cb);
}
- return (atomic_load(&__state_uv_udp_send));
+ return atomic_load(&__state_uv_udp_send);
}
static atomic_int __state_uv_udp_recv_start = 0;
__wrap_uv_udp_recv_start(uv_udp_t *handle, uv_alloc_cb alloc_cb,
uv_udp_recv_cb recv_cb) {
if (atomic_load(&__state_uv_udp_recv_start) == 0) {
- return (uv_udp_recv_start(handle, alloc_cb, recv_cb));
+ return uv_udp_recv_start(handle, alloc_cb, recv_cb);
}
- return (atomic_load(&__state_uv_udp_recv_start));
+ return atomic_load(&__state_uv_udp_recv_start);
}
static atomic_int __state_uv_udp_recv_stop = 0;
int
__wrap_uv_udp_recv_stop(uv_udp_t *handle) {
if (atomic_load(&__state_uv_udp_recv_stop) == 0) {
- return (uv_udp_recv_stop(handle));
+ return uv_udp_recv_stop(handle);
}
- return (atomic_load(&__state_uv_udp_recv_stop));
+ return atomic_load(&__state_uv_udp_recv_stop);
}
static atomic_int __state_uv_tcp_open = 0;
int
__wrap_uv_tcp_open(uv_tcp_t *handle, uv_os_sock_t sock) {
if (atomic_load(&__state_uv_tcp_open) == 0) {
- return (uv_tcp_open(handle, sock));
+ return uv_tcp_open(handle, sock);
}
- return (atomic_load(&__state_uv_tcp_open));
+ return atomic_load(&__state_uv_tcp_open);
}
static atomic_int __state_uv_tcp_bind = 0;
__wrap_uv_tcp_bind(uv_tcp_t *handle, const struct sockaddr *addr,
unsigned int flags) {
if (atomic_load(&__state_uv_tcp_bind) == 0) {
- return (uv_tcp_bind(handle, addr, flags));
+ return uv_tcp_bind(handle, addr, flags);
}
- return (atomic_load(&__state_uv_tcp_bind));
+ return atomic_load(&__state_uv_tcp_bind);
}
static atomic_int __state_uv_tcp_getsockname = 0;
__wrap_uv_tcp_getsockname(const uv_tcp_t *handle, struct sockaddr *name,
int *namelen) {
if (atomic_load(&__state_uv_tcp_getsockname) == 0) {
- return (uv_tcp_getsockname(handle, name, namelen));
+ return uv_tcp_getsockname(handle, name, namelen);
}
- return (atomic_load(&__state_uv_tcp_getsockname));
+ return atomic_load(&__state_uv_tcp_getsockname);
}
static atomic_int __state_uv_tcp_getpeername = 0;
__wrap_uv_tcp_getpeername(const uv_tcp_t *handle, struct sockaddr *name,
int *namelen) {
if (atomic_load(&__state_uv_tcp_getpeername) == 0) {
- return (uv_tcp_getpeername(handle, name, namelen));
+ return uv_tcp_getpeername(handle, name, namelen);
}
- return (atomic_load(&__state_uv_tcp_getpeername));
+ return atomic_load(&__state_uv_tcp_getpeername);
}
static atomic_int __state_uv_tcp_connect = 0;
__wrap_uv_tcp_connect(uv_connect_t *req, uv_tcp_t *handle,
const struct sockaddr *addr, uv_connect_cb cb) {
if (atomic_load(&__state_uv_tcp_connect) == 0) {
- return (uv_tcp_connect(req, handle, addr, cb));
+ return uv_tcp_connect(req, handle, addr, cb);
}
- return (atomic_load(&__state_uv_tcp_connect));
+ return atomic_load(&__state_uv_tcp_connect);
}
static atomic_int __state_uv_listen = 0;
int
__wrap_uv_listen(uv_stream_t *stream, int backlog, uv_connection_cb cb) {
if (atomic_load(&__state_uv_listen) == 0) {
- return (uv_listen(stream, backlog, cb));
+ return uv_listen(stream, backlog, cb);
}
- return (atomic_load(&__state_uv_listen));
+ return atomic_load(&__state_uv_listen);
}
static atomic_int __state_uv_accept = 0;
int
__wrap_uv_accept(uv_stream_t *server, uv_stream_t *client) {
if (atomic_load(&__state_uv_accept) == 0) {
- return (uv_accept(server, client));
+ return uv_accept(server, client);
}
- return (atomic_load(&__state_uv_accept));
+ return atomic_load(&__state_uv_accept);
}
static atomic_int __state_uv_send_buffer_size = 0;
int
__wrap_uv_send_buffer_size(uv_handle_t *handle, int *value) {
if (atomic_load(&__state_uv_send_buffer_size) == 0) {
- return (uv_send_buffer_size(handle, value));
+ return uv_send_buffer_size(handle, value);
}
- return (atomic_load(&__state_uv_send_buffer_size));
+ return atomic_load(&__state_uv_send_buffer_size);
}
static atomic_int __state_uv_recv_buffer_size = 0;
int
__wrap_uv_recv_buffer_size(uv_handle_t *handle, int *value) {
if (atomic_load(&__state_uv_recv_buffer_size) == 0) {
- return (uv_recv_buffer_size(handle, value));
+ return uv_recv_buffer_size(handle, value);
}
- return (atomic_load(&__state_uv_recv_buffer_size));
+ return atomic_load(&__state_uv_recv_buffer_size);
}
static atomic_int __state_uv_fileno = 0;
int
__wrap_uv_fileno(const uv_handle_t *handle, uv_os_fd_t *fd) {
if (atomic_load(&__state_uv_fileno) == 0) {
- return (uv_fileno(handle, fd));
+ return uv_fileno(handle, fd);
}
- return (atomic_load(&__state_uv_fileno));
+ return atomic_load(&__state_uv_fileno);
}
#define uv_udp_open(...) __wrap_uv_udp_open(__VA_ARGS__)
result = isc_log_usechannel(logconfig, "stderr", NULL, NULL);
if (result != ISC_R_SUCCESS) {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
ISC_TEARDOWN_TEST_IMPL(group) {
if (lctx == NULL) {
- return (-1);
+ return -1;
}
isc_log_setcontext(NULL);
isc_log_destroy(&lctx);
- return (0);
+ return 0;
}
struct duration_conf {
result = isc_log_usechannel(logconfig, "stderr", NULL, NULL);
if (result != ISC_R_SUCCESS) {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
ISC_TEARDOWN_TEST_IMPL(group) {
if (lctx == NULL) {
- return (-1);
+ return -1;
}
isc_log_setcontext(NULL);
isc_log_destroy(&lctx);
- return (0);
+ return 0;
}
/* mimic calling nzf_append() */
result = dns_view_create(mctx, dns_rdataclass_in, name, &view);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (with_cache) {
&cache);
if (result != ISC_R_SUCCESS) {
dns_view_detach(&view);
- return (result);
+ return result;
}
dns_view_setcache(view, cache, false);
*viewp = view;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
*/
result = dns_zone_create(&zone, mctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
*zonep = zone;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
detach_zone:
dns_zone_detach(&zone);
- return (result);
+ return result;
}
isc_result_t
REQUIRE(zonemgr == NULL);
result = dns_zonemgr_create(mctx, taskmgr, timermgr, netmgr, &zonemgr);
- return (result);
+ return result;
}
isc_result_t
result = dns_zonemgr_setsize(zonemgr, 1);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_zonemgr_managezone(zonemgr, zone);
- return (result);
+ return result;
}
void
result = dns_name_fromstring(name, origin, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_create(mctx, "rbt", name, dbtype, dns_rdataclass_in, 0,
NULL, db);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_load(*db, testfile, dns_masterformat_text, 0);
- return (result);
+ return result;
}
static int
fromhex(char c) {
if (c >= '0' && c <= '9') {
- return (c - '0');
+ return c - '0';
} else if (c >= 'a' && c <= 'f') {
- return (c - 'a' + 10);
+ return c - 'a' + 10;
} else if (c >= 'A' && c <= 'F') {
- return (c - 'A' + 10);
+ return c - 'A' + 10;
}
printf("bad input format: %02x\n", c);
result = isc_hex_totext((isc_region_t *)&source, 1, " ", &target);
INSIST(result == ISC_R_SUCCESS);
- return (buf);
+ return buf;
}
isc_result_t
result = isc_stdio_open(file, "r", &f);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
bp = buf;
}
isc_stdio_close(f);
- return (result);
+ return result;
}
static void
*/
result = isc_lex_create(mctx, 64, &lex);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
destroy_lexer:
isc_lex_destroy(&lex);
- return (result);
+ return result;
}
void
dns_diff_clear(diff);
}
- return (result);
+ return result;
}
result = isc_managers_create(mctx, workers, 0, &netmgr, &taskmgr,
&timermgr);
if (result != ISC_R_SUCCESS) {
- return (-1);
+ return -1;
}
result = isc_task_create_bound(taskmgr, 0, &maintask, 0);
if (result != ISC_R_SUCCESS) {
- return (-1);
+ return -1;
}
isc_taskmgr_setexcltask(taskmgr, maintask);
- return (0);
+ return 0;
}
int
isc_task_detach(&maintask);
isc_managers_destroy(&netmgr, &taskmgr, &timermgr);
- return (0);
+ return 0;
}
UNUSED(sigresultp);
UNUSED(viewp);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
int
result = dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr);
if (result != ISC_R_SUCCESS) {
- return (-1);
+ return -1;
}
result = ns_interfacemgr_create(mctx, sctx, taskmgr, timermgr, netmgr,
dispatchmgr, maintask, NULL, workers,
false, &interfacemgr);
if (result != ISC_R_SUCCESS) {
- return (-1);
+ return -1;
}
result = ns_listenlist_default(mctx, port, true, AF_INET, &listenon);
if (result != ISC_R_SUCCESS) {
- return (-1);
+ return -1;
}
ns_interfacemgr_setlistenon4(interfacemgr, listenon);
clientmgr = ns_interfacemgr_getclientmgr(interfacemgr);
- return (0);
+ return 0;
}
int
}
teardown_managers(state);
- return (0);
+ return 0;
}
static dns_zone_t *served_zone = NULL;
*/
result = dns_test_makezone(zonename, &served_zone, view, false);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
dns_db_detach(&db);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
release_zone:
dns_test_releasezone(served_zone);
free_zone:
dns_zone_detach(&served_zone);
- return (result);
+ return result;
}
void
client->handle = (isc_nmhandle_t *)client; /* Hack */
*clientp = client;
- return (result);
+ return result;
}
/*%
* Parse the rendered query, storing results in client->message.
*/
isc_buffer_first(&querybuf);
- return (dns_message_parse(client->message, &querybuf, 0));
+ return dns_message_parse(client->message, &querybuf, 0);
put_name:
dns_message_puttempname(message, &qname);
destroy_message:
dns_message_detach(&message);
- return (result);
+ return result;
}
/*%
*qctxp = qctx;
*resultp = ISC_R_UNSET;
- return (NS_HOOK_RETURN);
+ return NS_HOOK_RETURN;
}
/*%
isc_nmhandle_detach(&client->reqhandle);
if (*qctxp == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
*/
result = ns_test_getclient(NULL, false, &client);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
TIME_NOW(&client->tnow);
handle = client->handle;
isc_nmhandle_detach(&handle);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
detach_query:
dns_message_detach(&client->message);
detach_client:
isc_nmhandle_detach(&client->handle);
- return (result);
+ return result;
}
void
*resultp = ISC_R_UNSET;
- return (NS_HOOK_RETURN);
+ return NS_HOOK_RETURN;
}
isc_result_t
result = dns_name_fromstring(name, origin, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_create(mctx, "rbt", name, dbtype, dns_rdataclass_in, 0,
NULL, db);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_load(*db, testfile, dns_masterformat_text, 0);
- return (result);
+ return result;
}
static int
fromhex(char c) {
if (c >= '0' && c <= '9') {
- return (c - '0');
+ return c - '0';
} else if (c >= 'a' && c <= 'f') {
- return (c - 'a' + 10);
+ return c - 'a' + 10;
} else if (c >= 'A' && c <= 'F') {
- return (c - 'A' + 10);
+ return c - 'A' + 10;
}
printf("bad input format: %02x\n", c);
result = isc_stdio_open(file, "r", &f);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
bp = buf;
cleanup:
isc_stdio_close(f);
- return (result);
+ return result;
}
setup_managers(state);
- return (0);
+ return 0;
}
static int
teardown_managers(state);
- return (0);
+ return 0;
}
/* test that ns_listenlist_default() works */
static int
setup_test(void **state) {
isc__nm_force_tid(0);
- return (setup_server(state));
+ return setup_server(state);
}
static int
teardown_test(void **state) {
isc__nm_force_tid(-1);
- return (teardown_server(state));
+ return teardown_server(state);
}
static void
setup_test(void **state) {
isc__nm_force_tid(0);
setup_server(state);
- return (0);
+ return 0;
}
static int
teardown_test(void **state) {
isc__nm_force_tid(-1);
teardown_server(state);
- return (0);
+ return 0;
}
/* can be used for client->sendcb to avoid disruption on sending a response */
ns_hook_resevent_t *rev = NULL;
if (asdata->start_result != ISC_R_SUCCESS) {
- return (asdata->start_result);
+ return asdata->start_result;
}
ctx = isc_mem_get(memctx, sizeof(*ctx));
ctx->cancel = cancel_hookactx;
*ctxp = ctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
}
*resultp = ISC_R_UNSET;
- return (NS_HOOK_RETURN);
+ return NS_HOOK_RETURN;
}
static ns_hookresult_t
hook_async_query_setup(void *arg, void *data, isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp, NS_QUERY_SETUP));
+ return hook_async_common(arg, data, resultp, NS_QUERY_SETUP);
}
static ns_hookresult_t
hook_async_query_start_begin(void *arg, void *data, isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp, NS_QUERY_START_BEGIN));
+ return hook_async_common(arg, data, resultp, NS_QUERY_START_BEGIN);
}
static ns_hookresult_t
hook_async_query_lookup_begin(void *arg, void *data, isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp, NS_QUERY_LOOKUP_BEGIN));
+ return hook_async_common(arg, data, resultp, NS_QUERY_LOOKUP_BEGIN);
}
static ns_hookresult_t
hook_async_query_resume_begin(void *arg, void *data, isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp, NS_QUERY_RESUME_BEGIN));
+ return hook_async_common(arg, data, resultp, NS_QUERY_RESUME_BEGIN);
}
static ns_hookresult_t
hook_async_query_got_answer_begin(void *arg, void *data,
isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp,
- NS_QUERY_GOT_ANSWER_BEGIN));
+ return hook_async_common(arg, data, resultp, NS_QUERY_GOT_ANSWER_BEGIN);
}
static ns_hookresult_t
hook_async_query_respond_any_begin(void *arg, void *data,
isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp,
- NS_QUERY_RESPOND_ANY_BEGIN));
+ return hook_async_common(arg, data, resultp,
+ NS_QUERY_RESPOND_ANY_BEGIN);
}
static ns_hookresult_t
hook_async_query_addanswer_begin(void *arg, void *data, isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp,
- NS_QUERY_ADDANSWER_BEGIN));
+ return hook_async_common(arg, data, resultp, NS_QUERY_ADDANSWER_BEGIN);
}
static ns_hookresult_t
hook_async_query_notfound_begin(void *arg, void *data, isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp, NS_QUERY_NOTFOUND_BEGIN));
+ return hook_async_common(arg, data, resultp, NS_QUERY_NOTFOUND_BEGIN);
}
static ns_hookresult_t
hook_async_query_prep_delegation_begin(void *arg, void *data,
isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp,
- NS_QUERY_PREP_DELEGATION_BEGIN));
+ return hook_async_common(arg, data, resultp,
+ NS_QUERY_PREP_DELEGATION_BEGIN);
}
static ns_hookresult_t
hook_async_query_zone_delegation_begin(void *arg, void *data,
isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp,
- NS_QUERY_ZONE_DELEGATION_BEGIN));
+ return hook_async_common(arg, data, resultp,
+ NS_QUERY_ZONE_DELEGATION_BEGIN);
}
static ns_hookresult_t
hook_async_query_delegation_begin(void *arg, void *data,
isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp,
- NS_QUERY_DELEGATION_BEGIN));
+ return hook_async_common(arg, data, resultp, NS_QUERY_DELEGATION_BEGIN);
}
static ns_hookresult_t
hook_async_query_delegation_recurse_begin(void *arg, void *data,
isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp,
- NS_QUERY_DELEGATION_RECURSE_BEGIN));
+ return hook_async_common(arg, data, resultp,
+ NS_QUERY_DELEGATION_RECURSE_BEGIN);
}
static ns_hookresult_t
hook_async_query_nodata_begin(void *arg, void *data, isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp, NS_QUERY_NODATA_BEGIN));
+ return hook_async_common(arg, data, resultp, NS_QUERY_NODATA_BEGIN);
}
static ns_hookresult_t
hook_async_query_nxdomain_begin(void *arg, void *data, isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp, NS_QUERY_NXDOMAIN_BEGIN));
+ return hook_async_common(arg, data, resultp, NS_QUERY_NXDOMAIN_BEGIN);
}
static ns_hookresult_t
hook_async_query_ncache_begin(void *arg, void *data, isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp, NS_QUERY_NCACHE_BEGIN));
+ return hook_async_common(arg, data, resultp, NS_QUERY_NCACHE_BEGIN);
}
static ns_hookresult_t
hook_async_query_cname_begin(void *arg, void *data, isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp, NS_QUERY_CNAME_BEGIN));
+ return hook_async_common(arg, data, resultp, NS_QUERY_CNAME_BEGIN);
}
static ns_hookresult_t
hook_async_query_dname_begin(void *arg, void *data, isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp, NS_QUERY_DNAME_BEGIN));
+ return hook_async_common(arg, data, resultp, NS_QUERY_DNAME_BEGIN);
}
static ns_hookresult_t
hook_async_query_respond_begin(void *arg, void *data, isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp, NS_QUERY_RESPOND_BEGIN));
+ return hook_async_common(arg, data, resultp, NS_QUERY_RESPOND_BEGIN);
}
static ns_hookresult_t
hook_async_query_response_begin(void *arg, void *data, isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp,
- NS_QUERY_PREP_RESPONSE_BEGIN));
+ return hook_async_common(arg, data, resultp,
+ NS_QUERY_PREP_RESPONSE_BEGIN);
}
static ns_hookresult_t
hook_async_query_done_begin(void *arg, void *data, isc_result_t *resultp) {
- return (hook_async_common(arg, data, resultp, NS_QUERY_DONE_BEGIN));
+ return hook_async_common(arg, data, resultp, NS_QUERY_DONE_BEGIN);
}
/*
asdata->qctx = *qctx; /* remember passed ctx for inspection */
*resultp = ISC_R_UNSET;
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
static void
hookasync_e2e_data_t *asdata = arg;
if (asdata->start_result != ISC_R_SUCCESS) {
- return (asdata->start_result);
+ return asdata->start_result;
}
ctx = isc_mem_get(memctx, sizeof(*ctx));
ctx->cancel = cancel_e2ehookactx;
*ctxp = ctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static ns_hookresult_t
result = ns_query_hookasync(qctx, test_hookasync_e2e, asdata);
if (result != ISC_R_SUCCESS) {
*resultp = result;
- return (NS_HOOK_RETURN);
+ return NS_HOOK_RETURN;
}
asdata->async = true;
asdata->rev->origresult = *resultp; /* save it for resume */
*resultp = ISC_R_UNSET;
- return (NS_HOOK_RETURN);
+ return NS_HOOK_RETURN;
} else {
/* Resume from the completion of async event */
asdata->async = false;
/* Don't touch 'resultp' */
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
}
INSIST(qctx->client->message->rcode == asdata->expected_rcode);
asdata->done = true; /* Let the test know this hook is called */
*resultp = ISC_R_UNSET;
- return (NS_HOOK_CONTINUE);
+ return NS_HOOK_CONTINUE;
}
static void
if (e == NULL || n == NULL || ctx == NULL || evp_md_ctx == NULL) {
ERR_clear_error();
- return (1);
+ return 1;
}
BN_set_bit(e, 0);
EVP_PKEY_keygen(ctx, &pkey) != 1 || pkey == NULL)
{
ERR_clear_error();
- return (1);
+ return 1;
}
EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_N, &n);
if (n == NULL) {
ERR_clear_error();
- return (1);
+ return 1;
}
bytes = BN_num_bytes(e);
EVP_SignFinal(evp_md_ctx, buf, &siglen, pkey) != 1)
{
ERR_clear_error();
- return (1);
+ return 1;
}
bytes = siglen;
printf("unsigned char sha1_sig[] = \"");
EVP_SignFinal(evp_md_ctx, buf, &siglen, pkey) != 1)
{
ERR_clear_error();
- return (1);
+ return 1;
}
bytes = siglen;
printf("unsigned char sha256_sig[] = \"");
EVP_SignFinal(evp_md_ctx, buf, &siglen, pkey) != 1)
{
ERR_clear_error();
- return (1);
+ return 1;
}
bytes = siglen;
printf("unsigned char sha512_sig[] = \"");
EVP_MD_CTX_free(evp_md_ctx);
EVP_PKEY_free(pkey);
- return (0);
+ return 0;
}
}
__coverity_negative_sink__(size);
if (condition) {
- return (0);
+ return 0;
}
- return (__coverity_alloc__(size));
+ return __coverity_alloc__(size);
}
void
}
__coverity_negative_sink__(size);
if (condition) {
- return (0);
+ return 0;
}
- return (__coverity_alloc__(size));
+ return __coverity_alloc__(size);
}
void *
} else if (ptr) {
__coverity_free__(ptr);
}
- return (p);
+ return p;
}
void
__coverity_panic__();
}
if (condition) {
- return (0);
+ return 0;
}
d = __coverity_alloc__(strlen(s) + 1);
__coverity_writeall__(d);
- return (d);
+ return d;
}
void *
__coverity_panic__();
}
if (condition) {
- return (0);
+ return 0;
}
- return (__coverity_alloc__(size));
+ return __coverity_alloc__(size);
}
void
projects / thirdparty / bind9.git / commitdiff
