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_LOG_DYNAMIC, ISC_LOGDESTINATION_FILE(errout), 0,
ISC_LOGCATEGORY_DEFAULT, ISC_LOGMODULE_DEFAULT);
- 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, 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;
}
r.base = UNCONST(zclass);
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(ZONEDB_DEFAULT, 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;
}
r.base = UNCONST(cfg_obj_asstring(classobj));
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 (result == ISC_R_SUCCESS ? 0 : 1);
+ return result == ISC_R_SUCCESS ? 0 : 1;
}
destroy();
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;
}
48, 80, 8, splitwidth, mctx);
}
- return (result);
+ return result;
}
static isc_result_t
if (result != ISC_R_SUCCESS) {
delv_log(ISC_LOG_ERROR, "failed to convert name %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
cfg_obj_t *bindkeys = NULL;
if (!root_validation) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (trust_anchor == 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;
result = parse_uint(&destport, port, 0xffff, "port");
if (result != ISC_R_SUCCESS) {
fatal("Couldn't parse port number");
}
- 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, 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;
}
}
UNUSED(handle);
UNUSED(arg);
- return (result);
+ return result;
}
static void
*viewp = view;
*viewpatchresultp = ISC_R_SUCCESS;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
isc_managers_destroy(&mctx, &loopmgr, &netmgr);
- 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;
}
/*%
}
}
- return (result);
+ return result;
}
static bool
/* start syntax analysis and verification */
if (!rule_proxy_addrs(&st)) {
warn("PROXY source and destination addresses cannot be parsed");
- return (false);
+ return false;
}
/* get port numeric values */
if (result != ISC_R_SUCCESS) {
warn("Cannot get PROXY source address: %s",
isc_result_totext(result));
- return (false);
+ return false;
}
result = proxy_handle_addr_string(st.dst_addr_start, st.dst_addr_len,
if (result != ISC_R_SUCCESS) {
warn("Cannot get PROXY destination address: %s",
isc_result_totext(result));
- return (false);
+ return false;
}
/* addresses should be of the same type */
if (isc_sockaddr_pf(&src) != isc_sockaddr_pf(&dst)) {
warn("PROXY source and destination addresses must be of the "
"same type");
- return (false);
+ return false;
}
*psrc = src;
*pdst = dst;
- return (true);
+ return true;
}
static bool
rule_proxy_addrs(isc_proxy_addrs_parser_state_t *st) {
if (!rule_addr(st)) {
- return (false);
+ return false;
}
st->src_addr_start = st->last_addr_start;
st->src_port_len = st->last_port_len;
if (!MATCH('-')) {
- return (false);
+ return false;
}
ADVANCE();
if (!rule_addr(st)) {
- return (false);
+ return false;
}
st->dst_addr_start = st->last_addr_start;
st->dst_port_len = st->last_port_len;
if (!MATCH('\0')) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static bool
rule_addr(isc_proxy_addrs_parser_state_t *st) {
const char *start = GETP();
if (!rule_addr_char(st)) {
- return (false);
+ return false;
}
while (rule_addr_char(st)) {
ADVANCE();
if (!rule_port(st)) {
- return (false);
+ return false;
}
}
- return (true);
+ return true;
}
static bool
rule_port(isc_proxy_addrs_parser_state_t *st) {
const char *start = GETP();
if (!MATCH_DIGIT()) {
- return (false);
+ return false;
}
ADVANCE();
st->last_port_start = start;
st->last_port_len = GETP() - start;
- return (true);
+ return true;
}
static bool
rule_addr_char(isc_proxy_addrs_parser_state_t *st) {
if (MATCH('#') || MATCH('-') || MATCH('\0')) {
- return (false);
+ return false;
}
ADVANCE();
- return (true);
+ return true;
}
#undef GETP
* We are not interested in the option value in that
* case
*/
- return (true);
+ return true;
}
if (value == NULL || *value == '\0') {
lookup->proxy_local = true;
- return (true);
+ return true;
}
if (!parse_proxy_addresses(value, &lookup->proxy_src_addr,
&lookup->proxy_dst_addr))
{
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static bool
default:
goto invalid_option;
}
- return (true);
+ return true;
invalid_option:
- return (false);
+ return false;
}
static bool
goto invalid_option;
}
- return (true);
+ return true;
invalid_option:
- return (false);
+ return false;
}
/*%
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':
batchname = 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, 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, &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,
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",
result = isc_getaddresses(host, myport, sockaddr, 1, &count);
isc_loopmgr_nonblocking(loopmgr);
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;
}
/*%
}
resetlocale(LC_ALL);
if (res != IDN2_OK) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
*/
dstlen = strlen(dst);
if (isc_buffer_length(buffer) < start + dstlen) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_subtract(buffer, srclen);
memmove(isc_buffer_used(buffer), dst, dstlen);
isc_buffer_add(buffer, dstlen);
idn2_free(dst);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
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;
}
ISC_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();
- 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;
}
}
cancel_all();
destroy_libs();
- 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_cput(mctx, algo, nkey, sizeof(algo[0]));
- return (ok);
+ return ok;
}
/*
}
isc_mem_cput(mctx, algo, nkey, sizeof(algo[0]));
- 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_cput(mctx, ds, n, sizeof(dns_rdata_ds_t));
isc_mem_cput(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;
}
if (t > 0 && t > start && t < end) {
r = t;
}
- return (r);
+ return r;
}
static void
dns_dnsseckey_t **key1 = (dns_dnsseckey_t **)k1;
dns_dnsseckey_t **key2 = (dns_dnsseckey_t **)k2;
if (dst_key_alg((*key1)->key) < dst_key_alg((*key2)->key)) {
- return (-1);
+ return -1;
} else if (dst_key_alg((*key1)->key) > dst_key_alg((*key2)->key)) {
- return (1);
+ return 1;
} else if (dst_key_id((*key1)->key) < dst_key_id((*key2)->key)) {
- return (-1);
+ return -1;
} else if (dst_key_id((*key1)->key) > dst_key_id((*key2)->key)) {
- return (1);
+ return 1;
}
- return (0);
+ return 0;
}
static void
namestr, algstr, timestr);
}
- return (next_bundle);
+ return next_bundle;
}
static isc_stdtime_t
print_rdata(&rrsigset);
freerrset(&rrsigset);
- return (next_bundle);
+ return next_bundle;
}
/*
dns_rdatalist_tordataset(cdnskeylist, cdnskeyset);
dns_rdatalist_tordataset(cdslist, cdsset);
- return (next_bundle);
+ return next_bundle;
fail:
fatal("failed to create KSK/CDS/CDNSKEY");
- return (0);
+ return 0;
}
static void
isc_buffer_add(&b, strlen(owner));
ret = dns_name_fromtext(dname, &b, dns_rootname, 0, NULL);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
if (dns_name_compare(dname, name) != 0) {
- return (DNS_R_BADOWNERNAME);
+ return DNS_R_BADOWNERNAME;
}
isc_buffer_clear(&b);
cleanup:
isc_lex_setcomments(lex, 0);
- return (ret);
+ return ret;
}
static void
}
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_LIST_APPEND(keylist, key, link);
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;
}
/*%
}
isc_mutex_destroy(&namelock);
- return (vresult == ISC_R_SUCCESS ? 0 : 1);
+ return vresult == ISC_R_SUCCESS ? 0 : 1;
}
}
isc_mem_destroy(&mctx);
- 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 (isnone(str)) {
SET_IF_NOT_NULL(setp, false);
- return ((isc_stdtime_t)0);
+ return (isc_stdtime_t)0;
}
SET_IF_NOT_NULL(setp, true);
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;
}
r.base = UNCONST(str);
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;
}
/*
if (id < min || id > max) {
fprintf(stderr, "Key ID %d outside of [%u..%u]\n", id,
min, max);
- return (true);
+ return true;
}
if (rid < min || rid > max) {
fprintf(stderr,
"Revoked Key ID %d (for tag %d) outside of "
"[%u..%u]\n",
rid, id, min, max);
- return (true);
+ return true;
}
}
result = dns_dnssec_findmatchingkeys(name, NULL, dir, NULL, 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;
}
void
rdatalist->ttl = ttl;
ISC_LIST_APPEND(node->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(node->buffers, rdatabuf, link);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_constregion_t r = { .base = type, .length = strlen(type) };
result = dns_rdatatype_fromtext(&typeval, (isc_textregion_t *)&r);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_lex_create(mctx, 64, &lex);
result = isc_lex_openbuffer(lex, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_buffer_allocate(mctx, &rb, DNS_RDATA_MAXLENGTH);
isc_buffer_free(&rb);
- return (result);
+ return result;
}
/* Reasonable default SOA values */
serial, DEFAULT_REFRESH, DEFAULT_RETRY, DEFAULT_EXPIRE,
DEFAULT_MINIMUM);
if (n >= (int)sizeof(str) || n < 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
- return (putrr(node, "SOA", DEFAULT_TTL, str));
+ return putrr(node, "SOA", DEFAULT_TTL, str);
}
static isc_result_t
}
buf[0] = len;
memmove(&buf[1], text, len);
- return (putrdata(node, dns_rdatatype_txt, 0, buf, len + 1));
+ return putrdata(node, dns_rdatatype_txt, 0, buf, len + 1);
}
/*
}
}
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 (putrdata(node, dns_rdatatype_ptr, 3600, ipv4only,
- sizeof(ipv4only)));
+ return putrdata(node, dns_rdatatype_ptr, 3600, ipv4only,
+ sizeof(ipv4only));
}
- return (putrdata(node, dns_rdatatype_cname, 600, rdata,
- (unsigned int)len));
+ return putrdata(node, dns_rdatatype_cname, 600, rdata,
+ (unsigned int)len);
}
static isc_result_t
builtin_lookup(bdb_t *bdb, const dns_name_t *name, bdbnode_t *node) {
if (name->labels == 0 && name->length == 0) {
- return (bdb->lookup(node));
+ return bdb->lookup(node);
} else if ((node->bdb->implementation->flags & BDB_DNS64) != 0) {
- return (dns64_cname(&bdb->common.origin, name, node));
+ return dns64_cname(&bdb->common.origin, name, node);
} else {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
}
result = putsoa(node, server, contact, 0);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
result = putrr(node, "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
version_lookup(bdbnode_t *node) {
if (named_g_server->version_set) {
if (named_g_server->version == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (puttxt(node, named_g_server->version));
+ return puttxt(node, named_g_server->version);
}
} else {
- return (puttxt(node, PACKAGE_VERSION));
+ return puttxt(node, PACKAGE_VERSION);
}
}
hostname_lookup(bdbnode_t *node) {
if (named_g_server->hostname_set) {
if (named_g_server->hostname == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (puttxt(node, named_g_server->hostname));
+ return puttxt(node, named_g_server->hostname);
}
} else {
char buf[256];
if (gethostname(buf, sizeof(buf)) != 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
- return (puttxt(node, buf));
+ return puttxt(node, 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 = puttxt(node, *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 (puttxt(node, buf));
+ return puttxt(node, buf);
} else if (named_g_server->sctx->server_id != NULL) {
- return (puttxt(node, named_g_server->sctx->server_id));
+ return puttxt(node, named_g_server->sctx->server_id);
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
empty_lookup(bdbnode_t *node) {
UNUSED(node);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
for (int i = 0; i < 2; i++) {
result = putrdata(node, 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 = putrdata(node, dns_rdatatype_ptr, 3600, ipv4only,
sizeof(ipv4only));
- return (result);
+ return result;
}
/*
bdbnode_t *bdbnode = (bdbnode_t *)iterator->node;
if (ISC_LIST_EMPTY(bdbnode->lists)) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
bdbiterator->current = ISC_LIST_HEAD(bdbnode->lists);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
bdbiterator->current = ISC_LIST_NEXT(bdbiterator->current, link);
if (bdbiterator->current == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
} else {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
node->magic = BDBNODE_MAGIC;
*nodep = node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
result = createnode(bdb, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = builtin_lookup(bdb, name, node);
if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND) {
destroynode(node);
- return (result);
+ return result;
}
result = builtin_authority(bdb, node);
if (result != ISC_R_SUCCESS) {
destroynode(node);
- return (result);
+ return result;
}
*nodep = (dns_dbnode_t *)node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
result = createnode(bdb, &node);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = builtin_lookup(bdb, name, node);
if (result != ISC_R_SUCCESS && (!isorigin || result != ISC_R_NOTFOUND))
{
destroynode(node);
- return (result);
+ return result;
}
if (isorigin) {
result = builtin_authority(bdb, node);
if (result != ISC_R_SUCCESS) {
destroynode(node);
- return (result);
+ return result;
}
}
*nodep = (dns_dbnode_t *)node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(version == NULL || version == (dns_dbversion_t *)&dummy);
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 DNS__DB_FLARG_PASS);
}
- return (result);
+ return result;
}
static void
UNUSED(sigrdataset);
if (type == dns_rdatatype_rrsig) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
list = ISC_LIST_HEAD(bdbnode->lists);
list = ISC_LIST_NEXT(list, link);
}
if (list == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
new_rdataset(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 dns_dbmethods_t bdb_methods = {
REQUIRE(implementation != NULL);
if (type != dns_dbtype_zone) {
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
bdb = isc_mem_get(mctx, sizeof(*bdb));
*dbp = (dns_db_t *)bdb;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_name_free(&bdb->common.origin, mctx);
}
isc_mem_putanddetach(&bdb->common.mctx, bdb, sizeof(bdb_t));
- return (result);
+ return result;
}
/*
result = dns_db_register("_builtin", create, &builtin, named_g_mctx,
&builtin.dbimp);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_register("_dns64", create, &dns64, named_g_mctx,
&dns64.dbimp);
if (result != ISC_R_SUCCESS) {
dns_db_unregister(&builtin.dbimp);
- return (result);
+ return result;
}
- 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 | CFG_PCTX_NOOBSOLETE |
- CFG_PCTX_NOEXPERIMENTAL,
- conf));
+ return cfg_parse_buffer(parser, &b, __FILE__, 0, &cfg_type_namedconf,
+ CFG_PCTX_NODEPRECATED | CFG_PCTX_NOOBSOLETE |
+ CFG_PCTX_NOEXPERIMENTAL,
+ 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;
}
r.base = UNCONST(cfg_obj_asstring(classobj));
r.length = strlen(r.base);
cfg_obj_log(classobj, 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;
}
r.base = UNCONST(cfg_obj_asstring(typeobj));
r.length = strlen(r.base);
cfg_obj_log(typeobj, ISC_LOG_ERROR, "unknown type '%s'",
r.base);
}
- return (result);
+ return result;
}
dns_zonetype_t
} else {
UNREACHABLE();
}
- return (ztype);
+ return ztype;
}
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);
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_cput(mctx, stack, stackcount, sizeof(stack[0]));
}
- return (result);
+ return result;
}
isc_result_t
if (cfg_obj_asuint32(portobj) >= UINT16_MAX) {
cfg_obj_log(portobj, 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 {
}
}
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;
}
SET_IF_NOT_NULL(typep, algorithms[i].type);
SET_IF_NOT_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;
}
isc_lex_create(named_g_mctx, strlen(cmdline), &lex);
isc_lex_destroy(&lex);
}
- return (result);
+ return result;
}
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
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, &pctx));
if (pctx != NULL) {
cfg_parser_destroy(&pctx);
}
- return (result);
+ return result;
}
/*
cfg_obj_log(controls, ISC_LOG_ERROR,
"UNIX domain sockets are not "
"supported");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
(void)cfg_map_get(controls, "inet", &inetcontrols);
* 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_loopmgr_shutdown(named_g_loopmgr);
- return (NULL);
+ return NULL;
}
raise(SIGSTOP);
goto next;
named_server_flushonshutdown(named_g_server, false);
isc_loopmgr_shutdown(named_g_loopmgr);
- return (NULL);
+ return NULL;
}
/*
named_server_flushonshutdown(named_g_server,
false);
isc_loopmgr_shutdown(named_g_loopmgr);
- 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_loopmgr_shutdown(named_g_loopmgr);
- return (NULL);
+ return NULL;
}
#endif /* ENABLE_AFL */
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_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
ISC_LOG_INFO, "opened GeoIP2 database '%s'",
pathbuf);
- return (mmdb);
+ return mmdb;
}
isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
"unable to open GeoIP2 database '%s' (status %d)",
pathbuf, ret);
- return (NULL);
+ return NULL;
}
#endif /* HAVE_GEOIP2 */
named_g_logging = true;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
rcu_read_unlock();
- return (result);
+ return result;
}
void
}
cleanup:
- return (result);
+ return result;
}
isc_result_t
result = isc_log_usechannel(lcfg, "null", NAMED_LOGCATEGORY_UNMATCHED,
ISC_LOGMODULE_DEFAULT);
- return (result);
+ return result;
}
/*
* 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;
}
destinations = cfg_tuple_get(ccat, "destinations");
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 {
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
named_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;
}
FILE *
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
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, 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, actx, mctx, 3, aclp);
- return (result);
+ return result;
}
static isc_result_t
/*
* No value available. *ntp == 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;
}
}
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_nametree_detach(ntp);
- 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:
cfg_obj_log(key, ISC_LOG_WARNING, "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
cfg_obj_log(key, ISC_LOG_ERROR, "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) {
}
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_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
ISC_LOG_ERROR,
"could not get query source dispatcher (%s): %s",
buf, isc_result_totext(result));
- 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 void
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;
}
static isc_result_t
cfg_obj_log(obj, DNS_RPZ_ERROR_LEVEL, "invalid %s '%s'", msg,
str);
}
- return (result);
+ return result;
}
static isc_result_t
if (result != ISC_R_SUCCESS) {
cfg_obj_log(obj, DNS_RPZ_ERROR_LEVEL, "invalid zone '%s'", str);
}
- return (result);
+ return result;
}
static isc_result_t
cfg_obj_log(rpz_obj, 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, 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, DNS_RPZ_ERROR_LEVEL,
"invalid zone name '%s'", str);
- return (DNS_R_EMPTYLABEL);
+ return DNS_R_EMPTYLABEL;
}
for (rpz_num = 0; rpz_num < view->rpzs->p.num_zones - 1; ++rpz_num) {
if (dns_name_equal(&view->rpzs->zones[rpz_num]->origin,
cfg_obj_log(rpz_obj, DNS_RPZ_ERROR_LEVEL,
"duplicate '%s'", str);
result = DNS_R_DUPLICATE;
- return (result);
+ return result;
}
}
if (*old_rpz_okp && !dns_name_equal(&old->origin, &zone->origin)) {
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;
result = dns_rpz_new_zones(view, named_g_loopmgr, &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
isc_async_run(named_g_mainloop, action, cz);
- 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,
void *udata) {
- return (catz_run(entry, origin, view, udata, CATZ_ADDZONE));
+ return catz_run(entry, origin, view, udata, CATZ_ADDZONE);
}
static isc_result_t
catz_delzone(dns_catz_entry_t *entry, dns_catz_zone_t *origin, dns_view_t *view,
void *udata) {
- return (catz_run(entry, origin, view, udata, CATZ_DELZONE));
+ return catz_run(entry, origin, view, udata, CATZ_DELZONE);
}
static isc_result_t
catz_modzone(dns_catz_entry_t *entry, dns_catz_zone_t *origin, dns_view_t *view,
void *udata) {
- return (catz_run(entry, origin, view, udata, CATZ_MODZONE));
+ return catz_run(entry, origin, view, udata, CATZ_MODZONE);
}
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;
}
if (pview != NULL) {
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 */
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 };
dns_dyndb_destroyctx(&dctx);
}
- return (result);
+ return result;
}
static isc_result_t
dns_db_detach(&db);
}
- return (result);
+ return result;
}
static isc_result_t
if (val > UINT16_MAX) {
cfg_obj_log(portobj, ISC_LOG_ERROR,
"port '%u' out of range", val);
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
port = (in_port_t)val;
}
cfg_obj_log(portobj, 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
if (result != ISC_R_SUCCESS) {
cfg_obj_log(obj, ISC_LOG_ERROR, "'%s' is not a valid name",
str);
- return (result);
+ return result;
}
if (strcasecmp(str, "ephemeral") != 0) {
if (tlsmap == NULL) {
cfg_obj_log(obj, ISC_LOG_ERROR,
"tls '%s' is not defined", str);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
dns_name_dup(nm, view->mctx, *name);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
if (val > UINT16_MAX) {
cfg_obj_log(portobj, ISC_LOG_ERROR,
"port '%u' out of range", val);
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
port = tls_port = (in_port_t)val;
}
result = validate_tls(config, view, tlspobj,
tls, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
}
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, named_g_dispatchmgr, 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, vconfig,
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_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, ISC_LOG_ERROR,
"change directory to '%s' failed: %s", directory,
isc_result_totext(result));
- return (result);
+ return result;
}
char cwd[PATH_MAX];
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 int)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 int)m > r.length) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
isc_textregion_consume(&r, m);
}
- return (dns_name_fromstring(target, label, keyname, 0, NULL));
+ return dns_name_fromstring(target, label, keyname, 0, NULL);
}
static void
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
result = dst_key_generate(keyname, alg, bits, 1, 0, DNS_KEYPROTO_ANY,
dns_rdataclass_in, NULL, mctx, &key, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
}
*keyp = key;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
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;
}
static isc_result_t
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_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, ISC_LOG_ERROR,
"'lmdb-mapsize "
"%" PRId64 "' "
"is too large",
mapsize);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
#else /* ifdef HAVE_LMDB */
if (!allow) {
dns_view_setnewzones(view, false, NULL, NULL, 0ULL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
nzcfg = isc_mem_get(view->mctx, sizeof(*nzcfg));
cfg_parser_destroy(&nzcfg->conf_parser);
isc_mem_putanddetach(&nzcfg->mctx, nzcfg, sizeof(*nzcfg));
dns_view_setnewzones(view, false, NULL, NULL, 0ULL);
- return (result);
+ return result;
}
cfg_obj_attach(config, &nzcfg->config);
}
result = load_nzf(view, nzcfg);
- 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_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
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, dns_view_t *view,
cfg_aclconfctx_t *actx) {
- return (configure_zone(
+ return configure_zone(
config, zconfig, vconfig, view, &named_g_server->viewlist,
&named_g_server->kasplist, &named_g_server->keystorelist, actx,
- true, false, false, false));
+ 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_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
UNLOCK(&view->new_zone_lock);
- return (result);
+ return result;
}
static isc_result_t
isc_buffer_free(&text);
}
- return (result);
+ return result;
}
#endif /* HAVE_LMDB */
ISC_LOG_DEBUG(1), "load_configuration: %s",
isc_result_totext(result));
- return (result);
+ return result;
}
static isc_result_t
ISC_LOG_NOTICE, "running");
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_loopmgr_resume(named_g_loopmgr);
- 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;
}
static void
if (view == NULL || rdclass == view->rdclass ||
rdclass == dns_rdataclass_any)
{
- return (view);
+ return view;
}
view = ISC_LIST_NEXT(view, link);
};
if (loop == NULL) {
*viewmatchresult = get_matching_view_sync(
srcaddr, destaddr, message, env, sigresult, viewp);
- return (*viewmatchresult);
+ return *viewmatchresult;
}
/* Also no offloading when there is no view at all to match against. */
view = get_matching_view_next(NULL, message->rdclass);
if (view == NULL) {
*viewmatchresult = ISC_R_NOTFOUND;
- return (*viewmatchresult);
+ return *viewmatchresult;
}
dns_message_resetsig(message);
{
*mvctx->viewmatchresult = ISC_R_QUOTA;
isc_async_run(loop, get_matching_view_done, mvctx);
- return (DNS_R_WAIT);
+ return DNS_R_WAIT;
}
}
get_matching_view_continue, mvctx);
INSIST(result == DNS_R_WAIT);
- return (DNS_R_WAIT);
+ return DNS_R_WAIT;
}
void
atomic_store(&server->reload_status, NAMED_RELOAD_FAILED);
}
- return (result);
+ return result;
}
static isc_result_t
"STATUS=reload command finished: %s\n",
isc_result_totext(result));
#endif /* HAVE_LIBSYSTEMD */
- 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, arg, &zone, NULL, text, false);
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;
}
/*
"STATUS=reconfig command finished: %s\n",
isc_result_totext(result));
#endif /* HAVE_LIBSYSTEMD */
- 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, option);
{
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, option, value);
isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
ISC_LOG_INFO, "%s is now %s", optname,
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, 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, 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);
}
actx, mctx, family, &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 */
ISC_LOG_ERROR, "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_view_apply(view, 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 */
ISC_LOG_ERROR, "dumpsecroots failed: %s",
isc_result_totext(result));
}
- return (result);
+ return result;
}
isc_result_t
ISC_LOG_ERROR, "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_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_loopmgr_resume(named_g_loopmgr);
- 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_loopmgr_resume(named_g_loopmgr);
- 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_loopmgr_resume(named_g_loopmgr);
- 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;
}
/*
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) {
ISC_LOG_INFO, "dumping all zones%s: %s",
cleanup ? ", removing journal files" : "",
isc_result_totext(result));
- return (tresult);
+ return tresult;
}
isc_loopmgr_pause(named_g_loopmgr);
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) {
isc_loopmgr_pause(named_g_loopmgr);
ISC_LOG_INFO, "%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;
}
isc_loopmgr_pause(named_g_loopmgr);
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;
}
static isc_result_t
/* The new zone file may not exist. That is OK. */
if (!isc_file_exists(view->new_zone_file)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
view->new_zone_file, isc_result_totext(result));
}
- return (result);
+ return result;
}
#else /* HAVE_LMDB */
isc_buffer_free(&text);
}
- return (result);
+ return result;
}
/*
isc_log_write(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;
}
/*
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
cleanup:
isc_loopmgr_resume(named_g_loopmgr);
- 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;
}
isc_result_t
/* Skip the command name. */
ptr = next_token(lex, text);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
/* Look for the view name. */
(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;
}
/* 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, "-import") != 0) {
ptr = next_token(lex, NULL);
if (ptr == NULL) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
(void)snprintf(skrfile, sizeof(skrfile), "%s", ptr);
dns_zone_detach(&zone);
}
- 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 */
}
INSIST(0 < len && (size_t)len < space);
used += len + 1;
- return (desc);
+ return desc;
}
static void
memset(values, 0, sizeof(values[0]) * ncounters);
isc_stats_dump(stats, generalstat_dump, &dumparg, options);
- return (dump_counters(type, arg, category, desc, ncounters, indices,
- values, options));
+ return dump_counters(type, arg, category, desc, ncounters, indices,
+ values, options);
}
#if defined(EXTENDED_STATS)
}
isc_histo_destroy(&hg);
- return (dump_counters(type, arg, category, desc, ncounters, indices,
- values, options));
+ return dump_counters(type, arg, category, desc, ncounters, indices,
+ values, options);
}
#endif /* defined(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_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_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
ISC_LOG_ERROR, "Failed at zone_xmlrender()");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
static isc_result_t
statlevel = dns_zone_getstatlevel(zone);
if (statlevel == dns_zonestat_none) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (dns_zone_getxfr(zone, &xfr, &is_firstrefresh, &is_running,
* (if any), but we still want to continue generating the
* remaining parts of the output.
*/
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (!is_running && !is_deferred && !is_presoa && !is_pending &&
dns_xfrin_detach(&xfr);
}
/* No ongoing/queued transfer. */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (is_running && xfr == NULL) {
/* The transfer is finished, and it's shutting down. */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "xfrin"));
dns_xfrin_detach(&xfr);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (xfr != NULL) {
isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
ISC_LOG_ERROR, "Failed at xfrin_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_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
if (doc != NULL) {
xmlFreeDoc(doc);
}
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
static void
ISC_LOG_ERROR, "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
isc_httpdfree_t **freecb, void **freecb_args) {
UNUSED(httpd);
UNUSED(urlinfo);
- return (render_xml(STATS_XML_XFRINS, arg, retcode, retmsg, mimetype, b,
- freecb, freecb_args));
+ return render_xml(STATS_XML_XFRINS, 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
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
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 (xfrinobj != NULL) {
json_object_put(xfrinobj);
}
- 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
ISC_LOG_ERROR, "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_XFRINS, arg, retcode, retmsg, mimetype,
- b, freecb, freecb_args));
+ return render_json(STATS_JSON_XFRINS, 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_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);
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;
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, 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, 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:
if (secret != NULL) {
}
cfg_obj_log(key, ISC_LOG_ERROR, "configuring key '%s': %s", keyid,
isc_result_totext(ret));
- return (ret);
+ return ret;
}
isc_result_t
}
*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, 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:
isc_buffer_clearmctx(&dbuf);
dns_ssutable_detach(&table);
- return (result);
+ return result;
}
/*
cfg_obj_log(zconfig, 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, 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
if (res != ISC_R_SUCCESS ||
strcmp(cfg_obj_asstring(policy), "none") == 0)
{
- return (false);
+ return false;
}
/* Lookup the policy. */
res = dns_kasplist_find(kasplist, cfg_obj_asstring(policy), &kasp);
if (res != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
inline_signing = dns_kasp_inlinesigning(kasp);
*/
res = cfg_map_get(maps[0], "inline-signing", &signing);
if (res == ISC_R_SUCCESS && cfg_obj_isboolean(signing)) {
- return (cfg_obj_asboolean(signing));
+ return 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, &pctx);
isc_mem_free(mctx, keystr);
}
- return (result);
+ return result;
}
static void
isc_buffer_add(&namesrc, strlen(str));
isc_buffer_init(&namebuf, namedata, len);
- return (dns_name_fromtext(name, &namesrc, dns_rootname,
- DNS_NAME_DOWNCASE, &namebuf));
+ return dns_name_fromtext(name, &namesrc, dns_rootname,
+ DNS_NAME_DOWNCASE, &namebuf);
}
static void
error("couldn't get address for '%s': %s", host,
isc_result_totext(result));
}
- return (count);
+ return count;
}
#define PARSE_ARGS_FMT "46A:C:dDE:ghH:iK:lL:MoOk:p:Pr:R:St:Tu:vVy:"
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;
}
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 void
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")) {
keylease = 0;
keylease_set = false;
updateopt();
- return (STATUS_MORE);
+ return STATUS_MORE;
}
result = isc_parse_uint32(&value1, word, 10);
if (result != ISC_R_SUCCESS) {
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
word = nsu_strsep(&cmdline, " \t\r\n");
keylease = 0;
keylease_set = false;
updateopt();
- return (STATUS_MORE);
+ return STATUS_MORE;
}
result = isc_parse_uint32(&value2, word, 10);
if (result != ISC_R_SUCCESS) {
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
lease = value1;
keylease_set = true;
updateopt();
- return (STATUS_MORE);
+ return STATUS_MORE;
}
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;
}
}
servers = isc_mem_cget(gmctx, 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(namestr, n - namestr, &hmac_alg, &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;
}
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 uint16_t
word = nsu_strsep(&cmdline, " \t\r\n");
if (word == NULL || *word == 0) {
fprintf(stderr, "could not read check-svcb directive\n");
- return (STATUS_SYNTAX);
+ return STATUS_SYNTAX;
}
if (strcasecmp(word, "yes") == 0 || strcasecmp(word, "true") == 0 ||
strcasecmp(word, "on") == 0)
checksvcb = false;
} else {
fprintf(stderr, "incorrect check-svcb 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, "lease") == 0) {
- return (evaluate_lease(cmdline));
+ return evaluate_lease(cmdline);
}
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, "check-svcb") == 0 ||
strcasecmp(word, "checksvcb") == 0)
{
- return (evaluate_checksvcb(cmdline));
+ return evaluate_checksvcb(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
cleanup();
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,
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,
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_managers_destroy(&rndc_mctx, &loopmgr, &netmgr);
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;
}
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_newversion(sampledb->db, versionp));
+ return dns_db_newversion(sampledb->db, versionp);
}
static void
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns__db_findnode(sampledb->db, name, create,
- nodep DNS__DB_FLARG_PASS));
+ return dns__db_findnode(sampledb->db, name, create,
+ nodep DNS__DB_FLARG_PASS);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns__db_find(sampledb->db, name, version, type, options, now,
- nodep, foundname, rdataset,
- sigrdataset DNS__DB_FLARG_PASS));
+ return dns__db_find(sampledb->db, name, version, type, options, now,
+ nodep, foundname, rdataset,
+ sigrdataset DNS__DB_FLARG_PASS);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns__db_findzonecut(sampledb->db, name, options, now, nodep,
- foundname, dcname, rdataset,
- sigrdataset DNS__DB_FLARG_PASS));
+ return dns__db_findzonecut(sampledb->db, name, options, now, nodep,
+ foundname, dcname, rdataset,
+ sigrdataset DNS__DB_FLARG_PASS);
}
static void
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_createiterator(sampledb->db, options, iteratorp));
+ return dns_db_createiterator(sampledb->db, options, iteratorp);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns__db_findrdataset(sampledb->db, node, version, type, covers,
- now, rdataset,
- sigrdataset DNS__DB_FLARG_PASS));
+ return dns__db_findrdataset(sampledb->db, node, version, type, covers,
+ now, rdataset,
+ sigrdataset DNS__DB_FLARG_PASS);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns__db_allrdatasets(sampledb->db, node, version, options, now,
- iteratorp DNS__DB_FLARG_PASS));
+ return dns__db_allrdatasets(sampledb->db, node, version, options, now,
+ iteratorp DNS__DB_FLARG_PASS);
}
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->db, node, version, type,
- covers DNS__DB_FLARG_PASS));
+ return dns__db_deleterdataset(sampledb->db, node, version, type,
+ covers DNS__DB_FLARG_PASS);
}
static bool
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_issecure(sampledb->db));
+ return dns_db_issecure(sampledb->db);
}
static unsigned int
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_nodecount(sampledb->db, tree));
+ return dns_db_nodecount(sampledb->db, tree);
}
static void
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns__db_getoriginnode(sampledb->db, nodep DNS__DB_FLARG_PASS));
+ return dns__db_getoriginnode(sampledb->db, nodep DNS__DB_FLARG_PASS);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_getnsec3parameters(sampledb->db, version, hash, flags,
- iterations, salt, salt_length));
+ return dns_db_getnsec3parameters(sampledb->db, version, hash, flags,
+ iterations, salt, salt_length);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns__db_findnsec3node(sampledb->db, name, create,
- nodep DNS__DB_FLARG_PASS));
+ return dns__db_findnsec3node(sampledb->db, name, create,
+ nodep DNS__DB_FLARG_PASS);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_setsigningtime(sampledb->db, rdataset, resign));
+ return dns_db_setsigningtime(sampledb->db, rdataset, resign);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_getsigningtime(sampledb->db, resign, name, type));
+ return dns_db_getsigningtime(sampledb->db, resign, name, type);
}
static dns_stats_t *
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_getrrsetstats(sampledb->db));
+ return dns_db_getrrsetstats(sampledb->db);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns__db_findnodeext(sampledb->db, name, create, methods,
- clientinfo, nodep DNS__DB_FLARG_PASS));
+ return dns__db_findnodeext(sampledb->db, name, create, methods,
+ clientinfo, nodep DNS__DB_FLARG_PASS);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns__db_findext(sampledb->db, name, version, type, options, now,
- nodep, foundname, methods, clientinfo, rdataset,
- sigrdataset DNS__DB_FLARG_PASS));
+ return dns__db_findext(sampledb->db, name, version, type, options, now,
+ nodep, foundname, methods, clientinfo, rdataset,
+ sigrdataset DNS__DB_FLARG_PASS);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_setcachestats(sampledb->db, stats));
+ return dns_db_setcachestats(sampledb->db, stats);
}
static isc_result_t
REQUIRE(VALID_SAMPLEDB(sampledb));
- return (dns_db_nodefullname(sampledb->db, node, name));
+ return dns_db_nodefullname(sampledb->db, node, name);
}
/*
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 (dns_name_dynamic(&sampledb->common.origin)) {
isc_mem_putanddetach(&sampledb->common.mctx, sampledb,
sizeof(*sampledb));
- return (result);
+ return result;
}
isc_mem_cput(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_mem_put(mctx, syncptr, sizeof(*syncptr));
}
- 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;
}
/*
dns_view_freeze(inst->view);
}
- 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-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 */
}
if (fips != NULL) {
OSSL_PROVIDER_unload(fips);
}
- return (fips != NULL ? 0 : 1);
+ return fips != NULL ? 0 : 1;
#else
- return (1);
+ return 1;
#endif
}
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-fips-dh") == 0) {
#if defined(ENABLE_FIPS_MODE)
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
- return (0);
+ return 0;
#else
- return (1);
+ return 1;
#endif
#else
if (isc_fips_mode()) {
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
- return (0);
+ return 0;
#else
- return (1);
+ return 1;
#endif
}
- return (0);
+ return 0;
#endif
}
if (strcmp(argv[1], "--have-fips-mode") == 0) {
#if defined(ENABLE_FIPS_MODE)
- return (0);
+ return 0;
#else
- return (isc_fips_mode() ? 0 : 1);
+ return isc_fips_mode() ? 0 : 1;
#endif
}
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 (strcmp(argv[1], "--md5") == 0) {
if (!dst_algorithm_supported(DST_ALG_HMACMD5)) {
- return (1);
+ return 1;
}
- return (0);
+ return 0;
}
if (strcmp(argv[1], "--ipv6only=no") == 0) {
(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 (strcasecmp(argv[1], "--rsasha1") == 0) {
if (!dst_algorithm_supported(DST_ALG_RSASHA1)) {
- return (1);
+ return 1;
}
- return (0);
+ return 0;
}
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(mctx);
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_async_run(loop, cb, 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, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_create(mctx, ZONEDB_DEFAULT, 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);
if (result == DNS_R_SEENINCLUDE) {
result = ISC_R_SUCCESS;
}
- 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++;
isc_loop_main(loopmgr), recvresponse, message, &request);
CHECK("dns_request_create", result);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
isc_managers_destroy(&mctx, &loopmgr, &netmgr);
- 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;
}
dst_key_free(&key);
isc_mem_destroy(&mctx);
- return (0);
+ return 0;
}
/*! \file */
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;
}
static void
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_managers_destroy(&mctx, &loopmgr, &netmgr);
- return (0);
+ return 0;
}
}
}
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;
}
cd->record = UNCONST(name);
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;
}
cd->zone = UNCONST(p);
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
dns_dbtype_zone, dns_rdataclass_in, 0, NULL,
&db);
if (result != ISC_R_SUCCESS) {
- return (0);
+ return 0;
}
result = dns_db_beginload(db, &callbacks);
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, "dns_view_create failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
dns_tsigkeyring_create(mctx, &ring);
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, DST_ALG_HMACSHA256, secret,
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_tsigkey_create failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
result = dns_tsigkeyring_add(ring, tsigkey);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_tsigkeyring_add failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
result = dns_name_fromstring(name, "sig0key", dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_name_fromstring failed: %s\n",
isc_result_totext(result));
- return (1);
+ return 1;
}
dns_zone_create(&zone, mctx, 0);
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_zone_setview(zone, 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 = 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 ISC_ATTR_UNUSED, char ***argv ISC_ATTR_UNUSED) {
- return (0);
+ return 0;
}
int
fprintf(stderr, "dns_name_fromtext: %s\n",
isc_result_totext(result));
}
- return (0);
+ return 0;
}
int
LLVMFuzzerInitialize(int *argc ISC_ATTR_UNUSED, char ***argv ISC_ATTR_UNUSED) {
- return (0);
+ return 0;
}
int
REQUIRE(new_buf.used == old_buf.used);
REQUIRE(new_buf.length == old_buf.length);
- return (0);
+ return 0;
}
assert(ctx == NULL);
assert(pval == &item[ival]);
memmove(key, item[ival].key, item[ival].len);
- return (item[ival].len);
+ return item[ival].len;
}
static void
static uint8_t
random_byte(void) {
- return (isc_random_uniform(SHIFT_OFFSET - SHIFT_NOBYTE) + SHIFT_NOBYTE);
+ return isc_random_uniform(SHIFT_OFFSET - SHIFT_NOBYTE) + SHIFT_NOBYTE;
}
int
qp_test_keytoascii(item[i].ascii, len);
}
- return (0);
+ return 0;
}
int
assert(item[i].refcount == 0);
}
- return (0);
+ return 0;
}
LLVMFuzzerInitialize(int *argc, char ***argv) {
UNUSED(argc);
UNUSED(argv);
- return (0);
+ return 0;
}
int
assert((namerel == 0) == (keyrel == 0));
assert((namerel > 0) == (keyrel > 0));
- 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;
}
isc_mem_create(&mctx);
isc_lex_create(mctx, 1024, &lex);
- 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;
}
isc_mem_create(&mctx);
isc_lex_create(mctx, 1024, &lex);
- return (0);
+ return 0;
}
int
result = isc_lex_gettoken(lex, 0, &token);
} while (result == ISC_R_SUCCESS);
- return (0);
+ return 0;
}
ret = LLVMFuzzerInitialize(&argc, &argv);
if (ret != 0) {
fprintf(stderr, "LLVMFuzzerInitialize failure: %d\n", ret);
- return (1);
+ return 1;
}
if (argv[1] != NULL && strcmp(argv[1], "-d") == 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
LLVMFuzzerInitialize(&argc, &argv);
if (ret != 0) {
fprintf(stderr, "LLVMFuzzerInitialize failure: %d\n", ret);
- return (1);
+ return 1;
}
#ifdef __AFL_LOOP
#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 */
* 14-bit compression pointer
*/
if (!dns_decompress_getpermitted(dctx)) {
- return (DNS_R_DISALLOWED);
+ return DNS_R_DISALLOWED;
}
new_current = c & 0x3F;
state = fw_newcurrent;
} else {
- return (DNS_R_BADLABELTYPE);
+ return DNS_R_BADLABELTYPE;
}
break;
case fw_ordinary:
new_current *= 256;
new_current += c;
if (new_current >= biggest_pointer) {
- return (DNS_R_BADPOINTER);
+ return DNS_R_BADPOINTER;
}
biggest_pointer = new_current;
current = new_current;
}
if (!done) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
name->ndata = (unsigned char *)target->base + target->used;
isc_buffer_forward(source, cused);
isc_buffer_add(target, name->length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
full:
if (nmax == DNS_NAME_MAXWIRE) {
* The name did not fit even though we had a buffer
* big enough to fit a maximum-length name.
*/
- return (DNS_R_NAMETOOLONG);
+ return DNS_R_NAMETOOLONG;
} else {
/*
* The name might fit if only the caller could give us a
* big enough buffer.
*/
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
}
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;
}
rcu_read_lock();
dns_acl_attach(rcu_dereference(env->localhost), &inner);
case dns_aclelementtype_localnets:
if (env == NULL) {
- return (false);
+ return false;
}
rcu_read_lock();
dns_acl_attach(rcu_dereference(env->localnets), &inner);
#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;
}
static 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;
}
/*
ttl = ADB_CACHE_MAXIMUM;
}
- return (ttl);
+ return ttl;
}
/*
UNREACHABLE();
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
match_ptr(void *node, const void *key) {
- return (node == key);
+ return node == key;
}
/*
*/
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;
}
/*
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;
}
/*
dns_name_init(&name->target, NULL);
inc_adbstats(adb, dns_adbstats_namescnt);
- return (name);
+ return name;
}
#if DNS_ADB_TRACE
.magic = DNS_ADBNAMEHOOK_MAGIC,
};
- return (nh);
+ return nh;
}
static void
inc_adbstats(adb, dns_adbstats_entriescnt);
- return (entry);
+ return entry;
}
static void
find->magic = DNS_ADBFIND_MAGIC;
- return (find);
+ return find;
}
static void
fetch->magic = DNS_ADBFETCH_MAGIC;
- return (fetch);
+ return fetch;
}
static void
isc_sockaddr_setport(&ai->sockaddr, port);
- return (ai);
+ return ai;
}
static void
if ((adbname0->flags & ADBNAME_FLAGS_MASK) !=
(adbname1->flags & ADBNAME_FLAGS_MASK))
{
- return (false);
+ return false;
}
- return (dns_name_equal(adbname0->name, adbname1->name));
+ return dns_name_equal(adbname0->name, adbname1->name);
}
static uint32_t
isc_hash32_hash(&hash, adbname->name->ndata, adbname->name->length,
false);
isc_hash32_hash(&hash, &flags, sizeof(flags), true);
- return (isc_hash32_finalize(&hash));
+ return isc_hash32_finalize(&hash);
}
/*
*/
RWUNLOCK(&adb->names_lock, locktype);
- return (adbname);
+ return adbname;
}
static void
match_adbentry(void *node, const void *key) {
dns_adbentry_t *adbentry = node;
- return (isc_sockaddr_equal(&adbentry->sockaddr, key));
+ return isc_sockaddr_equal(&adbentry->sockaddr, key);
}
/*
RWUNLOCK(&adb->entries_lock, locktype);
- return (adbentry);
+ return adbentry;
}
static void
/* Leave this name alone if it still has active namehooks... */
if (NAME_HAS_V4(adbname) || NAME_HAS_V6(adbname)) {
- return (false);
+ return false;
}
/* ...an active fetch in progres... */
if (NAME_FETCH(adbname)) {
- return (false);
+ return false;
}
/* ... or is not yet expired. */
!EXPIRE_OK(adbname->expire_v6, now) ||
!EXPIRE_OK(adbname->expire_target, now))
{
- return (false);
+ return false;
}
expire_name(adbname, DNS_ADB_EXPIRED);
- return (true);
+ return true;
}
static void
static bool
entry_expired(dns_adbentry_t *adbentry, isc_stdtime_t now) {
if (!ISC_LIST_EMPTY(adbentry->nhs)) {
- return (false);
+ return false;
}
if (!EXPIRE_OK(adbentry->expires, now)) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static bool
if (entry_expired(adbentry, now)) {
expire_entry(adbentry);
- return (true);
+ return true;
}
- return (false);
+ return false;
}
/*%
DP(DEF_LEVEL, "dns_adb_createfind: returning "
"ISC_R_SHUTTINGDOWN");
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
if (now == 0) {
UNLOCK(&adbname->lock);
dns_adbname_detach(&adbname);
- return (result);
+ return result;
}
void
dns_adb_findstatus(dns_adbfind_t *find) {
REQUIRE(DNS_ADBFIND_VALID(find));
- return (atomic_load(&find->status));
+ return atomic_load(&find->status);
}
void
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
isc_hashmap_iter_destroy(&it);
RWUNLOCK(&adb->entries_lock, isc_rwlocktype_read);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdataset_disassociate(&rdataset);
}
- return (result);
+ return result;
}
static void
dns_rdataset_disassociate(&rdataset);
}
- return (result);
+ return result;
}
void
size = entry->udpsize;
UNLOCK(&entry->lock);
- return (size);
+ return size;
}
void
unlock:
UNLOCK(&entry->lock);
- return (len);
+ return len;
}
isc_result_t
in_port_t port;
if (atomic_load(&adb->exiting)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
entry = get_attached_and_locked_entry(adb, now, sa);
dns_adbentry_detach(&entry);
- 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;
}
bool
dns_adb_overquota(dns_adb_t *adb ISC_ATTR_UNUSED, dns_adbaddrinfo_t *addrinfo) {
REQUIRE(DNS_ADBADDRINFO_VALID(addrinfo));
- return (adbentry_overquota(addrinfo->entry));
+ return adbentry_overquota(addrinfo->entry);
}
void
dns_adb_getstats(dns_adb_t *adb) {
REQUIRE(DNS_ADB_VALID(adb));
- return (adb->stats);
+ return adb->stats;
}
isc_mem_attach(mctx, &bc->mctx);
- return (bc);
+ return bc;
}
void
const dns_name_t *name = key;
dns_bcentry_t *bad = caa_container_of(ht_node, dns_bcentry_t, ht_node);
- return (dns_name_equal(bad->name, name));
+ return dns_name_equal(bad->name, name);
}
static dns_bcentry_t *
bad->name = dns_fixedname_initname(&bad->fname);
dns_name_copy(name, bad->name);
- return (bad);
+ return bad;
}
static void
static bool
bcentry_alive(struct cds_lfht *ht, dns_bcentry_t *bad, isc_stdtime_t now) {
if (cds_lfht_is_node_deleted(&bad->ht_node)) {
- return (false);
+ return false;
} else if (atomic_load_relaxed(&bad->expire) < now) {
bcentry_evict(ht, bad);
- return (false);
+ return false;
}
- return (true);
+ return true;
}
#define cds_lfht_for_each_entry_next(ht, iter, pos, member) \
rcu_read_unlock();
- return (result);
+ return result;
}
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);
}
*hmctxp = hmctx;
*tmctxp = tmctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_db:
dns_db_detach(&db);
isc_mem_detach(&hmctx);
isc_mem_detach(&tmctx);
- return (result);
+ return result;
}
static void
}
*cachep = cache;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
cache_destroy(cache);
- return (result);
+ return result;
}
static void
dns_cache_getname(dns_cache_t *cache) {
REQUIRE(VALID_CACHE(cache));
- return (cache->name);
+ return cache->name;
}
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;
}
isc_result_t
result = cache_create_db(cache, &db, &tmctx, &hmctx);
if (result != ISC_R_SUCCESS) {
- 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));
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_dup(domain, mctx, &ncoo->name);
isc_refcount_init(&ncoo->references, 1);
- return (ncoo);
+ return ncoo;
}
static void
dns_catz_options_init(&nentry->opts);
isc_refcount_init(&nentry->references, 1);
- return (nentry);
+ return nentry;
}
dns_name_t *
dns_catz_entry_getname(dns_catz_entry_t *entry) {
REQUIRE(DNS_CATZ_ENTRY_VALID(entry));
- return (&entry->name);
+ return &entry->name;
}
dns_catz_entry_t *
dns_catz_options_copy(catz->catzs->mctx, &entry->opts, &nentry->opts);
- return (nentry);
+ return nentry;
}
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;
}
dns_catz_zones_t *
isc_ht_init(&catzs->zones, mctx, 4, ISC_HT_CASE_SENSITIVE);
isc_mem_attach(mctx, &catzs->mctx);
- return (catzs);
+ return catzs;
}
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
dns_name_init(&catz->name, NULL);
dns_name_dup(name, catzs->mctx, &catz->name);
- return (catz);
+ return catz;
}
static void
*catzp = catz;
- 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);
}
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);
for (result = dns_rdata_apl_first(&rdata_apl); result == ISC_R_SUCCESS;
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);
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;
}
}
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
catzs = (dns_catz_zones_t *)fn_arg;
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, dispatchmgr, rdclass,
DNS_CLIENTVIEW_NAME, &view);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/* Initialize view security roots */
&view->cachedb));
*viewp = view;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_view_detach(&view);
- return (result);
+ return result;
}
isc_result_t
*clientp = client;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_references:
isc_refcount_decrementz(&client->references);
cleanup_client:
isc_mem_put(mctx, client, sizeof(*client));
- return (result);
+ return result;
}
static void
result = dns_fwdtable_add(client->view->fwdtable, name_space, addrs,
dns_fwdpolicy_only);
- return (result);
+ return result;
}
void
*rdatasetp = rdataset;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
rctx->client->loop, 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
*transp = (dns_clientrestrans_t *)rctx;
client_resfind(rctx, NULL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
if (rdataset != NULL) {
isc_mem_put(mctx, rctx, sizeof(*rctx));
isc_mem_put(mctx, rev, sizeof(*rev));
- return (result);
+ return result;
}
isc_result_t
resolve_done, resarg, &resarg->trans);
if (result != ISC_R_SUCCESS) {
isc_mem_put(client->mctx, resarg, sizeof(*resarg));
- return (result);
+ return result;
}
- return (result);
+ return result;
}
void
REQUIRE(DNS_CLIENT_VALID(client));
REQUIRE(rdclass == dns_rdataclass_in);
- return (dns_view_addtrustedkey(client->view, rdtype, keyname, databuf));
+ return dns_view_addtrustedkey(client->view, rdtype, keyname, databuf);
}
bool
dns_compress_getpermitted(dns_compress_t *cctx) {
REQUIRE(CCTX_VALID(cctx));
- return ((cctx->flags & DNS_COMPRESS_PERMITTED) != 0);
+ return (cctx->flags & DNS_COMPRESS_PERMITTED) != 0;
}
/*
}
}
- return (isc_hash_bits32(hash, 16));
+ return isc_hash_bits32(hash, 16);
}
static bool
match_wirename(uint8_t *a, uint8_t *b, unsigned int len, bool sensitive) {
if (sensitive) {
- return (memcmp(a, b, len) == 0);
+ return memcmp(a, b, len) == 0;
} else {
/* label lengths are < 'A' so unaffected by tolower() */
- return (isc_ascii_lowerequal(a, b, len));
+ return isc_ascii_lowerequal(a, b, len);
}
}
INSIST(llen <= 64 && llen < slen);
if (blen < new_coff + llen) {
- return (false);
+ return false;
}
blen -= new_coff;
/* does the first label of the suffix appear here? */
if (!match_wirename(bptr, sptr, llen, sensitive)) {
- return (false);
+ return false;
}
/* is this label followed by the previously matched suffix? */
if (old_coff == new_coff + llen) {
- return (true);
+ return true;
}
blen -= llen;
/* are both labels followed by the root label? */
if (blen >= 1 && slen == 1 && bptr[0] == 0 && sptr[0] == 0) {
- return (true);
+ return true;
}
/* is this label followed by a pointer to the previous match? */
if (blen >= 2 && bptr[0] == pptr[0] && bptr[1] == pptr[1]) {
- return (true);
+ return true;
}
/* is this label followed by a copy of the rest of the suffix? */
- return (blen >= slen && match_wirename(bptr, sptr, slen, sensitive));
+ return blen >= slen && match_wirename(bptr, sptr, slen, sensitive);
}
/*
*/
static unsigned int
probe_distance(dns_compress_t *cctx, unsigned int slot) {
- return ((slot - cctx->set[slot].hash) & cctx->mask);
+ return (slot - cctx->set[slot].hash) & cctx->mask;
}
static unsigned int
slot_index(dns_compress_t *cctx, unsigned int hash, unsigned int probe) {
- return ((hash + probe) & cctx->mask);
+ return (hash + probe) & cctx->mask;
}
static bool
unsigned int prefix_len = name->offsets[label];
unsigned int coff = isc_buffer_usedlength(buffer) + prefix_len;
if (coff >= 0x4000 || cctx->count > cctx->mask * 3 / 4) {
- return (false);
+ return false;
}
for (;;) {
unsigned int slot = slot_index(cctx, hash, probe);
cctx->set[slot].hash = hash;
cctx->set[slot].coff = coff;
cctx->count++;
- return (true);
+ return true;
}
/* he steals from the rich and gives to the poor */
if (probe > probe_distance(cctx, slot)) {
imp = ISC_LIST_NEXT(imp, link))
{
if (strcasecmp(name, imp->name) == 0) {
- return (imp);
+ return imp;
}
}
- return (NULL);
+ return NULL;
}
static void
fprintf(stderr, "dns_db_create:%s:%s:%d:%p->references = 1\n",
__func__, __FILE__, __LINE__ + 1, *dbp);
#endif
- return (result);
+ return result;
}
RWUNLOCK(&implock, isc_rwlocktype_read);
isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DB, ISC_LOG_ERROR,
"unsupported database type '%s'", db_type);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
static 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->issecure != NULL) {
- return ((db->methods->issecure)(db));
+ return (db->methods->issecure)(db);
}
- return (false);
+ return false;
}
bool
if (db->methods->beginload == NULL) {
/* If the database can't be loaded, assume it's persistent */
- return (true);
+ return true;
}
- return (false);
+ return false;
}
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_CALLBACK_VALID(callbacks));
if (db->methods->beginload != NULL) {
- return ((db->methods->beginload)(db, callbacks));
+ return (db->methods->beginload)(db, callbacks);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
call_updatenotify(db);
if (db->methods->endload != NULL) {
- return ((db->methods->endload)(db, callbacks));
+ return (db->methods->endload)(db, callbacks);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
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;
}
/***
REQUIRE(versionp != NULL && *versionp == NULL);
if (db->methods->newversion != NULL) {
- return ((db->methods->newversion)(db, versionp));
+ return (db->methods->newversion)(db, versionp);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
void
REQUIRE(nodep != NULL && *nodep == NULL);
if (db->methods->findnode != NULL) {
- return ((db->methods->findnode)(db, name, create,
- nodep DNS__DB_FLARG_PASS));
+ return (db->methods->findnode)(db, name, create,
+ nodep DNS__DB_FLARG_PASS);
} else {
- return ((db->methods->findnodeext)(db, name, create, NULL, NULL,
- nodep DNS__DB_FLARG_PASS));
+ return (db->methods->findnodeext)(db, name, create, NULL, NULL,
+ nodep DNS__DB_FLARG_PASS);
}
}
REQUIRE(nodep != NULL && *nodep == NULL);
if (db->methods->findnodeext != NULL) {
- return ((db->methods->findnodeext)(db, name, create, methods,
- clientinfo,
- nodep DNS__DB_FLARG_PASS));
+ return (db->methods->findnodeext)(db, name, create, methods,
+ clientinfo,
+ nodep DNS__DB_FLARG_PASS);
} else {
- return ((db->methods->findnode)(db, name, create,
- nodep DNS__DB_FLARG_PASS));
+ return (db->methods->findnode)(db, name, create,
+ nodep DNS__DB_FLARG_PASS);
}
}
REQUIRE(DNS_DB_VALID(db));
REQUIRE(nodep != NULL && *nodep == NULL);
- return ((db->methods->findnsec3node)(db, name, create,
- nodep DNS__DB_FLARG_PASS));
+ return (db->methods->findnsec3node)(db, name, create,
+ nodep DNS__DB_FLARG_PASS);
}
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 DNS__DB_FLARG_PASS));
+ return (db->methods->find)(db, name, version, type, options,
+ now, nodep, foundname, rdataset,
+ sigrdataset DNS__DB_FLARG_PASS);
} else {
- return ((db->methods->findext)(
+ return (db->methods->findext)(
db, name, version, type, options, now, nodep, foundname,
- NULL, NULL, rdataset, sigrdataset DNS__DB_FLARG_PASS));
+ NULL, NULL, rdataset, sigrdataset DNS__DB_FLARG_PASS);
}
}
!dns_rdataset_isassociated(sigrdataset)));
if (db->methods->findext != NULL) {
- return ((db->methods->findext)(db, name, version, type, options,
- now, nodep, foundname, methods,
- clientinfo, rdataset,
- sigrdataset DNS__DB_FLARG_PASS));
+ return (db->methods->findext)(db, name, version, type, options,
+ now, nodep, foundname, methods,
+ clientinfo, rdataset,
+ sigrdataset DNS__DB_FLARG_PASS);
} else {
- return ((db->methods->find)(db, name, version, type, options,
- now, nodep, foundname, rdataset,
- sigrdataset DNS__DB_FLARG_PASS));
+ return (db->methods->find)(db, name, version, type, options,
+ now, nodep, foundname, rdataset,
+ sigrdataset DNS__DB_FLARG_PASS);
}
}
!dns_rdataset_isassociated(sigrdataset)));
if (db->methods->findzonecut != NULL) {
- return ((db->methods->findzonecut)(
+ return (db->methods->findzonecut)(
db, name, options, now, nodep, foundname, dcname,
- rdataset, sigrdataset DNS__DB_FLARG_PASS));
+ rdataset, sigrdataset DNS__DB_FLARG_PASS);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
void
(DNS_DB_NSEC3ONLY | DNS_DB_NONSEC3));
if (db->methods->createiterator != NULL) {
- return (db->methods->createiterator(db, flags, iteratorp));
+ return db->methods->createiterator(db, flags, iteratorp);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
/***
(DNS_RDATASET_VALID(sigrdataset) &&
!dns_rdataset_isassociated(sigrdataset)));
- return ((db->methods->findrdataset)(db, node, version, type, covers,
- now, rdataset,
- sigrdataset DNS__DB_FLARG_PASS));
+ return (db->methods->findrdataset)(db, node, version, type, covers, now,
+ rdataset,
+ sigrdataset DNS__DB_FLARG_PASS);
}
isc_result_t
REQUIRE(DNS_DB_VALID(db));
REQUIRE(iteratorp != NULL && *iteratorp == NULL);
- return ((db->methods->allrdatasets)(db, node, version, options, now,
- iteratorp DNS__DB_FLARG_PASS));
+ return (db->methods->allrdatasets)(db, node, version, options, now,
+ iteratorp DNS__DB_FLARG_PASS);
}
isc_result_t
!dns_rdataset_isassociated(addedrdataset)));
if (db->methods->addrdataset != NULL) {
- return ((db->methods->addrdataset)(
+ return (db->methods->addrdataset)(
db, node, version, now, rdataset, options,
- addedrdataset DNS__DB_FLARG_PASS));
+ addedrdataset DNS__DB_FLARG_PASS);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
!dns_rdataset_isassociated(newrdataset)));
if (db->methods->subtractrdataset != NULL) {
- return ((db->methods->subtractrdataset)(
+ return (db->methods->subtractrdataset)(
db, node, version, rdataset, options,
- newrdataset DNS__DB_FLARG_PASS));
+ newrdataset DNS__DB_FLARG_PASS);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
((db->attributes & DNS_DBATTR_CACHE) != 0 && version == NULL));
if (db->methods->deleterdataset != NULL) {
- return ((db->methods->deleterdataset)(
- db, node, version, type, covers DNS__DB_FLARG_PASS));
+ return (db->methods->deleterdataset)(db, node, version, type,
+ covers DNS__DB_FLARG_PASS);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
isc_result_t
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
REQUIRE(DNS_DB_VALID(db));
if (db->methods->nodecount != NULL) {
- return ((db->methods->nodecount)(db, tree));
+ return (db->methods->nodecount)(db, tree);
}
- return (0);
+ return 0;
}
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 DNS__DB_FLARG_PASS));
+ return (db->methods->getoriginnode)(db,
+ nodep DNS__DB_FLARG_PASS);
}
- 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, isc_stdtime_t *resign, dns_name_t *name,
dns_typepair_t *typepair) {
if (db->methods->getsigningtime != NULL) {
- return ((db->methods->getsigningtime)(db, resign, name,
- typepair));
+ return (db->methods->getsigningtime)(db, resign, name,
+ typepair);
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
static void
caa_container_of(ht_node, dns_dbonupdatelistener_t, ht_node);
const dns_dbonupdatelistener_t *key = _key;
- return (listener->onupdate == key->onupdate &&
- listener->onupdate_arg == key->onupdate_arg);
+ return listener->onupdate == key->onupdate &&
+ listener->onupdate_arg == key->onupdate_arg;
}
/*
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;
}
isc_result_t
if (db->methods->addglue != NULL) {
(db->methods->addglue)(db, version, rdataset, msg);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
void
REQUIRE(name != NULL);
if (db->methods->nodefullname != NULL) {
- return ((db->methods->nodefullname)(db, node, name));
+ return (db->methods->nodefullname)(db, node, name);
}
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
void
case DNS_SIGTYPE(dns_rdatatype_ptr):
case dns_rdatatype_naptr:
case DNS_SIGTYPE(dns_rdatatype_naptr):
- return (true);
+ return true;
}
- return (false);
+ return false;
}
ISC_LANG_ENDDECLS
REQUIRE(DNS_DBITERATOR_VALID(iterator));
- return (iterator->methods->first(iterator DNS__DB_FLARG_PASS));
+ return iterator->methods->first(iterator DNS__DB_FLARG_PASS);
}
isc_result_t
REQUIRE(DNS_DBITERATOR_VALID(iterator));
- return (iterator->methods->last(iterator DNS__DB_FLARG_PASS));
+ return iterator->methods->last(iterator DNS__DB_FLARG_PASS);
}
isc_result_t
REQUIRE(DNS_DBITERATOR_VALID(iterator));
- return (iterator->methods->seek(iterator, name DNS__DB_FLARG_PASS));
+ return iterator->methods->seek(iterator, name DNS__DB_FLARG_PASS);
}
isc_result_t
REQUIRE(DNS_DBITERATOR_VALID(iterator));
- return (iterator->methods->prev(iterator DNS__DB_FLARG_PASS));
+ return iterator->methods->prev(iterator DNS__DB_FLARG_PASS);
}
isc_result_t
REQUIRE(DNS_DBITERATOR_VALID(iterator));
- return (iterator->methods->next(iterator DNS__DB_FLARG_PASS));
+ return iterator->methods->next(iterator DNS__DB_FLARG_PASS);
}
isc_result_t
REQUIRE(nodep != NULL && *nodep == NULL);
REQUIRE(name == NULL || dns_name_hasbuffer(name));
- return (iterator->methods->current(iterator, nodep,
- name DNS__DB_FLARG_PASS));
+ return iterator->methods->current(iterator, nodep,
+ name DNS__DB_FLARG_PASS);
}
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);
}
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;
}
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(). */
if (callbacks->commit != NULL) {
callbacks->commit(callbacks->add_private);
}
- return (result);
+ return result;
}
/*
length++;
}
if (length == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
v = isc_mem_cget(diff->mctx, length, sizeof(dns_difftuple_t *));
for (i = 0; i < length; i++) {
ISC_LIST_APPEND(diff->tuples, v[i], link);
}
isc_mem_cput(diff->mctx, v, length, sizeof(dns_difftuple_t *));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (mem != NULL) {
isc_mem_put(diff->mctx, mem, size);
}
- return (result);
+ return result;
}
switch (transport_type) {
case DNS_TRANSPORT_UDP:
- return ("UDP");
+ return "UDP";
case DNS_TRANSPORT_TCP:
- return ("TCP");
+ return "TCP";
case DNS_TRANSPORT_TLS:
- return ("TLS");
+ return "TLS";
case DNS_TRANSPORT_HTTP:
- return ("HTTP");
+ return "HTTP";
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>";
}
}
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;
}
static uint32_t
isc_hash32_hash(&hash, &dispentry->id, sizeof(dispentry->id), true);
isc_hash32_hash(&hash, &dispentry->port, sizeof(dispentry->port), true);
- return (isc_hash32_finalize(&hash));
+ return isc_hash32_finalize(&hash);
}
static int
caa_container_of(node, dns_dispentry_t, ht_node);
const dns_dispentry_t *key = key0;
- return (dispentry->id == key->id && dispentry->port == key->port &&
- isc_sockaddr_equal(&dispentry->peer, &key->peer));
+ return dispentry->id == key->id && dispentry->port == key->port &&
+ isc_sockaddr_equal(&dispentry->peer, &key->peer);
}
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;
}
/*
result = dns_message_peekheader(&source, &id, &flags);
if (result != ISC_R_SUCCESS) {
dispatch_log(disp, ISC_LOG_DEBUG(10), "got garbage packet");
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
dispatch_log(disp, ISC_LOG_DEBUG(92),
if ((flags & DNS_MESSAGEFLAG_QR) == 0) {
dispatch_log(disp, ISC_LOG_DEBUG(10),
"got DNS query instead of answer");
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
/*
"search for response in hashtable: %s",
isc_result_totext(result));
- 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
hashval ^= isc_sockaddr_hash(key->local, true);
}
- return (hashval);
+ return hashval;
}
static int
peer = disp->peer;
}
- return (isc_sockaddr_equal(&peer, key->peer) &&
- disp->transport == key->transport &&
- (key->local == NULL || isc_sockaddr_equal(&local, key->local)));
+ return isc_sockaddr_equal(&peer, key->peer) &&
+ disp->transport == key->transport &&
+ (key->local == NULL || isc_sockaddr_equal(&local, key->local));
}
isc_result_t
}
*dispp = disp;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
isc_result_t
*dispp = disp;
}
- 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
REQUIRE(disp->transport == transport);
if (disp->state == DNS_DISPATCHSTATE_CANCELED) {
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
in_port_t localport = isc_sockaddr_getport(&disp->local);
if (result != ISC_R_SUCCESS) {
isc_mem_put(disp->mctx, resp, sizeof(*resp));
inc_stats(disp->mgr, dns_resstatscounter_dispsockfail);
- return (result);
+ return result;
}
}
if (result != ISC_R_SUCCESS) {
isc_mem_put(disp->mctx, resp, sizeof(*resp));
rcu_read_unlock();
- return (result);
+ return result;
}
isc_mem_attach(disp->mctx, &resp->mctx);
*idp = resp->id;
*respp = resp;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
isc_time_t now = isc_loop_now(resp->loop);
timeout = resp->timeout - dispentry_runtime(resp, &now);
if (timeout <= 0) {
- return (ISC_R_TIMEDOUT);
+ return ISC_R_TIMEDOUT;
}
}
UNREACHABLE();
}
- return (result);
+ return result;
}
/*
resp->mctx, &tlsctx, &sess_cache);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
INSIST(tlsctx != NULL);
}
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;
}
INSIST(tid < dset->ndisp);
- return (dset->dispatches[tid]);
+ return dset->dispatches[tid];
}
isc_result_t
*dsetp = dset;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
fail:
for (size_t j = 0; j < i; j++) {
sizeof(dns_dispatch_t *));
isc_mem_putanddetach(&dset->mctx, dset, sizeof(dns_dispatchset_t));
- return (result);
+ return result;
}
void
REQUIRE(VALID_DISPATCH(disp));
if (disp->handle == NULL || disp->socktype == isc_socktype_udp) {
- return (ISC_R_NOPERM);
+ return ISC_R_NOPERM;
}
- return (isc_nm_xfr_checkperm(disp->handle));
+ return isc_nm_xfr_checkperm(disp->handle);
}
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 */
isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
ISC_LOG_DEBUG(2), "DLZ driver loaded successfully.");
*dbp = db;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ,
ISC_LOG_ERROR, "DLZ driver failed to load.");
/* impinfo->methods->create failed. */
isc_mem_free(mctx, db->dlzname);
isc_mem_put(mctx, db, sizeof(*db));
- return (result);
+ return result;
}
void
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_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 && reqaddr != 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;
}
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_cput(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) \
dns_rdatalist_tordataset(datalist, dataset);
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;
}
void
if (dstkey != NULL) {
dst_key_free(&dstkey);
}
- return (result);
+ return result;
}
/*%
dst_key_free(&key->key);
dns_dnsseckey_destroy(mctx, &key);
}
- return (result);
+ return result;
}
/*%
if (dns_rdataset_isassociated(&sigs)) {
dns_rdataset_disassociate(&sigs);
}
- return (result);
+ return result;
}
static isc_result_t
}
}
- 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 void
addrdata(&dnskey, diff, origin, ttl, mctx);
failure:
- return (result);
+ return result;
}
static isc_result_t
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;
}
static isc_result_t
ISC_LOG_ERROR,
"build rdata CDS (%s) for key %s failed", algbuf,
keystr);
- return (r);
+ return r;
}
cdsrdata.type = dns_rdatatype_cds;
keystr);
addrdata(&cdsrdata, diff, origin, ttl, mctx);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
r = dns_ds_buildrdata(origin, keyrdata, digesttype, dsbuf, &cdsrdata);
if (r != ISC_R_SUCCESS) {
- return (r);
+ return r;
}
cdsrdata.type = dns_rdatatype_cds;
keystr);
delrdata(&cdsrdata, diff, origin, cds->ttl, mctx);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
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
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
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_loopmgr_resume(loopmgr);
- 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;
}
*bufp = UNCONST(data);
- 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;
}
bool
dst_algorithm_supported(unsigned int alg) {
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(*dctx));
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
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
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
if (key->func->fromlabel == NULL) {
dst_key_free(&key);
- return (DST_R_UNSUPPORTEDALG);
+ return DST_R_UNSUPPORTEDALG;
}
result = key->func->fromlabel(key, 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
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
*n = 128; /*%< XXX */
break;
default:
- return (DST_R_UNSUPPORTEDALG);
+ return DST_R_UNSUPPORTEDALG;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
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);
dst_key_free(&key);
}
- return (result);
+ return result;
}
/***
isc_mutex_init(&key->mdlock);
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 int)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 int)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
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
algorithm_status(unsigned int alg) {
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
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;
}
ok = have[TAG_ECDSA_LABEL & mask] || 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;
}
ok = have[TAG_EDDSA_LABEL & mask] || 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_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_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);
}
dns_name_dupwithoffsets(name, mctx, &forwarders->name);
- return (forwarders);
+ return forwarders;
}
isc_result_t
dns_forwarders_detach(&forwarders);
- return (result);
+ return result;
}
isc_result_t
dns_forwarders_detach(&forwarders);
- return (result);
+ return result;
}
isc_result_t
}
dns_qpread_destroy(fwdtable->table, &qpr);
- return (result);
+ return result;
}
void
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
dns_forwarders_t *fwd = pval;
- return (dns_qpkey_fromname(key, &fwd->name));
+ return dns_qpkey_fromname(key, &fwd->name);
}
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;
}
static bool
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
static int
ttnam_cmp(const void *va, const void *vb) {
const struct ttnam *ttna = va, *ttnb = vb;
- return (ttna->type - ttnb->type);
+ return ttna->type - ttnb->type;
}
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 = {
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;
}
/*
result = dns_name_fromstring(machine, sname, dns_rootname, 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_fromstring(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);
static inline dns_decompress_t /* inline to suppress code generation */
dns_decompress_setpermitted(dns_decompress_t dctx, bool permitted) {
if (dctx == DNS_DECOMPRESS_NEVER || dctx == DNS_DECOMPRESS_ALWAYS) {
- return (dctx);
+ return dctx;
} else if (permitted) {
- return (DNS_DECOMPRESS_PERMITTED);
+ return DNS_DECOMPRESS_PERMITTED;
} else {
- return (DNS_DECOMPRESS_DEFAULT);
+ return DNS_DECOMPRESS_DEFAULT;
}
}
*/
static inline bool /* inline to suppress code generation */
dns_decompress_getpermitted(dns_decompress_t dctx) {
- return (dctx == DNS_DECOMPRESS_ALWAYS ||
- dctx == DNS_DECOMPRESS_PERMITTED);
+ return dctx == DNS_DECOMPRESS_ALWAYS ||
+ dctx == DNS_DECOMPRESS_PERMITTED;
}
ISC_LANG_ENDDECLS
REQUIRE(DNS_NAME_VALID(name));
REQUIRE(name->labels <= DNS_NAME_MAXLABELS);
- return (name->labels);
+ return name->labels;
}
/*%<
* How many labels does 'name' have?
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;
}
ipkl->addrs = isc_mem_creget(mctx, ipkl->addrs, ipkl->allocated, n,
sizeof(ipkl->labels[0]));
ipkl->allocated = n;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
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;
}
static 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(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
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(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
ISC_LOG_ERROR, "%s: read: %s", j->filename,
isc_result_totext(result));
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
j->offset += (off_t)nbytes;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
ISC_LOG_ERROR, "%s: write: %s", j->filename,
isc_result_totext(result));
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
j->offset += (off_t)nbytes;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
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(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
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(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
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);
ISC_LOG_ERROR, "%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;
}
/*
isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
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_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(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
"%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
if (result == ISC_R_NOTFOUND) {
isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
ISC_LOG_DEBUG(3), "no journal file");
- return (DNS_R_NOJOURNAL);
+ return DNS_R_NOJOURNAL;
} else if (result != ISC_R_SUCCESS) {
isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL,
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_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_refcount_init(&kasp->references, 1);
*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(DNS_KASP_VALID(kasp));
REQUIRE(kasp->frozen);
- return (kasp->inline_signing);
+ return kasp->inline_signing;
}
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
ISC_LINK_INIT(key, link);
*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;
}
dns_keystore_t *
dns_kasp_key_keystore(dns_kasp_key_t *key) {
REQUIRE(key != NULL);
- return (key->keystore);
+ return key->keystore;
}
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;
}
uint16_t
dns_kasp_key_tagmin(dns_kasp_key_t *key) {
REQUIRE(key != NULL);
- return (key->tag_min);
+ return key->tag_min;
}
uint16_t
dns_kasp_key_tagmax(dns_kasp_key_t *key) {
REQUIRE(key != NULL);
- return (key->tag_min);
+ return key->tag_min;
}
bool
/* Matching algorithms? */
if (dst_key_alg(dkey->key) != dns_kasp_key_algorithm(key)) {
- return (false);
+ return false;
}
/* Matching length? */
if (dst_key_size(dkey->key) != dns_kasp_key_size(key)) {
- return (false);
+ return false;
}
/* Matching role? */
ret = dst_key_getbool(dkey->key, DST_BOOL_KSK, &role);
if (ret != ISC_R_SUCCESS || role != dns_kasp_key_ksk(key)) {
- return (false);
+ return false;
}
ret = dst_key_getbool(dkey->key, DST_BOOL_ZSK, &role);
if (ret != ISC_R_SUCCESS || role != dns_kasp_key_zsk(key)) {
- return (false);
+ return false;
}
/* Valid key tag range? */
uint16_t id = dst_key_id(dkey->key);
uint16_t rid = dst_key_rid(dkey->key);
if (id < key->tag_min || id > key->tag_max) {
- return (false);
+ return false;
}
if (rid < key->tag_min || rid > key->tag_max) {
- return (false);
+ return false;
}
/* Found a match. */
- return (true);
+ return true;
}
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
REQUIRE(kasp != NULL);
REQUIRE(kasp->frozen);
- return (kasp->nsec3);
+ return kasp->nsec3;
}
void
REQUIRE(kasp != NULL);
REQUIRE(kasp->frozen);
- return (kasp->offlineksk);
+ return kasp->offlineksk;
}
void
REQUIRE(kasp != NULL);
REQUIRE(kasp->frozen);
- return (kasp->cdnskey);
+ return kasp->cdnskey;
}
void
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(kasp->frozen);
- return (kasp->digests);
+ return kasp->digests;
}
void
}
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;
}
const char *
dst_key_directory(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
- return (key->directory);
+ return key->directory;
}
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;
}
#define REVOKE(x) ((dst_key_flags(x) & DNS_KEYFLAG_REVOKE) != 0)
SET_IF_NOT_NULL(have_ksk, hksk);
SET_IF_NOT_NULL(have_zsk, hzsk);
- return (hksk && hzsk);
+ return hksk && hzsk;
}
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;
}
void
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;
}
if (ISC_OVERFLOW_ADD(active, klifetime, &retire)) {
*/
if (prepub > retire) {
/* We should have already prepublished the new key. */
- return (now);
+ return now;
}
- return (retire - prepub);
+ return retire - prepub;
}
static void
uint32_t alg = dst_key_alg(newkey);
if (id < min || id > max) {
- return (true);
+ return true;
}
if (rid < min || rid > max) {
- return (true);
+ return true;
}
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*keys); dkey != NULL;
dst_key_id(dkey->key) == rid ||
dst_key_rid(dkey->key) == rid)
{
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
/*
dst_key_setdirectory(newkey, dir);
}
*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(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(ISC_LOG_DEBUG(1))) {
char namestr[DNS_NAME_FORMATSIZE];
keymgr_createkey(kaspkey, origin, kasp, rdclass, mctx,
keydir, 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);
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
isc_log_write(DNS_LOGCATEGORY_DNSSEC, 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) {
dst_key_setmodified(ksk_key->key, false);
}
- return (result);
+ return result;
}
isc_result_t
dns_keymgr_checkds(dns_kasp_t *kasp, dns_dnsseckeylist_t *keyring,
isc_stdtime_t now, isc_stdtime_t when, bool dspublish) {
- return (keymgr_checkds(kasp, keyring, now, when, dspublish, 0, 0,
- false));
+ return keymgr_checkds(kasp, keyring, now, when, dspublish, 0, 0, false);
}
isc_result_t
dns_keymgr_checkds_id(dns_kasp_t *kasp, dns_dnsseckeylist_t *keyring,
isc_stdtime_t now, isc_stdtime_t when, bool dspublish,
dns_keytag_t id, unsigned int alg) {
- return (keymgr_checkds(kasp, keyring, now, when, dspublish, id, alg,
- true));
+ return keymgr_checkds(kasp, keyring, 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);
dst_key_setmodified(key->key, false);
}
- return (result);
+ return result;
}
isc_result_t
ISC_LOG_DEBUG(3), "keymgr: %s (offline-ksk) done",
namebuf);
}
- return (result);
+ return result;
}
keystore->magic = DNS_KEYSTORE_MAGIC;
*kspp = keystore;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static inline void
dns_keystore_name(dns_keystore_t *keystore) {
REQUIRE(DNS_KEYSTORE_VALID(keystore));
- return (keystore->name);
+ return keystore->name;
}
const char *
dns_keystore_directory(dns_keystore_t *keystore, const char *keydir) {
if (keystore == NULL) {
- return (keydir);
+ return keydir;
}
INSIST(DNS_KEYSTORE_VALID(keystore));
if (keystore->directory == NULL) {
- return (keydir);
+ return keydir;
}
- return (keystore->directory);
+ return keystore->directory;
}
void
dns_keystore_pkcs11uri(dns_keystore_t *keystore) {
REQUIRE(DNS_KEYSTORE_VALID(keystore));
- return (keystore->pkcs11uri);
+ return keystore->pkcs11uri;
}
void
/* uri + object */
if (isc_buffer_availablelength(buf) < strlen(uri) + strlen(";object="))
{
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putstr(buf, uri);
isc_buffer_putstr(buf, ";object=");
/* zone name */
result = dns_name_tofilenametext(zname, false, buf);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
* policy name
* dns_name_tofilenametext() certainly won't fit.
*/
if (isc_buffer_availablelength(buf) < (strlen(policy) + 1)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putstr(buf, "-");
result = dns_name_fromstring(pname, policy, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_name_tofilenametext(pname, false, buf);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/* key type + current time */
isc_time_formatshorttimestamp(&now, timebuf, sizeof(timebuf));
- return (isc_buffer_printf(buf, "-%s-%s", ksk ? "ksk" : "zsk", timebuf));
+ return isc_buffer_printf(buf, "-%s-%s", ksk ? "ksk" : "zsk", timebuf);
}
isc_result_t
"keystore: failed to create PKCS#11 object "
"for zone %s, policy %s: %s",
namebuf, policy, isc_result_totext(result));
- return (result);
+ return result;
}
/* Generate the key */
"keystore: failed to generate PKCS#11 object "
"%s: %s",
label, isc_result_totext(result));
- return (result);
+ return result;
}
isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
ISC_LOG_ERROR,
if (result == ISC_R_SUCCESS) {
*dstkey = newkey;
}
- return (result);
+ return result;
}
isc_result_t
REQUIRE(kspp != NULL && *kspp == NULL);
if (list == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
for (keystore = ISC_LIST_HEAD(*list); keystore != NULL;
}
if (keystore == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
dns_keystore_attach(keystore, kspp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
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;
}
/*
RWUNLOCK(&knode->rwlock, isc_rwlocktype_read);
dns_keynode_detach(&knode);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
knode->managed = managed;
knode->initial = initial;
- return (knode);
+ return knode;
}
/*%
dns_qp_compact(qp, DNS_QPGC_MAYBE);
dns_qpmulti_commit(keytable->table, &qp);
- 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
dns_qp_compact(qp, DNS_QPGC_MAYBE);
dns_qpmulti_commit(keytable->table, &qp);
- return (result);
+ return result;
}
isc_result_t
dns_qp_compact(qp, DNS_QPGC_MAYBE);
dns_qpmulti_commit(keytable->table, &qp);
- return (result);
+ return result;
}
isc_result_t
}
dns_qpread_destroy(keytable->table, &qpr);
- return (result);
+ return result;
}
isc_result_t
}
dns_qpread_destroy(keytable->table, &qpr);
- return (result);
+ return result;
}
isc_result_t
dns_qpread_destroy(keytable->table, &qpr);
- 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;
}
dns_name_format(&keynode->name, namebuf, sizeof(namebuf));
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
}
dns_qpread_destroy(keytable->table, &qpr);
- return (result);
+ return result;
}
void
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->keytable.iter == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
rdata = rdataset->keytable.iter;
if (rdata == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
keynode = rdataset->keytable.node;
RWUNLOCK(&keynode->rwlock, isc_rwlocktype_read);
if (rdataset->keytable.iter == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
dns_keynode_t *keynode = pval;
- return (dns_qpkey_fromname(key, &keynode->name));
+ return dns_qpkey_fromname(key, &keynode->name);
}
static 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
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
isc_mem_free(mctx, rhs);
}
- return (result);
+ return result;
}
static isc_result_t
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
cleanup:
dns_loadctx_detach(&lctx);
- return (result);
+ return result;
}
static void
result = (lctx->openfile)(lctx, master_file);
if (result != ISC_R_SUCCESS) {
dns_loadctx_detach(&lctx);
- return (result);
+ return result;
}
dns_loadctx_attach(lctx, lctxp);
isc_work_enqueue(loop, load, load_done, lctx);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
cleanup:
dns_loadctx_detach(&lctx);
- return (result);
+ return result;
}
isc_result_t
cleanup:
dns_loadctx_detach(&lctx);
- return (result);
+ return result;
}
/*
if (oldlist != NULL) {
isc_mem_cput(mctx, oldlist, old_len, sizeof(*oldlist));
}
- return (newlist);
+ return newlist;
}
/*
if (oldlist != NULL) {
isc_mem_cput(mctx, oldlist, old_len, sizeof(*oldlist));
}
- return (newlist);
+ return newlist;
}
static uint32_t
}
rdata = ISC_LIST_NEXT(rdata, link);
}
- return (when);
+ return when;
}
/*
this = ISC_LIST_HEAD(*head);
}
- return (result);
+ return result;
}
/*
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;
}
void
if (ntabs > 0) {
isc_buffer_availableregion(target, &r);
if (r.length < (unsigned int)ntabs) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
p = r.base;
isc_buffer_availableregion(target, &r);
if (r.length < (unsigned int)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;
}
/*
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;
}
dctx->done = done;
dctx->done_arg = done_arg;
dns_dumpctx_attach(dctx, dctxp);
isc_work_enqueue(loop, master_dump_cb, master_dump_done_cb, dctx);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
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
dns_dumpctx_attach(dctx, dctxp);
isc_work_enqueue(loop, master_dump_cb, master_dump_done_cb, dctx);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_tempname:
(void)isc_stdio_close(f);
cleanup_file:
isc_mem_free(mctx, file);
- return (result);
+ return result;
}
isc_result_t
result = opentmp(mctx, 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;
}
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
static bool
name_match(void *node, const void *key) {
- return (dns_name_equal(node, key));
+ return dns_name_equal(node, key);
}
static isc_result_t
if (foundname != NULL) {
*foundname = name;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
static uint32_t
isc_hash32_hash(&state, &rds->type, sizeof(rds->type), true);
isc_hash32_hash(&state, &rds->covers, sizeof(rds->covers), true);
- return (isc_hash32_finalize(&state));
+ return isc_hash32_finalize(&state);
}
static bool
const dns_rdataset_t *rds = node;
const dns_rdataset_t *key = key0;
- return (rds->rdclass == key->rdclass && rds->type == key->type &&
- rds->covers == key->covers);
+ return rds->rdclass == key->rdclass && rds->type == key->type &&
+ rds->covers == key->covers;
}
isc_result_t
if (rds->type == type && rds->covers == covers) {
SET_IF_NOT_NULL(rdatasetp, rds);
- 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_hashmap_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_hashmap_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
isc_buffer_remainingregion(&buffer, &r);
if (r.length < DNS_MESSAGE_HEADERLEN) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
id = isc_buffer_getuint16(&buffer);
SET_IF_NOT_NULL(flagsp, flags);
SET_IF_NOT_NULL(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
msgresetopt(msg);
if (opt == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = dns_rdataset_first(opt);
msg->opt = opt;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns__message_putassociatedrdataset(msg, &opt);
- return (result);
+ return result;
}
dns_rdataset_t *
REQUIRE(owner == NULL || *owner == NULL);
SET_IF_NOT_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;
}
void
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
dns_message_clonebuffer(msg);
isc_helper_run(loop, checksig_run, chsigctx);
- return (DNS_R_WAIT);
+ return DNS_R_WAIT;
}
isc_result_t
REQUIRE(DNS_MESSAGE_VALID(msg));
if (msg->tsigkey == NULL && msg->tsig == NULL && msg->sig0 == 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);
}
} else {
dns_rdata_t rdata = DNS_RDATA_INIT;
* meta-records are in the prerequisite and update sections.
*/
if (rdata.length == 0) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
result = dns_rdata_tostruct(&rdata, &sig, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_init(&keyset);
dns_rdataset_disassociate(&keyset);
}
dns_rdata_freestruct(&sig);
- return (result);
+ return result;
}
}
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;
}
for (i = 0; i < addrbytes; i++) {
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
ADD_STRING(target, " \"");
ADD_STRING(target, namebuf);
ADD_STRING(target, "\"");
- return (result);
+ return result;
}
result = ISC_R_FAILURE;
cleanup:
- return (result);
+ return result;
}
static const char *option_names[] = {
cleanup:
msg->indent.count = saved_count;
- return (result);
+ return result;
}
isc_result_t
REQUIRE(VALID_NAMED_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
dns_rdatalist_tordataset(rdatalist, rdataset);
*rdatasetp = rdataset;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_message_puttemprdata(message, &rdata);
dns_message_puttemprdataset(message, &rdataset);
dns_message_puttemprdatalist(message, &rdatalist);
- return (result);
+ return result;
}
void
if (rdata.type == dns_rdatatype_soa) {
*ttlp = ISC_MIN(rds->ttl, dns_soa_getminimum(&rdata));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
static isc_result_t
isc_result_t result;
if (msg->counts[DNS_SECTION_AUTHORITY] == 0) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
for (result = dns_message_firstname(msg, DNS_SECTION_AUTHORITY);
result = rdataset_soa_min(rds, ttlp);
if (result == ISC_R_SUCCESS) {
- 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;
}
void
unsigned int offset, count, length, nlabels;
if (!DNS_NAME_VALID(name)) {
- return (false);
+ return false;
}
if (name->length > DNS_NAME_MAXWIRE ||
name->labels > DNS_NAME_MAXLABELS)
{
- return (false);
+ return false;
}
ndata = name->ndata;
while (offset != length) {
count = *ndata;
if (count > DNS_NAME_LABELLEN) {
- 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;
}
bool
REQUIRE(DNS_NAME_VALID(name));
if (name->buffer != NULL) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
REQUIRE(DNS_NAME_VALID(name));
- return (name->attributes.absolute);
+ return name->attributes.absolute;
}
#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 <= DNS_NAME_LABELLEN);
if (count == 1 && *ndata == '*') {
- return (true);
+ return true;
}
ndata += count;
label++;
}
- return (false);
+ return false;
}
uint32_t
dns_name_hash(const dns_name_t *name) {
REQUIRE(DNS_NAME_VALID(name));
- return (isc_hash32(name->ndata, name->length, false));
+ return isc_hash32(name->ndata, name->length, false);
}
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
REQUIRE((name1->attributes.absolute) == (name2->attributes.absolute));
if (name1 == name2) {
- return (true);
+ return true;
}
length = name1->length;
if (length != name2->length) {
- return (false);
+ return false;
}
/* label lengths are < 64 so tolower() does not affect them */
- return (isc_ascii_lowerequal(name1->ndata, name2->ndata, length));
+ return isc_ascii_lowerequal(name1->ndata, name2->ndata, length);
}
bool
REQUIRE((name1->attributes.absolute) == (name2->attributes.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
REQUIRE(name2->attributes.absolute);
/* label lengths are < 64 so tolower() does not affect them */
- return (isc_ascii_lowercmp(name1->ndata, name2->ndata,
- ISC_MIN(name1->length, name2->length)));
+ return isc_ascii_lowercmp(name1->ndata, name2->ndata,
+ ISC_MIN(name1->length, name2->length));
}
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;
}
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 >= DNS_NAME_LABELLEN) {
- return (DNS_R_LABELTOOLONG);
+ return DNS_R_LABELTOOLONG;
}
count++;
if (downcase) {
* 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 >= DNS_NAME_LABELLEN) {
- return (DNS_R_LABELTOOLONG);
+ return DNS_R_LABELTOOLONG;
}
count++;
if (downcase) {
FALLTHROUGH;
case ft_escdecimal:
if (!isdigit((unsigned char)c)) {
- return (DNS_R_BADESCAPE);
+ return DNS_R_BADESCAPE;
}
value = 10 * value + c - '0';
digits++;
if (digits == 3) {
if (value > 255) {
- return (DNS_R_BADESCAPE);
+ return DNS_R_BADESCAPE;
}
if (count >= DNS_NAME_LABELLEN) {
- 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
* 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++ = '\\';
*tdata++ = c;
default:
if (c > 0x20 && c < 0x7f) {
if (trem == 0) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
*tdata++ = c;
ndata++;
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 (source->length > (target->length - target->used)) {
MAKE_EMPTY(name);
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/* label lengths are < 64 so tolower() does not affect them */
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 (!dns_decompress_getpermitted(dctx)) {
- 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
*/
if (compress && name_coff != NULL && *name_coff < 0x4000) {
if (isc_buffer_availablelength(target) < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint16(target, *name_coff | 0xc000);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (name->offsets == NULL) {
if (prefix_length > 0) {
if (isc_buffer_availablelength(target) < prefix_length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
memmove(isc_buffer_used(target), name->ndata, prefix_length);
isc_buffer_add(target, prefix_length);
*name_coff = suffix_coff;
}
if (isc_buffer_availablelength(target) < 2) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
isc_buffer_putuint16(target, suffix_coff | 0xc000);
}
- 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
REQUIRE(DNS_NAME_VALID(name));
if (!name->attributes.dynamic) {
- return (0);
+ return 0;
}
size = name->length;
size += name->labels;
}
- return (size);
+ return size;
}
isc_result_t
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.dynamic);
+ return name->attributes.dynamic;
}
isc_result_t
isc_buffer_init(&b, t, sizeof(t));
result = dns_name_totext(name, 0, &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, 0, &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
result = dns_name_fromtext(name, &buf, origin, options, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
if (name != target) {
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;
}
bool
REQUIRE(DNS_NAME_VALID(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] != '_' || isc_ascii_tolower(ndata[1]) != 't' ||
isc_ascii_tolower(ndata[2]) != 'a')
{
- return (false);
+ return false;
}
ndata += 3;
len -= 3;
!isc_hex_char(ndata[2]) || !isc_hex_char(ndata[3]) ||
!isc_hex_char(ndata[4]))
{
- return (false);
+ return false;
}
ndata += 5;
len -= 5;
}
- return (true);
+ return true;
}
bool
REQUIRE(DNS_NAME_VALID(name));
if (name->labels < 1 || name->length < 5) {
- return (false);
+ return false;
}
ndata = name->ndata;
ndata++;
if (len < 2 || ndata[0] != '_') {
- return (false);
+ return false;
}
if (isdigit(ndata[1]) && name->labels > 1) {
char buf[sizeof("65000")];
* Do we have a valid _port label?
*/
if (len > 6U || (ndata[1] == '0' && len != 2)) {
- return (false);
+ return false;
}
memcpy(buf, ndata + 1, len - 1);
buf[len - 1] = 0;
port = strtol(buf, &endp, 10);
if (*endp != 0 || port < 0 || port > 0xffff) {
- return (false);
+ return false;
}
/*
}
if (len == 4U && strncasecmp((const char *)ndata, "_dns", 4) == 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
bool
REQUIRE(DNS_NAME_VALID(rad));
if (name->labels < rad->labels + 4U || name->length < 4U) {
- return (false);
+ return false;
}
if (name->ndata[0] != 3 || name->ndata[1] != '_' ||
tolower(name->ndata[2]) != 'e' || tolower(name->ndata[3]) != 'r')
{
- return (false);
+ return false;
}
dns_name_init(&suffix, offsets);
if (suffix.ndata[0] != 3 || suffix.ndata[1] != '_' ||
tolower(suffix.ndata[2]) != 'e' || tolower(suffix.ndata[3]) != 'r')
{
- return (false);
+ return false;
}
/* type list */
memmove(labelbuf, suffix.ndata + 1, *suffix.ndata);
labelbuf[*suffix.ndata] = 0;
if (strlen(labelbuf) != *suffix.ndata) {
- return (false);
+ return false;
}
l = labelbuf;
do {
v = strtoul(l, &end, 10);
if (v > 0xffff || (*end != 0 && *end != '-') || end == l) {
- return (false);
+ return false;
}
if (last != ULONG_MAX && v <= last) {
- return (false);
+ return false;
}
last = v;
if (*end == '-') {
memmove(labelbuf, suffix.ndata + 1, *suffix.ndata);
labelbuf[*suffix.ndata] = 0;
if (strlen(labelbuf) != *suffix.ndata) {
- return (false);
+ return false;
}
v = strtoul(labelbuf, &end, 10);
if (v > 0xfff || *end != 0) {
- return (false);
+ return false;
}
- return (dns_name_issubdomain(name, rad));
+ return dns_name_issubdomain(name, rad);
}
dns_name_dupwithoffsets(name, mctx, &node->name);
- return (node);
+ return node;
}
static bool
unsigned int mask = 1 << (val % 8);
if (len <= bits[0] && (bits[len - 1] & mask) != 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
isc_result_t
out:
dns_qp_compact(qp, DNS_QPGC_MAYBE);
dns_qpmulti_commit(nametree->table, &qp);
- return (result);
+ return result;
}
isc_result_t
dns_qp_compact(qp, DNS_QPGC_MAYBE);
dns_qpmulti_commit(nametree->table, &qp);
- return (result);
+ return result;
}
isc_result_t
}
dns_qpread_destroy(nametree->table, &qpr);
- return (result);
+ return result;
}
bool
}
dns_qpread_destroy(nametree->table, &qpr);
- return (ret);
+ return ret;
}
static void
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
dns_ntnode_t *ntnode = pval;
- return (dns_qpkey_fromname(key, &ntnode->name));
+ return dns_qpkey_fromname(key, &ntnode->name);
}
static void
atomic_uchar *cp = isc_buffer_current(b);
uint8_t ret = atomic_load_relaxed(cp);
isc_buffer_forward(b, 1);
- return (ret);
+ return ret;
}
static isc_result_t
*/
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:
dns_compress_rollback(cctx, savedbuffer.used);
*countp = 0;
*target = savedbuffer;
- return (result);
+ return result;
}
static void
count = raw[0] * 256 + raw[1];
if (count == 0) {
rdataset->ncache.iter_pos = NULL;
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
/*
* iter_count is the number of rdata beyond the cursor position,
*/
rdataset->ncache.iter_pos = raw + 2;
rdataset->ncache.iter_count = count - 1;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
count = rdataset->ncache.iter_count;
if (count == 0) {
rdataset->ncache.iter_pos = NULL;
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
length = raw[0] * 256 + raw[1];
rdataset->ncache.iter_pos = raw + 2 + length;
rdataset->ncache.iter_count = count - 1;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
raw = rdataset->ncache.raw;
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->ncache.iter_pos = NULL;
rdataset->ncache.iter_count = 0;
- 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->ncache.iter_pos = NULL;
rdataset->ncache.iter_count = 0;
- 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;
}
SET_IF_NOT_NULL(hash_length, len);
/* 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);
dns_rdatatype_nsec3param, &buf1,
DNS_DECOMPRESS_NEVER, &buf2);
- 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;
}
REQUIRE(VALID_NTATABLE(ntatable));
if (atomic_load(&ntatable->shuttingdown)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
RWLOCK(&ntatable->rwlock, isc_rwlocktype_write);
dns_qpmulti_commit(ntatable->table, &qp);
RWUNLOCK(&ntatable->rwlock, isc_rwlocktype_write);
- return (result);
+ return result;
}
isc_result_t
dns_qp_compact(qp, DNS_QPGC_MAYBE);
dns_qpmulti_commit(ntatable->table, &qp);
- return (result);
+ return result;
}
static void
done:
RWUNLOCK(&ntatable->rwlock, isc_rwlocktype_read);
dns_qpread_destroy(ntatable->table, &qpr);
- 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_qpread_destroy(ntatable->table, &qpr);
RWUNLOCK(&ntatable->rwlock, isc_rwlocktype_read);
- return (result);
+ return result;
}
isc_result_t
result = ISC_R_NOTFOUND;
}
- return (result);
+ return result;
}
static void
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
dns__nta_t *nta = pval;
- return (dns_qpkey_fromname(key, &nta->name));
+ return dns_qpkey_fromname(key, &nta->name);
}
static void
}
err:
OSSL_STORE_close(ctx);
- return (ret);
+ return ret;
#else
UNUSED(key_base_id);
UNUSED(label);
UNUSED(pin);
UNUSED(ppub);
UNUSED(ppriv);
- return (DST_R_OPENSSLFAILURE);
+ return DST_R_OPENSSLFAILURE;
#endif
}
isc_result_t
dst__openssl_fromlabel(int key_base_id, const char *label, const char *pin,
EVP_PKEY **ppub, EVP_PKEY **ppriv) {
- return (dst__openssl_fromlabel_provider(key_base_id, label, pin, ppub,
- ppriv));
+ return dst__openssl_fromlabel_provider(key_base_id, label, pin, ppub,
+ ppriv);
}
bool
EVP_PKEY *pkey2 = key2->keydata.pkeypair.pub;
if (pkey1 == pkey2) {
- return (true);
+ return true;
} else if (pkey1 == NULL || pkey2 == NULL) {
- return (false);
+ return false;
}
/* `EVP_PKEY_eq` checks only the public components and parameters. */
if (EVP_PKEY_eq(pkey1, pkey2) != 1) {
- return (false);
+ return false;
}
/* The private key presence must be same for keys to match. */
if ((key1->keydata.pkeypair.priv != NULL) !=
(key2->keydata.pkeypair.priv != NULL))
{
- return (false);
+ return false;
}
- return (true);
+ return true;
}
bool
dst__openssl_keypair_isprivate(const dst_key_t *key) {
- return (key->keydata.pkeypair.priv != NULL);
+ return key->keydata.pkeypair.priv != NULL;
}
void
params[2] = OSSL_PARAM_construct_end();
if (EVP_PKEY_CTX_set_params(pctx, params) != 1) {
- return (dst__openssl_toresult2("EVP_PKEY_CTX_set_params",
- DST_R_OPENSSLFAILURE));
+ return dst__openssl_toresult2("EVP_PKEY_CTX_set_params",
+ DST_R_OPENSSLFAILURE);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#endif /* OPENSSL_VERSION_NUMBER >= 0x30200000L */
switch (key_alg) {
case DST_ALG_ECDSA256:
case DST_ALG_ECDSA384:
- return (true);
+ return true;
default:
- return (false);
+ return false;
}
}
opensslecdsa_key_alg_to_group_nid(unsigned int key_alg) {
switch (key_alg) {
case DST_ALG_ECDSA256:
- return (NID_X9_62_prime256v1);
+ return NID_X9_62_prime256v1;
case DST_ALG_ECDSA384:
- return (NID_secp384r1);
+ return NID_secp384r1;
default:
UNREACHABLE();
}
opensslecdsa_key_alg_to_publickey_size(unsigned int key_alg) {
switch (key_alg) {
case DST_ALG_ECDSA256:
- return (DNS_KEY_ECDSA256SIZE);
+ return DNS_KEY_ECDSA256SIZE;
case DST_ALG_ECDSA384:
- return (DNS_KEY_ECDSA384SIZE);
+ return DNS_KEY_ECDSA384SIZE;
default:
UNREACHABLE();
}
opensslecdsa_generate_public_key(const EC_GROUP *group, const BIGNUM *privkey) {
EC_POINT *pubkey = EC_POINT_new(group);
if (pubkey == NULL) {
- return (NULL);
+ return NULL;
}
if (EC_POINT_mul(group, pubkey, privkey, NULL, NULL, NULL) != 1) {
EC_POINT_free(pubkey);
- return (NULL);
+ return NULL;
}
- return (pubkey);
+ return pubkey;
}
static int
*buf++ = 0;
}
BN_bn2bin(bn, buf);
- return (size);
+ return size;
}
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
opensslecdsa_key_alg_to_group_name(unsigned int key_alg) {
switch (key_alg) {
case DST_ALG_ECDSA256:
- return ("prime256v1");
+ return "prime256v1";
case DST_ALG_ECDSA384:
- return ("secp384r1");
+ return "secp384r1";
default:
UNREACHABLE();
}
EC_POINT_free(pubkey);
EC_GROUP_free(group);
- return (ret);
+ return ret;
}
static bool
}
BN_clear_free(x);
BN_clear_free(y);
- return (ret);
+ return ret;
}
#endif
EC_POINT_free(pubkey);
EC_KEY_free(eckey);
EVP_PKEY_free(pkey);
- return (ret);
+ return ret;
}
static bool
size_t len;
if (group == NULL || pub == NULL) {
- return (false);
+ return false;
}
len = EC_POINT_point2oct(group, pub, POINT_CONVERSION_UNCOMPRESSED, buf,
sizeof(buf), NULL);
if (len == dstlen + 1) {
memmove(dst, buf + 1, dstlen);
- return (true);
+ return true;
}
- return (false);
+ return false;
}
#endif
size_t dstlen) {
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
if (opensslecdsa_extract_public_key_params(key, dst, dstlen)) {
- return (true);
+ return true;
}
#else
if (opensslecdsa_extract_public_key_legacy(key, dst, dstlen)) {
- return (true);
+ return true;
}
#endif
- return (false);
+ return false;
}
static isc_result_t
ret = opensslecdsa_create_pkey_params(key_alg, private, key, key_len,
retkey);
if (ret != ISC_R_FAILURE) {
- return (ret);
+ return ret;
}
#else
ret = opensslecdsa_create_pkey_legacy(key_alg, private, key, key_len,
retkey);
if (ret == ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
#endif
- return (DST_R_OPENSSLFAILURE);
+ return DST_R_OPENSSLFAILURE;
}
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
err:
EVP_PKEY_CTX_free(ctx);
- return (ret);
+ return ret;
}
static isc_result_t
int status;
if (label != NULL) {
- return (opensslecdsa_generate_pkey_with_uri(group_nid, label,
- retkey));
+ return opensslecdsa_generate_pkey_with_uri(group_nid, label,
+ retkey);
}
/* Generate the key's parameters. */
err:
EVP_PKEY_free(params_pkey);
EVP_PKEY_CTX_free(ctx);
- return (ret);
+ return ret;
}
static isc_result_t
char gname[64];
if (EVP_PKEY_get_group_name(pkey, gname, sizeof(gname), NULL) != 1) {
- return (DST_R_INVALIDPRIVATEKEY);
+ return DST_R_INVALIDPRIVATEKEY;
}
if (strcmp(gname, groupname) != 0) {
- return (DST_R_INVALIDPRIVATEKEY);
+ return DST_R_INVALIDPRIVATEKEY;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
BIGNUM *priv = NULL;
if (EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_PRIV_KEY, &priv) != 1) {
- return (false);
+ return false;
}
BN_bn2bin_fixed(priv, buf, buflen);
BN_clear_free(priv);
- return (true);
+ return true;
}
#else
err:
EC_KEY_free(eckey);
EVP_PKEY_free(pkey);
- return (ret);
+ return ret;
}
static isc_result_t
int group_nid;
if (eckey == NULL) {
- return (dst__openssl_toresult(DST_R_INVALIDPRIVATEKEY));
+ return dst__openssl_toresult(DST_R_INVALIDPRIVATEKEY);
}
group_nid = opensslecdsa_key_alg_to_group_nid(key_alg);
if (EC_GROUP_get_curve_name(EC_KEY_get0_group(eckey)) != group_nid) {
- return (DST_R_INVALIDPRIVATEKEY);
+ return DST_R_INVALIDPRIVATEKEY;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
eckey = EVP_PKEY_get0_EC_KEY(key->keydata.pkeypair.priv);
if (eckey == NULL) {
ERR_clear_error();
- return (false);
+ return false;
}
privkey = EC_KEY_get0_private_key(eckey);
if (privkey == NULL) {
ERR_clear_error();
- return (false);
+ return false;
}
BN_bn2bin_fixed(privkey, buf, buflen);
- return (true);
+ return true;
}
#endif /* OPENSSL_VERSION_NUMBER >= 0x30000000L */
dctx->ctxdata.evp_md_ctx = evp_md_ctx;
err:
- return (ret);
+ return ret;
}
static void
}
err:
- return (ret);
+ return ret;
}
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 isc_result_t
ret = opensslecdsa_generate_pkey(key->key_alg, key->label, &pkey);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
key->key_size = EVP_PKEY_bits(pkey);
key->keydata.pkeypair.priv = pkey;
key->keydata.pkeypair.pub = pkey;
- return (ret);
+ return ret;
}
static isc_result_t
ret = ISC_R_SUCCESS;
err:
- return (ret);
+ return ret;
}
static isc_result_t
ret = ISC_R_SUCCESS;
err:
- return (ret);
+ return ret;
}
static isc_result_t
err:
isc_safe_memwipe(buf, keylen);
- return (ret);
+ return ret;
}
static isc_result_t
dst__privstruct_free(&priv, key->mctx);
isc_safe_memwipe(&priv, sizeof(priv));
- return (ret);
+ return ret;
}
static isc_result_t
err:
EVP_PKEY_free(privpkey);
EVP_PKEY_free(pubpkey);
- return (ret);
+ return ret;
}
static dst_func_t opensslecdsa_functions = {
.key_size = DNS_KEY_ED25519SIZE,
.sig_size = DNS_SIG_ED25519SIZE,
};
- return (&ed25519_alginfo);
+ return &ed25519_alginfo;
}
#if HAVE_OPENSSL_ED448
if (key_alg == DST_ALG_ED448) {
.key_size = DNS_KEY_ED448SIZE,
.sig_size = DNS_SIG_ED448SIZE,
};
- return (&ed448_alginfo);
+ return &ed448_alginfo;
}
#endif /* HAVE_OPENSSL_ED448 */
- return (NULL);
+ return NULL;
}
static isc_result_t
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
REQUIRE(alginfo != NULL);
if (ctx == NULL) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
siglen = alginfo->sig_size;
isc_buffer_free(&buf);
dctx->ctxdata.generic = NULL;
- return (ret);
+ return ret;
}
static isc_result_t
REQUIRE(alginfo != NULL);
if (ctx == NULL) {
- return (dst__openssl_toresult(ISC_R_NOMEMORY));
+ return dst__openssl_toresult(ISC_R_NOMEMORY);
}
if (sig->length != alginfo->sig_size) {
isc_buffer_free(&buf);
dctx->ctxdata.generic = NULL;
- return (ret);
+ return ret;
}
static isc_result_t
ctx = EVP_PKEY_CTX_new_id(alginfo->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 isc_result_t
len = alginfo->key_size;
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;
ret = raw_key_to_ossl(alginfo, 0, r.base, &len, &pkey);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
isc_buffer_forward(data, len);
key->keydata.pkeypair.pub = pkey;
key->key_size = len * 8;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(alginfo != NULL);
if (key->keydata.pkeypair.pub == 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
EVP_PKEY_free(pkey);
dst__privstruct_free(&priv, mctx);
isc_safe_memwipe(&priv, sizeof(priv));
- return (ret);
+ return ret;
}
static isc_result_t
err:
EVP_PKEY_free(privpkey);
EVP_PKEY_free(pubpkey);
- return (ret);
+ return ret;
}
static dst_func_t openssleddsa_functions = {
EVP_MD_CTX_destroy(evp_md_ctx);
}
ERR_clear_error();
- return (ret);
+ return ret;
}
void
EVP_PKEY *priv = key->keydata.pkeypair.priv;
if (private && priv == NULL) {
- return (DST_R_INVALIDPRIVATEKEY);
+ return DST_R_INVALIDPRIVATEKEY;
}
/*
* NOTE: Errors regarding private compoments are ignored.
if (EVP_PKEY_get_bn_param(pub, OSSL_PKEY_PARAM_RSA_E,
(BIGNUM **)&c->e) != 1)
{
- return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
+ return dst__openssl_toresult(DST_R_OPENSSLFAILURE);
}
c->bnfree = true;
if (EVP_PKEY_get_bn_param(pub, OSSL_PKEY_PARAM_RSA_N,
(BIGNUM **)&c->n) != 1)
{
- return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
+ return dst__openssl_toresult(DST_R_OPENSSLFAILURE);
}
if (!private) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
(void)EVP_PKEY_get_bn_param(priv, OSSL_PKEY_PARAM_RSA_D,
(BIGNUM **)&c->d);
(void)EVP_PKEY_get_bn_param(priv, OSSL_PKEY_PARAM_RSA_COEFFICIENT1,
(BIGNUM **)&c->iqmp);
ERR_clear_error();
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#else
const RSA *rsa = EVP_PKEY_get0_RSA(pub);
if (rsa == NULL) {
- return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
+ return dst__openssl_toresult(DST_R_OPENSSLFAILURE);
}
RSA_get0_key(rsa, &c->n, &c->e, &c->d);
if (c->e == NULL || c->n == NULL) {
- return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
+ return dst__openssl_toresult(DST_R_OPENSSLFAILURE);
}
if (!private) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
rsa = EVP_PKEY_get0_RSA(priv);
if (rsa == NULL) {
- return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
+ return dst__openssl_toresult(DST_R_OPENSSLFAILURE);
}
RSA_get0_factors(rsa, &c->p, &c->q);
RSA_get0_crt_params(rsa, &c->dmp1, &c->dmq1, &c->iqmp);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#endif
}
case DST_ALG_NSEC3RSASHA1:
case DST_ALG_RSASHA256:
case DST_ALG_RSASHA512:
- return (true);
+ return true;
default:
- return (false);
+ return false;
}
}
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 bool
if (EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_E, &e) == 1) {
int bits = BN_num_bits(e);
BN_free(e);
- return (bits < maxbits);
+ return bits < maxbits;
}
#else
const RSA *rsa = EVP_PKEY_get0_RSA(pkey);
const BIGNUM *ce = NULL;
RSA_get0_key(rsa, NULL, &ce, NULL);
if (ce != NULL) {
- return (BN_num_bits(ce) < maxbits);
+ return BN_num_bits(ce) < maxbits;
}
}
#endif
- return (false);
+ return false;
}
static isc_result_t
pkey = key->keydata.pkeypair.pub;
if (maxbits != 0 && !opensslrsa_check_exponent_bits(pkey, maxbits)) {
- 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);
}
#if OPENSSL_VERSION_NUMBER < 0x30000000L
if (fptr != NULL) {
fptr(p);
}
- return (1);
+ return 1;
}
static isc_result_t
EVP_PKEY_free(pkey);
RSA_free(rsa);
BN_GENCB_free(cb);
- return (ret);
+ return ret;
}
static isc_result_t
EVP_PKEY_free(pkey);
RSA_free(rsa);
opensslrsa_components_free(c);
- return (ret);
+ return ret;
}
#else
static int
int p = EVP_PKEY_CTX_get_keygen_info(ctx, 0);
fptr(p);
}
- return (1);
+ return 1;
}
static isc_result_t
ret = ISC_R_SUCCESS;
err:
EVP_PKEY_CTX_free(ctx);
- return (ret);
+ return ret;
}
static isc_result_t
isc_result_t ret;
if (label != NULL) {
- return (opensslrsa_generate_pkey_with_uri(key_size, label,
- retkey));
+ return opensslrsa_generate_pkey_with_uri(key_size, label,
+ retkey);
}
ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL);
ret = ISC_R_SUCCESS;
err:
EVP_PKEY_CTX_free(ctx);
- return (ret);
+ return ret;
}
static isc_result_t
EVP_PKEY_CTX_free(ctx);
OSSL_PARAM_free(params);
OSSL_PARAM_BLD_free(bld);
- return (ret);
+ return ret;
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L */
err:
EVP_PKEY_free(pkey);
BN_free(e);
- return (ret);
+ return ret;
}
static isc_result_t
ret = ISC_R_SUCCESS;
err:
opensslrsa_components_free(&c);
- return (ret);
+ return ret;
}
static isc_result_t
err:
opensslrsa_components_free(&c);
- return (ret);
+ return ret;
}
static isc_result_t
rsa_components_t c = { 0 };
if (key->external) {
- return (dst__privstruct_writefile(key, &priv, directory));
+ return dst__privstruct_writefile(key, &priv, directory);
}
ret = opensslrsa_components_get(key, &c, true);
}
opensslrsa_components_free(&c);
- return (ret);
+ return ret;
}
static isc_result_t
dst__privstruct_free(&priv, mctx);
isc_safe_memwipe(&priv, sizeof(priv));
- return (ret);
+ return ret;
}
static isc_result_t
err:
EVP_PKEY_free(privpkey);
EVP_PKEY_free(pubpkey);
- return (ret);
+ return ret;
}
static dst_func_t opensslrsa_functions = {
EVP_PKEY_free(pkey);
EVP_MD_CTX_destroy(evp_md_ctx);
ERR_clear_error();
- return (ret);
+ return ret;
}
void
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
*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;
}
* 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;
}
if (name->labels == 0) {
key[0] = SHIFT_NOBYTE;
- return (0);
+ return 0;
}
if (name->offsets == NULL) {
/* mark end with a double NOBYTE */
key[len] = SHIFT_NOBYTE;
ENSURE(len < sizeof(dns_qpkey_t));
- return (len);
+ return len;
}
void
if (qpkey_bit(key_a, keylen_a, offset) !=
qpkey_bit(key_b, keylen_b, offset))
{
- return (offset);
+ return offset;
}
}
- return (QPKEY_EQUAL);
+ return QPKEY_EQUAL;
}
/***********************************************************************
static size_t
chunk_size_raw(void) {
size_t size = (size_t)sysconf(_SC_PAGE_SIZE);
- return (ISC_MAX(size, QP_CHUNK_BYTES));
+ return ISC_MAX(size, QP_CHUNK_BYTES);
}
static void *
void *ptr = mmap(NULL, size, PROT_READ | PROT_WRITE,
MAP_ANON | MAP_PRIVATE, -1, 0);
RUNTIME_CHECK(ptr != MAP_FAILED);
- return (ptr);
+ return ptr;
} else {
- return (isc_mem_allocate(qp->mctx, QP_CHUNK_BYTES));
+ return isc_mem_allocate(qp->mctx, QP_CHUNK_BYTES);
}
}
static void *
chunk_shrink_raw(dns_qp_t *qp, void *ptr, size_t bytes) {
if (qp->write_protect) {
- return (ptr);
+ return ptr;
} else {
- return (isc_mem_reallocate(qp->mctx, ptr, bytes));
+ return isc_mem_reallocate(qp->mctx, ptr, bytes);
}
}
dns_qpchunk_t chunk = ref_chunk(ref);
dns_qpcell_t cell = ref_cell(ref);
if (chunk == qp->bump) {
- return (cell < qp->fender);
+ return cell < qp->fender;
} else {
- return (qp->usage[chunk].immutable);
+ return qp->usage[chunk].immutable;
}
}
if (qp->write_protect) {
TRACE("chunk %u base %p", chunk, qp->base->ptr[chunk]);
}
- return (make_ref(chunk, 0));
+ return make_ref(chunk, 0);
}
/*
for (chunk = 0; chunk < qp->chunk_max; chunk++) {
if (!qp->usage[chunk].exists) {
- return (chunk_alloc(qp, chunk, size));
+ return chunk_alloc(qp, chunk, size);
}
}
ENSURE(chunk == qp->chunk_max);
realloc_chunk_arrays(qp, GROWTH_FACTOR(chunk));
- return (chunk_alloc(qp, chunk, size));
+ return chunk_alloc(qp, chunk, size);
}
/*
if (cell + size <= QP_CHUNK_SIZE) {
qp->usage[chunk].used += size;
qp->used_count += size;
- return (make_ref(chunk, cell));
+ return make_ref(chunk, cell);
} else {
- return (alloc_slow(qp, size));
+ return alloc_slow(qp, size);
}
}
if (cells_immutable(qp, twigs)) {
qp->hold_count += size;
ENSURE(qp->free_count >= qp->hold_count);
- return (false);
+ return false;
} else {
zero_twigs(ref_ptr(qp, twigs), size);
- return (true);
+ return true;
}
}
*/
static inline dns_qpcell_t
chunk_usage(dns_qp_t *qp, dns_qpchunk_t chunk) {
- return (qp->usage[chunk].used - qp->usage[chunk].free);
+ return qp->usage[chunk].used - qp->usage[chunk].free;
}
/*
attach_twigs(qp, new_twigs, size);
}
- return (new_ref);
+ return new_ref;
}
/*
if (cells_immutable(qp, qp->root_ref)) {
qp->root_ref = evacuate(qp, MOVABLE_ROOT(qp));
}
- return (ref_ptr(qp, qp->root_ref));
+ return ref_ptr(qp, qp->root_ref);
}
static inline void
}
*child = make_node(branch_index(child), new_grandtwigs);
}
- return (twigs_ref);
+ return twigs_ref;
}
static void
qp->compact_all = true;
}
}
- return (destroyed);
+ return destroyed;
}
/***********************************************************************
qp->chunk_max * sizeof(qp->base->ptr[0]) +
qp->chunk_max * sizeof(qp->usage[0]);
- return (memusage);
+ return memusage;
}
dns_qp_memusage_t
}
UNLOCK(&multi->mutex);
- return (memusage);
+ return memusage;
}
void
qp->hold_count = qp->free_count;
*qptp = qp;
- return (qp);
+ return qp;
}
/*
} else {
multi = unpack_reader(qp, reader);
}
- return (multi);
+ return multi;
}
/*
attach_leaf(qp, new_twigs);
qp->leaf_count++;
qp->root_ref = new_ref;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
old_keylen = leaf_qpkey(qp, n, old_key);
offset = qpkey_compare(new_key, new_keylen, old_key, old_keylen);
if (offset == QPKEY_EQUAL) {
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
new_bit = qpkey_bit(new_key, new_keylen, offset);
old_bit = qpkey_bit(old_key, old_keylen, offset);
attach_leaf(qp, &new_leaf);
qp->leaf_count++;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
growbranch:
INSIST(!branch_has_twig(n, new_bit));
}
qp->leaf_count++;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(search_keylen < sizeof(dns_qpkey_t));
if (get_root(qp) == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
dns_qpshift_t bit = 0; /* suppress warning */
prefetch_twigs(qp, n);
bit = branch_keybit(n, search_key, search_keylen);
if (!branch_has_twig(n, bit)) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
make_twigs_mutable(qp, n);
parent = n;
if (qpkey_compare(search_key, search_keylen, found_key, found_keylen) !=
QPKEY_EQUAL)
{
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
SET_IF_NOT_NULL(pval_r, leaf_pval(n));
INSIST(n == get_root(qp));
free_twigs(qp, qp->root_ref, 1);
qp->root_ref = INVALID_REF;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* step back to parent node */
squash_twigs(qp, ref + size - 1, 1);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
uint32_t *ival_r) {
dns_qpkey_t key;
size_t keylen = dns_qpkey_fromname(key, name);
- return (dns_qp_deletekey(qp, key, keylen, pval_r, ival_r));
+ return dns_qp_deletekey(qp, key, keylen, pval_r, ival_r);
}
/***********************************************************************
dns_qpchain_length(dns_qpchain_t *chain) {
REQUIRE(QPCHAIN_VALID(chain));
- return (chain->len);
+ return chain->len;
}
void
max = branch_twigs_size(parent) - 1;
}
}
- return (pos == max);
+ return pos == max;
}
/*
node = get_root(qp);
if (node == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
do {
* the iterator, then return ISC_R_NOMORE.
*/
dns_qpiter_init(qpi->qp, qpi);
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
/*
SET_IF_NOT_NULL(pval_r, leaf_pval(node));
SET_IF_NOT_NULL(ival_r, leaf_ival(node));
maybe_set_name(qpi->qp, node, name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
dns_qpiter_next(dns_qpiter_t *qpi, dns_name_t *name, void **pval_r,
uint32_t *ival_r) {
- return (iterate(true, qpi, name, pval_r, ival_r));
+ return iterate(true, qpi, name, pval_r, ival_r);
}
isc_result_t
dns_qpiter_prev(dns_qpiter_t *qpi, dns_name_t *name, void **pval_r,
uint32_t *ival_r) {
- return (iterate(false, qpi, name, pval_r, ival_r));
+ return iterate(false, qpi, name, pval_r, ival_r);
}
isc_result_t
node = qpi->stack[qpi->sp];
if (node == NULL || is_branch(node)) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
SET_IF_NOT_NULL(pval_r, leaf_pval(node));
SET_IF_NOT_NULL(ival_r, leaf_ival(node));
maybe_set_name(qpi->qp, node, name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/***********************************************************************
n = get_root(qp);
if (n == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
while (is_branch(n)) {
prefetch_twigs(qp, n);
bit = branch_keybit(n, search_key, search_keylen);
if (!branch_has_twig(n, bit)) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
n = branch_twig_ptr(qp, n, bit);
}
if (qpkey_compare(search_key, search_keylen, found_key, found_keylen) !=
QPKEY_EQUAL)
{
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
SET_IF_NOT_NULL(pval_r, leaf_pval(n));
SET_IF_NOT_NULL(ival_r, leaf_ival(n));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
uint32_t *ival_r) {
dns_qpkey_t key;
size_t keylen = dns_qpkey_fromname(key, name);
- return (dns_qp_getkey(qpr, key, keylen, pval_r, ival_r));
+ return dns_qp_getkey(qpr, key, keylen, pval_r, ival_r);
}
static inline void
while (is_branch(n)) {
n = branch_twigs(qp, n);
}
- return (n);
+ return n;
}
static inline int
dns_qpshift_t fbit) {
dns_qpweight_t pos = branch_twig_pos(n, sbit);
if (branch_has_twig(n, sbit)) {
- return (pos - (kbit < fbit));
+ return pos - (kbit < fbit);
}
- return (pos - 1);
+ return pos - 1;
}
/*
n = get_root(qp);
if (n == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
iter->stack[0] = n;
SET_IF_NOT_NULL(pval_r, leaf_pval(n));
SET_IF_NOT_NULL(ival_r, leaf_ival(n));
maybe_set_name(qp, n, foundname);
- return (result);
+ return result;
}
/*
SET_IF_NOT_NULL(pval_r, leaf_pval(n));
SET_IF_NOT_NULL(ival_r, leaf_ival(n));
maybe_set_name(qp, n, foundname);
- return (DNS_R_PARTIALMATCH);
+ return DNS_R_PARTIALMATCH;
} else {
/*
* oops, during the search we found and added
}
/* nothing was found at all */
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/**********************************************************************/
static inline dns_qpref_t
make_ref(dns_qpchunk_t chunk, dns_qpcell_t cell) {
- return (QP_CHUNK_SIZE * chunk + cell);
+ return QP_CHUNK_SIZE * chunk + cell;
}
static inline dns_qpchunk_t
ref_chunk(dns_qpref_t ref) {
- return (ref / QP_CHUNK_SIZE);
+ return ref / QP_CHUNK_SIZE;
}
static inline dns_qpcell_t
ref_cell(dns_qpref_t ref) {
- return (ref % QP_CHUNK_SIZE);
+ return ref % QP_CHUNK_SIZE;
}
/*
static inline bool
qpbase_unref(dns_qpreadable_t qpr) {
dns_qpreader_t *qp = dns_qpreader(qpr);
- return (qp->base != NULL &&
- isc_refcount_decrement(&qp->base->refcount) == 1);
+ return qp->base != NULL &&
+ isc_refcount_decrement(&qp->base->refcount) == 1;
}
/*
static inline dns_qpnode_t *
ref_ptr(dns_qpreadable_t qpr, dns_qpref_t ref) {
dns_qpreader_t *qp = dns_qpreader(qpr);
- return (qp->base->ptr[ref_chunk(ref)] + ref_cell(ref));
+ return qp->base->ptr[ref_chunk(ref)] + ref_cell(ref);
}
/***********************************************************************
node64(dns_qpnode_t *n) {
uint64_t lo = n->biglo;
uint64_t hi = n->bighi;
- return (lo | (hi << 32));
+ return lo | (hi << 32);
}
/*
*/
static inline uint32_t
node32(dns_qpnode_t *n) {
- return (n->small);
+ return n->small;
}
/*
*/
static inline dns_qpnode_t
make_node(uint64_t big, uint32_t small) {
- return ((dns_qpnode_t){
+ return (dns_qpnode_t){
.biglo = (uint32_t)(big),
.bighi = (uint32_t)(big >> 32),
.small = small,
- });
+ };
}
/*
*/
static inline void *
node_pointer(dns_qpnode_t *n) {
- return ((void *)(uintptr_t)(node64(n) & ~TAG_MASK));
+ return (void *)(uintptr_t)(node64(n) & ~TAG_MASK);
}
/*
*/
static inline uint32_t
node_tag(dns_qpnode_t *n) {
- return (n->biglo & TAG_MASK);
+ return n->biglo & TAG_MASK;
}
/*
*/
static inline bool
is_branch(dns_qpnode_t *n) {
- return (n->biglo & BRANCH_TAG);
+ return n->biglo & BRANCH_TAG;
}
/* leaf nodes *********************************************************/
*/
static inline void *
leaf_pval(dns_qpnode_t *n) {
- return (node_pointer(n));
+ return node_pointer(n);
}
/*
*/
static inline uint32_t
leaf_ival(dns_qpnode_t *n) {
- return (node32(n));
+ return node32(n);
}
/*
make_leaf(const void *pval, uint32_t ival) {
dns_qpnode_t leaf = make_node((uintptr_t)pval, ival);
REQUIRE(node_tag(&leaf) == LEAF_TAG);
- return (leaf);
+ return leaf;
}
/* branch nodes *******************************************************/
*/
static inline uint64_t
branch_index(dns_qpnode_t *n) {
- return (node64(n));
+ return node64(n);
}
/*
*/
static inline dns_qpref_t
branch_twigs_ref(dns_qpnode_t *n) {
- return (node32(n));
+ return node32(n);
}
/*
static inline dns_qpshift_t
qpkey_bit(const dns_qpkey_t key, size_t len, size_t offset) {
if (offset < len) {
- return (key[offset]);
+ return key[offset];
} else {
- return (SHIFT_NOBYTE);
+ return SHIFT_NOBYTE;
}
}
*/
static inline size_t
branch_key_offset(dns_qpnode_t *n) {
- return ((size_t)(branch_index(n) >> SHIFT_OFFSET));
+ return (size_t)(branch_index(n) >> SHIFT_OFFSET);
}
/*
*/
static inline dns_qpshift_t
branch_keybit(dns_qpnode_t *n, const dns_qpkey_t key, size_t len) {
- return (qpkey_bit(key, len, branch_key_offset(n)));
+ return qpkey_bit(key, len, branch_key_offset(n));
}
/*
*/
static inline dns_qpnode_t *
branch_twigs(dns_qpreadable_t qpr, dns_qpnode_t *n) {
- return (ref_ptr(qpr, branch_twigs_ref(n)));
+ return ref_ptr(qpr, branch_twigs_ref(n));
}
/*
get_root(dns_qpreadable_t qpr) {
dns_qpreader_t *qp = dns_qpreader(qpr);
if (qp->root_ref == INVALID_REF) {
- return (NULL);
+ return NULL;
} else {
- return (ref_ptr(qp, qp->root_ref));
+ return ref_ptr(qp, qp->root_ref);
}
}
branch_count_bitmap_before(dns_qpnode_t *n, dns_qpshift_t bit) {
uint64_t mask = (1ULL << bit) - 1 - TAG_MASK;
uint64_t bitmap = branch_index(n) & mask;
- return ((dns_qpweight_t)__builtin_popcountll(bitmap));
+ return (dns_qpweight_t)__builtin_popcountll(bitmap);
}
/*
*/
static inline dns_qpweight_t
branch_twigs_size(dns_qpnode_t *n) {
- return (branch_count_bitmap_before(n, SHIFT_OFFSET));
+ return branch_count_bitmap_before(n, SHIFT_OFFSET);
}
/*
*/
static inline dns_qpweight_t
branch_twig_pos(dns_qpnode_t *n, dns_qpshift_t bit) {
- return (branch_count_bitmap_before(n, bit));
+ return branch_count_bitmap_before(n, bit);
}
/*
*/
static inline dns_qpnode_t *
branch_twig_ptr(dns_qpreadable_t qpr, dns_qpnode_t *n, dns_qpshift_t bit) {
- return (ref_ptr(qpr, branch_twigs_ref(n) + branch_twig_pos(n, bit)));
+ return ref_ptr(qpr, branch_twigs_ref(n) + branch_twig_pos(n, bit));
}
/*
*/
static inline bool
branch_has_twig(dns_qpnode_t *n, dns_qpshift_t bit) {
- return (branch_index(n) & (1ULL << bit));
+ return branch_index(n) & (1ULL << bit);
}
/* twig logistics *****************************************************/
static inline bool
reader_valid(dns_qpnode_t *reader) {
- return (reader != NULL && //
- node_tag(&reader[0]) == READER_TAG &&
- node_tag(&reader[1]) == READER_TAG &&
- node32(&reader[0]) == QPREADER_MAGIC);
+ return reader != NULL && //
+ node_tag(&reader[0]) == READER_TAG &&
+ node_tag(&reader[1]) == READER_TAG &&
+ node32(&reader[0]) == QPREADER_MAGIC;
}
/*
.root_ref = node32(&reader[1]),
.base = base,
};
- return (multi);
+ return multi;
}
/***********************************************************************
size_t len = qp->methods->makekey(key, qp->uctx, leaf_pval(n),
leaf_ival(n));
INSIST(len < sizeof(dns_qpkey_t));
- return (len);
+ return len;
}
static inline char *
triename(dns_qpreadable_t qpr, char *buf, size_t size) {
dns_qpreader_t *qp = dns_qpreader(qpr);
qp->methods->triename(qp->uctx, buf, size);
- return (buf);
+ return buf;
}
#define TRIENAME(qp) \
*/
static inline bool
qp_common_character(uint8_t byte) {
- return (('-' <= byte && byte <= '9') || ('_' <= byte && byte <= 'z'));
+ return ('-' <= byte && byte <= '9') || ('_' <= byte && byte <= 'z');
}
/*
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
qpcnode_t *data = pval;
- return (dns_qpkey_fromname(key, &data->name));
+ return dns_qpkey_fromname(key, &data->name);
}
static void
DNS_SLABHEADERATTR_ANCIENT |
DNS_SLABHEADERATTR_ZEROTTL)) != 0)
{
- return (false);
+ return false;
}
#if DNS_QPDB_LIMITLRUUPDATE
* Glue records are updated if at least DNS_QPDB_LRUUPDATE_GLUE
* seconds have passed since the previous update time.
*/
- return (header->last_used + DNS_QPDB_LRUUPDATE_GLUE <= now);
+ return header->last_used + DNS_QPDB_LRUUPDATE_GLUE <= now;
}
/*
* Other records are updated if DNS_QPDB_LRUUPDATE_REGULAR seconds
* have passed.
*/
- return (header->last_used + DNS_QPDB_LRUUPDATE_REGULAR <= now);
+ return header->last_used + DNS_QPDB_LRUUPDATE_REGULAR <= now;
#else
UNUSED(now);
- return (true);
+ return true;
#endif /* if DNS_QPDB_LIMITLRUUPDATE */
}
}
qpcnode_unref(node);
- return (no_reference);
+ return no_reference;
}
/* Upgrade the lock? */
if (refs > 1) {
qpcnode_unref(node);
- return (false);
+ return false;
}
INSIST(refs == 1);
}
qpcnode_unref(node);
- return (true);
+ return true;
}
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
DNS_SLABHEADER_SETATTR(
header,
DNS_SLABHEADERATTR_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, &nlocktype);
- return (result);
+ return result;
}
static isc_result_t
}
}
- return (result);
+ return result;
}
/*
result = dns_qp_lookup(search->qpdb->nsec, name, NULL, &iter, NULL,
(void **)&node, NULL);
if (result != DNS_R_PARTIALMATCH) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
fname = dns_fixedname_initname(&fixed);
*/
result = dns_qpiter_current(&iter, predecessor, NULL, NULL);
if (result != ISC_R_SUCCESS) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
result = dns_qp_getname(search->qpdb->tree, predecessor, (void **)&node,
NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_name_copy(&node->name, fname);
result = ISC_R_NOTFOUND;
}
NODE_UNLOCK(lock, &nlocktype);
- return (result);
+ return result;
}
static isc_result_t
}
update_cachestats(search.qpdb, result);
- return (result);
+ return result;
}
static isc_result_t
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
static isc_result_t
NODE_UNLOCK(lock, &nlocktype);
if (found == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (NEGATIVE(found)) {
update_cachestats(qpdb, result);
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(stats != NULL);
isc_stats_attach(stats, &qpdb->cachestats);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static dns_stats_t *
REQUIRE(VALID_QPDB(qpdb));
- return (qpdb->rrsetstats);
+ return qpdb->rrsetstats;
}
static isc_result_t
/* currently no bounds checking. 0 means disable. */
qpdb->common.serve_stale_ttl = ttl;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(VALID_QPDB(qpdb));
*ttl = qpdb->common.serve_stale_ttl;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
/* currently no bounds checking. 0 means disable. */
qpdb->serve_stale_refresh = interval;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(VALID_QPDB(qpdb));
*interval = qpdb->serve_stale_refresh;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
static size_t
rdataset_size(dns_slabheader_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 size_t
purged += header_size;
}
- return (purged);
+ return purged;
}
/*%
dns_slabheader_t *h1 = v1;
dns_slabheader_t *h2 = v2;
- return (h1->ttl < h2->ttl);
+ return h1->ttl < h2->ttl;
}
/*%
fprintf(stderr, "new_qpcnode:%s:%s:%d:%p->references = 1\n", __func__,
__FILE__, __LINE__ + 1, name);
#endif
- return (newdata);
+ return newdata;
}
static isc_result_t
unlock:
TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
- return (result);
+ return result;
}
static void
dns_qpiter_init(qpdb->tree, &qpdbiter->iter);
*iteratorp = (dns_dbiterator_t *)qpdbiter;
- 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 bool
overmaxtype(qpcache_t *qpdb, uint32_t ntypes) {
if (qpdb->maxtypepername == 0) {
- return (false);
+ return false;
}
- return (ntypes >= qpdb->maxtypepername);
+ return ntypes >= qpdb->maxtypepername;
}
static bool
prio_header(dns_slabheader_t *header) {
if (NEGATIVE(header) && prio_type(DNS_TYPEPAIR_COVERS(header->type))) {
- return (true);
+ return true;
}
- return (prio_type(header->type));
+ return prio_type(header->type);
}
static isc_result_t
addedrdataset
DNS__DB_FLARG_PASS);
}
- return (DNS_R_UNCHANGED);
+ return DNS_R_UNCHANGED;
}
/*
* The new rdataset is better. Expire the
*/
if (header_nx && newheader_nx) {
dns_slabheader_destroy(&newheader);
- return (DNS_R_UNCHANGED);
+ return DNS_R_UNCHANGED;
}
/*
nlocktype, tlocktype,
addedrdataset DNS__DB_FLARG_PASS);
}
- return (DNS_R_UNCHANGED);
+ return DNS_R_UNCHANGED;
}
/*
nlocktype, tlocktype,
addedrdataset DNS__DB_FLARG_PASS);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
nlocktype, tlocktype,
addedrdataset DNS__DB_FLARG_PASS);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (loading) {
*/
if (newheader_nx) {
dns_slabheader_destroy(&newheader);
- return (DNS_R_UNCHANGED);
+ return DNS_R_UNCHANGED;
}
idx = HEADERNODE(newheader)->locknum;
addedrdataset DNS__DB_FLARG_PASS);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_rdataset_disassociate(&neg);
dns_rdataset_disassociate(&negsig);
- return (result);
+ return result;
}
static isc_result_t
cleanup:
dns_rdataset_disassociate(&neg);
dns_rdataset_disassociate(&negsig);
- return (result);
+ return result;
}
static void
®ion, sizeof(dns_slabheader_t),
qpdb->maxrrperset);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
name = dns_fixedname_initname(&fixed);
qpdb->maxrrperset, rdataset);
if (result != ISC_R_SUCCESS) {
dns_slabheader_destroy(&newheader);
- return (result);
+ return result;
}
}
if ((rdataset->attributes & DNS_RDATASETATTR_CLOSEST) != 0) {
qpdb->maxrrperset, rdataset);
if (result != ISC_R_SUCCESS) {
dns_slabheader_destroy(&newheader);
- return (result);
+ return result;
}
}
}
INSIST(tlocktype == isc_rwlocktype_none);
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(version == NULL);
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 = dns_slabheader_new(db, node);
isc_rwlocktype_none DNS__DB_FLARG_PASS);
NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
- return (result);
+ return result;
}
static unsigned int
}
TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
- return (mu.leaves);
+ return mu.leaves;
}
static isc_result_t
result = ISC_R_NOTFOUND;
}
- return (result);
+ return result;
}
static void
*dbp = (dns_db_t *)qpdb;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
* Is this a "this rdataset doesn't exist" record?
*/
if (NONEXISTENT(header)) {
- return (false);
+ return false;
}
/*
* If this header is still active then return it.
*/
if (ACTIVE(header, iterator->common.now)) {
- return (true);
+ return true;
}
/*
* too old don't return it.
*/
if (!STALEOK(iterator) || (iterator->common.now > stale_ttl)) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static isc_result_t
iterator->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 = iterator->current;
if (header == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
NODE_RDLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
iterator->current = header;
if (header == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
qpdbiter->result != DNS_R_PARTIALMATCH &&
qpdbiter->result != ISC_R_NOMORE)
{
- return (qpdbiter->result);
+ return qpdbiter->result;
}
if (qpdbiter->paused) {
ENSURE(!qpdbiter->paused);
}
- return (result);
+ return result;
}
static isc_result_t
qpdbiter->result != DNS_R_PARTIALMATCH &&
qpdbiter->result != ISC_R_NOMORE)
{
- return (qpdbiter->result);
+ return qpdbiter->result;
}
if (qpdbiter->paused) {
}
qpdbiter->result = result;
- return (result);
+ return result;
}
static isc_result_t
qpdbiter->result != DNS_R_PARTIALMATCH &&
qpdbiter->result != ISC_R_NOMORE)
{
- return (qpdbiter->result);
+ return qpdbiter->result;
}
if (qpdbiter->paused) {
qpdbiter->result = (result == DNS_R_PARTIALMATCH) ? ISC_R_SUCCESS
: result;
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(qpdbiter->node != NULL);
if (qpdbiter->result != ISC_R_SUCCESS) {
- return (qpdbiter->result);
+ return qpdbiter->result;
}
if (qpdbiter->paused) {
}
qpdbiter->result = result;
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(qpdbiter->node != NULL);
if (qpdbiter->result != ISC_R_SUCCESS) {
- return (qpdbiter->result);
+ return qpdbiter->result;
}
if (qpdbiter->paused) {
}
qpdbiter->result = result;
- return (result);
+ return result;
}
static isc_result_t
qpdbiter->tree_locked DNS__DB_FLARG_PASS);
*nodep = (dns_dbnode_t *)qpdbiter->node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
qpdbiter->result != DNS_R_PARTIALMATCH &&
qpdbiter->result != ISC_R_NOMORE)
{
- return (qpdbiter->result);
+ return qpdbiter->result;
}
if (qpdbiter->paused) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
qpdbiter->paused = true;
}
INSIST(qpdbiter->tree_locked == isc_rwlocktype_none);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
qpc_dbit_t *qpdbiter = (qpc_dbit_t *)iterator;
if (qpdbiter->result != ISC_R_SUCCESS) {
- return (qpdbiter->result);
+ return qpdbiter->result;
}
dns_name_copy(dns_rootname, name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
dns_slabheader_t *h1 = v1;
dns_slabheader_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 == DNS_SIGTYPE(dns_rdatatype_soa)));
+ 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 == DNS_SIGTYPE(dns_rdatatype_soa));
}
/*%
fprintf(stderr, "new_qpznode:%s:%s:%d:%p->references = 1\n", __func__,
__FILE__, __LINE__ + 1, name);
#endif
- return (newdata);
+ return newdata;
}
static qpz_version_t *
isc_rwlock_init(&version->rwlock);
isc_refcount_init(&version->references, references);
- return (version);
+ return version;
}
isc_result_t
if (result != ISC_R_SUCCESS) {
INSIST(result != ISC_R_EXISTS);
free_qpdb(qpdb, false);
- return (result);
+ return result;
}
/*
if (result != ISC_R_SUCCESS) {
INSIST(result != ISC_R_EXISTS);
free_qpdb(qpdb, false);
- return (result);
+ return result;
}
/*
*dbp = (dns_db_t *)qpdb;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
*versionp = (dns_dbversion_t *)version;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
}
if (found == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
delegating_type(qpzonedb_t *qpdb, qpznode_t *node, dns_typepair_t type) {
- return (type == dns_rdatatype_dname ||
- (type == dns_rdatatype_ns &&
- (node != qpdb->origin || IS_STUB(qpdb))));
+ return type == dns_rdatatype_dname ||
+ (type == dns_rdatatype_ns &&
+ (node != qpdb->origin || IS_STUB(qpdb)));
}
static void
* with priority types, we know there will not be a
* CNAME, and are safe to skip the rest.
*/
- return (false);
+ return false;
}
rdtype = DNS_TYPEPAIR_TYPE(header->type);
}
if (cname && other) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static qpz_changed_t *
newref(qpdb, node DNS__DB_FLARG_PASS);
RWUNLOCK(&qpdb->lock, isc_rwlocktype_write);
- return (changed);
+ return changed;
}
static uint64_t
recordsize(dns_slabheader_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
}
} else {
dns_slabheader_destroy(&newheader);
- return (result);
+ return result;
}
}
*/
if (NONEXISTENT(newheader)) {
dns_slabheader_destroy(&newheader);
- return (DNS_R_UNCHANGED);
+ return DNS_R_UNCHANGED;
}
if (RESIGN(newheader)) {
ntypes >= qpdb->maxtypepername)
{
dns_slabheader_destroy(&newheader);
- return (DNS_R_TOOMANYRECORDS);
+ return DNS_R_TOOMANYRECORDS;
}
INSIST(newheader->down == NULL);
* Check if the node now contains CNAME and other data.
*/
if (cname_and_other(node, version->serial)) {
- return (DNS_R_CNAMEANDOTHER);
+ return DNS_R_CNAMEANDOTHER;
}
if (addedrdataset != NULL) {
addedrdataset DNS__DB_FLARG_PASS);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
if (rdataset->type == dns_rdatatype_soa &&
!dns_name_equal(name, &qpdb->common.origin))
{
- return (DNS_R_NOTZONETOP);
+ return DNS_R_NOTZONETOP;
}
if (rdataset->type != dns_rdatatype_nsec3 &&
/*
* NS owners cannot legally be wild cards.
*/
- return (DNS_R_INVALIDNS);
+ return DNS_R_INVALIDNS;
}
if (rdataset->type == dns_rdatatype_nsec3) {
/*
* NSEC3 owners cannot legally be wild cards.
*/
- return (DNS_R_INVALIDNSEC3);
+ return DNS_R_INVALIDNSEC3;
}
wildcardmagic(qpdb, loadctx->tree, name);
®ion, sizeof(dns_slabheader_t),
qpdb->maxrrperset);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
newheader = (dns_slabheader_t *)region.base;
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
static void
callbacks->commit = loading_commit;
callbacks->add_private = loadctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_mem_put(qpdb->common.mctx, loadctx, sizeof(*loadctx));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
secure = qpdb->current_version->secure;
RWUNLOCK(&qpdb->lock, isc_rwlocktype_read);
- return (secure);
+ return secure;
}
static isc_result_t
}
RWUNLOCK(&qpdb->lock, isc_rwlocktype_read);
- return (result);
+ return result;
}
static isc_result_t
RWUNLOCK(&version->rwlock, isc_rwlocktype_read);
RWUNLOCK(&qpdb->lock, isc_rwlocktype_read);
- return (result);
+ return result;
}
static isc_result_t
}
NODE_UNLOCK(&qpdb->node_locks[HEADERNODE(header)->locknum].lock,
&nlocktype);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
header = isc_heap_element(qpdb->heap, 1);
if (header == NULL) {
RWUNLOCK(&qpdb->lock, isc_rwlocktype_read);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
locknum = HEADERNODE(header)->locknum;
RWUNLOCK(&qpdb->lock, isc_rwlocktype_read);
RWUNLOCK(&qpdb->lock, isc_rwlocktype_read);
NODE_UNLOCK(&qpdb->node_locks[locknum].lock, &nlocktype);
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(stats != NULL);
isc_stats_attach(stats, &qpdb->gluecachestats);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
if (result != ISC_R_SUCCESS) {
if (!create) {
dns_qpread_destroy(dbtree, &qpr);
- return (result);
+ return result;
}
node = new_qpznode(qpdb, name);
*nodep = (dns_dbnode_t *)node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
REQUIRE(VALID_QPZONE(qpdb));
- return (findnodeintree(qpdb, name, create, false,
- nodep DNS__DB_FLARG_PASS));
+ return findnodeintree(qpdb, name, create, false,
+ nodep DNS__DB_FLARG_PASS);
}
static isc_result_t
REQUIRE(VALID_QPZONE(qpdb));
- return (findnodeintree(qpdb, name, create, true,
- nodep DNS__DB_FLARG_PASS));
+ return findnodeintree(qpdb, name, create, true,
+ nodep DNS__DB_FLARG_PASS);
}
static bool
memcmp(nsec3.salt, search->version->salt,
nsec3.salt_length) == 0)
{
- return (true);
+ return true;
}
dns_rdata_reset(&rdata);
}
- return (false);
+ return false;
}
static isc_result_t
}
if (type == dns_rdatatype_dname) {
- return (DNS_R_DNAME);
+ return DNS_R_DNAME;
}
- return (DNS_R_DELEGATION);
+ return DNS_R_DELEGATION;
}
typedef enum { FORWARD, BACK } direction_t;
if (nextname != NULL) {
dns_name_copy(nodename, nextname);
}
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static bool
isc_result_t result = dns_qpiter_next(it, NULL, NULL, NULL);
if (result != ISC_R_SUCCESS) {
/* An ENT at the end of the zone is impossible */
- return (false);
+ return false;
}
- return (step(search, it, FORWARD, next) &&
- dns_name_issubdomain(next, current));
+ return step(search, it, FORWARD, next) &&
+ dns_name_issubdomain(next, current);
}
static bool
if (!check_prev && !check_next) {
/* No predecessor or successor was found at all? */
- return (false);
+ return false;
}
dns_name_clone(qname, &rname);
if ((check_prev && dns_name_issubdomain(prev, &rname)) ||
(check_next && dns_name_issubdomain(next, &rname)))
{
- return (true);
+ return true;
}
/*
dns_name_getlabelsequence(&rname, 1, n - 1, &rname);
} while (!dns_name_equal(&rname, &tname));
- return (false);
+ return false;
}
static isc_result_t
if (wildcard_blocked(search, qname,
wname))
{
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
/*
}
}
- return (result);
+ return result;
}
/*
if (type == dns_rdatatype_nsec3) {
result = dns_qpiter_prev(&search->iter, name, (void **)nodep,
NULL);
- return (result);
+ return result;
}
dns_qpmulti_query(search->qpdb->nsec, &qpr);
}
dns_qpread_destroy(search->qpdb->nsec, &qpr);
- return (result);
+ return result;
}
/*
*/
result = dns_qpiter_current(&search->iter, name, (void **)&node, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
again:
do {
result = DNS_R_BADDB;
}
- return (result);
+ return result;
}
static isc_result_t
NODE_UNLOCK(&(search->qpdb->node_locks[node->locknum].lock),
&nlocktype);
- return (result);
+ return result;
}
static isc_result_t
newref(search.qpdb, node DNS__DB_FLARG_PASS);
*nodep = (dns_dbnode_t *)node;
}
- if ((search.version->secure && !search.version->havensec3)) {
+ if (search.version->secure && !search.version->havensec3) {
bindrdataset(search.qpdb, node, nsecheader, 0,
rdataset DNS__DB_FLARG_PASS);
if (nsecsig != NULL) {
closeversion(db, &version, false DNS__DB_FLARG_PASS);
}
- return (result);
+ return result;
}
static isc_result_t
newref(qpdb, node DNS__DB_FLARG_PASS);
*iteratorp = (dns_rdatasetiter_t *)iterator;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
UNREACHABLE();
}
- return (mu.leaves);
+ return mu.leaves;
}
static void
newref(qpdb, qpdb->origin DNS__DB_FLARG_PASS);
*nodep = (dns_dbnode_t *)qpdb->origin;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
qrditer->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 = qrditer->current;
if (header == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
NODE_RDLOCK(&qpdb->node_locks[node->locknum].lock, &nlocktype);
qrditer->current = header;
if (header == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
qpdbiter->result != DNS_R_PARTIALMATCH &&
qpdbiter->result != ISC_R_NOMORE)
{
- return (qpdbiter->result);
+ return qpdbiter->result;
}
dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
qpdbiter->node = NULL;
}
qpdbiter->result = result;
- return (result);
+ return result;
}
static isc_result_t
qpdbiter->result != DNS_R_PARTIALMATCH &&
qpdbiter->result != ISC_R_NOMORE)
{
- return (qpdbiter->result);
+ return qpdbiter->result;
}
dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
qpdbiter->node = NULL;
}
qpdbiter->result = result;
- return (result);
+ return result;
}
static isc_result_t
qpdbiter->result != DNS_R_PARTIALMATCH &&
qpdbiter->result != ISC_R_NOMORE)
{
- return (qpdbiter->result);
+ return qpdbiter->result;
}
dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
qpdbiter->result = (result == DNS_R_PARTIALMATCH) ? ISC_R_SUCCESS
: result;
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(qpdbiter->node != NULL);
if (qpdbiter->result != ISC_R_SUCCESS) {
- return (qpdbiter->result);
+ return qpdbiter->result;
}
dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
}
qpdbiter->result = result;
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(qpdbiter->node != NULL);
if (qpdbiter->result != ISC_R_SUCCESS) {
- return (qpdbiter->result);
+ return qpdbiter->result;
}
dereference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
}
qpdbiter->result = result;
- return (result);
+ return result;
}
static isc_result_t
*nodep = (dns_dbnode_t *)qpdbiter->node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dbiterator_pause(dns_dbiterator_t *iterator ISC_ATTR_UNUSED) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
if (qpdbiter->result != ISC_R_SUCCESS) {
- return (qpdbiter->result);
+ return qpdbiter->result;
}
dns_name_copy(dns_rootname, name);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_qpiter_init(iter->nsnap, &iter->nsec3iter);
*iteratorp = (dns_dbiterator_t *)iter;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
* SOA records are only allowed at top of zone.
*/
if (rdataset->type == dns_rdatatype_soa && node != qpdb->origin) {
- return (DNS_R_NOTZONETOP);
+ return DNS_R_NOTZONETOP;
}
- REQUIRE(((node->nsec == DNS_DB_NSEC_NSEC3 &&
- (rdataset->type == dns_rdatatype_nsec3 ||
- rdataset->covers == dns_rdatatype_nsec3)) ||
- (node->nsec != DNS_DB_NSEC_NSEC3 &&
- rdataset->type != dns_rdatatype_nsec3 &&
- rdataset->covers != dns_rdatatype_nsec3)));
+ REQUIRE((node->nsec == DNS_DB_NSEC_NSEC3 &&
+ (rdataset->type == dns_rdatatype_nsec3 ||
+ rdataset->covers == dns_rdatatype_nsec3)) ||
+ (node->nsec != DNS_DB_NSEC_NSEC3 &&
+ rdataset->type != dns_rdatatype_nsec3 &&
+ rdataset->covers != dns_rdatatype_nsec3));
result = dns_rdataslab_fromrdataset(rdataset, qpdb->common.mctx,
®ion, sizeof(dns_slabheader_t),
qpdb->maxrrperset);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_name_copy(&node->name, name);
dns_qpmulti_commit(qpdb->nsec, &nsec);
}
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(VALID_QPZONE(qpdb));
REQUIRE(version != NULL && version->qpdb == qpdb);
- REQUIRE(((node->nsec == DNS_DB_NSEC_NSEC3 &&
- (rdataset->type == dns_rdatatype_nsec3 ||
- rdataset->covers == dns_rdatatype_nsec3)) ||
- (node->nsec != DNS_DB_NSEC_NSEC3 &&
- rdataset->type != dns_rdatatype_nsec3 &&
- rdataset->covers != dns_rdatatype_nsec3)));
+ REQUIRE((node->nsec == DNS_DB_NSEC_NSEC3 &&
+ (rdataset->type == dns_rdatatype_nsec3 ||
+ rdataset->covers == dns_rdatatype_nsec3)) ||
+ (node->nsec != DNS_DB_NSEC_NSEC3 &&
+ rdataset->type != dns_rdatatype_nsec3 &&
+ rdataset->covers != dns_rdatatype_nsec3));
dns_name_copy(&node->name, nodename);
result = dns_rdataslab_fromrdataset(rdataset, qpdb->common.mctx,
®ion, sizeof(dns_slabheader_t),
0);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
newheader = (dns_slabheader_t *)region.base;
unlock:
NODE_UNLOCK(&qpdb->node_locks[node->locknum].lock, &nlocktype);
- return (result);
+ return result;
}
static isc_result_t
REQUIRE(version != NULL && version->qpdb == qpdb);
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 = dns_slabheader_new(db, (dns_dbnode_t *)node);
result = add(qpdb, node, nodename, version, newheader, DNS_DBADD_FORCE,
false, NULL, 0 DNS__DB_FLARG_PASS);
NODE_UNLOCK(&qpdb->node_locks[node->locknum].lock, &nlocktype);
- return (result);
+ return result;
}
static isc_result_t
NODE_RDLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
dns_name_copy(&qpnode->name, name);
NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static dns_glue_t *
dns_name_copy(name, gluename);
- return (glue);
+ return glue;
}
static isc_result_t
(dns_dbnode_t **)&node_aaaa DNS__DB_FLARG_PASS);
}
- return (result);
+ return result;
}
#define IS_REQUIRED_GLUE(r) (((r)->attributes & DNS_RDATASETATTR_REQUIRED) != 0)
(void)dns_rdataset_additionaldata(rdataset, dns_rootname,
glue_nsdname_cb, &ctx);
- return (ctx.glue_list);
+ return ctx.glue_list;
}
static dns_gluenode_t *
isc_mem_attach(db->mctx, &gluenode->mctx);
qpznode_attach(node, &gluenode->node);
- return (gluenode);
+ return gluenode;
}
static void
static uint32_t
qpznode_hash(const qpznode_t *node) {
const uintptr_t key = (uintptr_t)node;
- return (isc_hash32(&key, sizeof(key), true));
+ return isc_hash32(&key, sizeof(key), true);
}
static int
caa_container_of(ht_node, dns_gluenode_t, ht_node);
const qpznode_t *node = key;
- return (gluenode->node == node);
+ return gluenode->node == node;
}
static uint32_t
gluenode_hash(const dns_gluenode_t *gluenode) {
- return (qpznode_hash(gluenode->node));
+ return qpznode_hash(gluenode->node);
}
static int
gluenode_match(struct cds_lfht_node *ht_node, const void *key) {
const dns_gluenode_t *gluenode = key;
- return (qpznode_match(ht_node, gluenode->node));
+ return qpznode_match(ht_node, gluenode->node);
}
static void
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
qpznode_t *data = pval;
- return (dns_qpkey_fromname(key, &data->name));
+ return dns_qpkey_fromname(key, &data->name);
}
static void
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 int)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 |= (ch - hexval);
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
REQUIRE(source != NULL);
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 isc_result_t
*/
isc_buffer_activeregion(source, &sr);
if (sr.length == 0) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
} else if (alg == DNS_KEYALG_PRIVATEOID) {
/*
ASN1_OBJECT_free(obj);
/* There should be a public key or signature after the OID. */
if (in >= sr.base + sr.length) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#include "code.h"
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;
dns_compress_rollback(cctx, target->used);
}
- return (result);
+ return result;
}
/*
result = dns_rdata_fromwire(NULL, rdclass, type, src,
DNS_DECOMPRESS_NEVER, dest);
- 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 = isc_ascii_tolower(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
hexvalue(char value) {
int hexval = isc_hex_char(value);
if (hexval == 0) {
- return (-1);
+ return -1;
} else {
- return (value - hexval);
+ return value - hexval;
}
}
static int
decvalue(char value) {
if (isdigit((unsigned char)value)) {
- return (value - '0');
+ return value - '0';
} else {
- return (-1);
+ return -1;
}
}
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";
}
static bool
for (size_t i = 0; i < ARRAY_SIZE(http); i++) {
if (len == http[i].len && memcmp(s, http[i].value, len) == 0) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static bool
isc_textregion_consume(alpn, 1);
if (c == ',') {
if (svcb_ishttp(s, (alpn->base - s) - 1)) {
- return (true);
+ return true;
}
s = alpn->base;
}
}
if (svcb_ishttp(s, (alpn->base - s))) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
isc_result_t
* Check that Alias Mode records don't have SvcParamKeys.
*/
if (svcb.priority == 0 && svcb.svclen != 0) {
- return (DNS_R_HAVEPARMKEYS);
+ return DNS_R_HAVEPARMKEYS;
}
if (dns_name_isdnssvcb(owner)) {
isc_region_consume(&r, len);
}
if (key != SVCB_ALPN_KEY) {
- return (DNS_R_NOALPN);
+ return DNS_R_NOALPN;
}
alpn = (isc_textregion_t){ .base = (char *)r.base,
.length = len };
isc_region_consume(&r, len);
}
if (key != SVCB_DOHPATH_KEY) {
- return (DNS_R_NODOHPATH);
+ return DNS_R_NODOHPATH;
}
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
* 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, NULL));
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->other = mem_maybedup(mctx, sr.base, tsig->otherlen);
tsig->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 (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
dns_name_fromregion(&name, ®ion);
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, 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, target));
+ return dns_name_fromwire(&name, source, dctx, 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, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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 DNS__DB_FILELINE));
+ return (add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE);
}
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, 0, target));
+ return dns_name_totext(&name, 0, 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, target));
+ return dns_name_fromwire(&name, source, dctx, 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->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
caa->value = mem_maybedup(mctx, sr.base, sr.length);
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);
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
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, target);
}
static isc_result_t
dctx = dns_decompress_setpermitted(dctx, true);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, target));
+ return dns_name_fromwire(&name, source, dctx, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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->len = region.length;
csync->typebits = mem_maybedup(mctx, region.base, region.length);
csync->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_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
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, target);
}
static isc_result_t
dctx = dns_decompress_setpermitted(dctx, false);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, target));
+ return dns_name_fromwire(&name, source, dctx, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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->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
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);
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
}
gpos->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_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(rdclass);
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->os = mem_maybedup(mctx, region.base, hinfo->os_len);
hinfo->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_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, 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;
}
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 int)(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
}
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
}
isdn->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_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;
}
/*
RETERR(check_private(&b, alg));
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
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
key->datalen = sr.length;
key->data = mem_maybedup(mctx, sr.base, key->datalen);
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) {
/* Not KEYDATA */
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
keydata->refresh = uint32_fromregion(&sr);
isc_region_consume(&sr, 4);
/* Add hold-down */
if (sr.length < 4) {
/* Not KEYDATA */
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
keydata->addhd = uint32_fromregion(&sr);
isc_region_consume(&sr, 4);
/* Remove hold-down */
if (sr.length < 4) {
/* Not KEYDATA */
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
keydata->removehd = uint32_fromregion(&sr);
isc_region_consume(&sr, 4);
/* Flags */
if (sr.length < 2) {
/* Not KEYDATA */
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
keydata->flags = uint16_fromregion(&sr);
isc_region_consume(&sr, 2);
/* Protocol */
if (sr.length < 1) {
/* Not KEYDATA */
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
keydata->protocol = uint8_fromregion(&sr);
isc_region_consume(&sr, 1);
/* Algorithm */
if (sr.length < 1) {
/* Not KEYDATA */
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
keydata->algorithm = uint8_fromregion(&sr);
isc_region_consume(&sr, 1);
keydata->datalen = sr.length;
keydata->data = mem_maybedup(mctx, sr.base, keydata->datalen);
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);
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, 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, target));
+ return dns_name_fromwire(&name, source, dctx, 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 DNS__DB_FILELINE);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return ((add)(arg, &name, dns_rdatatype_l64, NULL DNS__DB_FILELINE));
+ return (add)(arg, &name, dns_rdatatype_l64, NULL DNS__DB_FILELINE);
}
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
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, target);
}
static isc_result_t
dctx = dns_decompress_setpermitted(dctx, true);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, target));
+ return dns_name_fromwire(&name, source, dctx, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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 DNS__DB_FILELINE));
+ return (add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE);
}
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
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, target);
}
static isc_result_t
dctx = dns_decompress_setpermitted(dctx, true);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, target));
+ return dns_name_fromwire(&name, source, dctx, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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 DNS__DB_FILELINE));
+ return (add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE);
}
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
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, target);
}
static isc_result_t
dctx = dns_decompress_setpermitted(dctx, true);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, target));
+ return dns_name_fromwire(&name, source, dctx, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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 DNS__DB_FILELINE));
+ return (add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE);
}
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
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, target);
}
static isc_result_t
dctx = dns_decompress_setpermitted(dctx, true);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, target));
+ return dns_name_fromwire(&name, source, dctx, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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
opts = name_prefix(&email, tctx->origin, &prefix)
? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, target);
}
static isc_result_t
dns_name_init(&email, NULL);
RETERR(dns_name_fromwire(&rmail, source, dctx, target));
- return (dns_name_fromwire(&email, source, dctx, target));
+ return dns_name_fromwire(&email, source, dctx, target);
}
static isc_result_t
dns_name_fromregion(&rmail, ®ion);
isc_region_consume(®ion, rmail.length);
- return (dns_name_towire(&rmail, cctx, target, NULL));
+ return dns_name_towire(&rmail, cctx, target, NULL);
}
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
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, target);
}
static isc_result_t
dctx = dns_decompress_setpermitted(dctx, true);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, target));
+ return dns_name_fromwire(&name, source, dctx, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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);
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, 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, target));
+ return dns_name_fromwire(&name, source, dctx, target);
}
static isc_result_t
dns_name_init(&name, offsets);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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 DNS__DB_FILELINE);
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 DNS__DB_FILELINE));
+ return (add)(arg, dns_fixedname_name(&fixed), dns_rdatatype_tlsa,
+ NULL DNS__DB_FILELINE);
}
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);
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, 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, target));
+ return dns_name_fromwire(&name, source, dctx, target);
}
static isc_result_t
*/
dns_name_init(&name, offsets);
dns_name_fromregion(&name, &sr);
- return (dns_name_towire(&name, cctx, target, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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;
}
static void
dns_name_fromregion(&name, &sr);
if (atype != 0) {
- return ((add)(arg, &name, atype, NULL DNS__DB_FILELINE));
+ return (add)(arg, &name, atype, NULL DNS__DB_FILELINE);
}
- 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
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, target);
}
static isc_result_t
dctx = dns_decompress_setpermitted(dctx, true);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, target));
+ return dns_name_fromwire(&name, source, dctx, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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 DNS__DB_FILELINE));
+ return (add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE);
}
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
nsec3->len = region.length;
nsec3->typebits = mem_maybedup(mctx, region.base, region.length);
nsec3->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_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
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, NULL));
- 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->len = region.length;
nsec->typebits = mem_maybedup(mctx, region.base, region.length);
nsec->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_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);
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, NULL));
- 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->len = region.length;
nxt->typebits = mem_maybedup(mctx, region.base, region.length);
nxt->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));
- 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->length = sr.length;
sig->keyring = mem_maybedup(mctx, sr.base, sig->length);
sig->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
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;
case DNS_OPT_UL:
if (length != 4U && length != 8U) {
- 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;
case DNS_OPT_REPORT_CHANNEL:
/* A domain name in wire format. RFC 9567 */
if (length == 0 || length > DNS_NAME_MAXWIRE) {
- return (DNS_R_OPTERR);
+ return DNS_R_OPTERR;
}
isc_buffer_init(&b, sregion.base, length);
isc_buffer_add(&b, length);
if (result != ISC_R_SUCCESS || name->length != length ||
!dns_name_isabsolute(name))
{
- 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->options = mem_maybedup(mctx, r.base, r.length);
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) {
/* see RFC 3597 */
dctx = dns_decompress_setpermitted(dctx, false);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static isc_result_t towire_ #(ARGS_TOWIRE) {
/* see RFC 3597 */
dns_compress_setpermitted(cctx, false);
- 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
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, target);
}
static isc_result_t
dctx = dns_decompress_setpermitted(dctx, true);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, target));
+ return dns_name_fromwire(&name, source, dctx, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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
opts = name_prefix(&email, tctx->origin, &prefix)
? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, target);
}
static isc_result_t
dns_name_init(&email, NULL);
RETERR(dns_name_fromwire(&rmail, source, dctx, target));
- return (dns_name_fromwire(&email, source, dctx, target));
+ return dns_name_fromwire(&email, source, dctx, target);
}
static isc_result_t
dns_name_fromregion(&rmail, ®ion);
isc_region_consume(®ion, rmail.length);
- return (dns_name_towire(&rmail, cctx, target, NULL));
+ return dns_name_towire(&rmail, cctx, target, NULL);
}
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 */
RETERR(check_private(&b, alg));
}
- 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
* key footprint: 2
*/
if (sr.length < 18) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
algorithm = sr.base[2];
*/
isc_buffer_activeregion(source, &sr);
if (sr.length < 1) {
- return (DNS_R_FORMERR);
+ return DNS_R_FORMERR;
}
if (algorithm == DNS_KEYALG_PRIVATEDNS ||
}
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->siglen = sr.length;
sig->signature = mem_maybedup(mctx, sr.base, sig->siglen);
sig->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 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
dns_name_fromregion(&name, ®ion);
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, 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, target));
+ return dns_name_fromwire(&name, source, dctx, 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, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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 DNS__DB_FILELINE);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = (add)(arg, &name, dns_rdatatype_isdn, NULL DNS__DB_FILELINE);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return ((add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE));
+ return (add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE);
}
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 */
RETERR(check_private(&b, alg));
}
- 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
* key footprint: 2
*/
if (sr.length < 18) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
algorithm = sr.base[2];
*/
isc_buffer_activeregion(source, &sr);
if (sr.length == 0) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (algorithm == DNS_KEYALG_PRIVATEDNS ||
}
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->siglen = sr.length;
sig->signature = mem_maybedup(mctx, sr.base, sig->siglen);
sig->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 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
sink->datalen = sr.length;
sink->data = mem_maybedup(mctx, sr.base, sink->datalen);
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);
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
opts = name_prefix(&next, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, target);
}
static isc_result_t
dns_name_init(&next, NULL);
RETERR(dns_name_fromwire(&prev, source, dctx, target));
- return (dns_name_fromwire(&next, source, dctx, target));
+ return dns_name_fromwire(&next, source, dctx, target);
}
static isc_result_t
dns_name_fromregion(&next, &sregion);
isc_region_consume(&sregion, name_length(&next));
- return (dns_name_towire(&next, cctx, target, NULL));
+ return dns_name_towire(&next, cctx, target, NULL);
}
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, NULL));
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
INSIST(tkey->otherlen <= sr.length);
tkey->other = mem_maybedup(mctx, sr.base, tkey->otherlen);
tkey->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_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);
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 = mem_maybedup(mctx, r.base, r.length);
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
uri->tgt_len = sr.length;
uri->target = mem_maybedup(mctx, sr.base, sr.length);
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);
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);
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_fromregion(&name, &sr);
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, 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, target));
+ return dns_name_fromwire(&name, source, dctx, 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, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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, DNS_DECOMPRESS_DEFAULT,
- target));
+ return fromwire_in_apl(rdclass, type, &b, DNS_DECOMPRESS_DEFAULT,
+ target);
}
static isc_result_t
apl->apl = mem_maybedup(mctx, r.base, r.length);
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);
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);
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);
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);
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, 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, target));
+ return dns_name_fromwire(&name, source, dctx, target);
}
static isc_result_t
dns_name_init(&name, offsets);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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 DNS__DB_FILELINE));
+ return (add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE);
}
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);
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
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, target);
}
static isc_result_t
dctx = dns_decompress_setpermitted(dctx, false);
dns_name_init(&name, NULL);
- return (dns_name_fromwire(&name, source, dctx, target));
+ return dns_name_fromwire(&name, source, dctx, target);
}
static isc_result_t
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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);
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);
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, 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, target));
+ return dns_name_fromwire(&name, source, dctx, target);
}
static isc_result_t
*/
dns_name_init(&name, offsets);
dns_name_fromregion(&name, ®ion);
- return (dns_name_towire(&name, cctx, target, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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);
opts = name_prefix(&name, tctx->origin, &prefix) ? DNS_NAME_OMITFINALDOT
: 0;
- return (dns_name_totext(&prefix, opts, target));
+ return dns_name_totext(&prefix, opts, 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, target));
+ return dns_name_fromwire(&name, source, dctx, target);
}
static isc_result_t
*/
dns_name_init(&name, offsets);
dns_name_fromregion(&name, &sr);
- return (dns_name_towire(&name, cctx, target, NULL));
+ return dns_name_towire(&name, cctx, target, NULL);
}
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 DNS__DB_FILELINE);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_fixedname_init(&fixed);
result = dns_name_fromstring(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 DNS__DB_FILELINE));
+ return (add)(arg, dns_fixedname_name(&fixed), dns_rdatatype_tlsa,
+ NULL DNS__DB_FILELINE);
}
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) {
}
RETERR(uint16_tobuffer(ul, target));
SET_IF_NOT_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 int)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
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 DNS__DB_FILELINE));
+ return (add)(arg, owner, dns_rdatatype_a,
+ NULL DNS__DB_FILELINE);
}
/*
* 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 DNS__DB_FILELINE));
+ return (add)(arg, &name, dns_rdatatype_a, NULL DNS__DB_FILELINE);
}
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);
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->rdlist.iter = ISC_LIST_HEAD(rdatalist->rdata);
if (rdataset->rdlist.iter == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
rdata = rdataset->rdlist.iter;
if (rdata == NULL) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
rdataset->rdlist.iter = ISC_LIST_NEXT(rdata, link);
if (rdataset->rdlist.iter == 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->rdlist.noqname = 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->rdlist.closest = 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 isc_result_t
question_cursor(dns_rdataset_t *rdataset ISC_ATTR_UNUSED) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
static void
REQUIRE(rdataset->methods != NULL);
REQUIRE(rdataset->methods->count != NULL);
- return ((rdataset->methods->count)(rdataset));
+ return (rdataset->methods->count)(rdataset);
}
void
REQUIRE(rdataset->methods != NULL);
REQUIRE(rdataset->methods->first != NULL);
- return ((rdataset->methods->first)(rdataset));
+ return (rdataset->methods->first)(rdataset);
}
isc_result_t
REQUIRE(rdataset->methods != NULL);
REQUIRE(rdataset->methods->next != 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 = dns_rdataset_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_cget(cctx->mctx, count, sizeof(*in));
out = isc_mem_cget(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_cput(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 DNS__DB_FLARG_PASS));
+ return (rdataset->methods->getnoqname)(rdataset, name, neg,
+ negsig DNS__DB_FLARG_PASS);
}
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 DNS__DB_FLARG_PASS));
+ return (rdataset->methods->getclosest)(rdataset, name, neg,
+ negsig DNS__DB_FLARG_PASS);
}
void
REQUIRE(DNS_RDATASETITER_VALID(iterator));
- return (iterator->methods->first(iterator DNS__DB_FLARG_PASS));
+ return iterator->methods->first(iterator DNS__DB_FLARG_PASS);
}
isc_result_t
REQUIRE(DNS_RDATASETITER_VALID(iterator));
- return (iterator->methods->next(iterator DNS__DB_FLARG_PASS));
+ return iterator->methods->next(iterator DNS__DB_FLARG_PASS);
}
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_cput(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
unsigned char *current = slab + reservelen;
uint16_t count = get_uint16(current);
- return (count);
+ return count;
}
/*
int 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 = get_uint16(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;
current2 += length1;
}
- return (true);
+ return true;
}
bool
count2 = get_uint16(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;
}
dns_slabheader_t *
dns_slabheader_fromrdataset(const dns_rdataset_t *rdataset) {
dns_slabheader_t *header = (dns_slabheader_t *)rdataset->slab.raw;
- return (header - 1);
+ return header - 1;
}
void *
dns_slabheader_raw(dns_slabheader_t *header) {
- return (header + 1);
+ return header + 1;
}
void
.link = ISC_LINK_INITIALIZER,
};
dns_slabheader_reset(h, db, node);
- return (h);
+ return h;
}
void
if (count == 0) {
rdataset->slab.iter_pos = NULL;
rdataset->slab.iter_count = 0;
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
if ((rdataset->attributes & DNS_RDATASETATTR_LOADORDER) == 0) {
rdataset->slab.iter_pos = raw + DNS_RDATASET_LENGTH;
rdataset->slab.iter_count = count - 1;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
uint16_t count = rdataset->slab.iter_count;
if (count == 0) {
rdataset->slab.iter_pos = NULL;
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
rdataset->slab.iter_count = count - 1;
rdataset->slab.iter_pos = raw + DNS_RDATASET_ORDER +
DNS_RDATASET_LENGTH;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
raw = rdataset->slab.raw;
count = get_uint16(raw);
- 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
isc_sockaddr_t *
dns_remote_addresses(dns_remote_t *remote) {
REQUIRE(DNS_REMOTE_VALID(remote));
- return (remote->addresses);
+ return remote->addresses;
}
isc_sockaddr_t *
dns_remote_sources(dns_remote_t *remote) {
REQUIRE(DNS_REMOTE_VALID(remote));
- return (remote->sources);
+ return remote->sources;
}
unsigned int
dns_remote_count(dns_remote_t *remote) {
REQUIRE(DNS_REMOTE_VALID(remote));
- return (remote->addrcnt);
+ return remote->addrcnt;
}
dns_name_t **
dns_remote_keynames(dns_remote_t *remote) {
REQUIRE(DNS_REMOTE_VALID(remote));
- return (remote->keynames);
+ return remote->keynames;
}
dns_name_t **
dns_remote_tlsnames(dns_remote_t *remote) {
REQUIRE(DNS_REMOTE_VALID(remote));
- return (remote->tlsnames);
+ return remote->tlsnames;
}
void
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 (!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;
}
void
REQUIRE(DNS_REMOTE_VALID(b));
if (a->addrcnt != b->addrcnt) {
- return (false);
+ return false;
}
if (!same_addrs(a->addresses, b->addresses, a->addrcnt)) {
- return (false);
+ return false;
}
if (!same_names(a->keynames, b->keynames, a->addrcnt)) {
- return (false);
+ return false;
}
if (!same_names(a->tlsnames, b->tlsnames, a->addrcnt)) {
- return (false);
+ return false;
}
- return (true);
+ return true;
}
void
REQUIRE(remote->addresses != NULL);
REQUIRE(remote->curraddr < remote->addrcnt);
- return (remote->addresses[remote->curraddr]);
+ return remote->addresses[remote->curraddr];
}
isc_sockaddr_t
REQUIRE(remote->addresses != NULL);
REQUIRE(i < remote->addrcnt);
- return (remote->addresses[i]);
+ return remote->addresses[i];
}
isc_sockaddr_t
REQUIRE(remote->sources != NULL);
REQUIRE(remote->curraddr < remote->addrcnt);
- return (remote->sources[remote->curraddr]);
+ return remote->sources[remote->curraddr];
}
dns_name_t *
REQUIRE(DNS_REMOTE_VALID(remote));
if (remote->keynames == NULL) {
- return (NULL);
+ return NULL;
}
if (remote->curraddr >= remote->addrcnt) {
- return (NULL);
+ return NULL;
}
- return (remote->keynames[remote->curraddr]);
+ return remote->keynames[remote->curraddr];
}
dns_name_t *
REQUIRE(DNS_REMOTE_VALID(remote));
if (remote->tlsnames == NULL) {
- return (NULL);
+ return NULL;
}
if (remote->curraddr >= remote->addrcnt) {
- return (NULL);
+ return NULL;
}
- return (remote->tlsnames[remote->curraddr]);
+ return remote->tlsnames[remote->curraddr];
}
void
dns_remote_done(dns_remote_t *remote) {
REQUIRE(DNS_REMOTE_VALID(remote));
- return (remote->curraddr >= remote->addrcnt);
+ return remote->curraddr >= remote->addrcnt;
}
void
req_log(ISC_LOG_DEBUG(3), "%s: %p", __func__, requestmgr);
*requestmgrp = requestmgr;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
request->timeout = udptimeout * 1000;
}
- return (request);
+ return request;
}
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, transport, 0, 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
done:
rcu_read_unlock();
- return (result);
+ return result;
}
isc_result_t
if (srcaddr != NULL &&
isc_sockaddr_pf(srcaddr) != isc_sockaddr_pf(destaddr))
{
- return (ISC_R_FAMILYMISMATCH);
+ return ISC_R_FAMILYMISMATCH;
}
mctx = requestmgr->mctx;
done:
rcu_read_unlock();
- return (result);
+ return result;
}
static isc_result_t
dns_compress_invalidate(&cctx);
isc_buffer_free(&buf1);
*bufferp = buf2;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup:
dns_message_renderreset(message);
if (buf2 != NULL) {
isc_buffer_free(&buf2);
}
- return (result);
+ return result;
}
static void
dns_message_setquerytsig(message, request->tsig);
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 *
REQUIRE(VALID_REQUEST(request));
REQUIRE(request->tid == isc_tid());
- return (request->answer);
+ return request->answer;
}
bool
REQUIRE(VALID_REQUEST(request));
REQUIRE(request->tid == isc_tid());
- return ((request->flags & DNS_REQUEST_F_TCP) != 0);
+ return (request->flags & DNS_REQUEST_F_TCP) != 0;
}
void
REQUIRE(VALID_REQUEST(request));
REQUIRE(request->tid == isc_tid());
- return (request->arg);
+ return request->arg;
}
isc_result_t
REQUIRE(VALID_REQUEST(request));
REQUIRE(request->tid == isc_tid());
- return (request->result);
+ return request->result;
}
#if DNS_REQUEST_TRACE
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;
}
address = isc_mem_get(mctx, sizeof(*address));
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;
}
fctx->validator = validator;
}
ISC_LIST_APPEND(fctx->validators, validator, link);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
const fctxcount_t *counter = node;
const dns_name_t *domain = key;
- return (dns_name_equal(counter->domain, domain));
+ return dns_name_equal(counter->domain, domain);
}
static isc_result_t
/* Skip any counting if fetches-per-zone is disabled */
spill = atomic_load_acquire(&res->zspill);
if (spill == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
hashval = dns_name_hash(fctx->domain);
UNLOCK(&counter->lock);
RWUNLOCK(&res->counters_lock, locktype);
- return (result);
+ return result;
}
static bool
match_ptr(void *node, const void *key) {
- return (node == key);
+ return node == key;
}
static void
/* We need to do this under the lock for intra-thread synchronization */
if (fctx->state == fetchstate_done) {
UNLOCK(&fctx->lock);
- return (false);
+ return false;
}
fctx->state = fetchstate_done;
release_fctx(fctx);
isc_timer_destroy(&fctx->timer);
- return (true);
+ return true;
}
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
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;
}
dns_message_gettempname(fctx->qmessage, &qname);
transport_type, &zr, &query->start, NULL, &buffer);
#endif /* HAVE_DNSTAP */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_message:
dns_compress_invalidate(&cctx);
*/
dns_dispatch_done(&query->dispentry);
- 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;
}
/*
result = fcount_incr(fctx, true);
if (result != ISC_R_SUCCESS) {
dns_forwarders_detach(&forwarders);
- return (result);
+ return result;
}
}
dns_forwarders_detach(&forwarders);
}
if ((stdoptions & DNS_ADBFIND_ADDRESSMASK) == 0) {
- return (DNS_R_SERVFAIL);
+ return DNS_R_SERVFAIL;
}
now = isc_stdtime_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
*fctxp = fctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_qmessage:
dns_message_detach(&fctx->qmessage);
dns_resolver_detach(&fctx->res);
isc_mem_putanddetach(&fctx->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;
}
}
*/
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->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(&fctx->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;
}
/*
zname, apex, &(int){ 0 }, &(unsigned int){ 0U });
dns_zone_detach(&zone);
if (reln == dns_namereln_subdomain) {
- return (true);
+ return true;
}
}
bool better = !dns_name_equal(&forwarders->name,
fctx->fwdname);
dns_forwarders_detach(&forwarders);
- return (better);
+ return better;
}
/*
* 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) {
/*
* If 'name' is covered by a 'forward only' clause then we
bool nocache = (forwarders->fwdpolicy == dns_fwdpolicy_only &&
!ISC_LIST_EMPTY(forwarders->fwdrs));
dns_forwarders_detach(&forwarders);
- return (nocache);
+ return nocache;
}
- 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 DNS__DB_FLARG) {
- 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;
}
/*
* exactly or partially, allow it.
*/
if (dns_nametree_covered(view->answeracl_exclude, name, NULL, 0)) {
- 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);
NULL);
if (result == DNS_R_NAMETOOLONG) {
SET_IF_NOT_NULL(chainingp, true);
- return (true);
+ return true;
}
RUNTIME_CHECK(result == ISC_R_SUCCESS);
break;
SET_IF_NOT_NULL(chainingp, true);
if (view->denyanswernames == NULL) {
- return (true);
+ return true;
}
/*
* exactly or partially, allow it.
*/
if (dns_nametree_covered(view->answernames_exclude, qname, NULL, 0)) {
- return (true);
+ return true;
}
/*
* filters can be applied; see GL #1574.
*/
if (!fctx->forwarding && dns_name_issubdomain(tname, fctx->domain)) {
- return (true);
+ return true;
}
/*
isc_log_write(DNS_LOGCATEGORY_RESOLVER, 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;
}
#if DNS_RESOLVER_TRACE
isc_hash32_hash(&hash32, fctx->name->ndata, fctx->name->length, false);
isc_hash32_hash(&hash32, &fctx->options, sizeof(fctx->options), true);
isc_hash32_hash(&hash32, &fctx->type, sizeof(fctx->type), true);
- return (isc_hash32_finalize(&hash32));
+ return isc_hash32_finalize(&hash32);
}
static bool
const fetchctx_t *fctx0 = node;
const fetchctx_t *fctx1 = key;
- return (fctx0->options == fctx1->options &&
- fctx0->type == fctx1->type &&
- dns_name_equal(fctx0->name, fctx1->name));
+ return fctx0->options == fctx1->options && fctx0->type == fctx1->type &&
+ dns_name_equal(fctx0->name, fctx1->name);
}
/* Must be fctx locked */
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.cache = true;
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.cache = true;
{
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.cache = true;
{
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.cache = true;
{
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;
}
static void
*fctxp = fctx;
}
- return (result);
+ return result;
}
isc_result_t
REQUIRE(fetchp != NULL && *fetchp == NULL);
if (atomic_load_acquire(&res->exiting)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
log_fetch(name, type);
if (result != ISC_R_SUCCESS) {
dns_resolver_detach(&fetch->res);
isc_mem_putanddetach(&fetch->mctx, fetch, sizeof(*fetch));
- return (result);
+ return result;
}
FTRACE("created");
*fetchp = fetch;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
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);
}
uint32_t
dns_resolver_getlamettl(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
- return (resolver->lame_ttl);
+ return resolver->lame_ttl;
}
void
isc_result_t
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,
- isc_time_seconds(now)));
+ return dns_badcache_find(resolver->badcache, name, type, NULL,
+ isc_time_seconds(now));
}
void
REQUIRE(VALID_RESOLVER(resolver));
if (alg > 255) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
- return (dns_nametree_add(resolver->algorithms, name, alg));
+ return dns_nametree_add(resolver->algorithms, name, alg);
}
isc_result_t
REQUIRE(VALID_RESOLVER(resolver));
if (digest_type > 255) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
- return (dns_nametree_add(resolver->digests, name, digest_type));
+ return dns_nametree_add(resolver->digests, name, digest_type);
}
bool
REQUIRE(VALID_RESOLVER(resolver));
if ((alg == DST_ALG_DH) || (alg == DST_ALG_INDIRECT)) {
- return (false);
+ return false;
}
if (dns_nametree_covered(resolver->algorithms, name, NULL, alg)) {
- return (false);
+ return false;
}
- return (dst_algorithm_supported(alg));
+ return dst_algorithm_supported(alg);
}
bool
REQUIRE(VALID_RESOLVER(resolver));
if (dns_nametree_covered(resolver->digests, name, NULL, digest_type)) {
- return (false);
+ return false;
}
- return (dst_ds_digest_supported(digest_type));
+ return dst_ds_digest_supported(digest_type);
}
isc_result_t
REQUIRE(VALID_RESOLVER(resolver));
result = dns_nametree_add(resolver->mustbesecure, name, value);
- return (result);
+ return result;
}
bool
dns_resolver_getmustbesecure(dns_resolver_t *resolver, const dns_name_t *name) {
REQUIRE(VALID_RESOLVER(resolver));
- return (dns_nametree_covered(resolver->mustbesecure, name, NULL, 0));
+ return dns_nametree_covered(resolver->mustbesecure, name, NULL, 0);
}
void
dns_resolver_getfetchesperzone(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
- return (atomic_load_relaxed(&resolver->zspill));
+ return atomic_load_relaxed(&resolver->zspill);
}
bool
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
spill = atomic_load_acquire(&res->zspill);
if (spill == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
RWLOCK(&res->counters_lock, isc_rwlocktype_read);
cleanup:
RWUNLOCK(&res->counters_lock, isc_rwlocktype_read);
isc_hashmap_iter_destroy(&it);
- return (result);
+ return result;
}
void
REQUIRE(VALID_RESOLVER(resolver));
REQUIRE(which == dns_quotatype_zone || which == dns_quotatype_server);
- return (resolver->quotaresp[which]);
+ return resolver->quotaresp[which];
}
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_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;
}
uint16_t
unsigned int n;
if (str == NULL) {
- return (UINT16_MAX);
+ return UINT16_MAX;
}
for (n = 0; n < sizeof(tbl) / sizeof(tbl[0]); ++n) {
if (!strcasecmp(tbl[n].str, str)) {
- return (tbl[n].ede);
+ return tbl[n].ede;
}
}
- return (UINT16_MAX);
+ return UINT16_MAX;
}
/*
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 (parent == NULL) {
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);
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);
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;
}
RWLOCK(&rpz->rpzs->search_lock, isc_rwlocktype_write);
adj_trigger_cnt(rpz, rpz_type, &tgt_ip, tgt_prefix, true);
done:
RWUNLOCK(&rpz->rpzs->search_lock, isc_rwlocktype_write);
- return (result);
+ return result;
}
static nmdata_t *
__FILE__, __LINE__ + 1, name);
#endif
- return (newdata);
+ return newdata;
}
static isc_result_t
dns_qp_compact(qp, DNS_QPGC_MAYBE);
dns_qpmulti_commit(rpzs->table, &qp);
- return (result);
+ return result;
}
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) {
RWLOCK(&rpz->rpzs->search_lock, isc_rwlocktype_write);
adj_trigger_cnt(rpz, rpz_type, NULL, 0, true);
RWUNLOCK(&rpz->rpzs->search_lock, isc_rwlocktype_write);
}
- return (result);
+ return result;
}
/*
isc_mem_attach(mctx, &rpzs->mctx);
*rpzsp = rpzs;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
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;
}
isc_result_t
unlock:
UNLOCK(&rpz->rpzs->maint_lock);
- return (result);
+ return result;
}
void
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
break;
}
- 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;
}
/*
isc_log_write(DNS_LOGCATEGORY_RPZ, 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;
}
dns_qpmulti_query(rpzs->table, &qpr);
}
dns_qpread_destroy(rpzs->table, &qpr);
- 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;
}
static void
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
nmdata_t *data = pval;
- return (dns_qpkey_fromname(key, &data->name));
+ return dns_qpkey_fromname(key, &data->name);
}
static void
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_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_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_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_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;
}
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;
}
}
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, DNS_NAME_OMITFINALDOT, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
} else {
result = dns_name_totext(name, DNS_NAME_OMITFINALDOT, &b);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
isc_buffer_putuint8(&b, 0);
result = dns_name_totext(&sdlz->common.origin, DNS_NAME_OMITFINALDOT,
&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;
}
&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 = (dns_dbnode_t *)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 DNS__DB_FLARG) {
- 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 DNS__DB_FLARG) {
- return (getnodedata(db, name, create, 0, NULL, NULL, nodep));
+ return getnodedata(db, name, create, 0, NULL, NULL, nodep);
}
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, DNS_NAME_OMITFINALDOT,
&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 DNS__DB_FILELINE);
- 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 DNS__DB_FLARG_PASS);
}
- 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 DNS__DB_FLARG) {
- return (findext(db, name, version, type, options, now, nodep, foundname,
- NULL, NULL, rdataset, sigrdataset DNS__DB_FLARG_PASS));
+ return findext(db, name, version, type, options, now, nodep, foundname,
+ NULL, NULL, rdataset, sigrdataset DNS__DB_FLARG_PASS);
}
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 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;
}
}
nodep DNS__DB_FLARG_PASS);
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 (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
isc_buffer_init(&b, namestr, sizeof(namestr));
result = dns_name_totext(name, DNS_NAME_OMITFINALDOT, &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, DNS_NAME_OMITFINALDOT, &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(*imp));
- return (result);
+ return result;
}
void
result = dns_sdlzcreateDBP(dlzdatabase->mctx,
dlzdatabase->implementation->driverarg,
dlzdatabase->dbdata, name, rdclass, dbp);
- return (result);
+ return result;
}
isc_buffer_add(&b, strlen(owner));
ret = dns_name_fromtext(dname, &b, dns_rootname, 0, NULL);
if (ret != ISC_R_SUCCESS) {
- return (ret);
+ return ret;
}
if (dns_name_compare(dname, origin) != 0) {
- return (DNS_R_BADOWNERNAME);
+ return DNS_R_BADOWNERNAME;
}
isc_buffer_clear(&b);
buf, &callbacks);
cleanup:
isc_lex_setcomments(lex, 0);
- return (ret);
+ return ret;
}
static void
result = dns_rdata_tostruct(&tuple->rdata, &rrsig, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
rrsig.keyid == dst_key_id(key))
{
dns_rdata_clone(&tuple->rdata, sigrdata);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
tuple = ISC_LIST_NEXT(tuple, link);
}
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
void
ISC_LOG_ERROR, "unable to open ksr file %s: %s",
filename, isc_result_totext(result));
isc_lex_destroy(&lex);
- return (result);
+ return result;
}
for (result = isc_lex_gettoken(lex, opt, &token);
/* Clean up */
isc_lex_destroy(&lex);
- return (result);
+ return result;
}
dns_skrbundle_t *
if (next == NULL) {
isc_stdtime_t expired = b->inception + sigval;
if (b->inception <= time && time < expired) {
- return (b);
+ return b;
}
- return (NULL);
+ return NULL;
}
if (b->inception <= time && time < next->inception) {
- return (b);
+ return b;
}
}
- return (NULL);
+ return NULL;
}
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
*/
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
mtypetostring(dns_ssumatchtype_t matchtype) {
switch (matchtype) {
case dns_ssumatchtype_name:
- return ("name");
+ return "name";
case dns_ssumatchtype_wildcard:
- return ("wildcard");
+ return "wildcard";
case dns_ssumatchtype_self:
- return ("self");
+ return "self";
case dns_ssumatchtype_selfsub:
- return ("selfsub");
+ return "selfsub";
case dns_ssumatchtype_selfwild:
- return ("selfwild");
+ return "selfwild";
case dns_ssumatchtype_selfms:
- return ("ms-self");
+ return "ms-self";
case dns_ssumatchtype_selfsubms:
- return ("ms-selfsub");
+ return "ms-selfsub";
case dns_ssumatchtype_selfkrb5:
- return ("krb5-self");
+ return "krb5-self";
case dns_ssumatchtype_selfsubkrb5:
- return ("krb5-selfsub");
+ return "krb5-selfsub";
case dns_ssumatchtype_subdomainms:
- return ("ms-subdomain");
+ return "ms-subdomain";
case dns_ssumatchtype_subdomainselfmsrhs:
- return ("ms-subdomain-self-rhs");
+ return "ms-subdomain-self-rhs";
case dns_ssumatchtype_subdomainkrb5:
- return ("krb5-subdomain");
+ return "krb5-subdomain";
case dns_ssumatchtype_subdomainselfkrb5rhs:
- return ("krb5-subdomain-self-rhs");
+ return "krb5-subdomain-self-rhs";
case dns_ssumatchtype_tcpself:
- return ("tcp-self");
+ return "tcp-self";
case dns_ssumatchtype_6to4self:
- return ("6to4-self");
+ return "6to4-self";
case dns_ssumatchtype_subdomain:
- return ("subdomain");
+ return "subdomain";
case dns_ssumatchtype_external:
- return ("external");
+ return "external";
case dns_ssumatchtype_local:
- return ("local");
+ return "local";
case dns_ssumatchtype_dlz:
- return ("dlz");
+ return "dlz";
}
- return ("UnknownMatchType");
+ return "UnknownMatchType";
}
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
}
if (signer == NULL && addr == NULL) {
- return (false);
+ return false;
}
for (rule = ISC_LIST_HEAD(table->rules); rule != NULL;
rule->debug != NULL ? rule->debug
: "not available");
}
- return (rule->grant);
+ return rule->grant;
}
if (logit) {
isc_log_write(DNS_LOGCATEGORY_UPDATE_POLICY, DNS_LOGMODULE_SSU,
"update-policy: no match found");
}
- 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;
}
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
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;
}
isc_mem_attach(mctx, &tctx->mctx);
*tctxp = tctx;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
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");
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
}
tkeyout->error = dns_tsigerror_badkey;
tkey_log("process_gsstkey(): dns_tsigerror_badkey");
- 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));
- 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;
}
dns_message_currentname(msg, DNS_SECTION_QUESTION, &qname);
ISC_LIST_UNLINK(namelist, name, link);
dns_message_addname(msg, name, DNS_SECTION_ANSWER);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
free_namelist(msg, &namelist);
- return (result);
+ return result;
}
static isc_result_t
if (result != ISC_R_SUCCESS) {
dns_message_puttemprdata(msg, &rdata);
isc_buffer_free(&dynbuf);
- return (result);
+ return result;
}
dns_message_takebuffer(msg, &dynbuf);
dns_message_addname(msg, qname, DNS_SECTION_QUESTION);
dns_message_addname(msg, aname, DNS_SECTION_ADDITIONAL);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
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 = (dns_rdata_tkey_t){
};
dns_name_clone(DNS_TSIG_GSSAPI_NAME, &tkey.algorithm);
- return (buildquery(msg, name, &tkey));
+ return buildquery(msg, name, &tkey);
}
static isc_result_t
dns_rdataset_current(tkeyset, rdata);
*name = cur;
- 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
REQUIRE(outkey == NULL || *outkey == 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));
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));
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
RETERR(dst_key_fromgssapi(dns_rootname, *context, rmsg->mctx, &dstkey,
}
dst_key_free(&dstkey);
- return (result);
+ return result;
failure:
if (tsigkey != NULL) {
if (dstkey != NULL) {
dst_key_free(&dstkey);
}
- return (result);
+ return result;
}
transport_match(void *node, const void *key) {
dns_transport_t *transport = node;
- return (dns_name_equal(transport->name, key));
+ return dns_name_equal(transport->name, key);
}
static isc_result_t
transport, NULL);
RWUNLOCK(&list->lock, isc_rwlocktype_write);
- return (result);
+ return result;
}
dns_transport_type_t
dns_transport_get_type(const dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->type);
+ return transport->type;
}
char *
dns_transport_get_certfile(const dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->tls.certfile);
+ return transport->tls.certfile;
}
char *
dns_transport_get_keyfile(const dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->tls.keyfile);
+ return transport->tls.keyfile;
}
char *
dns_transport_get_cafile(const dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->tls.cafile);
+ return transport->tls.cafile;
}
char *
dns_transport_get_remote_hostname(const dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->tls.remote_hostname);
+ return transport->tls.remote_hostname;
}
char *
dns_transport_get_endpoint(const dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->doh.endpoint);
+ return transport->doh.endpoint;
}
dns_http_mode_t
dns_transport_get_mode(const 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(const dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->tls.ciphers);
+ return transport->tls.ciphers;
}
void
dns_transport_get_cipher_suites(const dns_transport_t *transport) {
REQUIRE(VALID_TRANSPORT(transport));
- return (transport->tls.cipher_suites);
+ return transport->tls.cipher_suites;
}
char *
dns_transport_get_tlsname(const 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();
- return (false);
+ return false;
}
void
REQUIRE(transport->type == DNS_TRANSPORT_TLS ||
transport->type == DNS_TRANSPORT_HTTP);
- return (transport->tls.always_verify_remote);
+ return transport->tls.always_verify_remote;
}
isc_result_t
*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 void
}
RWUNLOCK(&list->lock, isc_rwlocktype_read);
- return (transport);
+ return transport;
}
dns_transport_list_t *
isc_hashmap_create(list->mctx, 10, &list->transports[type]);
}
- return (list);
+ return list;
}
void
dns_transport_totext(dns_transport_type_t type) {
switch (type) {
case DNS_TRANSPORT_UDP:
- return ("udp");
+ return "udp";
case DNS_TRANSPORT_TCP:
- return ("tcp");
+ return "tcp";
case DNS_TRANSPORT_TLS:
- return ("tls");
+ return "tls";
case DNS_TRANSPORT_HTTP:
- return ("https");
+ return "https";
default:
UNREACHABLE();
}
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
tkey_match(void *node, const void *key) {
dns_tsigkey_t *tkey = node;
- return (dns_name_equal(tkey->name, key));
+ return dns_name_equal(tkey->name, key);
}
static bool
match_ptr(void *node, const void *key) {
- return (node == key);
+ return node == key;
}
static void
namefromalg(dst_algorithm_t 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:
- return (NULL);
+ return NULL;
}
}
}
SET_IF_NOT_NULL(keyp, tkey);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_name:
isc_mem_put(mctx, tkey, sizeof(dns_tsigkey_t));
- return (result);
+ return result;
}
static void
for (size_t i = 0; i < ARRAY_SIZE(known_algs); ++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 (DST_ALG_UNKNOWN);
+ return DST_ALG_UNKNOWN;
}
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 == DST_ALG_UNKNOWN) {
- 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, dstalg, dstkey, true, true,
if (dstkey != NULL) {
dst_key_free(&dstkey);
}
- return (result);
+ return result;
}
static void
isc_hashmap_iter_destroy(&it);
RWUNLOCK(&ring->lock, isc_rwlocktype_read);
- return (found ? ISC_R_SUCCESS : ISC_R_NOTFOUND);
+ return found ? ISC_R_SUCCESS : ISC_R_NOTFOUND;
}
const dns_name_t *
REQUIRE(tsigkey == NULL || VALID_TSIGKEY(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, false,
if (dstkey != NULL) {
dst_key_free(&dstkey);
}
- return (result);
+ return result;
}
static void
response = is_response(msg);
if (response && msg->querytsig == NULL) {
if (msg->tkey != 1) {
- return (DNS_R_EXPECTEDTSIG);
+ return DNS_R_EXPECTEDTSIG;
}
}
result = dst_context_create(
key->key, mctx, DNS_LOGCATEGORY_DNSSEC, true, 0, &ctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
/* Windows does not like the tsig name being compressed. */
msg->tsigname->attributes.nocompress = true;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_dynbuf:
isc_buffer_free(&dynbuf);
if (ctx != NULL) {
dst_context_destroy(&ctx);
}
- return (result);
+ return result;
}
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;
result = dns_rdataset_first(msg->tsig);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_current(msg->tsig, &rdata);
result = dns_rdata_tostruct(&rdata, &tsig, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdata_reset(&rdata);
if (response) {
result = dns_rdataset_first(msg->querytsig);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_current(msg->querytsig, &rdata);
result = dns_rdata_tostruct(&rdata, &querytsig, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
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;
}
/*
keyname, dns__tsig_algfromname(&tsig.algorithm),
NULL, 0, mctx, &msg->tsigkey);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
tsig_log(msg->tsigkey, 2, "unknown key");
- return (DNS_R_TSIGVERIFYFAILURE);
+ return DNS_R_TSIGVERIFYFAILURE;
}
msg->tsigkey = tsigkey;
}
alg = dst_key_alg(key);
result = dst_key_sigsize(key, &siglen);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
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;
}
}
result = dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC,
false, 0, &ctx);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
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 (result);
+ return result;
}
static isc_result_t
msg->tsigstatus = dns_tsigerror_badsig;
if (!is_response(msg)) {
- return (DNS_R_EXPECTEDRESPONSE);
+ return DNS_R_EXPECTEDRESPONSE;
}
mctx = msg->mctx;
*/
result = dns_rdataset_first(msg->querytsig);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdataset_current(msg->querytsig, &rdata);
result = dns_rdata_tostruct(&rdata, &querytsig, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
dns_rdata_reset(&rdata);
cleanup_querystruct:
dns_rdata_freestruct(&querytsig);
- return (result);
+ return result;
}
isc_result_t
name, (void **)&key);
if (result == ISC_R_NOTFOUND) {
RWUNLOCK(&ring->lock, locktype);
- return (result);
+ return result;
}
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)) {
/*
rm_lru(key);
rm_hashmap(key);
RWUNLOCK(&ring->lock, locktype);
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
dns_tsigkey_ref(key);
RWUNLOCK(&ring->lock, locktype);
adjust_lru(key);
*tsigkey = key;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
}
RWUNLOCK(&ring->lock, isc_rwlocktype_write);
- 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] =
isc_ascii_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
dns_rdata_t *rdata) {
dns_difftuple_t *tuple = NULL;
dns_difftuple_create(diff->mctx, op, name, ttl, rdata, &tuple);
- 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);
}
/**************************************************************************/
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
*flag = true;
*cut = false;
SET_IF_NOT_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)
{
*flag = false;
*cut = false;
SET_IF_NOT_NULL(unsecure, false);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
/*
* Silence compiler.
*flag = false;
*cut = false;
SET_IF_NOT_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 (result != ISC_R_SUCCESS) {
*nkeys = 0;
- return (result);
+ return result;
}
/* Add new 'dnskeys' to 'keys' */
}
*nkeys = count;
- 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:
now = isc_stdtime_now();
- return (now);
+ return now;
case dns_updatemethod_date:
now = isc_stdtime_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();
}
SET_IF_NOT_NULL(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_rdataset_settrust(val->sigrdataset, dns_trust_answer);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
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;
}
static void
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) {
dns_validator_detach(&val);
}
- return (result);
+ return result;
}
/*%
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. */
dns_validator_attach(val, &val->subvalidator->parent);
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->rdataset->type == dns_rdatatype_dnskey) {
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
}
/*
* points cannot be self-signed.
*/
if (dns_rdatatype_atparent(val->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_rdataset_disassociate(&val->fsigrdataset);
}
- return (validate_helper_run(val,
- resume_answer_with_key));
+ return validate_helper_run(val, resume_answer_with_key);
}
break;
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);
}
static bool
over_max_validations(dns_validator_t *val) {
if (val->nvalidations == NULL || (*val->nvalidations) > 0) {
- return (false);
+ return false;
}
/* The attribute is set only on failure */
val->attributes |= VALATTR_MAXVALIDATIONS;
- return (true);
+ return true;
}
static void
static bool
over_max_fails(dns_validator_t *val) {
if (val->nfails == NULL || (*val->nfails) > 0) {
- return (false);
+ return false;
}
/* The attribute is set only on failure */
val->attributes |= VALATTR_MAXVALIDATIONFAILS;
- return (true);
+ return true;
}
static void
isc_mem_t *mctx = val->view->mctx;
if (rdataset->type != dns_rdatatype_dnskey) {
- return (DNS_R_NOKEYMATCH);
+ return DNS_R_NOKEYMATCH;
}
for (result = dns_rdataset_first(rdataset); result == ISC_R_SUCCESS;
* This will be verified later.
*/
if ((key.flags & DNS_KEYFLAG_REVOKE) == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
result = dns_dnssec_keyfromrdata(name, &keyrdata, mctx,
{
if (over_max_validations(val)) {
dst_key_free(&dstkey);
- return (ISC_R_QUOTA);
+ return ISC_R_QUOTA;
}
result = dns_dnssec_verify(
name, rdataset, dstkey, true,
consume_validation(val);
if (over_max_fails(val)) {
dst_key_free(&dstkey);
- return (ISC_R_QUOTA);
+ return ISC_R_QUOTA;
}
consume_validation_fail(val);
}
}
}
- return (DNS_R_NOKEYMATCH);
+ return DNS_R_NOKEYMATCH;
}
/*%
val->attributes |= VALATTR_TRIEDVERIFY;
wild = dns_fixedname_initname(&fixed);
if (over_max_validations(val)) {
- return (ISC_R_QUOTA);
+ return ISC_R_QUOTA;
}
again:
result = dns_dnssec_verify(val->name, val->rdataset, key, ignore,
}
consume_validation_fail(val);
}
- return (result);
+ return result;
}
/*%
static isc_result_t
validate_async_run(dns_validator_t *val, isc_job_cb cb) {
isc_async_run(val->loop, cb, val);
- return (DNS_R_WAIT);
+ return DNS_R_WAIT;
}
static isc_result_t
validate_helper_run(dns_validator_t *val, isc_job_cb cb) {
isc_helper_run(val->loop, cb, val);
- return (DNS_R_WAIT);
+ return DNS_R_WAIT;
}
static void
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;
}
static void
RUNTIME_CHECK(result == ISC_R_SUCCESS);
if (ds.digest_type == DNS_DSDIGEST_SHA1 && val->digest_sha1 == false) {
- return (DNS_R_BADALG);
+ return DNS_R_BADALG;
}
if (!dns_resolver_ds_digest_supported(val->view->resolver, val->name,
ds.digest_type))
{
- return (DNS_R_BADALG);
+ return DNS_R_BADALG;
}
if (!dns_resolver_algorithm_supported(val->view->resolver, val->name,
ds.algorithm))
{
- return (DNS_R_BADALG);
+ return DNS_R_BADALG;
}
val->supported_algorithm = true;
&keyrdata);
if (result != ISC_R_SUCCESS) {
validator_log(val, ISC_LOG_DEBUG(3), "no DNSKEY matching DS");
- return (DNS_R_NOKEYMATCH);
+ return DNS_R_NOKEYMATCH;
}
/*
validator_log(val, ISC_LOG_DEBUG(3),
"no RRSIG matching DS key");
- return (DNS_R_NOVALIDSIG);
+ return DNS_R_NOVALIDSIG;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
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);
dns_ncache_current(val->rdataset, *namep, *rdatasetp);
}
}
- return (result);
+ return result;
}
static isc_result_t
dns_ncache_current(val->rdataset, *namep, *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);
- 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->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->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;
}
- 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->rdataset == NULL && val->sigrdataset == NULL)) {
+ } else if (val->rdataset == NULL && val->sigrdataset == NULL) {
/*
* This is a validation of a negative response.
*/
}
result = validate_nx(val, false);
- } else if ((val->rdataset != NULL && NEGATIVE(val->rdataset))) {
+ } else if (val->rdataset != NULL && NEGATIVE(val->rdataset)) {
/*
* This is a delayed validation of a negative cache entry.
*/
result = dns_view_getsecroots(view, &kt);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
val = isc_mem_get(view->mctx, sizeof(*val));
*validatorp = val;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
result = isc_file_sanitize(NULL, name, "nta", buffer, sizeof(buffer));
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
view = isc_mem_get(mctx, sizeof(*view));
view->magic = DNS_VIEW_MAGIC;
*viewp = view;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_order:
if (view->order != NULL) {
isc_mem_free(mctx, view->name);
isc_mem_putanddetach(&view->mctx, view, sizeof(*view));
- return (result);
+ return result;
}
static void
tlsctx_cache, dispatchv4, dispatchv6,
&view->resolver);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
isc_mem_create(&mctx);
goto cleanup_adb;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_adb:
dns_adb_shutdown(view->adb);
dns_resolver_shutdown(view->resolver);
dns_resolver_detach(&view->resolver);
- return (result);
+ return result;
}
void
dns_view_iscacheshared(dns_view_t *view) {
REQUIRE(DNS_VIEW_VALID(view));
- return (view->cacheshared);
+ return view->cacheshared;
}
void
}
rcu_read_unlock();
- return (result);
+ return result;
}
isc_result_t
}
rcu_read_unlock();
- return (result);
+ return result;
}
isc_result_t
}
rcu_read_unlock();
- 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
result = ISC_R_SUCCESS;
}
rcu_read_unlock();
- return (result);
+ return result;
}
isc_result_t
result = ISC_R_SUCCESS;
}
rcu_read_unlock();
- return (result);
+ return result;
}
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
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);
}
rcu_read_unlock();
- 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;
}
isc_result_t
}
rcu_read_unlock();
- return (result);
+ return result;
}
void
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;
}
void
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_keynode_detach(&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;
}
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;
}
void
result = ISC_R_SHUTTINGDOWN;
}
UNLOCK(&view->lock);
- return (result);
+ return result;
}
void
uint16_t
dns_view_getudpsize(dns_view_t *view) {
REQUIRE(DNS_VIEW_VALID(view));
- return (view->udpsize);
+ return view->udpsize;
}
dns_dispatchmgr_t *
}
rcu_read_unlock();
- return (dispatchmgr);
+ return dispatchmgr;
}
isc_result_t
NULL, NULL));
cleanup:
- return (result);
+ return result;
}
isc_result_t
result = ISC_R_SHUTTINGDOWN;
}
rcu_read_unlock();
- return (result);
+ return result;
}
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));
dns_diff_append(&xfr->diff, &tuple);
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
/*
result = dns_zone_replacedb(xfr->zone, xfr->db, true);
LIBDNS_XFRIN_AXFR_FINALIZE_END(xfr, xfr->info, result);
- 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;
}
atomic_store(&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) {
xfr->ixfr.diffs++;
failure:
- return (result);
+ return result;
}
static isc_result_t
CHECK(dns_journal_begin_transaction(xfr->ixfr.journal));
}
failure:
- return (result);
+ return result;
}
static isc_result_t
CHECK(dns_journal_commit(xfr->ixfr.journal));
}
failure:
- return (result);
+ return result;
}
static isc_result_t
result = ixfr_end_transaction(xfr);
- return (result);
+ return result;
failure:
/* We need to end the transaction, but keep the previous error */
(void)ixfr_end_transaction(xfr);
- return (result);
+ return result;
}
static void
}
failure:
- return (result);
+ return result;
}
/**************************************************************************/
}
result = ISC_R_SUCCESS;
failure:
- return (result);
+ return result;
}
void
xfrin_fail(xfr, result, "zone transfer start failed");
}
- return (result);
+ return result;
}
static void
dns_xfrin_getstarttime(dns_xfrin_t *xfr) {
REQUIRE(VALID_XFRIN(xfr));
- return (atomic_load_relaxed(&xfr->start));
+ return atomic_load_relaxed(&xfr->start);
}
void
dns_xfrin_getendserial(dns_xfrin_t *xfr) {
REQUIRE(VALID_XFRIN(xfr));
- return (atomic_load_relaxed(&xfr->end_serial));
+ return atomic_load_relaxed(&xfr->end_serial);
}
void
dns_xfrin_getsourceaddr(const dns_xfrin_t *xfr) {
REQUIRE(VALID_XFRIN(xfr));
- return (&xfr->sourceaddr);
+ return &xfr->sourceaddr;
}
const isc_sockaddr_t *
dns_xfrin_getprimaryaddr(const dns_xfrin_t *xfr) {
REQUIRE(VALID_XFRIN(xfr));
- return (&xfr->primaryaddr);
+ return &xfr->primaryaddr;
}
dns_transport_type_t
REQUIRE(VALID_XFRIN(xfr));
if (xfr->transport != NULL) {
- return (dns_transport_get_type(xfr->transport));
+ return dns_transport_get_type(xfr->transport);
}
- return (DNS_TRANSPORT_TCP);
+ return DNS_TRANSPORT_TCP;
}
dns_transport_type_t
dns_xfrin_getsoatransporttype(dns_xfrin_t *xfr) {
REQUIRE(VALID_XFRIN(xfr));
- return (atomic_load_relaxed(&xfr->soa_transport_type));
+ return atomic_load_relaxed(&xfr->soa_transport_type);
}
const dns_name_t *
REQUIRE(VALID_XFRIN(xfr));
if (xfr->tsigkey == NULL || xfr->tsigkey->key == NULL) {
- return (NULL);
+ return NULL;
}
- return (dst_key_name(xfr->tsigkey->key));
+ return dst_key_name(xfr->tsigkey->key);
}
static void
*/
CHECK(dns_dispatch_connect(xfr->dispentry));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
xfrin_cancelio(xfr);
dns_xfrin_detach(&xfr);
- return (result);
+ return result;
}
/* XXX the resolver could use this, too */
result = ISC_R_SUCCESS;
failure:
dns_compress_invalidate(&cctx);
- return (result);
+ return result;
}
/*
request_type(dns_xfrin_t *xfr) {
switch (xfr->reqtype) {
case dns_rdatatype_soa:
- return ("SOA");
+ return "SOA";
case dns_rdatatype_axfr:
- return ("AXFR");
+ return "AXFR";
case dns_rdatatype_ixfr:
- return ("IXFR");
+ return "IXFR";
default:
ISC_UNREACHABLE();
}
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_db_closeversion(xfr->db, &ver, false);
}
- 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_redirect &&
dns_remote_addresses(&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;
}
/*
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;
}
/*
parentcatz = zone->parentcatz;
UNLOCK_ZONE(zone);
- return (parentcatz);
+ return 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_async_run(zone->loop, zone_asyncload, asl);
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_CHECKSVCB;
}
- return (options);
+ return options;
}
static void
goto cleanup;
}
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
} else if (zone->stream != NULL) {
FILE *stream = UNCONST(zone->stream);
result = dns_master_loadstream(
zone_idetach(&load->zone);
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
dns_difftuple_t *tuple = NULL;
dns_difftuple_create(diff->mctx, op, name, ttl, rdata, &tuple);
- 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;
}
static void
* If this zone isn't logging reports, it's fine.
*/
if (!DNS_ZONE_OPTION(zone, DNS_ZONEOPT_LOGREPORTS)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
}
failure:
- return (result);
+ return result;
}
/*
zone_debuglog(zone, __func__, 99, "done");
- return (result);
+ return result;
}
static bool
* DNS_ZONEFLG_SHUTDOWN can only be set if references == 0.
*/
INSIST(isc_refcount_current(&zone->references) == 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_SOA_VALUES(soattl_v, serial_v, refresh_v, retry_v, expire_v, \
dns_rdataset_invalidate(&rdataset);
- return (result);
+ return result;
}
/*
closeversion:
dns_db_closeversion(db, &version, false);
- return (answer);
+ return answer;
}
static 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
}
UNLOCK_ZONE(zone);
- return (kasp);
+ return kasp;
}
static void
}
UNLOCK_ZONE(zone);
- return (bundle);
+ return bundle;
}
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->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;
}
void
has_pf(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;
}
static isc_result_t
}
*key = foundkey;
- return (result);
+ return result;
}
#define is_zone_key(key) \
}
}
*nkeys = count;
- return (result);
+ return result;
}
/*%
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);
}
- return (result);
+ return result;
}
isc_result_t
if (!dumping) {
result = zone_dump(zone, false);
}
- return (result);
+ return result;
}
static void
* Asyncronous write is in progress. Zone flags will get
* updated on completion. Cleanup is complete. We are done.
*/
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
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,
¬ify->rlevent);
if (result != ISC_R_SUCCESS) {
- return (true);
+ return true;
}
notify->flags &= ~DNS_NOTIFY_STARTUP;
notify->zone->zmgr->notifyrl, notify->zone->loop,
notify_send_toaddr, notify, ¬ify->rlevent);
if (result != ISC_R_SUCCESS) {
- 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;
}
/*
static isc_result_t
notify_send_queue(dns_notify_t *notify, bool startup) {
- return (isc_ratelimiter_enqueue(
+ return isc_ratelimiter_enqueue(
startup ? notify->zone->zmgr->startupnotifyrl
: notify->zone->zmgr->notifyrl,
notify->zone->loop, notify_send_toaddr, notify,
- ¬ify->rlevent));
+ ¬ify->rlevent);
}
static void
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(&sgr->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;
}
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_logc(zone, DNS_LOGCATEGORY_XFER_IN, 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_logc(zone, DNS_LOGCATEGORY_XFER_IN, 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_logc(zone, DNS_LOGCATEGORY_XFER_IN, ISC_LOG_INFO,
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 (dns_remote_addresses(&zone->primaries) == NULL
- ? dns_zone_primary
- : dns_zone_secondary);
+ return dns_remote_addresses(&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
&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_async_run(zone->secure->loop, receive_secure_serial, rss);
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.
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
isc_async_run(zone->secure->loop, receive_secure_db, rss);
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;
}
isc_sockaddr_t
sourceaddr = zone->sourceaddr;
UNLOCK_ZONE(zone);
- return (sourceaddr);
+ return sourceaddr;
}
isc_sockaddr_t
curraddr = dns_remote_curraddr(&zone->primaries);
UNLOCK_ZONE(zone);
- return (curraddr);
+ return curraddr;
}
isc_time_t
xfrintime = zone->xfrintime;
UNLOCK_ZONE(zone);
- return (xfrintime);
+ return xfrintime;
}
static void
}
}
- return (transport_type);
+ return transport_type;
}
dns_transport_type_t
transport_type = get_request_transport_type(zone);
UNLOCK_ZONE(zone);
- return (transport_type);
+ return transport_type;
}
/*
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING)) {
UNLOCK_ZONE(zone);
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
next:
if (forward->which >= dns_remote_count(&forward->zone->primaries)) {
UNLOCK_ZONE(zone);
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
forward->addr = dns_remote_addr(&zone->primaries, forward->which);
isc_result_totext(result));
}
- 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;
}
}
kfio_match(void *node, const void *key) {
const dns_keyfileio_t *kfio = node;
- return (dns_name_equal(kfio->name, key));
+ return dns_name_equal(kfio->name, key);
}
static void
static bool
match_ptr(void *node, const void *key) {
- return (node == key);
+ return node == key;
}
static void
REQUIRE(zonep != NULL && *zonep == NULL);
if (zmgr->mctxpool == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
tid = isc_random_uniform(zmgr->workers);
mctx = zmgr->mctxpool[tid];
if (mctx == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
dns_zone_create(&zone, mctx, tid);
*zonep = zone;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
UNLOCK_ZONE(zone);
RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_write);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
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
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;
}
/*
/* 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;
}
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;
}
void
}
UNLOCK_ZONE(zone);
- return (ks);
+ return ks;
}
unsigned int
RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_read);
- return (count);
+ return count;
}
isc_result_t
REQUIRE(xfrp != NULL && *xfrp == NULL);
if (zone->zmgr == NULL) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
/* Reset. */
UNLOCK_ZONE(zone);
RWUNLOCK(&zone->zmgr->rwlock, isc_rwlocktype_read);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
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
default:
dns_zone_log(zone, ISC_LOG_WARNING,
"checkds: option is disabled");
- return (false);
+ return false;
}
if (dspublish) {
count, dst_key_id(key));
if (count != num) {
- return (false);
+ return false;
}
} else {
(void)dst_key_getnum(key, DST_NUM_DSDELCOUNT, &count);
count, dst_key_id(key));
if (count != num) {
- return (false);
+ return false;
}
}
dns_zone_log(zone, ISC_LOG_WARNING,
"checkds: checkds for key %u failed: %s",
dst_key_id(key), isc_result_totext(result));
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static isc_result_t
/* Validate DS RRset. */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
continue;
}
if (name != NULL && dns_name_equal(name, &checkds->ns)) {
- return (true);
+ return true;
}
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 void
dns_diff_appendminimal(diff, &tuple);
}
if (result != ISC_R_NOMORE) {
- 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
bool
dns_zone_getrequestixfrmaxdiffs(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
- return (zone->requestixfr_maxdiffs);
+ return zone->requestixfr_maxdiffs;
}
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 (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
LOCK(&zone->lock);
israw = zone->secure != NULL;
UNLOCK(&zone->lock);
- return (israw);
+ return israw;
}
bool
LOCK(&zone->lock);
issecure = zone->raw != NULL;
UNLOCK(&zone->lock);
- return (issecure);
+ return issecure;
}
struct keydone {
isc_mem_put(zone->mctx, kd, sizeof(*kd));
}
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
failure:
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
failure:
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
isc_mem_t *
dns_zone_getmem(dns_zone_t *zone) {
- return (zone->mctx);
+ return zone->mctx;
}
unsigned int
dns_zone_gettid(dns_zone_t *zone) {
- return (zone->tid);
+ return zone->tid;
}
isc_loop_t *
dns_zone_getloop(dns_zone_t *zone) {
- return (zone->loop);
+ return zone->loop;
}
isc_result_t
: 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;
}
isc_result_t
failure:
dns_skr_detach(&skr);
- return (result);
+ return result;
}
isc_result_t
result = ISC_R_SUCCESS;
}
UNLOCK_ZONE(zone);
- return (result);
+ return result;
}
void
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);
- return (result);
+ return result;
}
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;
}
sr.base = UNCONST(d1 - first->next_length);
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;
}
uint32_t ival ISC_ATTR_UNUSED) {
dns_zone_t *zone = pval;
dns_name_t *name = dns_zone_getorigin(zone);
- return (dns_qpkey_fromname(key, name));
+ return dns_qpkey_fromname(key, name);
}
static void
dns_qp_compact(qp, DNS_QPGC_MAYBE);
dns_qpmulti_commit(zt->multi, &qp);
- return (result);
+ return result;
}
isc_result_t
dns_qp_compact(qp, DNS_QPGC_MAYBE);
dns_qpmulti_commit(zt->multi, &qp);
- return (result);
+ return result;
}
isc_result_t
}
}
- 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
{
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
isc_result_t
dns_zt_load(dns_zt_t *zt, bool stop, bool newonly) {
REQUIRE(VALID_ZT(zt));
- return (dns_zt_apply(zt, stop, NULL, load, newonly ? &newonly : NULL));
+ return dns_zt_apply(zt, stop, NULL, load, newonly ? &newonly : NULL);
}
static void
zt_destroy(zt);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
isc_refcount_decrement1(&zt->references);
isc_refcount_decrement1(&zt->loads_pending);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
loaded_all(params);
}
- return (result);
+ return 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;
}
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;
}
typedef void
setview(dns_zone_t *zone, void *arg) {
setview_cb *cb = arg;
cb(zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
SET_IF_NOT_NULL(sub, tresult);
- return (result);
+ return result;
}
default:
result = "UNKNOWN";
}
- return (result);
+ return result;
}
/*
* 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;
}
* 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
static void *
isc__crypto_malloc_ex(size_t size, const char *file, int line) {
- return (isc__mem_allocate(isc__crypto_mctx, size, 0, file,
- (unsigned int)line));
+ return isc__mem_allocate(isc__crypto_mctx, size, 0, file,
+ (unsigned int)line);
}
static void *
isc__crypto_realloc_ex(void *ptr, size_t size, const char *file, int line) {
- return (isc__mem_reallocate(isc__crypto_mctx, ptr, size, 0, file,
- (unsigned int)line));
+ return isc__mem_reallocate(isc__crypto_mctx, ptr, size, 0, file,
+ (unsigned int)line);
}
static void
isc__crypto_malloc_ex(size_t size, const char *file, int line) {
UNUSED(file);
UNUSED(line);
- return (isc_mem_allocate(isc__crypto_mctx, size));
+ return isc_mem_allocate(isc__crypto_mctx, size);
}
static void *
isc__crypto_realloc_ex(void *ptr, size_t size, const char *file, int line) {
UNUSED(file);
UNUSED(line);
- return (isc_mem_reallocate(isc__crypto_mctx, ptr, size));
+ return isc_mem_reallocate(isc__crypto_mctx, ptr, size);
}
static 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 */
}
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;
}
}
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
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 int)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;
}
#include <openssl/evp.h>
bool
isc_fips_mode(void) {
- return (EVP_default_properties_is_fips_enabled(NULL) != 0);
+ return EVP_default_properties_is_fips_enabled(NULL) != 0;
}
isc_result_t
isc_fips_set_mode(int mode) {
- return (EVP_default_properties_enable_fips(NULL, mode) != 0
- ? ISC_R_SUCCESS
- : ISC_R_FAILURE);
+ return EVP_default_properties_enable_fips(NULL, mode) != 0
+ ? ISC_R_SUCCESS
+ : ISC_R_FAILURE;
}
#elif defined(HAVE_FIPS_MODE)
#include <openssl/crypto.h>
bool
isc_fips_mode(void) {
- return (FIPS_mode() != 0);
+ return FIPS_mode() != 0;
}
isc_result_t
isc_fips_set_mode(int mode) {
- return (FIPS_mode_set(mode) != 0 ? ISC_R_SUCCESS : ISC_R_FAILURE);
+ return FIPS_mode_set(mode) != 0 ? ISC_R_SUCCESS : ISC_R_FAILURE;
}
#else
bool
isc_fips_mode(void) {
- return (false);
+ return false;
}
isc_result_t
isc_fips_set_mode(int mode) {
UNUSED(mode);
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
#endif
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;
}
}
const void *
isc_hash_get_initializer(void) {
- return (isc_hash_key);
+ return isc_hash_key;
}
void
isc_halfsiphash24_finalize(state, (uint8_t *)&hval);
- return (hval);
+ return hval;
}
void
isc_siphash24_finalize(state, (uint8_t *)&hval);
- return (hval);
+ return hval;
}
static uint8_t
hashmap_nexttable(uint8_t idx) {
- return ((idx == 0) ? 1 : 0);
+ return (idx == 0) ? 1 : 0;
}
static bool
rehashing_in_progress(const isc_hashmap_t *hashmap) {
- return (hashmap->tables[hashmap_nexttable(hashmap->hindex)].table !=
- NULL);
+ return hashmap->tables[hashmap_nexttable(hashmap->hindex)].table !=
+ NULL;
}
static bool
try_nexttable(const isc_hashmap_t *hashmap, uint8_t idx) {
- return (idx == hashmap->hindex && rehashing_in_progress(hashmap));
+ return idx == hashmap->hindex && rehashing_in_progress(hashmap);
}
static void
if (match(node->value, key)) {
*pslp = psl;
*idxp = idx;
- return (node);
+ return node;
}
}
goto nexttable;
}
- return (NULL);
+ return NULL;
}
isc_result_t
hashmap_node_t *node = hashmap_find(hashmap, hashval, match, key,
&(uint32_t){ 0 }, &idx);
if (node == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
INSIST(node->key != NULL);
SET_IF_NOT_NULL(valuep, node->value);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static bool
}
*entry = (hashmap_node_t){ 0 };
- return (last);
+ return last;
}
static void
newbits = HASHMAP_MAX_BITS;
}
- return (newbits);
+ return newbits;
}
static uint32_t
newbits = HASHMAP_MIN_BITS;
}
- return (newbits);
+ return newbits;
}
static void
result = ISC_R_SUCCESS;
}
- return (result);
+ return result;
}
static bool
over_threshold(isc_hashmap_t *hashmap) {
uint32_t bits = hashmap->tables[hashmap->hindex].hashbits;
if (bits == HASHMAP_MAX_BITS) {
- return (false);
+ return false;
}
size_t threshold = APPROX_90_PERCENT(HASHSIZE(bits));
- return (hashmap->count > threshold);
+ return hashmap->count > threshold;
}
static bool
under_threshold(isc_hashmap_t *hashmap) {
uint32_t bits = hashmap->tables[hashmap->hindex].hashbits;
if (bits == HASHMAP_MIN_BITS) {
- return (false);
+ return false;
}
size_t threshold = APPROX_20_PERCENT(HASHSIZE(bits));
- return (hashmap->count < threshold);
+ return hashmap->count < threshold;
}
static isc_result_t
if (current->hashval == hashval) {
if (match != NULL && match(current->value, key)) {
SET_IF_NOT_NULL(foundp, current->value);
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
}
/* We found an empty place, store entry into current node */
*current = node;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
if (found != NULL) {
INSIST(found->key != NULL);
SET_IF_NOT_NULL(foundp, found->value);
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
}
- return (hashmap_add(hashmap, hashval, match, key, value, foundp,
- hashmap->hindex));
+ return hashmap_add(hashmap, hashval, match, key, value, foundp,
+ hashmap->hindex);
}
void
if (iter->i < iter->size) {
iter->cur = &hashmap->tables[iter->hindex].table[iter->i];
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (try_nexttable(hashmap, iter->hindex)) {
iter->hindex = hashmap_nexttable(iter->hindex);
iter->i = hashmap->hiter;
iter->size = hashmap->tables[iter->hindex].size;
- return (isc__hashmap_iter_next(iter));
+ return isc__hashmap_iter_next(iter);
}
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
isc_result_t
iter->i = 0;
iter->size = iter->hashmap->tables[iter->hashmap->hindex].size;
- return (isc__hashmap_iter_next(iter));
+ return isc__hashmap_iter_next(iter);
}
isc_result_t
iter->i++;
- return (isc__hashmap_iter_next(iter));
+ return isc__hashmap_iter_next(iter);
}
isc_result_t
iter->size--;
}
- return (isc__hashmap_iter_next(iter));
+ return isc__hashmap_iter_next(iter);
}
void
isc_hashmap_count(isc_hashmap_t *hashmap) {
REQUIRE(ISC_HASHMAP_VALID(hashmap));
- return (hashmap->count);
+ return hashmap->count;
}
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;
}
/*%
hexval = isc_hex_char(c);
if (hexval == 0) {
- return (ISC_R_BADHEX);
+ return ISC_R_BADHEX;
}
ctx->val[ctx->digits++] = c - hexval;
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;
}
uint
isc_histo_sigbits(isc_histo_t *hg) {
REQUIRE(HISTO_VALID(hg));
- return (hg->sigbits);
+ return hg->sigbits;
}
/*
isc_histo_bits_to_digits(uint bits) {
REQUIRE(bits >= ISC_HISTO_MINBITS);
REQUIRE(bits <= ISC_HISTO_MAXBITS);
- return (floor(1.0 - (1.0 - bits) * LN_2 / LN_10));
+ return floor(1.0 - (1.0 - bits) * LN_2 / LN_10);
}
uint
isc_histo_digits_to_bits(uint digits) {
REQUIRE(digits >= ISC_HISTO_MINDIGITS);
REQUIRE(digits <= ISC_HISTO_MAXDIGITS);
- return (ceil(1.0 - (1.0 - digits) * LN_10 / LN_2));
+ return ceil(1.0 - (1.0 - digits) * LN_10 / LN_2);
}
/**********************************************************************/
/* mantissa has leading bit set except for denormals */
uint mantissa = value >> exponent;
/* leading bit of mantissa adds one to exponent */
- return ((exponent << hg->sigbits) + mantissa);
+ return (exponent << hg->sigbits) + mantissa;
}
/*
uint chunksize = CHUNKSIZE(hg);
uint exponent = (key / chunksize) - 1;
uint64_t mantissa = (key % chunksize) + chunksize;
- return (key < chunksize ? key : mantissa << exponent);
+ return key < chunksize ? key : mantissa << exponent;
}
static inline uint64_t
key_to_maxval(const isc_histo_t *hg, uint key) {
- return (key_to_minval(hg, key + 1) - 1);
+ return key_to_minval(hg, key + 1) - 1;
}
/**********************************************************************/
sizeof(hg_bucket_t));
hg_chunk_t *cpp = &hg->chunk[chunk];
if (atomic_compare_exchange_strong_acq_rel(cpp, &old_cp, new_cp)) {
- return (&new_cp[bucket]);
+ return &new_cp[bucket];
} else {
/* lost the race, so use the winner's chunk */
isc_mem_cput(hg->mctx, new_cp, CHUNKSIZE(hg),
sizeof(hg_bucket_t));
- return (&old_cp[bucket]);
+ return &old_cp[bucket];
}
}
static hg_bucket_t *
get_chunk(const isc_histo_t *hg, uint chunk) {
- return (atomic_load_acquire(&hg->chunk[chunk]));
+ return atomic_load_acquire(&hg->chunk[chunk]);
}
static inline hg_bucket_t *
uint chunk = key / chunksize;
uint bucket = key % chunksize;
hg_bucket_t *cp = get_chunk(hg, chunk);
- return (cp == NULL ? NULL : &cp[bucket]);
+ return cp == NULL ? NULL : &cp[bucket];
}
static inline uint64_t
bucket_count(const hg_bucket_t *bp) {
- return (bp == NULL ? 0 : atomic_load_relaxed(bp));
+ return bp == NULL ? 0 : atomic_load_relaxed(bp);
}
static inline uint64_t
get_key_count(const isc_histo_t *hg, uint key) {
- return (bucket_count(key_to_bucket(hg, key)));
+ return bucket_count(key_to_bucket(hg, key));
}
static inline void
SET_IF_NOT_NULL(minp, key_to_minval(hg, key));
SET_IF_NOT_NULL(maxp, key_to_maxval(hg, key));
SET_IF_NOT_NULL(countp, get_key_count(hg, key));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
}
double inpart = (double)(in - lo);
double outrange = (double)(max - min);
double outpart = round(outrange * inpart / inrange);
- return (min + ISC_MIN((uint64_t)outpart, max - min));
+ return min + ISC_MIN((uint64_t)outpart, max - min);
}
/*
*/
static inline bool
inside(uint64_t lo, uint64_t in, uint64_t hi) {
- return (lo < hi && lo <= in && in <= hi);
+ return lo < hi && lo <= in && in <= hi;
}
isc_result_t
key_to_maxval(hg, key),
bucket_lo, rank[i], bucket_hi);
if (++i == size) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
}
}
}
- return (ISC_R_UNSET);
+ return ISC_R_UNSET;
}
/**********************************************************************/
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)
- : (isc_ascii_lowerequal(node->key, key, keysize))));
+ return node->hashval == hashval && node->keysize == keysize &&
+ (case_sensitive
+ ? (memcmp(node->key, key, keysize) == 0)
+ : (isc_ascii_lowerequal(node->key, key, keysize)));
}
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;
}
SET_IF_NOT_NULL(valuep, node->value);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
STRUCT_FLEX_SIZE(node, key, 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_httpd_attach(httpd, &req->httpd);
- 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;
}
*/
static inline uint8_t
isc__ascii_tolower1(uint8_t c) {
- return (c + ('a' - 'A') * ('A' <= c && c <= 'Z'));
+ return c + ('a' - 'A') * ('A' <= c && c <= 'Z');
}
/*
* Move the is_upper flag bits to bit 0x20 (which is 'a' - 'A')
* and use them to adjust each byte as required
*/
- return (octets | (is_upper >> 2));
+ return octets | (is_upper >> 2);
}
/*
uint32_t is_gt_Z = heptets + (0x7F - 'Z') * all_bytes;
uint32_t is_ge_A = heptets + (0x80 - 'A') * all_bytes;
uint32_t is_upper = (is_ge_A ^ is_gt_Z) & is_ascii;
- return (octets | (is_upper >> 2));
+ return octets | (is_upper >> 2);
}
/*
isc__ascii_load8(const uint8_t *ptr) {
uint64_t bytes = 0;
memmove(&bytes, ptr, sizeof(bytes));
- return (bytes);
+ return bytes;
}
/*
a8 = isc_ascii_tolower8(isc__ascii_load8(a));
b8 = isc_ascii_tolower8(isc__ascii_load8(b));
if (a8 != b8) {
- return (false);
+ return false;
}
len -= 8;
a += 8;
}
while (len-- > 0) {
if (isc_ascii_tolower(*a++) != isc_ascii_tolower(*b++)) {
- return (false);
+ return false;
}
}
- return (true);
+ return true;
}
/*
}
ret:
if (a8 < b8) {
- return (-1);
+ return -1;
}
if (a8 > b8) {
- return (+1);
+ return +1;
}
- return (0);
+ return 0;
}
uint8_t *cp = isc_buffer_current(b);
SET_IF_NOT_NULL(valp, (uint8_t)(cp[0]));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static inline uint8_t
isc_result_t result = isc_buffer_peekuint8(b, &val);
ENSURE(result == ISC_R_SUCCESS);
b->current += sizeof(val);
- return (val);
+ return val;
}
#define ISC_BUFFER_PUT_RESERVE(b, v, s) \
uint8_t *cp = isc_buffer_current(b);
SET_IF_NOT_NULL(valp, ISC_U8TO16_BE(cp));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static inline uint16_t
isc_result_t result = isc_buffer_peekuint16(b, &val);
ENSURE(result == ISC_R_SUCCESS);
b->current += sizeof(val);
- return (val);
+ return val;
}
static inline void
uint8_t *cp = isc_buffer_current(b);
SET_IF_NOT_NULL(valp, ISC_U8TO32_BE(cp));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
uint32_t
isc_result_t result = isc_buffer_peekuint32(b, &val);
ENSURE(result == ISC_R_SUCCESS);
b->current += sizeof(val);
- return (val);
+ return val;
}
static inline void
uint8_t *cp = isc_buffer_current(b);
SET_IF_NOT_NULL(valp, ISC_U8TO48_BE(cp));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static inline uint64_t
isc_result_t result = isc_buffer_peekuint48(b, &val);
ENSURE(result == ISC_R_SUCCESS);
b->current += 6; /* 48-bits */
- return (val);
+ return val;
}
static inline void
len = dbuf->length;
if ((len - dbuf->used) >= size) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
if (dbuf->mctx == NULL) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
}
/* Round to nearest buffer size increment */
}
if ((len - dbuf->used) < size) {
- return (ISC_R_NOMEMORY);
+ return ISC_R_NOMEMORY;
}
if (!dbuf->dynamic) {
}
dbuf->length = (unsigned int)len;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static inline 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;
}
static inline isc_result_t
if (b->mctx) {
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;
}
static inline isc_result_t
va_end(ap);
if (n < 0) {
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (b->mctx) {
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;
}
ISC_LANG_ENDDECLS
newasm = isc_mem_get(memctx, sizeof(*newasm));
isc_dnsstream_assembler_init(newasm, memctx, cb, cbarg);
- return (newasm);
+ return newasm;
}
static inline void
ret = dnsasm->onmsg_cb(dnsasm, result, region, dnsasm->cbarg, userarg);
dnsasm->calling_cb = false;
- return (ret);
+ return ret;
}
static inline bool
userarg);
}
- return (cont);
+ return cont;
}
static inline void
size_t remaining_no_len;
if (isc_buffer_peekuint16(dnsasm->current, &dnslen) != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
remaining = isc_buffer_remaininglength(dnsasm->current);
* previous iteration we stopped prematurely intentionally.
*/
if (remaining_no_len >= dnslen) {
- return (false);
+ return false;
}
/*
INSIST(isc_buffer_remaininglength(dnsasm->current) == 0);
if (unprocessed_size == 0) {
- return (true);
+ return true;
}
if (cont) {
unprocessed_size);
}
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static inline void
const isc_dnsstream_assembler_t *restrict dnsasm) {
REQUIRE(dnsasm != NULL);
- return (dnsasm->result);
+ return dnsasm->result;
}
static inline size_t
const isc_dnsstream_assembler_t *restrict dnsasm) {
REQUIRE(dnsasm != NULL);
- return (isc_buffer_remaininglength(dnsasm->current));
+ return isc_buffer_remaininglength(dnsasm->current);
}
static inline void
isc_hash32_t state;
isc_hash32_init(&state);
isc_hash32_hash(&state, data, length, case_sensitive);
- return (isc_hash32_finalize(&state));
+ return isc_hash32_finalize(&state);
}
void
isc_hash64_t state;
isc_hash64_init(&state);
isc_hash64_hash(&state, data, length, case_sensitive);
- return (isc_hash64_finalize(&state));
+ return isc_hash64_finalize(&state);
}
/*!<
* \brief Calculate a hash over data.
isc_hash_bits32(uint32_t val, unsigned int bits) {
ISC_REQUIRE(bits <= ISC_HASH_MAX_BITS);
/* High bits are more random. */
- return (val * ISC_HASH_GOLDENRATIO_32 >> (32 - bits));
+ return val * ISC_HASH_GOLDENRATIO_32 >> (32 - bits);
}
ISC_LANG_ENDDECLS
static inline isc_loop_t *
isc_loop(void) {
- return (isc__loop_local);
+ return isc__loop_local;
}
void
isc_loopmgr_create(isc_mem_t *mctx, uint32_t nloops, isc_loopmgr_t **loopmgrp);
static inline bool
isc_queue_empty(isc_queue_t *queue) {
- return (cds_wfcq_empty(&(queue)->head, &(queue)->tail));
+ return cds_wfcq_empty(&(queue)->head, &(queue)->tail);
}
static inline bool
isc_queue_enqueue(isc_queue_t *queue, isc_queue_node_t *node) {
- return (cds_wfcq_enqueue(&(queue)->head, &(queue)->tail, node));
+ return cds_wfcq_enqueue(&(queue)->head, &(queue)->tail, node);
}
#define isc_queue_enqueue_entry(queue, entry, member) \
static inline isc_queue_node_t *
isc_queue_dequeue(isc_queue_t *queue) {
- return (__cds_wfcq_dequeue_nonblocking(&(queue)->head, &(queue)->tail));
+ return __cds_wfcq_dequeue_nonblocking(&(queue)->head, &(queue)->tail);
}
#define isc_queue_entry(ptr, type, member) \
INSIST(ret != CDS_WFCQ_RET_WOULDBLOCK &&
ret != CDS_WFCQ_RET_DEST_NON_EMPTY);
- return (ret != CDS_WFCQ_RET_SRC_EMPTY);
+ return ret != CDS_WFCQ_RET_SRC_EMPTY;
}
#define isc_queue_first_entry(queue, type, member) \
static inline uint32_t
isc_tid(void) {
- return (isc__tid_local);
+ return isc__tid_local;
}
/*%<
* Returns the thread ID of the currently-running loop.
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;
}
void
const unsigned char *buf;
if (hashalg != 1) {
- return (0);
+ return 0;
}
buf = in;
len = outlength;
} while (n++ < iterations);
- return (outlength);
+ return outlength;
fail:
ERR_clear_error();
- return (0);
+ return 0;
}
void
memset(ptr, 0, size);
}
- 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;
}
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;
}
isc_logconfig_get(void) {
REQUIRE(VALID_CONTEXT(isc__lctx));
- return (rcu_dereference(isc__lctx->logconfig));
+ return rcu_dereference(isc__lctx->logconfig);
}
void
category++)
{
if (strcmp(categories_description[category], name) == 0) {
- return (category);
+ return category;
}
}
- return (ISC_LOGCATEGORY_INVALID);
+ return ISC_LOGCATEGORY_INVALID;
}
void
}
if (channel == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
if (category != ISC_LOGCATEGORY_DEFAULT) {
}
rcu_read_unlock();
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_log_getdebuglevel(void) {
REQUIRE(VALID_CONTEXT(isc__lctx));
- return (atomic_load_acquire(&isc__lctx->debug_level));
+ return atomic_load_acquire(&isc__lctx->debug_level);
}
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 (isc__lctx == NULL) {
- return (false);
+ return false;
}
if (forcelog) {
- return (true);
+ return true;
}
int highest_level = atomic_load_acquire(&isc__lctx->highest_level);
if (level <= highest_level) {
- return (true);
+ return true;
}
if (atomic_load_acquire(&isc__lctx->dynamic)) {
int debug_level = atomic_load_acquire(&isc__lctx->debug_level);
if (level <= debug_level) {
- return (true);
+ return true;
}
}
- return (false);
+ return false;
}
static void
isc_barrier_wait(&helper->loopmgr->stopping);
- return (NULL);
+ return NULL;
}
static void *
isc_barrier_wait(&loopmgr->stopping);
- return (NULL);
+ return NULL;
}
/**
cds_wfcq_enqueue(&loop->setup_jobs.head, &loop->setup_jobs.tail,
&job->wfcq_node);
- return (job);
+ return job;
}
isc_job_t *
cds_wfcq_enqueue(&loop->teardown_jobs.head, &loop->teardown_jobs.tail,
&job->wfcq_node);
- return (job);
+ return job;
}
void
isc_loopmgr_nloops(isc_loopmgr_t *loopmgr) {
REQUIRE(VALID_LOOPMGR(loopmgr));
- return (loopmgr->nloops);
+ return loopmgr->nloops;
}
isc_mem_t *
isc_loop_getmctx(isc_loop_t *loop) {
REQUIRE(VALID_LOOP(loop));
- return (loop->mctx);
+ return loop->mctx;
}
isc_loop_t *
isc_loop_main(isc_loopmgr_t *loopmgr) {
REQUIRE(VALID_LOOPMGR(loopmgr));
- return (DEFAULT_LOOP(loopmgr));
+ return DEFAULT_LOOP(loopmgr);
}
isc_loop_t *
REQUIRE(VALID_LOOPMGR(loopmgr));
REQUIRE(tid < loopmgr->nloops);
- return (LOOP(loopmgr, tid));
+ return LOOP(loopmgr, tid);
}
void
isc_loop_getloopmgr(isc_loop_t *loop) {
REQUIRE(VALID_LOOP(loop));
- return (loop->loopmgr);
+ return loop->loopmgr;
}
isc_time_t
.nanoseconds = (msec % MS_PER_SEC) * NS_PER_MS,
};
- return (t);
+ return t;
}
bool
REQUIRE(VALID_LOOP(loop));
REQUIRE(loop->tid == isc_tid());
- return (loop->shuttingdown);
+ return loop->shuttingdown;
}
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;
}
memset(ret, 0xbe, size); /* Mnemonic for "beef". */
}
- return (ret);
+ return ret;
}
/*!
}
}
- return (new_ptr);
+ return new_ptr;
}
/*!
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 /* JEMALLOC_API_SUPPORTED */
}
(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 /* JEMALLOC_API_SUPPORTED */
}
mem_getstats(ctx, size);
ADD_TRACE(ctx, ptr, size, file, line);
- return (ptr);
+ return ptr;
}
void
mem_getstats(ctx, size);
ADD_TRACE(ctx, ptr, size, file, line);
- return (ptr);
+ return ptr;
}
void *
*/
}
- return (new_ptr);
+ return new_ptr;
}
void *
*/
}
- 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_relaxed(&ctx->inuse));
+ return atomic_load_relaxed(&ctx->inuse);
}
void
/* We are not overmem, check whether we should be? */
size_t hiwater = atomic_load_relaxed(&ctx->hi_water);
if (hiwater == 0) {
- return (false);
+ return false;
}
size_t inuse = atomic_load_relaxed(&ctx->inuse);
if (inuse <= hiwater) {
- return (false);
+ return false;
}
if ((isc_mem_debugging & ISC_MEM_DEBUGUSAGE) != 0) {
}
atomic_store_relaxed(&ctx->is_overmem, true);
- return (true);
+ return true;
} else {
/* We are overmem, check whether we should not be? */
size_t lowater = atomic_load_relaxed(&ctx->lo_water);
if (lowater == 0) {
- return (false);
+ return false;
}
size_t inuse = atomic_load_relaxed(&ctx->inuse);
if (inuse >= lowater) {
- return (true);
+ return true;
}
if ((isc_mem_debugging & ISC_MEM_DEBUGUSAGE) != 0) {
inuse, lowater);
}
atomic_store_relaxed(&ctx->is_overmem, false);
- return (false);
+ return false;
}
}
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);
}
#ifdef HAVE_LIBXML2
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, "Malloced", 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 /* JEMALLOC_API_SUPPORTED */
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
}
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
#if UV_VERSION_HEX >= UV_VERSION(1, 29, 0)
uint64_t cmem = uv_get_constrained_memory();
if (cmem > 0 && cmem < tmem) {
- return (cmem);
+ return cmem;
}
#endif /* UV_VERSION_HEX >= UV_VERSION(1, 29, 0) */
- return (tmem);
+ return tmem;
}
#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;
}
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;
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
type = &netaddr->type.in6;
break;
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
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 *
http_calloc(size_t n, size_t sz, isc_mem_t *mctx) {
- return (isc_mem_callocate(mctx, n, sz));
+ return isc_mem_callocate(mctx, n, sz);
}
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
isc__nm_httpsession_handle(isc_nm_http_session_t *session) {
REQUIRE(VALID_HTTP2_SESSION(session));
- return (session->handle);
+ return session->handle;
}
static http_cstream_t *
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;
}
/*
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;
}
INSIST(session->handle->sock->tid == isc_tid());
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->worker->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->worker->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;
}
static void
* 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;
}
/*
REQUIRE(VALID_NMSOCK(handle->sock));
if (isc__nm_closing(handle->sock->worker)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
REQUIRE(VALID_NMSOCK(httpserver));
/* 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) {
sock->closed = true;
isc__nmsocket_detach(&sock);
- return (result);
+ return result;
}
sock->nchildren = sock->outer->nchildren;
sock->fd = (uv_os_sock_t)-1;
*sockp = sock;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_nm_http_endpoints_t *
atomic_init(&eps->in_use, false);
eps->magic = HTTP_ENDPOINTS_MAGIC;
- return (eps);
+ return eps;
}
void
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_has_encryption(session->handle));
+ return isc_nm_has_encryption(session->handle);
}
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;
}
static 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);
}
isc_nm_getloadbalancesockets(isc_nm_t *mgr) {
REQUIRE(VALID_NM(mgr));
- return (mgr->load_balance_sockets);
+ return mgr->load_balance_sockets;
}
void
isc__nmsocket_active(isc_nmsocket_t *sock) {
REQUIRE(VALID_NMSOCK(sock));
- return (sock->active);
+ return sock->active;
}
void
static bool
nmsocket_has_active_handles(isc_nmsocket_t *sock) {
if (!ISC_LIST_EMPTY(sock->active_handles)) {
- return (true);
+ return true;
}
if (sock->children != NULL) {
for (size_t i = 0; i < sock->nchildren; i++) {
isc_nmsocket_t *csock = &sock->children[i];
if (!ISC_LIST_EMPTY(csock->active_handles)) {
- return (true);
+ return true;
}
}
}
- return (false);
+ return false;
}
static void
};
isc_refcount_init(&handle->references, 1);
- return (handle);
+ return handle;
}
static isc_nmhandle_t *
isc_refcount_init(&handle->references, 1);
INSIST(VALID_NMHANDLE(handle));
- return (handle);
+ return handle;
}
#else
INSIST(ISC_LIST_EMPTY(sock->inactive_handles));
#endif /* !__SANITIZE_ADDRESS__ && !__SANITIZE_THREAD__ */
- return (NULL);
+ return NULL;
}
isc_nmhandle_t *
}
#endif
- return (handle);
+ return handle;
}
bool
isc_nmhandle_is_stream(isc_nmhandle_t *handle) {
REQUIRE(VALID_NMHANDLE(handle));
- return (handle->sock->type == isc_nm_tcpsocket ||
- handle->sock->type == isc_nm_tlssocket ||
- handle->sock->type == isc_nm_httpsocket ||
- handle->sock->type == isc_nm_streamdnssocket ||
- handle->sock->type == isc_nm_proxystreamsocket);
+ return handle->sock->type == isc_nm_tcpsocket ||
+ handle->sock->type == isc_nm_tlssocket ||
+ handle->sock->type == isc_nm_httpsocket ||
+ handle->sock->type == isc_nm_streamdnssocket ||
+ handle->sock->type == isc_nm_proxystreamsocket;
}
static void
isc_nmhandle_getdata(isc_nmhandle_t *handle) {
REQUIRE(VALID_NMHANDLE(handle));
- return (handle->opaque);
+ return handle->opaque;
}
void
switch (sock->type) {
case isc_nm_tlssocket:
- return (isc__nmsocket_tls_timer_running(sock));
+ return isc__nmsocket_tls_timer_running(sock);
case isc_nm_streamdnssocket:
- return (isc__nmsocket_streamdns_timer_running(sock));
+ return isc__nmsocket_streamdns_timer_running(sock);
case isc_nm_proxystreamsocket:
- return (isc__nmsocket_proxystream_timer_running(sock));
+ return isc__nmsocket_proxystream_timer_running(sock);
case isc_nm_proxyudpsocket:
- return (isc__nmsocket_proxyudp_timer_running(sock));
+ return isc__nmsocket_proxyudp_timer_running(sock);
default:
break;
}
- 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 (uv_is_active(&sock->uv_handle.handle)) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
switch (sock->type) {
result = isc_uverr2result(r);
}
- return (result);
+ return result;
}
void
bool
isc__nm_closing(isc__networker_t *worker) {
- return (worker->shuttingdown);
+ return worker->shuttingdown;
}
bool
isc__nmsocket_closing(isc_nmsocket_t *sock) {
- return (!sock->active || sock->closing ||
- isc__nm_closing(sock->worker) ||
- (sock->server != NULL && !isc__nmsocket_active(sock->server)));
+ return !sock->active || sock->closing ||
+ isc__nm_closing(sock->worker) ||
+ (sock->server != NULL && !isc__nmsocket_active(sock->server));
}
void
REQUIRE(VALID_NMHANDLE(handle));
REQUIRE(VALID_NMSOCK(handle->sock));
- return (isc__nmsocket_timer_running(handle->sock));
+ return isc__nmsocket_timer_running(handle->sock);
}
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->worker->netmgr);
+ return handle->sock->worker->netmgr;
}
isc__nm_uvreq_t *
ISC_LIST_APPEND(sock->active_uvreqs, req, active_link);
- return (req);
+ return req;
}
void
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)
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;
}
static isc_nmhandle_t *
switch (sock->type) {
case isc_nm_proxystreamsocket:
case isc_nm_proxyudpsocket:
- return (handle);
+ return handle;
#ifdef HAVE_LIBNGHTTP2
case isc_nm_httpsocket:
if (sock->h2 != NULL) {
- return (get_proxy_handle(
- isc__nm_httpsession_handle(sock->h2->session)));
+ return get_proxy_handle(
+ isc__nm_httpsession_handle(sock->h2->session));
}
- return (NULL);
+ return NULL;
#endif /* HAVE_LIBNGHTTP2 */
default:
break;
}
if (sock->outerhandle != NULL) {
- return (get_proxy_handle(sock->outerhandle));
+ return get_proxy_handle(sock->outerhandle);
}
- return (NULL);
+ return NULL;
}
bool
REQUIRE(VALID_NMHANDLE(handle));
REQUIRE(VALID_NMSOCK(handle->sock));
- return (get_proxy_handle(handle) != NULL);
+ return get_proxy_handle(handle) != NULL;
}
bool
REQUIRE(VALID_NMSOCK(handle->sock));
if (handle->sock->client) {
- return (false);
+ return false;
}
proxyhandle = get_proxy_handle(handle);
if (proxyhandle == NULL) {
- return (false);
+ return false;
}
- return (proxyhandle->proxy_is_unspec);
+ return proxyhandle->proxy_is_unspec;
}
isc_sockaddr_t
proxyhandle = get_proxy_handle(handle);
if (proxyhandle == NULL) {
- return (isc_nmhandle_peeraddr(handle));
+ return isc_nmhandle_peeraddr(handle);
}
INSIST(VALID_NMSOCK(proxyhandle->sock));
addr = isc_nmhandle_peeraddr(proxyhandle->proxy_udphandle);
}
- return (addr);
+ return addr;
}
isc_sockaddr_t
proxyhandle = get_proxy_handle(handle);
if (proxyhandle == NULL) {
- return (isc_nmhandle_localaddr(handle));
+ return isc_nmhandle_localaddr(handle);
}
INSIST(VALID_NMSOCK(proxyhandle->sock));
addr = isc_nmhandle_localaddr(proxyhandle->proxy_udphandle);
}
- return (addr);
+ return addr;
}
bool
isc_netaddr_t src_addr = { 0 }, dst_addr = { 0 };
if (src == NULL || dst == NULL) {
- return (false);
+ return false;
}
/*
* addresses (kdig).
*/
if (isc_sockaddr_getport(dst) == 0) {
- return (false);
+ return false;
}
/*
switch (isc_sockaddr_pf(src)) {
case AF_INET:
if (isc_netaddr_equal(&src_addr, &zerov4)) {
- return (false);
+ return false;
}
if (isc_netaddr_equal(&dst_addr, &zerov4)) {
- return (false);
+ return false;
}
break;
case AF_INET6:
if (isc_netaddr_equal(&src_addr, &zerov6)) {
- return (false);
+ return false;
}
if (isc_netaddr_equal(&dst_addr, &zerov6)) {
- return (false);
+ return false;
}
break;
default:
UNREACHABLE();
}
- return (true);
+ return true;
}
void
REQUIRE(VALID_NMHANDLE(handle));
REQUIRE(VALID_NMSOCK(handle->sock));
- return (handle->sock->type);
+ return handle->sock->type;
}
bool
switch (handle->sock->type) {
case isc_nm_tlssocket:
- 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 */
case isc_nm_streamdnssocket:
- return (isc__nm_streamdns_has_encryption(handle));
+ return isc__nm_streamdns_has_encryption(handle);
case isc_nm_proxystreamsocket:
- return (isc__nm_proxystream_has_encryption(handle));
+ return isc__nm_proxystream_has_encryption(handle);
default:
- return (false);
+ return false;
};
- return (false);
+ return false;
}
const char *
sock = handle->sock;
switch (sock->type) {
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_proxystreamsocket:
- return (isc__nm_proxystream_verify_tls_peer_result_string(
- handle));
+ return isc__nm_proxystream_verify_tls_peer_result_string(
+ handle);
break;
#if HAVE_LIBNGHTTP2
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 */
case isc_nm_streamdnssocket:
- return (isc__nm_streamdns_verify_tls_peer_result_string(
- handle));
+ return isc__nm_streamdns_verify_tls_peer_result_string(handle);
break;
default:
break;
}
- return (NULL);
+ return NULL;
}
typedef struct settlsctx_data {
break;
};
- return (result);
+ return result;
}
isc_sockaddr_t
isc_nmsocket_getaddr(isc_nmsocket_t *sock) {
REQUIRE(VALID_NMSOCK(sock));
- return (sock->iface);
+ return sock->iface;
}
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_tlssocket:
- return ("isc_nm_tlssocket");
+ return "isc_nm_tlssocket";
case isc_nm_tlslistener:
- return ("isc_nm_tlslistener");
+ return "isc_nm_tlslistener";
case isc_nm_httplistener:
- return ("isc_nm_httplistener");
+ return "isc_nm_httplistener";
case isc_nm_httpsocket:
- return ("isc_nm_httpsocket");
+ return "isc_nm_httpsocket";
case isc_nm_streamdnslistener:
- return ("isc_nm_streamdnslistener");
+ return "isc_nm_streamdnslistener";
case isc_nm_streamdnssocket:
- return ("isc_nm_streamdnssocket");
+ return "isc_nm_streamdnssocket";
case isc_nm_proxystreamlistener:
- return ("isc_nm_proxystreamlistener");
+ return "isc_nm_proxystreamlistener";
case isc_nm_proxystreamsocket:
- return ("isc_nm_proxystreamsocket");
+ return "isc_nm_proxystreamsocket";
case isc_nm_proxyudplistener:
- return ("isc_nm_proxyudplistener");
+ return "isc_nm_proxyudplistener";
case isc_nm_proxyudpsocket:
- return ("isc_nm_proxyudpsocket");
+ return "isc_nm_proxyudpsocket";
default:
UNREACHABLE();
}
}
}
- return (sock);
+ return sock;
}
static isc_result_t
isc_sockaddr_t iface;
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
INSIST(VALID_NMHANDLE(handle));
INSIST(listensock->type == isc_nm_proxystreamlistener);
if (isc__nm_closing(handle->sock->worker)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
} else if (isc__nmsocket_closing(handle->sock)) {
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
iface = isc_nmhandle_localaddr(handle);
proxystream_read_start(nsock);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(sockp != NULL && *sockp == NULL);
if (isc__nm_closing(worker)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
listener = proxystream_sock_new(worker, isc_nm_proxystreamlistener,
if (result != ISC_R_SUCCESS) {
listener->closed = true;
isc__nmsocket_detach(&listener);
- return (result);
+ return result;
}
listener->active = true;
*sockp = listener;
- return (result);
+ return result;
}
static void
if (sock->outerhandle != NULL) {
INSIST(VALID_NMHANDLE(sock->outerhandle));
REQUIRE(VALID_NMSOCK(sock->outerhandle->sock));
- return (isc__nmsocket_timer_running(sock->outerhandle->sock));
+ return isc__nmsocket_timer_running(sock->outerhandle->sock);
}
- return (false);
+ return false;
}
void
result = isc_nmhandle_set_tcp_nodelay(sock->outerhandle, value);
}
- return (result);
+ return result;
}
static void
static bool
proxystream_closing(isc_nmsocket_t *sock) {
- return (isc__nmsocket_closing(sock) || sock->outerhandle == NULL ||
- (sock->outerhandle != NULL &&
- isc__nmsocket_closing(sock->outerhandle->sock)));
+ return isc__nmsocket_closing(sock) || sock->outerhandle == NULL ||
+ (sock->outerhandle != NULL &&
+ isc__nmsocket_closing(sock->outerhandle->sock));
}
static void
sock->proxy.nsending++;
- return (send_req);
+ return send_req;
}
static void
sock = handle->sock;
if (sock->outerhandle != NULL) {
INSIST(VALID_NMHANDLE(sock->outerhandle));
- return (isc_nm_has_encryption(sock->outerhandle));
+ return isc_nm_has_encryption(sock->outerhandle);
}
- return (false);
+ return false;
}
const char *
sock = handle->sock;
if (sock->outerhandle != NULL) {
INSIST(VALID_NMHANDLE(sock->outerhandle));
- return (isc_nm_verify_tls_peer_result_string(
- sock->outerhandle));
+ return isc_nm_verify_tls_peer_result_string(sock->outerhandle);
}
- return (NULL);
+ return NULL;
}
void
static bool
proxyudp_closing(isc_nmsocket_t *sock) {
- return (isc__nmsocket_closing(sock) ||
- (sock->client && sock->outerhandle == NULL) ||
- (sock->outerhandle != NULL &&
- isc__nmsocket_closing(sock->outerhandle->sock)));
+ return isc__nmsocket_closing(sock) ||
+ (sock->client && sock->outerhandle == NULL) ||
+ (sock->outerhandle != NULL &&
+ isc__nmsocket_closing(sock->outerhandle->sock));
}
static void
worker->mctx, nworkers, sizeof(isc_nmsocket_t *));
}
- return (sock);
+ return sock;
}
static void
REQUIRE(sockp != NULL && *sockp == NULL);
if (isc__nm_closing(worker)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
listener = proxyudp_sock_new(worker, isc_nm_proxyudplistener, iface,
isc__nmsocket_detach(&listener);
}
- return (result);
+ return result;
}
static void
if (sock->outerhandle != NULL) {
INSIST(VALID_NMHANDLE(sock->outerhandle));
REQUIRE(VALID_NMSOCK(sock->outerhandle->sock));
- return (isc__nmsocket_timer_running(sock->outerhandle->sock));
+ return isc__nmsocket_timer_running(sock->outerhandle->sock);
}
- return (false);
+ return false;
}
void
sock->proxy.nsending++;
- return (send_req);
+ return send_req;
}
static 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
}
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 = tcp_bind_now(handle, addr, flags);
r = tcp_bind_now(handle, addr, flags);
}
- return (r);
+ return r;
}
isc_result_t
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
#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
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
}
}
if (ret == -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;
}
sock);
}
- return (false);
+ return false;
}
/*
* A complete DNS message has been assembled from the incoming
* data. Let's process it.
*/
- return (streamdns_on_complete_dnsmessage(dnsasm, region, sock,
- transphandle));
+ return streamdns_on_complete_dnsmessage(dnsasm, region, sock,
+ transphandle);
case ISC_R_RANGE:
/*
* It seems that someone attempts to send us some binary junk
* We should treat it as a hard error.
*/
streamdns_failed_read_cb(sock, result, false);
- return (false);
+ return false;
case ISC_R_NOMORE:
/*
* We do not have enough data to process the next message and
if (sock->recv_handle != NULL) {
streamdns_readmore(sock, transphandle);
}
- return (false);
+ return false;
default:
UNREACHABLE();
};
sock);
}
- return (sock);
+ return sock;
}
static void
REQUIRE(sock->type == isc_nm_streamdnssocket);
if (sock->outerhandle == NULL) {
- return (false);
+ return false;
}
INSIST(VALID_NMHANDLE(sock->outerhandle));
transp_sock = sock->outerhandle->sock;
INSIST(VALID_NMSOCK(transp_sock));
- return (isc__nmsocket_timer_running(transp_sock));
+ return isc__nmsocket_timer_running(transp_sock);
}
void
sock->streamdns.nsending++;
- return (send_req);
+ return send_req;
}
static void
static bool
streamdns_closing(isc_nmsocket_t *sock) {
- return (isc__nmsocket_closing(sock) || isc__nm_closing(sock->worker) ||
- sock->outerhandle == NULL ||
- (sock->outerhandle != NULL &&
- isc__nmsocket_closing(sock->outerhandle->sock)));
+ return isc__nmsocket_closing(sock) || isc__nm_closing(sock->worker) ||
+ sock->outerhandle == NULL ||
+ (sock->outerhandle != NULL &&
+ isc__nmsocket_closing(sock->outerhandle->sock));
}
static void
REQUIRE(VALID_NMSOCK(handle->sock));
if (isc__nm_closing(handle->sock->worker)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
} else if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
REQUIRE(VALID_NMSOCK(listensock));
exit:
nsock->accepting = false;
- return (result);
+ return result;
}
isc_result_t
worker = &mgr->workers[isc_tid()];
if (isc__nm_closing(worker)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
listener = streamdns_sock_new(worker, isc_nm_streamdnslistener, iface,
if (result != ISC_R_SUCCESS) {
listener->closed = true;
isc__nmsocket_detach(&listener);
- return (result);
+ return result;
}
/* copy the actual port we're listening on into sock->iface */
*sockp = listener;
- return (result);
+ return result;
}
void
sock = handle->sock;
if (sock->outerhandle != NULL) {
INSIST(VALID_NMHANDLE(sock->outerhandle));
- return (isc_nm_has_encryption(sock->outerhandle));
+ return isc_nm_has_encryption(sock->outerhandle);
}
- return (false);
+ return false;
}
const char *
sock = handle->sock;
if (sock->outerhandle != NULL) {
INSIST(VALID_NMHANDLE(sock->outerhandle));
- return (isc_nm_verify_tls_peer_result_string(
- sock->outerhandle));
+ return isc_nm_verify_tls_peer_result_string(sock->outerhandle);
} else if (sock->streamdns.tls_verify_error != NULL) {
- return (sock->streamdns.tls_verify_error);
+ return sock->streamdns.tls_verify_error;
}
- return (NULL);
+ return NULL;
}
void
}
}
- return (result);
+ return result;
}
void
isc_stdtime_t now = isc_stdtime_now();
last = atomic_exchange_relaxed(&last_tcpquota_log, now);
if (now != last) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static isc_result_t
if (r != 0) {
isc__nm_closesocket(sock->fd);
isc__nm_incstats(sock, STATID_OPENFAIL);
- return (isc_uverr2result(r));
+ return isc_uverr2result(r);
}
isc__nm_incstats(sock, STATID_OPEN);
r = uv_tcp_bind(&sock->uv_handle.tcp, &req->local.type.sa, 0);
if (r != 0) {
isc__nm_incstats(sock, STATID_BINDFAIL);
- return (isc_uverr2result(r));
+ return isc_uverr2result(r);
}
}
&req->peer.type.sa, tcp_connect_cb);
if (r != 0) {
isc__nm_incstats(sock, STATID_CONNECTFAIL);
- return (isc_uverr2result(r));
+ return isc_uverr2result(r);
}
uv_handle_set_data((uv_handle_t *)&sock->read_timer,
&req->uv_req.connect);
isc__nmsocket_timer_start(sock);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
RUNTIME_CHECK(result == ISC_R_SUCCESS);
}
- return (sock);
+ return sock;
}
static void
isc__nm_tcp_stoplistening(sock);
isc_nmsocket_close(&sock);
- return (result);
+ return result;
}
sock->active = true;
*sockp = sock;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
*/
isc__nmsocket_detach(&csock);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
failure:
csock->active = false;
isc__nmsocket_detach(&csock);
- return (result);
+ return result;
}
static void
size_t nbufs = 1;
if (isc__nmsocket_closing(sock)) {
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
/* Check if we are not trying to send a DNS message */
/* Wrote everything */
isc__nm_sendcb(sock, req, ISC_R_SUCCESS, true);
tcp_maybe_restart_reading(sock);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (r > 0) {
bufs[0].base += (size_t)r;
bufs[0].len -= (size_t)r;
} else if (!(r == UV_ENOSYS || r == UV_EAGAIN)) {
- return (isc_uverr2result(r));
+ return isc_uverr2result(r);
}
} else {
nbufs = 2;
/* Wrote everything */
isc__nm_sendcb(sock, req, ISC_R_SUCCESS, true);
tcp_maybe_restart_reading(sock);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
} else if (r == 1) {
/* Partial write of DNSMSG length */
bufs[0].base = req->tcplen + 1;
bufs[0].base = req->uvbuf.base + (r - 2);
bufs[0].len = req->uvbuf.len - (r - 2);
} else if (!(r == UV_ENOSYS || r == UV_EAGAIN)) {
- return (isc_uverr2result(r));
+ return isc_uverr2result(r);
}
}
r = uv_write(&req->uv_req.write, &sock->uv_handle.stream, bufs, nbufs,
tcp_send_cb);
if (r < 0) {
- return (isc_uverr2result(r));
+ return isc_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
tls_status2str(int tls_status) {
switch (tls_status) {
case SSL_ERROR_NONE:
- return ("SSL_ERROR_NONE");
+ return "SSL_ERROR_NONE";
case SSL_ERROR_ZERO_RETURN:
- return ("SSL_ERROR_ZERO_RETURN");
+ return "SSL_ERROR_ZERO_RETURN";
case SSL_ERROR_WANT_WRITE:
- return ("SSL_ERROR_WANT_WRITE");
+ return "SSL_ERROR_WANT_WRITE";
case SSL_ERROR_WANT_READ:
- return ("SSL_ERROR_WANT_READ");
+ return "SSL_ERROR_WANT_READ";
case SSL_ERROR_SSL:
- return ("SSL_ERROR_SSL");
+ return "SSL_ERROR_SSL";
default:
UNREACHABLE();
}
state2str(int state) {
switch (state) {
case TLS_INIT:
- return ("TLS_INIT");
+ return "TLS_INIT";
case TLS_HANDSHAKE:
- return ("TLS_HANDSHAKE");
+ return "TLS_HANDSHAKE";
case TLS_IO:
- return ("TLS_IO");
+ return "TLS_IO";
case TLS_CLOSED:
- return ("TLS_CLOSED");
+ return "TLS_CLOSED";
default:
UNREACHABLE();
}
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) || sock->closing ||
- sock->outerhandle == NULL ||
- !isc__nmsocket_active(sock->outerhandle->sock) ||
- sock->outerhandle->sock->closing ||
- isc__nm_closing(sock->worker));
+ return !isc__nmsocket_active(sock) || sock->closing ||
+ sock->outerhandle == NULL ||
+ !isc__nmsocket_active(sock->outerhandle->sock) ||
+ sock->outerhandle->sock->closing ||
+ isc__nm_closing(sock->worker);
}
static void
INSIST(VALID_NMHANDLE(tlshandle));
cb(tlshandle, result, cbarg);
}
- return (0);
+ return 0;
}
if (finish) {
pending = BIO_pending(sock->tlsstream.bio_out);
if (pending <= 0) {
- return (pending);
+ return pending;
}
/* Try to reuse previously allocated object */
isc_buffer_remainingregion(&send_req->data, &used_region);
isc_nm_send(sock->outerhandle, &used_region, 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;
}
int 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 void
/* If accept() was unsuccessful we can't do anything */
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
REQUIRE(VALID_NMHANDLE(handle));
REQUIRE(tlslistensock->type == isc_nm_tlslistener);
if (isc__nm_closing(handle->sock->worker)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
} else if (isc__nmsocket_closing(handle->sock)) {
- return (ISC_R_CANCELED);
+ return ISC_R_CANCELED;
}
local = isc_nmhandle_localaddr(handle);
tlssock->closed = true;
isc_tlsctx_free(&tlssock->tlsstream.ctx);
isc__nmsocket_detach(&tlssock);
- return (ISC_R_TLSERROR);
+ return ISC_R_TLSERROR;
}
tlssock->accept_cb = tlslistensock->accept_cb;
isc__nmhandle_set_manual_timer(tlssock->outerhandle, true);
tls_do_bio(tlssock, NULL, NULL, false);
- return (result);
+ return result;
}
isc_result_t
worker = &mgr->workers[isc_tid()];
if (isc__nm_closing(worker)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
if (workers == 0) {
if (result != ISC_R_SUCCESS) {
tlssock->closed = true;
isc__nmsocket_detach(&tlssock);
- return (result);
+ return result;
}
/* copy the actual port we're listening on into sock->iface */
*sockp = tlssock;
}
- return (result);
+ return result;
}
static void
if (sock->outerhandle != NULL) {
INSIST(VALID_NMHANDLE(sock->outerhandle));
REQUIRE(VALID_NMSOCK(sock->outerhandle->sock));
- return (isc__nmsocket_timer_running(sock->outerhandle->sock));
+ return isc__nmsocket_timer_running(sock->outerhandle->sock);
}
- return (false);
+ return false;
}
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
}
}
- return (result);
+ return result;
}
RUNTIME_CHECK(result == ISC_R_SUCCESS);
}
- return (sock);
+ return sock;
}
/*
worker = &mgr->workers[0];
if (isc__nm_closing(worker)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
if (workers == 0) {
isc__nm_udp_stoplistening(sock);
isc_nmsocket_close(&sock);
- return (result);
+ return result;
}
sock->active = true;
*sockp = sock;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#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
uv_handle_set_data((uv_handle_t *)&sock->read_timer, sock);
if (isc__nm_closing(worker)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
r = uv_udp_open(&sock->uv_handle.udp, sock->fd);
if (r != 0) {
- return (isc_uverr2result(r));
+ return isc_uverr2result(r);
}
isc__nm_set_network_buffers(sock->worker->netmgr,
sock->connecting = false;
sock->connected = true;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
#endif /* USE_ROUTE_SOCKET */
worker = &mgr->workers[isc_tid()];
if (isc__nm_closing(worker)) {
- return (ISC_R_SHUTTINGDOWN);
+ return ISC_R_SHUTTINGDOWN;
}
result = route_socket(&fd);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
sock = isc_mempool_get(worker->nmsocket_pool);
isc__nmsocket_detach(&sock);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
#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_relaxed(&sock->worker->netmgr->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_t now = isc_stdtime_now();
isc_stdtime_t last = atomic_exchange_relaxed(&last_udpsends_log, now);
if (now != last) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
/*
r = uv_udp_open(&sock->uv_handle.udp, sock->fd);
if (r != 0) {
isc__nm_incstats(sock, STATID_OPENFAIL);
- return (isc_uverr2result(r));
+ return isc_uverr2result(r);
}
isc__nm_incstats(sock, STATID_OPEN);
uv_bind_flags);
if (r != 0) {
isc__nm_incstats(sock, STATID_BINDFAIL);
- return (isc_uverr2result(r));
+ return isc_uverr2result(r);
}
isc__nm_set_network_buffers(sock->worker->netmgr,
} while (r == UV_EADDRINUSE && --req->connect_tries > 0);
if (r != 0) {
isc__nm_incstats(sock, STATID_CONNECTFAIL);
- return (isc_uverr2result(r));
+ return isc_uverr2result(r);
}
isc__nm_incstats(sock, STATID_CONNECT);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
/* 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;
}
rv = 1;
}
- return (rv);
+ return rv;
}
#endif /* !HAVE_BIO_READ_EX */
rv = 1;
}
- return (rv);
+ return rv;
}
#endif /* !HAVE_BIO_WRITE_EX */
ERR_get_error_all(const char **file, int *line, const char **func,
const char **data, int *flags) {
SET_IF_NOT_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 */
static int
sysconf_ncpus(void) {
- long ncpus = sysconf((_SC_NPROCESSORS_ONLN));
- return ((int)ncpus);
+ long ncpus = sysconf(_SC_NPROCESSORS_ONLN);
+ return (int)ncpus;
}
#if HAVE_SYSCTLBYNAME
for (size_t i = 0; i < ARRAY_SIZE(mib); i++) {
int r = sysctlbyname(mib[i], &ncpu, &len, NULL, 0);
if (r != -1) {
- return (ncpu);
+ return ncpu;
}
}
- return (-1);
+ return -1;
}
#endif /* HAVE_SYSCTLBYNAME */
int r = sysctl(mib[i], ARRAY_SIZE(mib[i]), &ncpu, &len, NULL,
0);
if (r != -1) {
- return (ncpu);
+ return ncpu;
}
}
- return (-1);
+ return -1;
}
#endif /* HAVE_SYS_SYSCTL_H */
cpu_set_t cpus;
int r = sched_getaffinity(0, sizeof(cpus), &cpus);
if (r != -1) {
- return (CPU_COUNT(&cpus));
+ return CPU_COUNT(&cpus);
}
- return (-1);
+ return -1;
}
#endif
int r = cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, -1,
sizeof(cpus), &cpus);
if (r != -1) {
- return (CPU_COUNT(&cpus));
+ return CPU_COUNT(&cpus);
}
- return (-1);
+ return -1;
}
#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;
}
(void)ranges;
(void)ranges_size;
#endif
- return (buf);
+ return buf;
}
static const char *
++buf;
} else {
*ret = -1;
- return (NULL);
+ return NULL;
}
*token = token_start;
- return (buf);
+ return buf;
}
static const char *
ret_cnt = 0;
}
if (ret_cnt == 2) {
- return (buf);
+ return buf;
}
}
*ret = -2;
- return (NULL);
+ return NULL;
}
#define PARSE_INT(valp_, mul_) \
break;
} else if (!token_char_map[(unsigned char)*buf]) {
*ret = -1;
- return (NULL);
+ return NULL;
}
++buf;
CHECK_EOF();
}
*token = buf_start;
*token_len = buf - buf_start;
- return (buf);
+ return buf;
}
/* returned pointer is always within [buf, buf_end), or null */
/* we want at least [HTTP/1.<two chars>] to try to parse */
if (buf_end - buf < 9) {
*ret = -2;
- return (NULL);
+ return NULL;
}
EXPECT_CHAR_NO_CHECK('H');
EXPECT_CHAR_NO_CHECK('T');
EXPECT_CHAR_NO_CHECK('1');
EXPECT_CHAR_NO_CHECK('.');
PARSE_INT(minor_version, 1);
- return (buf);
+ return buf;
}
static const char *
}
if (*num_headers == max_headers) {
*ret = -1;
- return (NULL);
+ return NULL;
}
if (!(*num_headers != 0 && (*buf == ' ' || *buf == '\t'))) {
/* parsing name, but do not discard SP before colon, see
&headers[*num_headers].name_len,
':', ret)) == NULL)
{
- return (NULL);
+ return NULL;
}
if (headers[*num_headers].name_len == 0) {
*ret = -1;
- return (NULL);
+ return NULL;
}
++buf;
for (;; ++buf) {
if ((buf = get_token_to_eol(buf, buf_end, &value, &value_len,
ret)) == NULL)
{
- return (NULL);
+ return NULL;
}
/* remove trailing SPs and HTABs */
const char *value_end = value + value_len;
headers[*num_headers].value = value;
headers[*num_headers].value_len = value_end - value;
}
- return (buf);
+ return buf;
}
static const char *
if ((buf = parse_token(buf, buf_end, method, method_len, ' ', ret)) ==
NULL)
{
- return (NULL);
+ return NULL;
}
do {
++buf;
} while (*buf == ' ');
if (*method_len == 0 || *path_len == 0) {
*ret = -1;
- return (NULL);
+ return NULL;
}
if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) ==
NULL)
{
- return (NULL);
+ return NULL;
}
if (*buf == '\015') {
++buf;
++buf;
} else {
*ret = -1;
- return (NULL);
+ return NULL;
}
- return (parse_headers(buf, buf_end, headers, num_headers, max_headers,
- ret));
+ return parse_headers(buf, buf_end, headers, num_headers, max_headers,
+ ret);
}
int
/* if last_len != 0, check if the request is complete (a fast
countermeasure againt slowloris */
if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
- return (r);
+ return r;
}
if ((buf = parse_request(buf, buf_end, method, method_len, path,
path_len, minor_version, headers, num_headers,
max_headers, &r)) == NULL)
{
- return (r);
+ return r;
}
return (int)(buf - buf_start);
if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) ==
NULL)
{
- return (NULL);
+ return NULL;
}
/* skip space */
if (*buf != ' ') {
*ret = -1;
- return (NULL);
+ return NULL;
}
do {
++buf;
* char> to try to parse */
if (buf_end - buf < 4) {
*ret = -2;
- return (NULL);
+ return NULL;
}
PARSE_INT_3(status);
/* get message including preceding space */
if ((buf = get_token_to_eol(buf, buf_end, msg, msg_len, ret)) == NULL) {
- return (NULL);
+ return NULL;
}
if (*msg_len == 0) {
/* ok */
} else {
/* garbage found after status code */
*ret = -1;
- return (NULL);
+ return NULL;
}
- return (parse_headers(buf, buf_end, headers, num_headers, max_headers,
- ret));
+ return parse_headers(buf, buf_end, headers, num_headers, max_headers,
+ ret);
}
int
/* if last_len != 0, check if the response is complete (a fast
countermeasure against slowloris */
if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
- return (r);
+ return r;
}
if ((buf = parse_response(buf, buf_end, minor_version, status, msg,
msg_len, headers, num_headers, max_headers,
&r)) == NULL)
{
- return (r);
+ return r;
}
return (int)(buf - buf_start);
/* if last_len != 0, check if the response is complete (a fast
countermeasure against slowloris */
if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
- return (r);
+ return r;
}
if ((buf = parse_headers(buf, buf_end, headers, num_headers,
max_headers, &r)) == NULL)
{
- return (r);
+ return r;
}
return (int)(buf - buf_start);
static int
decode_hex(int ch) {
if ('0' <= ch && ch <= '9') {
- return (ch - '0');
+ return ch - '0';
} else if ('A' <= ch && ch <= 'F') {
- return (ch - 'A' + 0xa);
+ return ch - 'A' + 0xa;
} else if ('a' <= ch && ch <= 'f') {
- return (ch - 'a' + 0xa);
+ return ch - 'a' + 0xa;
} else {
- return (-1);
+ return -1;
}
}
memmove(buf + dst, buf + src, bufsz - src);
}
*_bufsz = dst;
- return (ret);
+ return ret;
}
int
phr_decode_chunked_is_in_data(struct phr_chunked_decoder *decoder) {
- return (decoder->_state == CHUNKED_IN_CHUNK_DATA);
+ return decoder->_state == CHUNKED_IN_CHUNK_DATA;
}
#undef CHECK_EOF
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
*portset = (isc_portset_t){ 0 };
*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
newhandler = isc_mem_get(mctx, sizeof(*newhandler));
isc_proxy2_handler_init(newhandler, mctx, max_size, cb, cbarg);
- return (newhandler);
+ return newhandler;
}
void
ISC_UNREACHABLE();
};
- return (socktype);
+ return socktype;
}
static inline void
if (memcmp(ISC_PROXY2_HEADER_SIGNATURE, remaining.base, len) != 0) {
isc__proxy2_handler_error(handler, ISC_R_UNEXPECTED);
- return (false);
+ return false;
} else if (len == ISC_PROXY2_HEADER_SIGNATURE_SIZE) {
isc_buffer_forward(&handler->hdrbuf,
ISC_PROXY2_HEADER_SIGNATURE_SIZE);
} else {
INSIST(len < ISC_PROXY2_HEADER_SIGNATURE_SIZE);
isc__proxy2_handler_error(handler, ISC_R_NOMORE);
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static inline bool
if ((ver_cmd & 0xF0U) >> 4 != 2) {
/* only support for version 2 is implemented */
isc__proxy2_handler_error(handler, ISC_R_NOTIMPLEMENTED);
- return (false);
+ return false;
}
/* extract command */
handler->state++;
- return (true);
+ return true;
error_unexpected:
isc__proxy2_handler_error(handler, ISC_R_UNEXPECTED);
- return (false);
+ return false;
error_range:
isc__proxy2_handler_error(handler, ISC_R_RANGE);
- return (false);
+ return false;
}
static inline isc_result_t
* without a terminating '\0' byte - not a friend
* knocking at the door.
*/
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
isc_buffer_forward(hdrbuf, addr_size);
ret = memchr(isc_buffer_current(hdrbuf), '\0', addr_size);
if (ret == NULL) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
isc_buffer_forward(hdrbuf, addr_size);
} break;
UNREACHABLE();
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static inline void
if (isc_buffer_remaininglength(&handler->hdrbuf) < handler->expect_data)
{
isc__proxy2_handler_error(handler, ISC_R_NOMORE);
- return (false);
+ return false;
}
switch (handler->state) {
* by byte, we would detect the problem when processing the
* first unexpected byte.
*/
- return (isc__proxy2_handler_handle_signature(handler));
+ return isc__proxy2_handler_handle_signature(handler);
case ISC_PROXY2_STATE_WAITING_HEADER:
/*
* Handle the rest of the header (except signature which we
* heave verified by now).
*/
- return (isc__proxy2_handler_handle_header(handler));
+ return isc__proxy2_handler_handle_header(handler);
case ISC_PROXY2_STATE_WAITING_PAYLOAD:
/*
* Handle the PROXYv2 header payload - addresses and TLVs.
break;
};
- return (false);
+ return false;
}
static inline isc_result_t
}
}
- return (handler->result);
+ return handler->result;
}
isc_result_t
result = isc__proxy2_handler_process_data(handler);
- return (result);
+ return result;
}
isc_result_t
result = isc_proxy2_handler_push_data(handler, region->base,
region->length);
- return (result);
+ return result;
}
static inline bool
if (handler->state < ISC_PROXY2_STATE_END ||
handler->result != ISC_R_SUCCESS)
{
- return (false);
+ return false;
}
- return (true);
+ return true;
}
size_t
(region->base == NULL && region->length == 0));
if (!proxy2_payload_is_processed(handler)) {
- return (0);
+ return 0;
}
if (region != NULL) {
region->length = handler->header_size;
}
- return (handler->header_size);
+ return handler->header_size;
}
size_t
(region->base == NULL && region->length == 0));
if (!proxy2_payload_is_processed(handler)) {
- return (0);
+ return 0;
}
SET_IF_NOT_NULL(region, handler->tlv_data);
- return (handler->tlv_data.length);
+ return handler->tlv_data.length;
}
size_t
(region->base == NULL && region->length == 0));
if (!proxy2_payload_is_processed(handler)) {
- return (0);
+ return 0;
}
SET_IF_NOT_NULL(region, handler->extra_data);
- return (handler->extra_data.length);
+ return handler->extra_data.length;
}
isc_result_t
isc_proxy2_handler_result(const isc_proxy2_handler_t *restrict handler) {
REQUIRE(handler != NULL);
- return (handler->result);
+ return handler->result;
}
isc_result_t
REQUIRE(handler != NULL);
if (!proxy2_payload_is_processed(handler)) {
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
ret = isc_proxy2_handler_header(handler, &header_region);
(isc_proxy2_handler_t *)handler, &buf, psrc_addr, pdst_addr);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
SET_IF_NOT_NULL(psocktype,
proxy2_socktype_to_socktype(handler->proxy_socktype));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
}
}
- return (result);
+ return result;
}
typedef struct proxy2_tls_cbarg {
(isc_proxy2_tlv_subtype_tls_t)tlv_type, data,
tls_cbarg->cbarg);
- return (ret);
+ return ret;
}
isc_result_t
*pclient_cert_verified == false);
if (tls_tlv_data->length < ISC_PROXY2_TLS_SUBHEADER_MIN_SIZE) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
p = tls_tlv_data->base;
SET_IF_NOT_NULL(pclient_flags, client_flags);
SET_IF_NOT_NULL(pclient_cert_verified, client_cert_verified);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(cb != NULL);
if (tls_tlv_data->length < ISC_PROXY2_TLS_SUBHEADER_MIN_SIZE) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
result = isc_proxy2_subtlv_tls_header_data(tls_tlv_data, &client_flags,
&client_cert_verified);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
p = tls_tlv_data->base;
&tls_cbarg);
}
- return (result);
+ return result;
}
typedef struct tls_subtlv_verify_cbarg {
type == ISC_PROXY2_TLV_TYPE_NETNS)
{
arg->verif_result = ISC_R_UNEXPECTED;
- return (false);
+ return false;
}
switch (tls_subtlv_type) {
case ISC_PROXY2_TLV_SUBTYPE_TLS_KEY_ALG:
if (data->length == 0) {
arg->verif_result = ISC_R_RANGE;
- return (false);
+ return false;
}
arg->count[tls_subtlv_type]++;
verify_count = true;
if (verify_count && arg->count[tls_subtlv_type] > 1) {
arg->verif_result = ISC_R_UNEXPECTED;
- return (false);
+ return false;
}
- return (true);
+ return true;
}
typedef struct tlv_verify_cbarg {
isc_proxy2_subtlv_tls_header_data(data, &client, NULL);
if (arg->verify_result != ISC_R_SUCCESS) {
- return (false);
+ return false;
}
arg->verify_result = isc_proxy2_subtlv_tls_iterate(
data, proxy2_subtlv_verify_iter_cb, &tls_cbarg);
if (arg->verify_result != ISC_R_SUCCESS) {
- return (false);
+ return false;
} else if (tls_cbarg.verif_result != ISC_R_SUCCESS) {
arg->verify_result = tls_cbarg.verif_result;
- return (false);
+ return false;
}
/*
goto error_unexpected;
}
- return (true);
+ return true;
error_unexpected:
arg->verify_result = ISC_R_UNEXPECTED;
- return (false);
+ return false;
error_range:
arg->verify_result = ISC_R_RANGE;
- return (false);
+ return false;
}
isc_result_t
result = isc_proxy2_tlv_iterate(tlv_data, isc_proxy2_tlv_verify_cb,
&cbarg);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
- return (cbarg.verify_result);
+ return cbarg.verify_result;
}
isc_result_t
result = isc__proxy2_handler_process_data(&handler);
- return (result);
+ return result;
}
isc_result_t
(void *)&dst_addr->type.sin6.sin6_addr;
break;
default:
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
}
break;
default:
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
switch (socktype) {
proxy_socktype = ISC_PROXY2_SOCK_DGRAM;
break;
default:
- return (ISC_R_UNEXPECTED);
+ return ISC_R_UNEXPECTED;
}
if (tlv_data != NULL) {
if (tlv_data->length > UINT16_MAX) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
total_size += tlv_data->length;
}
if (isc_buffer_availablelength(outbuf) < total_size) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
} else if (total_size > UINT16_MAX) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
/*
isc_buffer_putmem(outbuf, tlv_data->base, tlv_data->length);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
REQUIRE(data != NULL);
if (isc_buffer_availablelength(outbuf) < data->length) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
} else if ((data->length + header_data.length) > UINT16_MAX) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
INSIST(memcmp(header_data.base, ISC_PROXY2_HEADER_SIGNATURE,
new_len = ntohs(new_len);
/* check */
if ((data->length + new_len) > UINT16_MAX) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
/* update */
new_len += (uint16_t)data->length;
isc_buffer_putmem(outbuf, data->base, data->length);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static inline void
new_data_len = tlv_data->length + 3;
if (isc_buffer_availablelength(outbuf) < (new_data_len)) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
} else if ((isc_buffer_usedlength(outbuf) + new_data_len) > UINT16_MAX)
{
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
append_type_and_length(outbuf, (uint8_t)tlv_type,
RUNTIME_CHECK(result == ISC_R_SUCCESS);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
result = isc_proxy2_header_append_tlv(outbuf, tlv_type, ®ion);
- return (result);
+ return result;
}
isc_result_t
}
if (isc_buffer_availablelength(outbuf) < total_size) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
} else if (total_size > UINT16_MAX) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
isc_buffer_putuint8(outbuf, client_flags);
tls_subtlvs_data->length);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
new_data_len = (data->length + 3);
if (isc_buffer_availablelength(outbuf) < new_data_len) {
- return (ISC_R_NOSPACE);
+ return ISC_R_NOSPACE;
} else if ((isc_buffer_usedlength(outbuf) + (data->length + 3)) >
UINT16_MAX)
{
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
append_type_and_length(outbuf, (uint8_t)type, ((uint16_t)data->length),
isc_buffer_putmem(outbuf, data->base, data->length);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
isc_result_t
result = isc_proxy2_append_tlv(outbuf, type, ®ion);
- return (result);
+ return result;
}
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);
}
void
cds_wfcq_enqueue("a->jobs.head, "a->jobs.tail,
&job->wfcq_node);
}
- return (ISC_R_QUOTA);
+ return ISC_R_QUOTA;
}
uint_fast32_t soft = atomic_load_relaxed("a->soft);
if (soft != 0 && used >= soft) {
- return (ISC_R_SOFTQUOTA);
+ return ISC_R_SOFTQUOTA;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
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;
}
void
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 void
uint8_t
isc_random8(void) {
isc__random_initialize();
- return ((uint8_t)next());
+ return (uint8_t)next();
}
uint16_t
isc_random16(void) {
isc__random_initialize();
- return ((uint16_t)next());
+ return (uint16_t)next();
}
uint32_t
isc_random32(void) {
isc__random_initialize();
- return (next());
+ return next();
}
void
/*
* Return the integer part (upper 32 bits).
*/
- return ((uint32_t)(num >> 32));
+ return (uint32_t)(num >> 32);
}
UNREACHABLE();
}
UNLOCK(&rl->lock);
- return (result);
+ return result;
}
isc_result_t
result = ISC_R_NOTFOUND;
}
UNLOCK(&rl->lock);
- return (result);
+ return result;
}
static void
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;
}
}
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];
}
static bool
read_indicator_isempty(isc_rwlock_t *rwl) {
- return (atomic_load_acquire(&rwl->readers_egress) ==
- atomic_load_acquire(&rwl->readers_ingress));
+ return atomic_load_acquire(&rwl->readers_egress) ==
+ atomic_load_acquire(&rwl->readers_ingress);
}
static void
static bool
writers_barrier_israised(isc_rwlock_t *rwl) {
- return (atomic_load_acquire(&rwl->writers_barrier) > 0);
+ return atomic_load_acquire(&rwl->writers_barrier) > 0;
}
static bool
writers_lock_islocked(isc_rwlock_t *rwl) {
- return (atomic_load_acquire(&rwl->writers_lock) == ISC_RWLOCK_LOCKED);
+ return atomic_load_acquire(&rwl->writers_lock) == ISC_RWLOCK_LOCKED;
}
static bool
writers_lock_acquire(isc_rwlock_t *rwl) {
- return (atomic_compare_exchange_weak_acq_rel(
+ return atomic_compare_exchange_weak_acq_rel(
&rwl->writers_lock, &(bool){ ISC_RWLOCK_UNLOCKED },
- ISC_RWLOCK_LOCKED));
+ ISC_RWLOCK_LOCKED);
}
static void
read_indicator_depart(rwl);
LIBISC_RWLOCK_TRYRDLOCK(rwl, ISC_R_LOCKBUSY);
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
}
/* Acquired lock in read-only mode */
LIBISC_RWLOCK_TRYRDLOCK(rwl, ISC_R_SUCCESS);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
/* Write Barriers has been raised */
if (writers_barrier_israised(rwl)) {
LIBISC_RWLOCK_TRYUPGRADE(rwl, ISC_R_LOCKBUSY);
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
}
/* Try to acquire the write-lock */
if (!writers_lock_acquire(rwl)) {
LIBISC_RWLOCK_TRYUPGRADE(rwl, ISC_R_LOCKBUSY);
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
}
/* Unlock the read-lock */
/* Unlock the write-lock */
writers_lock_release(rwl);
LIBISC_RWLOCK_TRYUPGRADE(rwl, ISC_R_LOCKBUSY);
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
}
LIBISC_RWLOCK_TRYUPGRADE(rwl, ISC_R_SUCCESS);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
/* Write Barriers has been raised */
if (writers_barrier_israised(rwl)) {
LIBISC_RWLOCK_TRYWRLOCK(rwl, ISC_R_LOCKBUSY);
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
}
/* Try to acquire the write-lock */
if (!writers_lock_acquire(rwl)) {
LIBISC_RWLOCK_TRYWRLOCK(rwl, ISC_R_LOCKBUSY);
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
}
if (!read_indicator_isempty(rwl)) {
writers_lock_release(rwl);
LIBISC_RWLOCK_TRYWRLOCK(rwl, ISC_R_LOCKBUSY);
- return (ISC_R_LOCKBUSY);
+ return ISC_R_LOCKBUSY;
}
LIBISC_RWLOCK_TRYWRLOCK(rwl, ISC_R_SUCCESS);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
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;
}
uv_handle_set_data((uv_handle_t *)&signal->signal, signal);
- return (signal);
+ return signal;
}
static void
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
ntohs(sockaddr->type.sin6.sin6_port));
break;
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
isc_sockaddr_hash_ex(&hash, sockaddr, address_only);
- return (isc_hash32_finalize(&hash));
+ return isc_hash32_finalize(&hash);
}
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
length = sizeof(isa->type.sin6);
break;
default:
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
*isa = (isc_sockaddr_t){ .length = length,
.link = ISC_LINK_INITIALIZER };
memmove(isa, sa, 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;
}
isc_stats_ncounters(isc_stats_t *stats) {
REQUIRE(ISC_STATS_VALID(stats));
- return (stats->ncounters);
+ return stats->ncounters;
}
void
REQUIRE(ISC_STATS_VALID(stats));
REQUIRE(counter < stats->ncounters);
- return (atomic_fetch_add_relaxed(&stats->counters[counter], 1));
+ return atomic_fetch_add_relaxed(&stats->counters[counter], 1);
}
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);
}
}
}
}
SET_IF_NOT_NULL(nret, r);
- return (result);
+ return result;
}
isc_result_t
result = isc__errno2result(errno);
}
SET_IF_NOT_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);
}
}
INSIST(ts.tv_sec > 0 && ts.tv_nsec >= 0 &&
ts.tv_nsec < (long)NS_PER_SEC);
- return ((isc_stdtime_t)ts.tv_sec);
+ return (isc_stdtime_t)ts.tv_sec;
}
void
/* 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';
}
*/
int
isc_string_strerror_r(int errnum, char *buf, size_t buflen) {
- return (strerror_r(errnum, buf, buflen));
+ return strerror_r(errnum, buf, buflen);
}
#if !defined(HAVE_STRLCPY)
}
}
- 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
*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;
}
SET_IF_NOT_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;
}
.func = func,
.arg = arg,
};
- return (wrap);
+ return wrap;
}
static void *
ret = func(arg);
- return (ret);
+ return ret;
}
static void *
rcu_unregister_thread();
- return (ret);
+ return ret;
}
void
uint32_t
isc_tid_count(void) {
- return (tid_count);
+ return tid_count;
}
INSIST(t->nanoseconds < NS_PER_SEC);
if (t->seconds == 0 && t->nanoseconds == 0) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static isc_time_t
t.seconds = ts.tv_sec;
t.nanoseconds = ts.tv_nsec;
- return (t);
+ return t;
}
isc_time_t
isc_time_now_hires(void) {
- return (time_now(CLOCKSOURCE_HIRES));
+ return time_now(CLOCKSOURCE_HIRES);
}
isc_time_t
isc_time_now(void) {
- return (time_now(CLOCKSOURCE));
+ return time_now(CLOCKSOURCE);
}
isc_nanosecs_t
RUNTIME_CHECK(clock_gettime(CLOCK_MONOTONIC, &ts) != -1);
- return (isc_nanosecs_fromtime(((isc_time_t){
+ isc_time_t time = {
.seconds = ts.tv_sec,
.nanoseconds = ts.tv_nsec,
- })));
+ };
+
+ return isc_nanosecs_fromtime(time);
}
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 (ISC_OVERFLOW_ADD(t->seconds, i->seconds, &result->seconds)) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
/* Nanoseconds */
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 (ISC_OVERFLOW_SUB(t->seconds, i->seconds, &result->seconds)) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
/* Nanoseconds */
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;
}
uint32_t
REQUIRE(t != NULL);
INSIST(t->nanoseconds < NS_PER_SEC);
- return ((t->seconds * MS_PER_SEC) + (t->nanoseconds / NS_PER_MS));
+ return (t->seconds * MS_PER_SEC) + (t->nanoseconds / NS_PER_MS);
}
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
*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
REQUIRE(cipher_suites != NULL);
if (*cipher_suites == '\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_ciphersuites(tmp_ctx, cipher_suites) == 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;
}
void
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;
}
void
}
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;
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
break;
}
- return (result);
+ return result;
}
isc_result_t
done:
ERR_clear_error();
- return (result);
+ return result;
}
int rulim = ulim;
if (!isdigit((unsigned char)**buf)) {
- return (0);
+ return 0;
}
do {
isdigit((unsigned char)**buf));
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 */
- return (UNCONST(bp));
+ return UNCONST(bp);
}
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;
}
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;
}
}
static void *
isc__uv_malloc(size_t size) {
- return (isc_mem_allocate(isc__uv_mctx, size));
+ return isc_mem_allocate(isc__uv_mctx, size);
}
static void *
isc__uv_realloc(void *ptr, size_t size) {
- return (isc_mem_reallocate(isc__uv_mctx, ptr, size));
+ return isc_mem_reallocate(isc__uv_mctx, ptr, size);
}
static void *
isc__uv_calloc(size_t count, size_t size) {
- return (isc_mem_callocate(isc__uv_mctx, count, size));
+ return isc_mem_callocate(isc__uv_mctx, count, size);
}
static void
static void *
isc__xml_malloc(size_t size) {
- return (isc_mem_allocate(isc__xml_mctx, size));
+ return isc_mem_allocate(isc__xml_mctx, size);
}
static void *
isc__xml_realloc(void *ptr, size_t size) {
- return (isc_mem_reallocate(isc__xml_mctx, ptr, size));
+ return isc_mem_reallocate(isc__xml_mctx, ptr, size);
}
static char *
isc__xml_strdup(const char *str) {
- return (isc_mem_strdup(isc__xml_mctx, str));
+ return isc_mem_strdup(isc__xml_mctx, str);
}
static void
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 *
r.rstart = UNCONST(str);
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;
}
uint32_t len = 0;
if (isc_buffer_peekuint32(ccmsg->buffer, &len) != ISC_R_SUCCESS) {
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
if (len == 0) {
- return (ISC_R_UNEXPECTEDEND);
+ return ISC_R_UNEXPECTEDEND;
}
if (len > ccmsg->maxsize) {
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
if (isc_buffer_remaininglength(ccmsg->buffer) < sizeof(uint32_t) + len)
{
- return (ISC_R_NOMORE);
+ return ISC_R_NOMORE;
}
/* Skip the size we just peeked */
isc_buffer_forward(ccmsg->buffer, sizeof(uint32_t));
ccmsg->size = len;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
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 = calloc(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;
}
SET_IF_NOT_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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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 */
result = count_acl_elements(caml, cctx, ctx, mctx,
&nelem, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
} else {
nelem = cfg_list_length(caml, false);
dns_acl_detach(&inneracl);
}
dns_acl_detach(&dacl);
- return (result);
+ return result;
}
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
if (result != ISC_R_SUCCESS) {
cfg_obj_log(obj, ISC_LOG_ERROR, "'%s' is not a valid name",
str);
- return (result);
+ return result;
}
if (strcasecmp(str, "ephemeral") != 0) {
if (tlsmap == NULL) {
cfg_obj_log(obj, ISC_LOG_ERROR,
"tls '%s' is not defined", str);
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
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, ISC_LOG_ERROR,
"no matching 'forwarders' statement");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
if (forwarders != NULL) {
isc_result_t result = ISC_R_SUCCESS;
if (tls != NULL) {
result = validate_tls(config, tlspobj, tls);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
}
if (tls != NULL) {
result = validate_tls(config, faddresses, tls);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
}
}
- 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
isc_mem_free(mctx, key);
result = ISC_R_EXISTS;
}
- return (result);
+ return result;
}
static isc_result_t
"previous definition: %s:%u",
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, actx, mctx, 0, &acl);
if (acl != NULL) {
}
}
}
- 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;
}
static isc_result_t
}
}
if (map == NULL) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
obj = cfg_tuple_get(map, "low");
"fetch-quota-param low value (%0.1f) "
"out of range",
low);
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
obj = cfg_tuple_get(map, "high");
"fetch-quota-param high value (%0.1f) "
"out of range",
high);
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
obj = cfg_tuple_get(map, "discount");
"fetch-quota-param discount value (%0.1f) "
"out of range",
discount);
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
}
}
- return (result);
+ return result;
}
typedef struct {
dns_fixedname_t fixed;
dns_fixedname_init(&fixed);
- return (dns_name_fromstring(dns_fixedname_name(&fixed), str,
- dns_rootname, 0, NULL));
+ return dns_name_fromstring(dns_fixedname_name(&fixed), str,
+ dns_rootname, 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, ISC_LOG_ERROR, "port '%u' out of range",
cfg_obj_asuint32(portobj));
- return (ISC_R_RANGE);
+ return ISC_R_RANGE;
}
SET_IF_NOT_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 = check_remoteserverlist(cctx, "primaries", symtab, mctx);
if (tresult != ISC_R_SUCCESS) {
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 = check_remoteserverlist(cctx, "parental-agents", symtab, mctx);
if (tresult != ISC_R_SUCCESS) {
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
}
}
- return (result);
+ return result;
}
static isc_result_t
if (obj == NULL) {
cfg_obj_log(zconfig, 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, 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, ISC_LOG_ERROR,
"redirect zones must be called \".\"");
- return (ISC_R_FAILURE);
+ return ISC_R_FAILURE;
}
}
cfg_obj_log(obj, 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, 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, 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, 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, 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, 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, ISC_LOG_WARNING,
"key '%s' digest-bits too small "
cfg_obj_log(algobj, 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
size_t n;
if (kaspnamestr == NULL || strcmp(kaspnamestr, "none") == 0) {
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
dns_name_format(zname, keydirbuf, sizeof(keydirbuf));
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, ISC_LOG_ERROR,
optname, keydir,
cfg_obj_asstring(cfg_tuple_get(exist, "name")),
cfg_obj_asstring(kasp), file, line);
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
/*
result = isc_symtab_define(symtab, symkey, 2, symvalue,
isc_symexists_reject);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
- return (result);
+ return result;
}
/*
}
tresult = isccfg_check_key(key);
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
}
}
- 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, 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);
- 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);
if (symtab != NULL) {
isc_symtab_destroy(&symtab);
}
- return (result);
+ return result;
}
isc_result_t
isc_symtab_destroy(&keydirs);
}
- 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);
}
/*
result = confget(maps, option, &obj);
if (result == ISC_R_NOTFOUND) {
- return (NULL);
+ return NULL;
}
INSIST(result == ISC_R_SUCCESS);
- return (cfg_obj_asstring(obj));
+ return cfg_obj_asstring(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, ISC_LOG_ERROR,
"dnssec-policy: cannot use nsec3 with algorithm '%s'",
algstr);
- return (DNS_R_NSEC3BADALG);
+ return DNS_R_NSEC3BADALG;
}
if (iter != DEFAULT_NSEC3PARAM_ITER) {
"dnssec-policy: nsec3 iterations value %u "
"not allowed, must be zero",
iter);
- return (DNS_R_NSEC3ITERRANGE);
+ return DNS_R_NSEC3ITERRANGE;
}
/* Opt-out? */
cfg_obj_log(obj, 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;
}
static isc_result_t
} else {
dns_kasp_adddigest(kasp, alg);
}
- return (result);
+ return result;
}
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;
}
isc_result_t
cfg_obj_log(config, ISC_LOG_ERROR,
"key-store: duplicate key-store found '%s'", name);
dns_keystore_detach(&keystore);
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
if (result != ISC_R_NOTFOUND) {
cfg_obj_log(config, ISC_LOG_ERROR,
"key-store: lookup '%s' failed: %s", name,
isc_result_totext(result));
- return (result);
+ return result;
}
/*
INSIST(keystore == NULL);
result = dns_keystore_create(mctx, name, &keystore);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
INSIST(keystore != NULL);
}
/* Don't detach as keystore is on '*keystorelist' */
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
{
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
*ret = obj;
cleanup:
- return (result);
+ return result;
}
static void
*ret = obj;
cleanup:
- return (result);
+ return result;
}
static cfg_type_t cfg_type_optional_tagrange = {
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
}
*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
static isc_result_t
parse_checkds_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_checkds_type(cfg_printer_t *pctx, const cfg_type_t *type) {
"iso8601-tzinfo", "local", 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
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
if (result != ISC_R_SUCCESS) {
cfg_parser_error(pctx, CFG_LOG_NEAR, "invalid query source");
}
- 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:
- 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
cfg_obj_asduration(const cfg_obj_t *obj) {
REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_duration);
- return (isccfg_duration_toseconds(&(obj->value.duration)));
+ return isccfg_duration_toseconds(&(obj->value.duration));
}
static isc_result_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
CHECK(cfg_parse_rawaddr(pctx, flags, &netaddr));
isc_sockaddr_fromnetaddr(&obj->value.sockaddr, &netaddr, 0);
*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:
if (tls.base != NULL) {
isc_mem_put(pctx->mctx, tls.base, tls.length + 1);
}
CLEANUP_OBJ(obj);
- return (result);
+ return result;
}
isc_result_t
flagp = type->of;
- return (parse_sockaddrsub(pctx, klass, *flagp, ret));
+ return parse_sockaddrsub(pctx, klass, *flagp, ret);
}
static unsigned int sockaddr_flags = CFG_ADDR_V4OK | CFG_ADDR_V6OK |
isc_result_t
cfg_parse_sockaddr(cfg_parser_t *pctx, const cfg_type_t *type,
cfg_obj_t **ret) {
- return (cfg_parse_sockaddr_generic(pctx, &cfg_type_sockaddr, type,
- ret));
+ return cfg_parse_sockaddr_generic(pctx, &cfg_type_sockaddr, type, ret);
}
isc_result_t
cfg_parse_sockaddrtls(cfg_parser_t *pctx, const cfg_type_t *type,
cfg_obj_t **ret) {
- return (cfg_parse_sockaddr_generic(pctx, &cfg_type_sockaddrtls, type,
- ret));
+ return cfg_parse_sockaddr_generic(pctx, &cfg_type_sockaddrtls, type,
+ 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;
}
bool
cfg_obj_issockaddrtls(const cfg_obj_t *obj) {
REQUIRE(obj != NULL);
- return (obj->type->rep == &cfg_rep_sockaddrtls);
+ return obj->type->rep == &cfg_rep_sockaddrtls;
}
const isc_sockaddr_t *
REQUIRE(obj != NULL);
REQUIRE(obj->type->rep == &cfg_rep_sockaddr ||
obj->type->rep == &cfg_rep_sockaddrtls);
- return (&obj->value.sockaddr);
+ return &obj->value.sockaddr;
}
const char *
cfg_obj_getsockaddrtls(const cfg_obj_t *obj) {
REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_sockaddrtls);
- return (obj->value.sockaddrtls.tls.base);
+ return obj->value.sockaddrtls.tls.base;
}
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, 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;
}
isc_stdtime_t now = isc_stdtime_now();
last = atomic_exchange_relaxed(&last_sigchecks_quota_log, now);
if (now != last) {
- return (true);
+ return true;
}
- return (false);
+ return false;
}
static void
* When DoQ support this had to be removed to get correct DoQ entries.
*/
if (!TCP_CLIENT(client)) {
- return (DNS_TRANSPORT_UDP);
+ return DNS_TRANSPORT_UDP;
}
INSIST(client->handle != NULL);
case isc_nm_udplistener:
case isc_nm_proxyudpsocket:
case isc_nm_proxyudplistener:
- return (DNS_TRANSPORT_UDP);
+ return DNS_TRANSPORT_UDP;
case isc_nm_tlssocket:
case isc_nm_tlslistener:
- return (DNS_TRANSPORT_TLS);
+ return DNS_TRANSPORT_TLS;
case isc_nm_httpsocket:
case isc_nm_httplistener:
- return (DNS_TRANSPORT_HTTP);
+ return DNS_TRANSPORT_HTTP;
case isc_nm_streamdnslistener:
case isc_nm_streamdnssocket:
case isc_nm_proxystreamlistener:
case isc_nm_proxystreamsocket:
/* If it isn't DoT, it is DNS-over-TCP */
if (isc_nm_has_encryption(client->handle)) {
- return (DNS_TRANSPORT_TLS);
+ return DNS_TRANSPORT_TLS;
}
FALLTHROUGH;
case isc_nm_tcpsocket:
case isc_nm_tcplistener:
- return (DNS_TRANSPORT_TCP);
+ return DNS_TRANSPORT_TCP;
case isc_nm_maxsocket:
case isc_nm_nonesocket:
UNREACHABLE();
}
- return (DNS_TRANSPORT_UDP);
+ return DNS_TRANSPORT_UDP;
}
void
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->manager->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->manager->sctx->nsstats,
optlen);
if (result != ISC_R_SUCCESS) {
ns_client_error(client, result);
- return (result);
+ return result;
}
ns_stats_increment(
client->manager->sctx->nsstats,
ns_statscounter_edns0in);
client->attributes |= NS_CLIENTATTR_WANTOPT;
- return (result);
+ return result;
}
static void
/* Async mode. */
if (result == DNS_R_WAIT) {
INSIST(client->async == true);
- return (DNS_R_WAIT);
+ return DNS_R_WAIT;
}
/*
/* Non-async mode. */
ns_client_async_reset(client);
- return (result);
+ return result;
}
/*
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;
}
void
*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;
dns_message_gettemprdataset(client->message, &rdataset);
- 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 *
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_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS, ISC_LOG_ERROR,
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
RUNTIME_CHECK(result == ISC_R_SUCCESS);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_lock:
isc_mutex_destroy(&mgr->lock);
ns_server_detach(&mgr->sctx);
isc_mem_putanddetach(&mgr->mctx, mgr, sizeof(*mgr));
- return (result);
+ return result;
}
void
aclenv = mgr->aclenv;
UNLOCK(&mgr->lock);
- return (aclenv);
+ return aclenv;
}
ISC_REFCOUNT_IMPL(ns_interfacemgr, ns_interfacemgr__destroy);
&ifp->addr, ns_client_request,
ifp, &ifp->udplistensocket);
}
- return (result);
+ return result;
}
static isc_result_t
isc_result_totext(result));
}
- return (result);
+ return result;
}
/*
isc_log_write(NS_LOGCATEGORY_NETWORK, NS_LOGMODULE_INTERFACEMGR,
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 */
ISC_LOG_ERROR, "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(proxy);
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, elt->proxy);
goto cleanup_interface;
}
- if (((mgr->sctx->options & NS_SERVER_NOTCP) == 0)) {
+ if ((mgr->sctx->options & NS_SERVER_NOTCP) == 0) {
result = ns_interface_listentcp(ifp, elt->proxy);
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
* Check if transport type of the listener has not changed. That
* implies that PROXY type has not been changed as well.
*/
- return (same_transport_type && new_le->proxy == ifp->proxy_type);
+ return same_transport_type && new_le->proxy == ifp->proxy_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;
}
dns_acl_create(mgr->mctx, 0, &localhost);
dns_acl_detach(&localhost);
isc_interfaceiter_destroy(&iter);
- return (result);
+ return result;
}
isc_result_t
"not listening on any interfaces");
}
- return (result);
+ return result;
}
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((uint32_t)tid < mgr->ncpus);
- return (mgr->clientmgrs[tid]);
+ return mgr->clientmgrs[tid];
}
bool
* reliable kernel-based mechanism for tracking interface state
* changes is available.
*/
- return (true);
+ return true;
#else
- return (false);
+ return false;
#endif /* LINUX_NETLINK_AVAILABLE */
}
elt->proxy = proxy;
*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
const ns_listen_tls_params_t *tls_params,
isc_tlsctx_cache_t *tlsctx_cache, isc_nm_proxy_type_t proxy,
ns_listenelt_t **target) {
- return (listenelt_create(mctx, port, acl, family, false, tls,
- tls_params, tlsctx_cache, proxy, target));
+ return listenelt_create(mctx, port, acl, family, false, tls, tls_params,
+ tlsctx_cache, proxy, target);
}
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;
}
/*
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.ignoreacl) {
}
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;
approved:
/* Transfer ownership, if necessary. */
SET_IF_NOT_NULL(versionp, dbversion->version);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
*dbp = db;
if (partial && options.partial) {
- 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.
SET_IF_NOT_NULL(mnamep, mname);
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, options, &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
isc_quota_release(&client->manager->sctx->recursionquota);
FALLTHROUGH;
default:
- return (result);
+ return result;
}
recurscount = ns_stats_increment(client->manager->sctx->nsstats,
ns_statscounter_recurshighwater,
recurscount + 1);
- return (result);
+ return result;
}
static isc_result_t
recursionquotatype_attach_hard(ns_client_t *client) {
- return (recursionquotatype_attach(client, false));
+ return recursionquotatype_attach(client, false);
}
static isc_result_t
recursionquotatype_attach_soft(ns_client_t *client) {
- return (recursionquotatype_attach(client, true));
+ return recursionquotatype_attach(client, true);
}
static void
} else if (dns_rdataset_isassociated(*rdatasetp)) {
dns_rdataset_disassociate(*rdatasetp);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void
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;
}
}
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;
}
/*
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;
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)) {
isc_mem_cput(client->manager->mctx, aaaaok, count,
sizeof(bool));
}
- return (true);
+ return true;
}
if (aaaaok != NULL) {
isc_mem_cput(client->manager->mctx, aaaaok, count,
sizeof(bool));
}
- 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);
(dns_getdb_options_t){ 0 }, &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;
}
/*%
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_AD;
qctx->client->message->rcode = dns_rcode_badcookie;
qctx->client->attributes &= ~NS_CLIENTATTR_WANTRC;
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
}
/*
qctx->client->message->flags &= ~DNS_MESSAGEFLAG_AA;
qctx->client->message->flags &= ~DNS_MESSAGEFLAG_AD;
qctx->client->message->flags |= DNS_MESSAGEFLAG_TC;
- 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.stalefirst = false;
cleanup:
- return (result);
+ return result;
}
static void
qctx->sigrdataset = ns_client_newrdataset(qctx->client);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
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.stalefirst) {
&FETCH_RECTYPE_NORMAL(
qctx->client));
}
- return (query_lookup(qctx));
+ return query_lookup(qctx);
} else if (stale_client_answer(result)) {
/*
* Immediately return the stale answer, start a
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);
}
/*%
"no more recursive clients (%u/%u/%u)",
&client->manager->sctx->recursionquota);
ns_client_killoldestquery(client);
- return (result);
+ return result;
default:
UNREACHABLE();
}
dns_message_clonebuffer(client->message);
ns_client_recursing(client);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*%
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_FAILURE);
+ return ISC_R_FAILURE;
}
recparam_update(&client->query.recparam, qtype, qname, qdomain);
result = acquire_recursionquota(client);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
/*
* 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);
}
}
qctx->resuming = true;
- return (query_gotanswer(qctx, result));
+ return query_gotanswer(qctx, result);
cleanup:
- return (result);
+ return result;
}
static void
* the client task or pausing it.
*/
isc_nmhandle_attach(client->handle, &HANDLE_RECTYPE_HOOK(client));
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
cleanup_and_detach_from_quota:
release_recursionquota(client);
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;
}
if (failcache != ISC_R_SUCCESS) {
- return (ISC_R_COMPLETE);
+ return ISC_R_COMPLETE;
}
if (((flags & NS_FAILCACHE_CD) != 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;
}
static void
}
}
}
- 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);
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_keynode_detach(&keynode);
}
dns_keytable_detach(&keytable);
- return (false);
+ return false;
}
dns_rdataset_init(&dsset);
dns_keynode_detach(&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 (result == DNS_R_DUPLICATE || result == DNS_R_DROP) {
* Don't enable serve-stale if the result signals a duplicate
* query or query that is being dropped.
*/
- 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;
}
/*%
* 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 (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
if (clonesigset != NULL) {
ns_client_putrdataset(qctx->client, &clonesigset);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
result = query_synthwildcard(qctx, rdataset, sigrdataset);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
qctx->client->query.attributes |= NS_QUERYATTR_PARTIALANSWER;
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.nolog = true;
}
- return (result);
+ return result;
}
/*
if (clonesigset != NULL) {
ns_client_putrdataset(qctx->client, &clonesigset);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
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;
}
/*
query_addauth(qctx);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
cleanup:
- return (result);
+ return result;
}
/*
query_addauth(qctx);
- return (ns_query_done(qctx));
+ return ns_query_done(qctx);
cleanup:
- return (result);
+ return result;
}
/*%
}
if (qctx->type == dns_rdatatype_any) {
- return (query_respond_any(qctx));
+ return query_respond_any(qctx);
}
result = query_zerottl_refetch(qctx);
goto cleanup;
}
- return (query_respond(qctx));
+ return query_respond(qctx);
cleanup:
- return (result);
+ return result;
}
/*%
if (((client->manager->sctx->options & NS_SERVER_NOSOA) != 0) &&
(!WANTDNSSEC(client) || !dns_rdataset_isassociated(qctx->rdataset)))
{
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
dns_db_detachnode(qctx->db, &node);
}
- return (eresult);
+ return eresult;
}
/*%
}
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->restarthandle);
isc_async_run(qctx->client->manager->loop,
async_restart, saved_qctx);
- return (DNS_R_CONTINUE);
+ return DNS_R_CONTINUE;
} 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.stalefirst))
{
- return (qctx->result);
+ return qctx->result;
}
/*
qctx->detach_client = true;
- return (qctx->result);
+ return qctx->result;
cleanup:
- return (result);
+ return result;
}
static 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 = dns_acl_ref(inner);
rcu_read_unlock();
- return (NS_SORTLISTTYPE_2ELEMENT);
+ return NS_SORTLISTTYPE_2ELEMENT;
}
rcu_read_unlock();
}
if (inner != NULL) {
*argp = dns_acl_ref(inner);
rcu_read_unlock();
- return (NS_SORTLISTTYPE_2ELEMENT);
+ return NS_SORTLISTTYPE_2ELEMENT;
}
rcu_read_unlock();
}
* 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;
}
ns_stats_increment(ns_stats_t *stats, isc_statscounter_t counter) {
REQUIRE(NS_STATS_VALID(stats));
- return (isc_stats_increment(stats->counters, counter));
+ return isc_stats_increment(stats->counters, counter);
}
void
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
dns_difftuple_t *tuple = NULL;
dns_difftuple_create(diff->mctx, op, name, ttl, rdata, &tuple);
- 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;
}
/**************************************************************************/
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;
}
/*
dns_difftuple_create(ctx->del_diff.mctx, DNS_DIFFOP_DEL,
ctx->oldname, rr->ttl, &rr->rdata, &tuple);
dns_diff_append(&ctx->del_diff, &tuple);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/*
}
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/**************************************************************************/
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;
}
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_acquire(&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;
}
uev = isc_mem_get(client->manager->mctx, sizeof(*uev));
isc_nmhandle_attach(client->handle, &client->updatehandle);
isc_async_run(dns_zone_getloop(zone), forward_action, uev);
- 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
cmp_tolower1(void *va, void *vb, unsigned int size) {
for (uint8_t *a = va, *b = vb; size-- > 0; a++, b++) {
if (TOLOWER(*a) != TOLOWER(*b)) {
- return (false);
+ return false;
}
}
- return (true);
+ return true;
}
static bool oldskool_result;
isc_mem_destroy(&mctx);
- return (0);
+ return 0;
}
}
count++;
}
- return (count);
+ return count;
}
static uint32_t
}
count++;
}
- return (count);
+ return count;
}
static void
item_makekey(dns_qpkey_t key, void *ctx, void *pval, uint32_t ival) {
UNUSED(ctx);
assert(pval == &item[ival]);
- return (dns_qpkey_fromname(key, &item[ival].fixed.name));
+ return dns_qpkey_fromname(key, &item[ival].fixed.name);
}
static void
new_lfht(isc_mem_t *mem ISC_ATTR_UNUSED) {
struct cds_lfht *lfht = cds_lfht_new(
1, 1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
- return (lfht);
+ return lfht;
}
static int
ht_node);
const dns_name_t *key = _key;
- return (dns_name_equal(key, &i->fixed.name));
+ return dns_name_equal(key, &i->fixed.name);
}
static isc_result_t
&item[count].ht_node);
if (ht_node != &item[count].ht_node) {
- return (ISC_R_EXISTS);
+ return ISC_R_EXISTS;
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
struct cds_lfht_node *ht_node = cds_lfht_iter_get_node(&iter);
if (ht_node == NULL) {
- return (ISC_R_NOTFOUND);
+ return ISC_R_NOTFOUND;
}
*pval = caa_container_of(ht_node, struct item_s, ht_node);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static void *
arg->d0 = isc_time_microdiff(&t1, &t0);
arg->d1 = isc_time_microdiff(&t2, &t1);
- return (NULL);
+ return NULL;
}
/*
isc_hashmap_t *hashmap = NULL;
isc_hashmap_create(mem, 1, &hashmap);
- return (hashmap);
+ return hashmap;
}
static bool
name_match(void *node, const void *key) {
const struct item_s *i = node;
- return (dns_name_equal(&i->fixed.name, key));
+ return dns_name_equal(&i->fixed.name, key);
}
static isc_result_t
isc_result_t result = isc_hashmap_add(
hashmap, dns_name_hash(&item[count].fixed.name), name_match,
&item[count].fixed.name, &item[count], NULL);
- return (result);
+ return result;
}
static isc_result_t
isc_result_t result = isc_hashmap_find(
hashmap, dns_name_hash(&item[count].fixed.name), name_match,
&item[count].fixed.name, pval);
- return (result);
+ return result;
}
static void *
arg->d0 = isc_time_microdiff(&t1, &t0);
arg->d1 = isc_time_microdiff(&t2, &t1);
- return (NULL);
+ return NULL;
}
/*
new_ht(isc_mem_t *mem) {
isc_ht_t *ht = NULL;
isc_ht_init(&ht, mem, 1, 0);
- return (ht);
+ return ht;
}
static isc_result_t
isc_result_t result = isc_ht_add(ht, item[count].fixed.name.ndata,
item[count].fixed.name.length,
&item[count]);
- return (result);
+ return result;
}
static isc_result_t
get_ht(void *ht, size_t count, void **pval) {
isc_result_t result = isc_ht_find(ht, item[count].fixed.name.ndata,
item[count].fixed.name.length, pval);
- return (result);
+ return result;
}
static void *
arg->d0 = isc_time_microdiff(&t1, &t0);
arg->d1 = isc_time_microdiff(&t2, &t1);
- return (NULL);
+ return NULL;
}
/*
new_qp(isc_mem_t *mem) {
dns_qpmulti_t *qpmulti = NULL;
dns_qpmulti_create(mem, &qpmethods, NULL, &qpmulti);
- return (qpmulti);
+ return qpmulti;
}
static isc_result_t
add_qp(void *qp, size_t count) {
isc_result_t result = dns_qp_insert(qp, &item[count], count);
- return (result);
+ return result;
}
static void
static isc_result_t
get_qp(void *qp, size_t count, void **pval) {
- return (dns_qp_getname(qp, &item[count].fixed.name, pval, NULL));
+ return dns_qp_getname(qp, &item[count].fixed.name, pval, NULL);
}
static void *
arg->d0 = isc_time_microdiff(&t1, &t0);
arg->d1 = isc_time_microdiff(&t2, &t1);
- return (NULL);
+ return NULL;
}
static void *
thread_qp(void *arg0) {
- return (_thread_qp(arg0, true, false));
+ return _thread_qp(arg0, true, false);
}
static void *
thread_qp_nosqz(void *arg0) {
- return (_thread_qp(arg0, false, false));
+ return _thread_qp(arg0, false, false);
}
static void *
thread_qp_brr(void *arg0) {
- return (_thread_qp(arg0, true, true));
+ return _thread_qp(arg0, true, true);
}
/*
static inline size_t
smallname_length(void *pval, uint32_t ival) {
UNUSED(pval);
- return (ival & 0xff);
+ return ival & 0xff;
}
static inline size_t
smallname_labels(void *pval, uint32_t ival) {
UNUSED(pval);
- return (ival >> 8);
+ return ival >> 8;
}
static inline isc_refcount_t *
smallname_refcount(void *pval, uint32_t ival) {
UNUSED(ival);
- return (pval);
+ return pval;
}
static inline uint8_t *
smallname_ndata(void *pval, uint32_t ival) {
- return ((uint8_t *)(smallname_refcount(pval, ival) + 1));
+ return (uint8_t *)(smallname_refcount(pval, ival) + 1);
}
static inline uint8_t *
smallname_offsets(void *pval, uint32_t ival) {
- return (smallname_ndata(pval, ival) + smallname_length(pval, ival));
+ return smallname_ndata(pval, ival) + smallname_length(pval, ival);
}
static void
UNUSED(ctx);
dns_name_t name = DNS_NAME_INITEMPTY;
name_from_smallname(&name, pval, ival);
- return (dns_qpkey_fromname(key, &name));
+ return dns_qpkey_fromname(key, &name);
}
static void
qp_test_dumpdot(qp);
}
- return (0);
+ return 0;
}
static inline size_t
smallname_length(void *pval, uint32_t ival) {
UNUSED(pval);
- return (ival & 0xff);
+ return ival & 0xff;
}
static inline size_t
smallname_labels(void *pval, uint32_t ival) {
UNUSED(pval);
- return (ival >> 8);
+ return ival >> 8;
}
static inline isc_refcount_t *
smallname_refcount(void *pval, uint32_t ival) {
UNUSED(ival);
- return (pval);
+ return pval;
}
static inline uint8_t *
smallname_ndata(void *pval, uint32_t ival) {
- return ((uint8_t *)(smallname_refcount(pval, ival) + 1));
+ return (uint8_t *)(smallname_refcount(pval, ival) + 1);
}
static inline uint8_t *
smallname_offsets(void *pval, uint32_t ival) {
- return (smallname_ndata(pval, ival) + smallname_length(pval, ival));
+ return smallname_ndata(pval, ival) + smallname_length(pval, ival);
}
static void
UNUSED(ctx);
dns_name_t name = DNS_NAME_INITEMPTY;
name_from_smallname(&name, pval, ival);
- return (dns_qpkey_fromname(key, &name));
+ return dns_qpkey_fromname(key, &name);
}
static void
names++;
}
- return (names);
+ return names;
}
int
printf("%-57s%7.3fsec\n", buf, (stop - start) / (double)NS_PER_SEC);
isc_mem_cput(mctx, items, n, sizeof(dns_fixedname_t));
- return (0);
+ return 0;
}
double ratio = sample <= 1 ? pow(sample, -s)
: pow(sample, -s) / pow(invB, -s);
if (ratio > (double)isc_random32() / UINT32_MAX) {
- return (sample - 1);
+ return sample - 1;
}
}
}
UNUSED(ctx);
UNUSED(pval);
memmove(key, item[ival].key, item[ival].len);
- return (item[ival].len);
+ return item[ival].len;
}
static void
static uint8_t
random_byte(void) {
- return (isc_random_uniform(SHIFT_OFFSET - SHIFT_NOBYTE) + SHIFT_NOBYTE);
+ return isc_random_uniform(SHIFT_OFFSET - SHIFT_NOBYTE) + SHIFT_NOBYTE;
}
static void
isc_mem_checkdestroyed(stdout);
isc_mem_destroy(&mctx);
- return (0);
+ return 0;
}
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;
}
/*
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 int
udp_server_addr = (isc_sockaddr_t){ .length = 0 };
socket = setup_ephemeral_port(&udp_server_addr, SOCK_DGRAM);
if (socket < 0) {
- return (-1);
+ return -1;
}
close(socket);
tcp_server_addr = (isc_sockaddr_t){ .length = 0 };
socket = setup_ephemeral_port(&tcp_server_addr, SOCK_STREAM);
if (socket < 0) {
- return (-1);
+ return -1;
}
close(socket);
tls_server_addr = (isc_sockaddr_t){ .length = 0 };
socket = setup_ephemeral_port(&tls_server_addr, SOCK_STREAM);
if (socket < 0) {
- return (-1);
+ return -1;
}
close(socket);
if (isc_tlsctx_createserver(NULL, NULL, &tls_listen_tlsctx) !=
ISC_R_SUCCESS)
{
- return (-1);
+ return -1;
}
dns_name_init(&tls_name, NULL);
if (dns_name_fromtext(&tls_name, &namesrc, dns_rootname,
DNS_NAME_DOWNCASE, &namebuf) != ISC_R_SUCCESS)
{
- return (-1);
+ return -1;
}
transport_list = dns_transport_list_new(mctx);
tls_transport = dns_transport_new(&tls_name, DNS_TRANSPORT_TLS,
transport_list);
dns_transport_set_tlsname(tls_transport, tls_name_str);
- return (0);
+ return 0;
}
static int
teardown_netmgr(state);
teardown_loopmgr(state);
- return (0);
+ return 0;
}
static isc_result_t
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, dsetp, ndisps);
dns_dispatch_detach(&disp);
- return (result);
+ return result;
}
/* create dispatch set */
UNUSED(handle);
UNUSED(arg);
- 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 */
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 */
setup_test(void **state) {
setup_loopmgr(state);
- return (0);
+ return 0;
}
static int
teardown_test(void **state) {
teardown_loopmgr(state);
- return (0);
+ return 0;
}
dns_keytable_t *keytable = NULL;
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
static bool
name_attr_zero(struct dns_name_attrs attributes) {
- return (!(attributes.absolute | attributes.readonly |
- attributes.dynamic | attributes.dynoffsets |
- attributes.nocompress | attributes.cache | attributes.answer |
- attributes.ncache | attributes.chaining | attributes.chase |
- attributes.wildcard | attributes.prerequisite |
- attributes.update | attributes.hasupdaterec));
+ return !(attributes.absolute | attributes.readonly |
+ attributes.dynamic | attributes.dynoffsets |
+ attributes.nocompress | attributes.cache | attributes.answer |
+ attributes.ncache | attributes.chaining | attributes.chase |
+ attributes.wildcard | attributes.prerequisite |
+ attributes.update | attributes.hasupdaterec);
}
/* dns_name_init */
(void)dns_name_fromwire(&name, &source, &dctx, &target);
}
- return (NULL);
+ return NULL;
}
ISC_RUN_TEST_IMPL(benchmark) {
dns_test_namefromstring("sub.example.com.", &fn);
assert_int_equal(dns_nametree_add(bitstree, name, 2), ISC_R_SUCCESS);
- return (0);
+ return 0;
}
static int
dns_nametree_detach(&bitstree);
dns_nametree_detach(&counttree);
rcu_barrier();
- return (0);
+ return 0;
}
ISC_RUN_TEST_IMPL(add_bool) {
nsec3param.iterations = iter;
nsec3param.salt_length = saltlen;
nsec3param.salt = salt;
- return (nsec3param);
+ return nsec3param;
}
/*%
}
key[i++] = SHIFT_NOBYTE;
- return (i);
+ return i;
}
static void
UNUSED(uctx);
UNUSED(ival);
if (*(char *)pval == '\0') {
- return (0);
+ return 0;
}
dns_test_namefromstring(pval, &fixed);
- return (dns_qpkey_fromname(key, dns_fixedname_name(&fixed)));
+ return dns_qpkey_fromname(key, dns_fixedname_name(&fixed));
}
const dns_qpmethods_t string_methods = {
ISC_INSIST(pval == &item[ival]);
}
memmove(key, item[ival].key, item[ival].len);
- return (item[ival].len);
+ return item[ival].len;
}
static void
static uint8_t
random_byte(void) {
- return (isc_random_uniform(SHIFT_OFFSET - SHIFT_NOBYTE) + SHIFT_NOBYTE);
+ return isc_random_uniform(SHIFT_OFFSET - SHIFT_NOBYTE) + SHIFT_NOBYTE;
}
static void
rubric);
UNUSED(rubric);
}
- return (ok);
+ return ok;
}
static bool
qp_test_dumptrie(qp);
TRACE("checkallro failed");
}
- return (ok);
+ return ok;
}
static bool
qp_test_dumptrie(qp);
TRACE("checkallrw failed");
}
- return (ok);
+ return ok;
}
static void
NODE_DESTROYLOCK(&qpdb.node_locks[0].lock);
- return (dns_name_caseequal(name1, name2));
+ return dns_name_caseequal(name1, name2);
}
ISC_RUN_TEST_IMPL(ownercase) {
DNS_DECOMPRESS_ALWAYS, &target);
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);
}
/*
dns_dispatchmgr_detach(&dispatchmgr);
- return (0);
+ return 0;
}
static int
dns_view_detach(&view);
teardown_managers(state);
- return (0);
+ return 0;
}
static void
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_stdtime_t
isc_stdtime_now(void) {
- return (mystdtime);
+ return mystdtime;
}
/* simple increment by 1 */
setup_loopmgr(state);
setup_netmgr(state);
- return (0);
+ return 0;
}
static int
teardown_netmgr(state);
teardown_loopmgr(state);
- return (0);
+ return 0;
}
/* create zone manager */
UNUSED(zone);
*nzones += 1;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* apply a function to a zone table */
isc_loopmgr_shutdown(loopmgr);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_zone_asyncload(zone, true, load_done_last, zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
static isc_result_t
dns_zone_asyncload(zone, true, load_done_new_only, zone);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* asynchronous zone load */
dns_view_detach(&view);
isc_loopmgr_shutdown(loopmgr);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
/* asynchronous zone table load */
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
check_options(irs_resconf_t *resconf) {
if (irs_resconf_getattempts(resconf) != 3) {
- return (ISC_R_BADNUMBER); /* default value only */
+ return ISC_R_BADNUMBER; /* default value only */
}
if (irs_resconf_getndots(resconf) != 2) {
- return (ISC_R_BADNUMBER);
+ return ISC_R_BADNUMBER;
}
if (irs_resconf_gettimeout(resconf) != 1) {
- return (ISC_R_BADNUMBER);
+ 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_t **pdnsbuf = (isc_buffer_t **)state;
isc_buffer_allocate(mctx, pdnsbuf, STATIC_BUFFER_SIZE);
- return (0);
+ return 0;
}
static int
teardown_test_dnsbuf(void **state) {
isc_buffer_free((isc_buffer_t **)state);
- return (0);
+ return 0;
}
static bool
UNUSED(region);
UNUSED(cbarg);
UNUSED(userarg);
- return (true);
+ return true;
}
static int
(isc_dnsstream_assembler_t **)state;
*pdnsasm = isc_dnsstream_assembler_new(mctx, dnsasm_dummy, NULL);
- return (0);
+ return 0;
}
static int
teardown_test_dnsasm(void **state) {
isc_dnsstream_assembler_free((isc_dnsstream_assembler_t **)state);
- return (0);
+ return 0;
}
ISC_RUN_TEST_IMPL(dnsbuffer_generic_test) {
}
if (result != ISC_R_SUCCESS) {
- return (true);
+ return true;
}
if (vdata->verify_message != NULL &&
(isc_dnsstream_assembler_t *)dnsasm);
}
- return (vdata->cont_on_success);
+ return vdata->cont_on_success;
}
typedef struct verify_regions_cbdata {
}
if (result != ISC_R_SUCCESS) {
- return (true);
+ return true;
}
if (vdata->packets != NULL &&
vdata->packets++;
- return (vdata->cont_on_success);
+ return vdata->cont_on_success;
}
ISC_RUN_TEST_IMPL(dnsasm_sequence_test) {
static isc_nm_proxy_type_t
get_proxy_type(void) {
if (!atomic_load(&use_PROXY)) {
- return (ISC_NM_PROXY_NONE);
+ return ISC_NM_PROXY_NONE;
} else if (atomic_load(&use_TLS) && atomic_load(&use_PROXY_over_TLS)) {
- return (ISC_NM_PROXY_ENCRYPTED);
+ return ISC_NM_PROXY_ENCRYPTED;
}
- return (ISC_NM_PROXY_PLAIN);
+ return ISC_NM_PROXY_PLAIN;
}
static void
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 IPV6_RECVERR
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;
}
setup_loopmgr(state);
*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
static int
doh_timeout_recovery_teardown(void **state) {
assert_true(atomic_load(&ctimeouts) == 5);
- return (teardown_test(state));
+ return teardown_test(state);
}
ISC_LOOP_TEST_IMPL(doh_timeout_recovery_POST) {
assert_int_equal(atomic_load(&sreads), 1);
assert_int_equal(atomic_load(&ssends), 1);
- return (teardown_test(state));
+ return teardown_test(state);
}
ISC_LOOP_TEST_IMPL(doh_recv_one_POST) {
assert_int_equal(atomic_load(&sreads), 2);
assert_int_equal(atomic_load(&ssends), 2);
- return (teardown_test(state));
+ return teardown_test(state);
}
ISC_LOOP_TEST_IMPL(doh_recv_two_POST) {
CHECK_RANGE_FULL(sreads);
CHECK_RANGE_FULL(ssends);
- return (res);
+ return res;
}
ISC_LOOP_TEST_IMPL(doh_recv_send_POST) {
assert_int_equal(atomic_load(&sreads), 0);
assert_int_equal(atomic_load(&ssends), 0);
- return (teardown_test(state));
+ return teardown_test(state);
}
/* See: GL #2858, !5319 */
nodes_match(void *node0, const void *key) {
struct test_node *node = node0;
- return (memcmp(node->key, key, 16) == 0);
+ return memcmp(node->key, key, 16) == 0;
}
static bool
struct test_node *node = node0;
size_t len = strlen(key);
- return (memcmp(node->key, key, len) == 0);
+ return memcmp(node->key, key, len) == 0;
}
static bool
upper_nodes_match(void *node0, const void *key) {
struct test_node *node = node0;
- return (isc_ascii_lowerequal((uint8_t *)node->key, key, 16));
+ return isc_ascii_lowerequal((uint8_t *)node->key, key, 16);
}
static void
struct test_node *node = node0;
size_t len = strlen(key);
- return (memcmp(node->key, key, len) == 0);
+ return memcmp(node->key, key, len) == 0;
}
static bool
struct test_node *node = node0;
size_t len = strlen(key);
- return (isc_ascii_lowerequal((uint8_t *)node->key, key, len));
+ return isc_ascii_lowerequal((uint8_t *)node->key, key, len);
}
ISC_RUN_TEST_IMPL(isc_hashmap_case) {
struct e *e1 = p1;
struct e *e2 = p2;
- return (e1->value < e2->value);
+ return e1->value < e2->value;
}
static void
static double
millis_since(isc_nanosecs_t start) {
isc_nanosecs_t end = isc_time_monotonic();
- return ((double)(end - start) / NS_PER_MS);
+ return (double)(end - start) / NS_PER_MS;
}
#else
_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 (NULL);
+ return NULL;
}
ISC_RUN_TEST_IMPL(isc_mem_benchmark) {
}
assert_int_not_equal(delay_loop, 0);
- return (0);
+ return 0;
}
ISC_RUN_TEST_IMPL(isc_mutex) {
isc_pause_n(cont);
}
- return (NULL);
+ return NULL;
}
static void *
isc_pause_n(cont);
}
- return (NULL);
+ return NULL;
}
ISC_RUN_TEST_IMPL(isc_mutex_benchmark) {
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;
}
int
proxy_info = NULL;
- return (0);
+ return 0;
}
void
(void)atomic_fetch_add(&saccepts, 1);
}
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
F();
if (eresult != ISC_R_SUCCESS) {
- return (eresult);
+ return eresult;
}
if (have_expected_saccepts(atomic_fetch_add(&saccepts, 1) + 1)) {
isc_nmhandle_attach(handle, &(isc_nmhandle_t *){ NULL });
isc_refcount_increment0(&active_sreads);
- return (eresult);
+ return eresult;
}
isc_result_t
F();
if (eresult != ISC_R_SUCCESS) {
- return (eresult);
+ return eresult;
}
if (have_expected_saccepts(atomic_fetch_add(&saccepts, 1) + 1)) {
isc_nmhandle_attach(handle, &readhandle);
isc_nm_read(handle, listen_read_cb, readhandle);
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
}
void
isc_quota_max(&listener_quota, max_quota);
quotap = &listener_quota;
}
- return (quotap);
+ return quotap;
}
static void
isc_nm_proxyheader_info_t *
get_proxyheader_info(void) {
if (proxy_info != NULL) {
- return (proxy_info);
+ return proxy_info;
}
/*
* too.
*/
if (isc_random_uniform(2)) {
- return (&proxy_info_data);
+ return &proxy_info_data;
}
- return (NULL);
+ return NULL;
}
static void
stream_connect_function
get_stream_connect_function(void) {
if (stream_use_TLS && !stream_PROXY_over_TLS) {
- return (tls_connect);
+ return tls_connect;
} else if (stream_use_PROXY) {
- return (proxystream_connect);
+ return proxystream_connect;
} else {
- return (tcp_connect);
+ return tcp_connect;
}
UNREACHABLE();
listen_nm, ISC_NM_LISTEN_ALL, &tcp_listen_addr,
accept_cb, accept_cbarg, backlog, quota,
tcp_listen_tlsctx, stream_use_PROXY, sockp);
- return (result);
+ return result;
} else if (stream_use_PROXY) {
isc_tlsctx_t *tlsctx = stream_PROXY_over_TLS ? tcp_listen_tlsctx
: NULL;
result = isc_nm_listenproxystream(
listen_nm, ISC_NM_LISTEN_ALL, &tcp_listen_addr,
accept_cb, accept_cbarg, backlog, quota, tlsctx, sockp);
- return (result);
+ return result;
} else {
result = isc_nm_listentcp(listen_nm, ISC_NM_LISTEN_ALL,
&tcp_listen_addr, accept_cb,
accept_cbarg, backlog, quota, sockp);
- return (result);
+ return result;
}
UNREACHABLE();
isc_nm_proxy_type_t
get_proxy_type(void) {
if (!stream_use_PROXY) {
- return (ISC_NM_PROXY_NONE);
+ return ISC_NM_PROXY_NONE;
} else if (stream_PROXY_over_TLS) {
- return (ISC_NM_PROXY_ENCRYPTED);
+ return ISC_NM_PROXY_ENCRYPTED;
}
- return (ISC_NM_PROXY_PLAIN);
+ return ISC_NM_PROXY_PLAIN;
}
void
stream_noop_setup(void **state ISC_ATTR_UNUSED) {
int r = setup_netmgr_test(state);
expected_cconnects = 1;
- return (r);
+ return r;
}
int
proxystream_noop_setup(void **state) {
stream_use_PROXY = true;
- return (stream_noop_setup(state));
+ return stream_noop_setup(state);
}
int
proxystreamtls_noop_setup(void **state) {
stream_PROXY_over_TLS = true;
- return (proxystream_noop_setup(state));
+ return proxystream_noop_setup(state);
}
void
atomic_assert_int_eq(creads, 0);
atomic_assert_int_eq(sreads, 0);
atomic_assert_int_eq(ssends, 0);
- return (teardown_netmgr_test(state));
+ return teardown_netmgr_test(state);
}
int
int r = stream_noop_teardown(state);
stream_use_PROXY = false;
- return (r);
+ return r;
}
int
int r = proxystream_noop_teardown(state);
stream_PROXY_over_TLS = false;
- return (r);
+ return r;
}
static void
int r = setup_netmgr_test(state);
expected_cconnects = 1;
expected_saccepts = 1;
- return (r);
+ return r;
}
int
proxystream_noresponse_setup(void **state) {
stream_use_PROXY = true;
- return (stream_noresponse_setup(state));
+ return stream_noresponse_setup(state);
}
int
proxystream_noresponse_teardown(void **state) {
int r = stream_noresponse_teardown(state);
stream_use_PROXY = false;
- return (r);
+ return r;
}
int
proxystreamtls_noresponse_setup(void **state) {
stream_PROXY_over_TLS = true;
- return (proxystream_noresponse_setup(state));
+ return proxystream_noresponse_setup(state);
}
int
proxystreamtls_noresponse_teardown(void **state) {
int r = proxystream_noresponse_teardown(state);
stream_PROXY_over_TLS = false;
- return (r);
+ return r;
}
void
atomic_assert_int_eq(sreads, 0);
atomic_assert_int_eq(ssends, 0);
- return (teardown_netmgr_test(state));
+ return teardown_netmgr_test(state);
}
int
expected_sreads = 5;
sreads_shutdown = true;
- return (r);
+ return r;
}
typedef struct proxy_addrs {
int
proxystream_timeout_recovery_setup(void **state) {
stream_use_PROXY = true;
- return (stream_timeout_recovery_setup(state));
+ return stream_timeout_recovery_setup(state);
}
int
proxystream_timeout_recovery_teardown(void **state) {
int r = stream_timeout_recovery_teardown(state);
stream_use_PROXY = false;
- return (r);
+ return r;
}
int
proxystreamtls_timeout_recovery_setup(void **state) {
stream_PROXY_over_TLS = true;
- return (proxystream_timeout_recovery_setup(state));
+ return proxystream_timeout_recovery_setup(state);
}
int
proxystreamtls_timeout_recovery_teardown(void **state) {
int r = proxystream_timeout_recovery_teardown(state);
stream_PROXY_over_TLS = false;
- return (r);
+ return r;
}
void
int
stream_timeout_recovery_teardown(void **state ISC_ATTR_UNUSED) {
atomic_assert_int_eq(ctimeouts, expected_ctimeouts);
- return (teardown_netmgr_test(state));
+ return teardown_netmgr_test(state);
}
int
expected_creads = 1;
creads_shutdown = true;
- return (r);
+ return r;
}
int
proxystream_recv_one_setup(void **state) {
stream_use_PROXY = true;
- return (stream_recv_one_setup(state));
+ return stream_recv_one_setup(state);
}
int
proxystream_recv_one_teardown(void **state) {
int r = stream_recv_one_teardown(state);
stream_use_PROXY = false;
- return (r);
+ return r;
}
int
proxystreamtls_recv_one_setup(void **state) {
stream_PROXY_over_TLS = true;
- return (proxystream_recv_one_setup(state));
+ return proxystream_recv_one_setup(state);
}
int
proxystreamtls_recv_one_teardown(void **state) {
int r = proxystream_recv_one_teardown(state);
stream_PROXY_over_TLS = false;
- return (r);
+ return r;
}
void
atomic_assert_int_eq(ssends, expected_ssends);
atomic_assert_int_eq(creads, expected_creads);
- return (teardown_netmgr_test(state));
+ return teardown_netmgr_test(state);
}
int
expected_creads = 2;
creads_shutdown = true;
- return (r);
+ return r;
}
int
proxystream_recv_two_setup(void **state) {
stream_use_PROXY = true;
- return (stream_recv_two_setup(state));
+ return stream_recv_two_setup(state);
}
int
proxystream_recv_two_teardown(void **state) {
int r = stream_recv_two_teardown(state);
stream_use_PROXY = false;
- return (r);
+ return r;
}
int
proxystreamtls_recv_two_setup(void **state) {
stream_PROXY_over_TLS = true;
- return (proxystream_recv_two_setup(state));
+ return proxystream_recv_two_setup(state);
}
int
proxystreamtls_recv_two_teardown(void **state) {
int r = proxystream_recv_two_teardown(state);
stream_PROXY_over_TLS = false;
- return (r);
+ return r;
}
void
atomic_assert_int_eq(ssends, expected_ssends);
atomic_assert_int_eq(creads, expected_creads);
- return (teardown_netmgr_test(state));
+ return teardown_netmgr_test(state);
}
int
nsends = expected_creads = workers;
do_send = true;
- return (r);
+ return r;
}
int
proxystream_recv_send_setup(void **state) {
stream_use_PROXY = true;
- return (stream_recv_send_setup(state));
+ return stream_recv_send_setup(state);
}
int
proxystream_recv_send_teardown(void **state) {
int r = stream_recv_send_teardown(state);
stream_use_PROXY = false;
- return (r);
+ return r;
}
int
proxystreamtls_recv_send_setup(void **state) {
stream_PROXY_over_TLS = true;
- return (proxystream_recv_send_setup(state));
+ return proxystream_recv_send_setup(state);
}
int
proxystreamtls_recv_send_teardown(void **state) {
int r = proxystream_recv_send_teardown(state);
stream_PROXY_over_TLS = false;
- return (r);
+ return r;
}
void
CHECK_RANGE_FULL(sreads);
CHECK_RANGE_FULL(ssends);
- return (teardown_netmgr_test(state));
+ return teardown_netmgr_test(state);
}
int
connect_readcb = connect_read_cb;
- return (0);
+ return 0;
}
int
teardown_netmgr(state);
teardown_loopmgr(state);
- return (0);
+ return 0;
}
static void
setup_udp_test(state);
expected_cconnects = 1;
cconnects_shutdown = true;
- return (0);
+ return 0;
}
int
udp_noop_teardown(void **state) {
atomic_assert_int_eq(cconnects, 1);
teardown_udp_test(state);
- return (0);
+ return 0;
}
void
int
proxyudp_noop_setup(void **state) {
udp_use_PROXY = true;
- return (udp_noop_setup(state));
+ return udp_noop_setup(state);
}
int
proxyudp_noop_teardown(void **state) {
int ret = udp_noop_teardown(state);
udp_use_PROXY = false;
- return (ret);
+ return ret;
}
static void
udp_noresponse_setup(void **state) {
setup_udp_test(state);
expected_csends = 1;
- return (0);
+ return 0;
}
int
udp_noresponse_teardown(void **state) {
atomic_assert_int_eq(csends, expected_csends);
teardown_udp_test(state);
- return (0);
+ return 0;
}
void
int
proxyudp_noresponse_setup(void **state) {
udp_use_PROXY = true;
- return (udp_noresponse_setup(state));
+ return udp_noresponse_setup(state);
}
int
proxyudp_noresponse_teardown(void **state) {
int ret = udp_noresponse_teardown(state);
udp_use_PROXY = false;
- return (ret);
+ return ret;
}
static void
expected_csends = 1;
expected_creads = 1;
expected_ctimeouts = 4;
- return (0);
+ return 0;
}
int
atomic_assert_int_eq(csends, expected_creads);
atomic_assert_int_eq(ctimeouts, expected_ctimeouts);
teardown_udp_test(state);
- return (0);
+ return 0;
}
void
int
proxyudp_timeout_recovery_setup(void **state) {
udp_use_PROXY = true;
- return (udp_timeout_recovery_setup(state));
+ return udp_timeout_recovery_setup(state);
}
int
proxyudp_timeout_recovery_teardown(void **state) {
int ret = udp_timeout_recovery_teardown(state);
udp_use_PROXY = false;
- return (ret);
+ return ret;
}
static void
udp_shutdown_connect_setup(void **state) {
setup_udp_test(state);
expected_cconnects = 2;
- return (0);
+ return 0;
}
int
udp_shutdown_connect_teardown(void **state) {
atomic_assert_int_eq(cconnects, expected_cconnects);
teardown_udp_test(state);
- return (0);
+ return 0;
}
void
int
proxyudp_shutdown_connect_setup(void **state) {
udp_use_PROXY = true;
- return (udp_shutdown_connect_setup(state));
+ return udp_shutdown_connect_setup(state);
}
int
proxyudp_shutdown_connect_teardown(void **state) {
int ret = udp_shutdown_connect_teardown(state);
udp_use_PROXY = false;
- return (ret);
+ return ret;
}
static void
setup_udp_test(state);
expected_cconnects = 1;
expected_creads = 1;
- return (0);
+ return 0;
}
int
atomic_assert_int_eq(cconnects, expected_cconnects);
atomic_assert_int_eq(creads, expected_creads);
teardown_udp_test(state);
- return (0);
+ return 0;
}
void
int
proxyudp_shutdown_read_setup(void **state) {
udp_use_PROXY = true;
- return (udp_shutdown_read_setup(state));
+ return udp_shutdown_read_setup(state);
}
int
proxyudp_shutdown_read_teardown(void **state) {
int ret = udp_shutdown_read_teardown(state);
udp_use_PROXY = false;
- return (ret);
+ return ret;
}
static void
setup_udp_test(state);
expected_cconnects = 1;
expected_creads = 1;
- return (0);
+ return 0;
}
int
atomic_assert_int_eq(cconnects, expected_cconnects);
atomic_assert_int_eq(creads, expected_creads);
teardown_udp_test(state);
- return (0);
+ return 0;
}
void
int
proxyudp_cancel_read_setup(void **state) {
udp_use_PROXY = true;
- return (udp_cancel_read_setup(state));
+ return udp_cancel_read_setup(state);
}
int
proxyudp_cancel_read_teardown(void **state) {
int ret = udp_cancel_read_teardown(state);
udp_use_PROXY = false;
- return (ret);
+ return ret;
}
int
expected_creads = 1;
creads_shutdown = true;
- return (0);
+ return 0;
}
int
teardown_udp_test(state);
- return (0);
+ return 0;
}
void
int
proxyudp_recv_one_setup(void **state) {
udp_use_PROXY = true;
- return (udp_recv_one_setup(state));
+ return udp_recv_one_setup(state);
}
int
proxyudp_recv_one_teardown(void **state) {
int ret = udp_recv_one_teardown(state);
udp_use_PROXY = false;
- return (ret);
+ return ret;
}
int
expected_creads = 2;
creads_shutdown = true;
- return (0);
+ return 0;
}
int
atomic_assert_int_eq(creads, expected_creads);
teardown_udp_test(state);
- return (0);
+ return 0;
}
void
int
proxyudp_recv_two_setup(void **state) {
udp_use_PROXY = true;
- return (udp_recv_two_setup(state));
+ return udp_recv_two_setup(state);
}
int
proxyudp_recv_two_teardown(void **state) {
int ret = udp_recv_two_teardown(state);
udp_use_PROXY = false;
- return (ret);
+ return ret;
}
int
expected_creads = workers * NSENDS;
do_send = true;
- return (0);
+ return 0;
}
int
atomic_assert_int_ge(creads, expected_creads);
teardown_udp_test(state);
- return (0);
+ return 0;
}
void
int
proxyudp_recv_send_setup(void **state) {
udp_use_PROXY = true;
- return (udp_recv_send_setup(state));
+ return udp_recv_send_setup(state);
}
int
proxyudp_recv_send_teardown(void **state) {
int ret = udp_recv_send_teardown(state);
udp_use_PROXY = false;
- return (ret);
+ return ret;
}
static void
connect_readcb = udp_double_read_cb;
- return (0);
+ return 0;
}
int
teardown_udp_test(state);
- return (0);
+ return 0;
}
void
int
proxyudp_double_read_setup(void **state) {
udp_use_PROXY = true;
- return (udp_double_read_setup(state));
+ return udp_double_read_setup(state);
}
int
proxyudp_double_read_teardown(void **state) {
int ret = udp_double_read_teardown(state);
udp_use_PROXY = false;
- return (ret);
+ return ret;
}
break;
};
- return (true);
+ return true;
}
static bool
assert_true(result == ISC_R_SUCCESS);
}
- return (true);
+ return true;
}
static void
setup_test_proxy(void **state) {
isc_proxy2_handler_t **handler = (isc_proxy2_handler_t **)state;
*handler = isc_proxy2_handler_new(mctx, 0, proxy2_handler_dummy, NULL);
- return (0);
+ return 0;
}
static int
teardown_test_proxy(void **state) {
isc_proxy2_handler_free((isc_proxy2_handler_t **)state);
- return (0);
+ return 0;
}
static void
result = isc_proxy2_append_tlv(outbuf, tls_subtlv_type, data);
assert_true(result == ISC_R_SUCCESS);
- return (true);
+ return true;
}
static bool
assert_true(result == ISC_R_SUCCESS);
}
- return (true);
+ return true;
}
static void
stream_use_TLS = false;
stream = true;
- return (0);
+ return 0;
}
ISC_TEST_MAIN_CUSTOM(proxystream_setup, NULL)
quota_release(void *arg) {
uv_sleep(10);
isc_quota_release((isc_quota_t *)arg);
- return (NULL);
+ return NULL;
}
static void
&g_threads[tnum]);
}
}
- return (NULL);
+ return NULL;
}
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;
}
/***
r = setup_loopmgr(state);
if (r != 0) {
- return (r);
+ return r;
}
- return (0);
+ return 0;
}
static int
r = teardown_loopmgr(state);
if (r != 0) {
- return (r);
+ return r;
}
- return (0);
+ return 0;
}
ISC_TEST_LIST_START
rnd[i] = (uint8_t)isc_random_uniform(100);
}
- return (0);
+ return 0;
}
static int
teardown_env(void **state __attribute__((__unused__))) {
isc_mem_cput(mctx, rnd, loops, sizeof(rnd[0]));
- return (0);
+ return 0;
}
static int
isc_barrier_init(&barrier1, 2);
isc_barrier_init(&barrier2, 2);
if (pthread_rwlock_init(&prwlock, NULL) == -1) {
- return (errno);
+ return errno;
}
- return (0);
+ return 0;
}
static int
rwlock_teardown(void **state __attribute__((__unused__))) {
if (pthread_rwlock_destroy(&prwlock) == -1) {
- return (errno);
+ return errno;
}
isc_barrier_destroy(&barrier2);
isc_barrier_destroy(&barrier1);
isc_rwlock_destroy(&rwlock);
- return (0);
+ return 0;
}
/*
isc_rwlock_unlock(&rwlock, isc_rwlocktype_read);
- return (NULL);
+ return NULL;
}
static void *
isc_rwlock_unlock(&rwlock, isc_rwlocktype_read);
- return (NULL);
+ return NULL;
}
ISC_RUN_TEST_IMPL(isc_rwlock_trylock) {
isc_pause_n(cont);
}
- return (NULL);
+ return NULL;
}
static void *
isc_pause_n(cont);
}
- return (NULL);
+ return NULL;
}
static void
}
assert_int_not_equal(delay_loop, 0);
- return (0);
+ return 0;
}
ISC_RUN_TEST_IMPL(isc_spinlock) {
isc_pause_n(cont);
}
- return (NULL);
+ return NULL;
}
#endif
isc_pause_n(cont);
}
- return (NULL);
+ return NULL;
}
ISC_RUN_TEST_IMPL(isc_spinlock_benchmark) {
int
stream_shutdownconnect_setup(void **state ISC_ATTR_UNUSED) {
int r = setup_netmgr_test(state);
- return (r);
+ return r;
}
int
proxystream_shutdownconnect_setup(void **state) {
stream_use_PROXY = true;
- return (stream_shutdownconnect_setup(state));
+ return stream_shutdownconnect_setup(state);
}
int
proxystream_shutdownconnect_teardown(void **state) {
int r = stream_shutdownconnect_teardown(state);
stream_use_PROXY = false;
- return (r);
+ return r;
}
int
proxystreamtls_shutdownconnect_setup(void **state) {
stream_PROXY_over_TLS = true;
- return (proxystream_shutdownconnect_setup(state));
+ return proxystream_shutdownconnect_setup(state);
}
int
proxystreamtls_shutdownconnect_teardown(void **state) {
int r = proxystream_shutdownconnect_teardown(state);
stream_PROXY_over_TLS = false;
- return (r);
+ return r;
}
void
atomic_assert_int_eq(csends, 0);
atomic_assert_int_eq(creads, 0);
- return (teardown_netmgr_test(state));
+ return teardown_netmgr_test(state);
}
/* Issue the shutdown before reading */
int
stream_shutdownread_setup(void **state ISC_ATTR_UNUSED) {
int r = setup_netmgr_test(state);
- return (r);
+ return r;
}
int
proxystream_shutdownread_setup(void **state) {
stream_use_PROXY = true;
- return (stream_shutdownread_setup(state));
+ return stream_shutdownread_setup(state);
}
int
proxystream_shutdownread_teardown(void **state) {
int r = stream_shutdownread_teardown(state);
stream_use_PROXY = false;
- return (r);
+ return r;
}
int
proxystreamtls_shutdownread_setup(void **state) {
stream_PROXY_over_TLS = true;
- return (proxystream_shutdownread_setup(state));
+ return proxystream_shutdownread_setup(state);
}
int
proxystreamtls_shutdownread_teardown(void **state) {
int r = proxystream_shutdownread_teardown(state);
stream_PROXY_over_TLS = false;
- return (r);
+ return r;
}
void
atomic_assert_int_eq(csends, 1);
atomic_assert_int_eq(creads, 1);
- return (teardown_netmgr_test(state));
+ return teardown_netmgr_test(state);
}
stream_use_TLS = false;
stream = true;
- return (0);
+ return 0;
}
ISC_TEST_MAIN_CUSTOM(tcp_setup, NULL)
tcpdns_setup(void **state ISC_ATTR_UNUSED) {
stream_port = TCPDNS_TEST_PORT;
- return (0);
+ return 0;
}
ISC_TEST_MAIN_CUSTOM(tcpdns_setup, NULL)
stream_use_TLS = true;
stream = true;
- return (0);
+ return 0;
}
ISC_TEST_MAIN_CUSTOM(tls_setup, NULL)
tlsdns_setup(void **state ISC_ATTR_UNUSED) {
stream_port = TLSDNS_TEST_PORT;
- return (0);
+ return 0;
}
ISC_TEST_MAIN_CUSTOM(tlsdns_setup, NULL)
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 ISC_ATTR_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);
}
static atomic_int __state_uv_udp_getpeername ISC_ATTR_UNUSED = 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);
}
static atomic_int __state_uv_udp_getsockname = 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__)
ISC_LOG_DYNAMIC, ISC_LOGDESTINATION_STDERR, 0,
ISC_LOGCATEGORY_DEFAULT, ISC_LOGMODULE_DEFAULT);
- return (0);
+ return 0;
}
struct duration_conf {
ISC_LOG_DYNAMIC, ISC_LOGDESTINATION_STDERR, 0,
ISC_LOGCATEGORY_DEFAULT, ISC_LOGMODULE_DEFAULT);
- return (0);
+ return 0;
}
/* mimic calling nzf_append() */
result = dns_dispatchmgr_create(mctx, loopmgr, netmgr,
&dispatchmgr);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
}
}
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
*zonep = zone;
- return (ISC_R_SUCCESS);
+ return ISC_R_SUCCESS;
detach_zone:
dns_zone_detach(&zone);
- return (result);
+ return result;
}
void
REQUIRE(zonemgr != NULL);
result = dns_zonemgr_managezone(zonemgr, zone);
- return (result);
+ return result;
}
void
result = dns_name_fromstring(name, origin, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_create(mctx, dbimp, 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
destroy_lexer:
isc_lex_destroy(&lex);
- return (result);
+ return result;
}
void
dns_diff_clear(diff);
}
- return (result);
+ return result;
}
}
INSIST(workers != 0);
- return (0);
+ return 0;
}
int
isc_mem_debugging |= ISC_MEM_DEBUGRECORD;
isc_mem_create(&mctx);
- return (0);
+ return 0;
}
int
teardown_mctx(void **state ISC_ATTR_UNUSED) {
isc_mem_destroy(&mctx);
- return (0);
+ return 0;
}
int
isc_loopmgr_create(mctx, workers, &loopmgr);
mainloop = isc_loop_main(loopmgr);
- return (0);
+ return 0;
}
int
mainloop = NULL;
isc_loopmgr_destroy(&loopmgr);
- return (0);
+ return 0;
}
int
isc_netmgr_create(mctx, loopmgr, &netmgr);
- return (0);
+ return 0;
}
int
isc_netmgr_destroy(&netmgr);
- return (0);
+ return 0;
}
int
setup_loopmgr(state);
setup_netmgr(state);
- return (0);
+ return 0;
}
int
teardown_netmgr(state);
teardown_loopmgr(state);
- return (0);
+ return 0;
}
UNUSED(viewp);
*viewmatchresultp = ISC_R_NOTIMPLEMENTED;
- return (ISC_R_NOTIMPLEMENTED);
+ return ISC_R_NOTIMPLEMENTED;
}
static void
isc_loop_setup(mainloop, scan_interfaces, NULL);
- return (0);
+ return 0;
cleanup:
teardown_server(state);
- return (-1);
+ return -1;
}
void
}
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);
dns_test_closezonemgr();
dns_zone_detach(&served_zone);
- return (result);
+ return result;
}
void
* 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;
}
}
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, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
- return (result);
+ return result;
}
result = dns_db_create(mctx, dbimp, 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;
}
qp_test_bittoascii(dns_qpshift_t bit) {
uint8_t byte = dns_qp_byte_for_bit[bit];
if (bit == SHIFT_NOBYTE) {
- return ('.');
+ return '.';
} else if (qp_common_character(byte)) {
- return (byte);
+ return byte;
} else if (byte < '-') {
- return ('#');
+ return '#';
} else if (byte < '_') {
- return ('@');
+ return '@';
} else {
- return ('~' - SHIFT_OFFSET + bit);
+ return '~' - SHIFT_OFFSET + bit;
}
}
key[offset] = qp_test_bittoascii(key[offset]);
}
key[len] = '\0';
- return ((const char *)key);
+ return (const char *)key;
}
/***********************************************************************
static size_t
getheight(dns_qp_t *qp, dns_qpnode_t *n) {
if (node_tag(n) == LEAF_TAG) {
- return (0);
+ return 0;
}
size_t max_height = 0;
dns_qpnode_t *twigs = branch_twigs(qp, n);
size_t height = getheight(qp, &twigs[pos]);
max_height = ISC_MAX(max_height, height);
}
- return (max_height + 1);
+ return max_height + 1;
}
size_t
qp_test_getheight(dns_qp_t *qp) {
dns_qpnode_t *root = get_root(qp);
- return (root == NULL ? 0 : getheight(qp, root));
+ return root == NULL ? 0 : getheight(qp, root);
}
static size_t
maxkeylen(dns_qp_t *qp, dns_qpnode_t *n) {
if (node_tag(n) == LEAF_TAG) {
dns_qpkey_t key;
- return (leaf_qpkey(qp, n, key));
+ return leaf_qpkey(qp, n, key);
}
size_t max_len = 0;
dns_qpnode_t *twigs = branch_twigs(qp, n);
size_t len = maxkeylen(qp, &twigs[pos]);
max_len = ISC_MAX(max_len, len);
}
- return (max_len);
+ return max_len;
}
size_t
qp_test_maxkeylen(dns_qp_t *qp) {
dns_qpnode_t *root = get_root(qp);
- return (root == NULL ? 0 : maxkeylen(qp, root));
+ return root == NULL ? 0 : maxkeylen(qp, root);
}
/***********************************************************************
ns_hook_resume_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));
isc_mem_attach(memctx, &ctx->mctx);
*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));
isc_mem_attach(memctx, &ctx->mctx);
*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 (ctx == NULL || evp_md_ctx == NULL) {
ERR_clear_error();
- return (1);
+ return 1;
}
if (EVP_PKEY_keygen_init(ctx) != 1 ||
EVP_PKEY_keygen(ctx, &pkey) != 1 || pkey == NULL)
{
ERR_clear_error();
- return (1);
+ return 1;
}
bytes = sizeof(buf);
if (EVP_PKEY_get_raw_public_key(pkey, buf, &bytes) != 1) {
ERR_clear_error();
- return (1);
+ return 1;
}
printf("unsigned char ed25519_pub[] = \"");
(const unsigned char *)"test", 4) != 1)
{
ERR_clear_error();
- return (1);
+ return 1;
}
printf("unsigned char ed25519_sig[] = \"");
evp_md_ctx = EVP_MD_CTX_create();
if (ctx == NULL || evp_md_ctx == NULL) {
ERR_clear_error();
- return (1);
+ return 1;
}
if (EVP_PKEY_keygen_init(ctx) != 1 ||
EVP_PKEY_keygen(ctx, &pkey) != 1 || pkey == NULL)
{
ERR_clear_error();
- return (1);
+ return 1;
}
bytes = sizeof(buf);
if (EVP_PKEY_get_raw_public_key(pkey, buf, &bytes) != 1) {
ERR_clear_error();
- return (1);
+ return 1;
}
printf("unsigned char ed448_pub[] = \"");
(const unsigned char *)"test", 4) != 1)
{
ERR_clear_error();
- return (1);
+ return 1;
}
printf("unsigned char ed448_sig[] = \"");
EVP_MD_CTX_free(evp_md_ctx);
EVP_PKEY_free(pkey);
- return (0);
+ return 0;
}
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
