#include <isc/netdb.h>
#include <isc/print.h>
#include <isc/region.h>
+#include <isc/result.h>
#include <isc/stdio.h>
#include <isc/string.h>
#include <isc/symtab.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/types.h>
#include <dns/zone.h>
#include <dns/log.h>
#include <dns/name.h>
#include <dns/rdataclass.h>
-#include <dns/result.h>
#include <dns/rootns.h>
#include <dns/zone.h>
NULL);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "%s/%s/%s: %s\n", view, zname, zclass,
- dns_result_totext(result));
+ isc_result_totext(result));
}
return (result);
}
RUNTIME_CHECK(setup_logging(mctx, stdout, &logc) == ISC_R_SUCCESS);
- dns_result_register();
-
RUNTIME_CHECK(cfg_parser_create(mctx, logc, &parser) == ISC_R_SUCCESS);
if (nodeprecate) {
#include <isc/log.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/socket.h>
#include <isc/string.h>
#include <isc/task.h>
#include <dns/name.h>
#include <dns/rdataclass.h>
#include <dns/rdataset.h>
-#include <dns/result.h>
#include <dns/types.h>
#include <dns/zone.h>
if (result != ISC_R_SUCCESS) { \
if (!quiet) \
fprintf(stderr, "%s() returned %s\n", \
- function, dns_result_totext(result)); \
+ function, isc_result_totext(result)); \
return (result); \
} \
} while (0)
ISC_R_SUCCESS);
}
- dns_result_register();
-
origin = argv[isc_commandline_index++];
if (isc_commandline_index == argc) {
#include <dns/keyvalues.h>
#include <dns/name.h>
-#include <dns/result.h>
#include <dst/dst.h>
int len = 0;
int ch;
- dns_result_register();
-
result = isc_file_progname(*argv, program, sizeof(program));
if (result != ISC_R_SUCCESS) {
memmove(program, "tsig-keygen", 11);
#include <isc/netmgr.h>
#include <isc/parseint.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/sockaddr.h>
#include <isc/socket.h>
#include <isc/string.h>
#include <dns/rdataset.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/secalg.h>
#include <dns/view.h>
#include <dst/dst.h>
-#include <dst/result.h>
#include <isccfg/log.h>
#include <isccfg/namedconf.h>
isc_mem_create(&mctx);
- dns_result_register();
-
result = dst_lib_init(mctx, NULL);
if (result != ISC_R_SUCCESS) {
fatal("dst_lib_init failed: %d", result);
#include <isc/netaddr.h>
#include <isc/parseint.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/task.h>
#include <isc/util.h>
#include <dns/rdataclass.h>
#include <dns/rdataset.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/tsig.h>
#include "dighost.h"
#include <dns/rdataset.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/tsig.h>
#include <dst/dst.h>
-#include <dst/result.h>
#include <isccfg/namedconf.h>
debug("setup_libs()");
- dns_result_register();
-
result = isc_net_probeipv4();
if (result == ISC_R_SUCCESS) {
have_ipv4 = true;
#include <isc/hash.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/serial.h>
#include <isc/string.h>
#include <isc/time.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/time.h>
#include <dst/dst.h>
"dns_ds_buildrdata("
"keytag=%d, algo=%d, digest=%d): %s\n",
ds.key_tag, ds.algorithm, ds.digest_type,
- dns_result_totext(result));
+ isc_result_totext(result));
continue;
}
/* allow for both DS and CDS */
vbprintf(3,
"dns_dnssec_keyfromrdata("
"keytag=%d, algo=%d): %s\n",
- ki->tag, ki->algo, dns_result_totext(result));
+ ki->tag, ki->algo, isc_result_totext(result));
}
}
isc_mem_create(&mctx);
- dns_result_register();
-
isc_commandline_errprint = false;
#define OPTIONS "a:c:Dd:f:i:ms:T:uv:V"
#include <isc/hash.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dst/dst.h>
isc_mem_create(&mctx);
- dns_result_register();
-
isc_commandline_errprint = false;
#define OPTIONS "12Aa:Cc:d:Ff:K:l:sT:v:hV"
#include <isc/hash.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dst/dst.h>
isc_mem_create(&mctx);
- dns_result_register();
-
isc_commandline_errprint = false;
#define CMDLINE_FLAGS "D:f:hK:L:P:v:V"
#include <isc/mem.h>
#include <isc/print.h>
#include <isc/region.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/log.h>
#include <dns/name.h>
#include <dns/rdataclass.h>
-#include <dns/result.h>
#include <dns/secalg.h>
#include <dst/dst.h>
isc_mem_create(&mctx);
- dns_result_register();
-
isc_commandline_errprint = false;
isc_stdtime_get(&now);
#include <isc/mem.h>
#include <isc/print.h>
#include <isc/region.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/log.h>
#include <dns/name.h>
#include <dns/rdataclass.h>
-#include <dns/result.h>
#include <dns/secalg.h>
#include <dst/dst.h>
usage();
}
- dns_result_register();
-
isc_commandline_errprint = false;
/*
#include <isc/hash.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/keyvalues.h>
-#include <dns/result.h>
#include <dst/dst.h>
isc_mem_create(&mctx);
- dns_result_register();
-
isc_commandline_errprint = false;
while ((ch = isc_commandline_parse(argc, argv, "E:fK:rRhv:V")) != -1) {
#include <isc/hash.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/time.h>
#include <isc/util.h>
#include <dns/keyvalues.h>
#include <dns/log.h>
-#include <dns/result.h>
#include <dst/dst.h>
setup_logging(mctx, &log);
- dns_result_register();
-
isc_commandline_errprint = false;
isc_stdtime_get(&now);
#include <isc/os.h>
#include <isc/print.h>
#include <isc/random.h>
+#include <isc/result.h>
#include <isc/rwlock.h>
#include <isc/safe.h>
#include <isc/serial.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/soa.h>
#include <dns/time.h>
#include <dns/update.h>
case DNS_R_CNAME:
case DNS_R_DNAME:
return (false);
+ default:
+ break;
}
dns_name_format(name, namestr, sizeof(namestr));
fatal("failure looking for '%s DNSKEY' in database: %s", namestr,
isc_mem_create(&mctx);
- dns_result_register();
-
isc_commandline_errprint = false;
while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) {
#include <isc/os.h>
#include <isc/print.h>
#include <isc/random.h>
+#include <isc/result.h>
#include <isc/rwlock.h>
#include <isc/serial.h>
#include <isc/stdio.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/soa.h>
#include <dns/time.h>
#include <dns/zoneverify.h>
isc_mem_create(&mctx);
- dns_result_register();
-
isc_commandline_errprint = false;
while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) {
#include <isc/list.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/time.h>
#include <isc/util.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/secalg.h>
#include <dns/time.h>
#include <isc/result.h>
#include <isc/util.h>
-#include <dns/result.h>
#include <dns/sdb.h>
#include <named/builtin.h>
#include <isc/event.h>
#include <isc/lex.h>
#include <isc/mem.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/timer.h>
#include <isc/util.h>
-#include <dns/result.h>
-
#include <isccc/alist.h>
#include <isccc/cc.h>
-#include <isccc/result.h>
#include <named/control.h>
#include <named/globals.h>
#include <isc/task.h>
#include <isc/util.h>
-#include <dns/result.h>
-
#include <isccc/alist.h>
#include <isccc/cc.h>
#include <isccc/ccmsg.h>
#include <isccc/events.h>
-#include <isccc/result.h>
#include <isccc/sexpr.h>
#include <isccc/symtab.h>
#include <isccc/util.h>
#include <dns/dlz_dlopen.h>
#include <dns/log.h>
-#include <dns/result.h>
#include <dlz/dlz_dlopen_driver.h>
#include <named/globals.h>
#include <isc/os.h>
#include <isc/print.h>
#include <isc/resource.h>
+#include <isc/result.h>
#include <isc/stdio.h>
#include <isc/string.h>
#include <isc/task.h>
#include <dns/dyndb.h>
#include <dns/name.h>
#include <dns/resolver.h>
-#include <dns/result.h>
#include <dns/view.h>
-#include <dst/result.h>
-
-#include <isccc/result.h>
-
#include <dlz/dlz_dlopen_driver.h>
#ifdef HAVE_GPERFTOOLS_PROFILER
named_os_init(program_name);
- dns_result_register();
- dst_result_register();
- isccc_result_register();
-
parse_command_line(argc, argv);
#ifdef ENABLE_AFL
#include <isc/print.h>
#include <isc/refcount.h>
#include <isc/resource.h>
+#include <isc/result.h>
#include <isc/siphash.h>
#include <isc/socket.h>
#include <isc/stat.h>
#include <dns/zt.h>
#include <dst/dst.h>
-#include <dst/result.h>
#include <isccfg/grammar.h>
#include <isccfg/kaspconf.h>
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"dumpstats failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
return (result);
}
}
if (result == ISC_R_NOTIMPLEMENTED) {
fprintf(dctx->fp, "; %s\n",
- dns_result_totext(result));
+ isc_result_totext(result));
} else if (result != ISC_R_SUCCESS) {
goto cleanup;
}
result = dns_zone_getdb(dctx->zone->zone, &dctx->db);
if (result != ISC_R_SUCCESS) {
fprintf(dctx->fp, "; %s\n",
- dns_result_totext(result));
+ isc_result_totext(result));
goto nextzone;
}
dns_db_currentversion(dctx->db, &dctx->version);
}
if (result == ISC_R_NOTIMPLEMENTED) {
fprintf(dctx->fp, "; %s\n",
- dns_result_totext(result));
+ isc_result_totext(result));
result = ISC_R_SUCCESS;
POST(result);
goto nextzone;
if (result != ISC_R_SUCCESS) {
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
- "dumpdb failed: %s", dns_result_totext(result));
+ "dumpdb failed: %s", isc_result_totext(result));
}
dumpcontext_destroy(dctx);
}
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"dumpsecroots failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
return (result);
}
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"dumprecursing failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
return (result);
}
"Check the logs to see the result.";
result = ISC_R_SUCCESS;
break;
+ default:
+ break;
}
}
}
#include <isc/base64.h>
#include <isc/buffer.h>
#include <isc/mem.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
-#include <dns/result.h>
#include <dns/tsig.h>
#include <isccfg/cfg.h>
#include <isc/file.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/stats.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
#include <isc/util.h>
#include <dns/rdatalist.h>
#include <dns/rdataset.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/sdlz.h>
#include <dns/ssu.h>
#include <dns/stats.h>
#include <isc/print.h>
#include <isc/random.h>
#include <isc/region.h>
+#include <isc/result.h>
#include <isc/sockaddr.h>
#include <isc/stdio.h>
#include <isc/string.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
#include <dns/request.h>
-#include <dns/result.h>
#include <dns/tkey.h>
#include <dns/tsig.h>
false, NULL, 0, 0, gmctx, NULL, &tsigkey);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "could not create key from %s: %s\n", keystr,
- dns_result_totext(result));
+ isc_result_totext(result));
} else {
dst_key_setbits(tsigkey->key, digestbits);
}
ddebug("setup_system()");
- dns_result_register();
-
isc_log_create(gmctx, &glctx, &logconfig);
isc_log_setcontext(glctx);
dns_log_init(glctx);
isc_mem_free(gmctx, secret);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "could not create key from %s %s: %s\n",
- namestr, secretstr, dns_result_totext(result));
+ namestr, secretstr, isc_result_totext(result));
return (STATUS_SYNTAX);
}
dst_key_setbits(tsigkey->key, digestbits);
result = dns_message_settsigkey(rcvmsg, tsigkey);
check_result(result, "dns_message_settsigkey");
result = dns_message_checksig(rcvmsg, NULL);
- ddebug("tsig verification: %s", dns_result_totext(result));
+ ddebug("tsig verification: %s", isc_result_totext(result));
check_result(result, "dns_message_checksig");
#endif /* 0 */
#include <dns/log.h>
#include <dns/message.h>
#include <dns/rdataset.h>
-#include <dns/result.h>
#include <dns/types.h>
#include <dns/view.h>
#include <dns/log.h>
#include <dns/message.h>
#include <dns/rdataset.h>
-#include <dns/result.h>
#include <dns/types.h>
#include <dns/view.h>
#include <isc/print.h>
#include <isc/random.h>
#include <isc/refcount.h>
+#include <isc/result.h>
#include <isc/socket.h>
#include <isc/stdtime.h>
#include <isc/string.h>
#include <isccc/base64.h>
#include <isccc/cc.h>
#include <isccc/ccmsg.h>
-#include <isccc/result.h>
#include <isccc/sexpr.h>
#include <isccc/types.h>
#include <isccc/util.h>
parse_config(rndc_mctx, log, keyname, &pctx, &config);
- isccc_result_register();
-
isc_buffer_allocate(rndc_mctx, &databuf, 2048);
/*
#define _LD_LOG_H_
#include <isc/error.h>
+#include <isc/result.h>
#include <dns/log.h>
-#include <dns/result.h>
#define fatal_error(...) isc_error_fatal(__FILE__, __LINE__, __VA_ARGS__)
#define log_error_r(fmt, ...) \
- log_error(fmt ": %s", ##__VA_ARGS__, dns_result_totext(result))
+ log_error(fmt ": %s", ##__VA_ARGS__, isc_result_totext(result))
#define log_error(format, ...) log_write(ISC_LOG_ERROR, format, ##__VA_ARGS__)
result = publish_zone(inst, raw);
if (result != ISC_R_SUCCESS) {
dns_zone_log(raw, ISC_LOG_ERROR, "cannot add zone to view: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
#include <isc/types.h>
#include <isc/util.h>
-#include <dns/result.h>
-
#include <ns/client.h>
#include <ns/events.h>
#include <ns/hooks.h>
#include <isc/log.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/util.h>
#include <dns/db.h>
#include <dns/journal.h>
#include <dns/log.h>
#include <dns/name.h>
-#include <dns/result.h>
#include <dns/types.h>
#define CHECK(r) \
CHECK(isc_log_usechannel(logconfig, "stderr", NULL, NULL));
- dns_result_register();
-
result = loadzone(&olddb, origin, file1);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "Couldn't load %s: ", file1);
#include <isc/netmgr.h>
#include <isc/parseint.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/sockaddr.h>
#include <isc/task.h>
#include <isc/util.h>
#include <dns/types.h>
#include <dns/view.h>
-#include <dst/result.h>
-
#define CHECK(str, x) \
{ \
if ((x) != ISC_R_SUCCESS) { \
CHECK("dns_request_getresponse", result);
if (response->rcode != dns_rcode_noerror) {
- result = ISC_RESULTCLASS_DNSRCODE + response->rcode;
+ result = dns_result_fromrcode(response->rcode);
fprintf(stderr, "I:response rcode: %s\n",
isc_result_totext(result));
exit(-1);
have_src = true;
}
- dns_result_register();
-
isc_sockaddr_any(&bind_any);
result = ISC_R_FAILURE;
#include <isc/mem.h>
#include <isc/netmgr.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/sockaddr.h>
#include <isc/task.h>
#include <isc/timer.h>
#include <dns/rdataset.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/secalg.h>
#include <dst/dst.h>
resopt, &namelist);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "resolution failed: %s\n",
- dns_result_totext(result));
+ isc_result_totext(result));
}
for (name = ISC_LIST_HEAD(namelist); name != NULL;
name = ISC_LIST_NEXT(name, link))
#include <openssl/objects.h>
#include <openssl/rsa.h>
+#include <isc/result.h>
+
#include <dns/dnssec.h>
#include <dns/fixedname.h>
#include <dns/keyvalues.h>
#include <dns/log.h>
#include <dns/name.h>
#include <dns/rdataclass.h>
-#include <dns/result.h>
#include <dns/secalg.h>
#include <dst/dst.h>
-#include <dst/result.h>
dst_key_t *key;
dns_fixedname_t fname;
exit(1);
}
- dns_result_register();
-
isc_mem_create(&mctx);
CHECK(dst_lib_init(mctx, NULL), "dst_lib_init()");
isc_log_create(mctx, &log_, &logconfig);
#include <isc/nonce.h>
#include <isc/print.h>
#include <isc/random.h>
+#include <isc/result.h>
#include <isc/sockaddr.h>
#include <isc/task.h>
#include <isc/util.h>
#include <dns/tsig.h>
#include <dns/view.h>
-#include <dst/result.h>
-
#define CHECK(str, x) \
{ \
if ((x) != ISC_R_SUCCESS) { \
CHECK("dns_request_getresponse", result);
if (response->rcode != dns_rcode_noerror) {
- result = ISC_RESULTCLASS_DNSRCODE + response->rcode;
+ result = dns_result_fromrcode(response->rcode);
fprintf(stderr, "I:response rcode: %s\n",
isc_result_totext(result));
exit(-1);
ownername_str = argv[4];
}
- dns_result_register();
-
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
isc_mem_create(&mctx);
#include <isc/netmgr.h>
#include <isc/print.h>
#include <isc/random.h>
+#include <isc/result.h>
#include <isc/sockaddr.h>
#include <isc/task.h>
#include <isc/util.h>
#include <dns/tsig.h>
#include <dns/view.h>
-#include <dst/result.h>
-
#define CHECK(str, x) \
{ \
if ((x) != ISC_R_SUCCESS) { \
CHECK("dns_request_getresponse", result);
if (response->rcode != dns_rcode_noerror) {
- result = ISC_RESULTCLASS_DNSRCODE + response->rcode;
+ result = dns_result_fromrcode(response->rcode);
fprintf(stderr, "I:response rcode: %s\n",
isc_result_totext(result));
exit(-1);
port = atoi(argv[2]);
keyname = argv[3];
- dns_result_register();
-
isc_mem_create(&mctx);
isc_log_create(mctx, &log, &logconfig);
#include <isc/file.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/message.h>
-#include <dns/result.h>
int parseflags = 0;
isc_mem_t *mctx = NULL;
static inline void
CHECKRESULT(isc_result_t result, const char *msg) {
if (result != ISC_R_SUCCESS) {
- printf("%s: %s\n", msg, dns_result_totext(result));
+ printf("%s: %s\n", msg, isc_result_totext(result));
exit(1);
}
#include <isc/hex.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/masterdump.h>
#include <dns/message.h>
#include <dns/name.h>
-#include <dns/result.h>
#include "dnstap.pb-c.h"
isc_mem_create(&mctx);
- dns_result_register();
-
CHECKM(dns_dt_open(argv[0], dns_dtmode_file, mctx, &handle),
"dns_dt_openfile");
#include <isc/parseint.h>
#include <isc/print.h>
#include <isc/random.h>
+#include <isc/result.h>
#include <isc/sockaddr.h>
#include <isc/string.h>
#include <isc/task.h>
#include <dns/rdatatype.h>
#include <dns/request.h>
#include <dns/resolver.h>
-#include <dns/result.h>
#include <dns/types.h>
#include <dns/view.h>
-#include <dst/result.h>
-
#include <bind9/getaddresses.h>
#define CHECK(str, x) \
RUNCHECK(isc_app_start());
- dns_result_register();
-
if (isc_net_probeipv4() == ISC_R_SUCCESS) {
have_ipv4 = true;
}
#include <isc/log.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/util.h>
#include <dns/journal.h>
#include <dns/log.h>
-#include <dns/result.h>
#include <dns/types.h>
const char *progname = NULL;
} else {
result = dns_journal_print(mctx, flags, file, stdout);
if (result == DNS_R_NOJOURNAL) {
- fprintf(stderr, "%s\n", dns_result_totext(result));
+ fprintf(stderr, "%s\n", isc_result_totext(result));
}
}
isc_log_destroy(&lctx);
#include <isc/lex.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/rdata.h>
#include <dns/rdataclass.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
static isc_mem_t *mctx;
static isc_lex_t *lex;
result = dns_name_fromstring(name, origin, 0, NULL);
if (result != ISC_R_SUCCESS) {
fatal("dns_name_fromstring: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
}
&rdclass, &token.value.as_textregion);
if (result != ISC_R_SUCCESS) {
fatal("dns_rdataclass_fromtext: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
if (dns_rdataclass_ismeta(rdclass)) {
fatal("class %.*s(%d) is a meta value",
&rdtype, &token.value.as_textregion);
if (result != ISC_R_SUCCESS) {
fatal("dns_rdatatype_fromtext: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
if (dns_rdatatype_ismeta(rdtype)) {
fatal("type %.*s(%d) is a meta value",
0, mctx, &dbuf, NULL);
if (result != ISC_R_SUCCESS) {
fatal("dns_rdata_fromtext: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
once = true;
}
result = dns_rdataclass_totext(rdclass, &tbuf);
if (result != ISC_R_SUCCESS) {
fatal("dns_rdataclass_totext: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
isc_buffer_putstr(&tbuf, "\t");
result = dns_rdatatype_totext(rdtype, &tbuf);
if (result != ISC_R_SUCCESS) {
fatal("dns_rdatatype_totext: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
isc_buffer_putstr(&tbuf, "\t");
result = dns_rdata_totext(&rdata, NULL, &tbuf);
if (result != ISC_R_SUCCESS) {
fatal("dns_rdata_totext: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
printf("%.*s\n", (int)tbuf.used, (char *)tbuf.base);
result = dns_rdataclass_tounknowntext(rdclass, &tbuf);
if (result != ISC_R_SUCCESS) {
fatal("dns_rdataclass_tounknowntext: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
isc_buffer_putstr(&tbuf, "\t");
result = dns_rdatatype_tounknowntext(rdtype, &tbuf);
if (result != ISC_R_SUCCESS) {
fatal("dns_rdatatype_tounknowntext: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
isc_buffer_putstr(&tbuf, "\t");
result = dns_rdata_tofmttext(&rdata, NULL,
"", &tbuf);
if (result != ISC_R_SUCCESS) {
fatal("dns_rdata_tofmttext: %sn",
- dns_result_totext(result));
+ isc_result_totext(result));
}
printf("%.*s\n", (int)tbuf.used, (char *)tbuf.base);
lib/dns/tests/Makefile
lib/ns/tests/Makefile
lib/irs/tests/Makefile
- lib/isccc/tests/Makefile
lib/isccfg/tests/Makefile])
AC_CONFIG_FILES([lib/unit-test-driver.sh],
When available, include standard library return codes via %s in the
format string, with strerrr(errno) from the system library or functions
-like isc_result_totext(result) and dns_result_totext(result).
+like isc_result_totext(result) and isc_result_totext(result).
THINGS I AM NOT KEEN ABOUT
#include <isc/file.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/message.h>
-#include <dns/result.h>
#include "fuzz.h"
#include <dns/rbt.h>
#include <dns/rdataclass.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/rrl.h>
#include <dns/secalg.h>
#include <dns/ssu.h>
#include <dst/dst.h>
-#include <dst/result.h>
#include <isccfg/aclconf.h>
#include <isccfg/cfg.h>
dstdir = $(includedir)/dst
dst_HEADERS = \
include/dst/dst.h \
- include/dst/gssapi.h \
- include/dst/result.h
+ include/dst/gssapi.h
libdns_la_SOURCES = \
$(libdns_la_HEADERS) \
dst_openssl.h \
dst_parse.c \
dst_parse.h \
- dst_result.c \
dyndb.c \
ecs.c \
fixedname.c \
#include <isc/netaddr.h>
#include <isc/print.h>
#include <isc/random.h>
+#include <isc/result.h>
#include <isc/stats.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
#include <isc/task.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
#include <dns/resolver.h>
-#include <dns/result.h>
#include <dns/stats.h>
#define DNS_ADB_MAGIC ISC_MAGIC('D', 'a', 'd', 'b')
adbname->fetch6_err = FIND_ERR_SUCCESS;
}
break;
+ default:
+ break;
}
if (dns_rdataset_isassociated(&rdataset)) {
dns_name_format(&name->name, buf, sizeof(buf));
DP(DEF_LEVEL, "adb: fetch of '%s' %s failed: %s", buf,
address_type == DNS_ADBFIND_INET ? "A" : "AAAA",
- dns_result_totext(dev->result));
+ isc_result_totext(dev->result));
/*
* Don't record a failure unless this is the initial
* fetch of a chain.
#include <isc/mem.h>
#include <isc/netaddr.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
#include <isc/task.h>
#include <isc/util.h>
#include <dns/rdataset.h>
#include <dns/rdatastruct.h>
#include <dns/resolver.h>
-#include <dns/result.h>
#include <dns/view.h>
/*
#include <isc/mem.h>
#include <isc/print.h>
#include <isc/refcount.h>
+#include <isc/result.h>
#include <isc/stats.h>
#include <isc/string.h>
#include <isc/task.h>
#include <dns/rdata.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
-#include <dns/result.h>
#include <dns/stats.h>
#ifdef HAVE_JSON_C
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR(__FILE__, __LINE__,
"isc_task_create() failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
result = ISC_R_UNEXPECTED;
goto cleanup;
}
UNEXPECTED_ERROR(__FILE__, __LINE__,
"cache cleaner: "
"isc_task_onshutdown() failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
UNEXPECTED_ERROR(__FILE__, __LINE__,
"cache cleaner: "
"dns_dbiterator_first() failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
dns_dbiterator_destroy(&cleaner->iterator);
} else if (cleaner->iterator != NULL) {
result = dns_dbiterator_pause(cleaner->iterator);
"cache cleaner: "
"dns_dbiterator_current() "
"failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
end_cleaning(cleaner, event);
return;
"cache cleaner: "
"dns_dbiterator_next() "
"failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
} else if (cleaner->overmem) {
result =
dns_dbiterator_first(cleaner->iterator);
UNEXPECTED_ERROR(__FILE__, __LINE__,
"cache cleaner: dns_db_expirenode() "
"failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
/*
* Continue anyway.
*/
#include <isc/mutex.h>
#include <isc/portset.h>
#include <isc/refcount.h>
+#include <isc/result.h>
#include <isc/safe.h>
#include <isc/sockaddr.h>
#include <isc/socket.h>
#include <dns/rdatatype.h>
#include <dns/request.h>
#include <dns/resolver.h>
-#include <dns/result.h>
#include <dns/tsec.h>
#include <dns/tsig.h>
#include <dns/view.h>
#include <stdbool.h>
#include <isc/mem.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/compress.h>
#include <dns/fixedname.h>
#include <dns/rbt.h>
-#include <dns/result.h>
#define CCTX_MAGIC ISC_MAGIC('C', 'C', 'T', 'X')
#define VALID_CCTX(x) ISC_MAGIC_VALID(x, CCTX_MAGIC)
#include <isc/buffer.h>
#include <isc/mem.h>
#include <isc/once.h>
+#include <isc/result.h>
#include <isc/rwlock.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/rdata.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
-#include <dns/result.h>
/***
*** Private Types
#include <isc/file.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/rdataset.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/time.h>
#define CHECK(op) \
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR(__FILE__, __LINE__,
"diff_tuple_tordataset failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
result = ISC_R_UNEXPECTED;
goto cleanup;
}
#include <isc/list.h>
#include <isc/mem.h>
#include <isc/netaddr.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/dns64.h>
#include <dns/rdata.h>
#include <dns/rdataset.h>
-#include <dns/result.h>
struct dns_dns64 {
unsigned char bits[16]; /*
#include <dns/db.h>
#define LIBRPZ_LIB_OPEN DNSRPS_LIB_OPEN
+#include <isc/result.h>
+
#include <dns/dnsrps.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
-#include <dns/result.h>
#include <dns/rpz.h>
librpz_t *librpz;
#include <isc/dir.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/serial.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/rdatalist.h>
#include <dns/rdataset.h>
#include <dns/rdatastruct.h>
-#include <dns/result.h>
#include <dns/stats.h>
#include <dns/tsig.h> /* for DNS_TSIG_FUDGE */
-#include <dst/result.h>
-
isc_stats_t *dns_dnssec_stats;
#define is_response(msg) ((msg->flags & DNS_MESSAGEFLAG_QR) != 0)
#include <isc/mutex.h>
#include <isc/once.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/sockaddr.h>
#include <isc/task.h>
#include <isc/thread.h>
#include <dns/message.h>
#include <dns/name.h>
#include <dns/rdataset.h>
-#include <dns/result.h>
#include <dns/stats.h>
#include <dns/types.h>
#include <dns/view.h>
#include <isc/buffer.h>
#include <isc/md.h>
#include <isc/region.h>
+#include <isc/result.h>
#include <isc/util.h>
#include <dns/ds.h>
#include <dns/name.h>
#include <dns/rdata.h>
#include <dns/rdatastruct.h>
-#include <dns/result.h>
#include <dst/dst.h>
#define DST_KEY_INTERNAL
+#include <isc/result.h>
+
#include <dns/fixedname.h>
#include <dns/keyvalues.h>
#include <dns/name.h>
#include <dns/ttl.h>
#include <dns/types.h>
-#include <dst/result.h>
-
#include "dst_internal.h"
#define DST_AS_STR(t) ((t).value.as_textregion.base)
UNUSED(engine);
- dst_result_register();
-
memset(dst_t_func, 0, sizeof(dst_t_func));
RETERR(dst__hmacmd5_init(&dst_t_func[DST_ALG_HMACMD5]));
RETERR(dst__hmacsha1_init(&dst_t_func[DST_ALG_HMACSHA1]));
#include <dns/log.h>
#include <dns/time.h>
-#include "dst/result.h"
#include "dst_internal.h"
+#include "isc/result.h"
#define DST_AS_STR(t) ((t).value.as_textregion.base)
+++ /dev/null
-/*
- * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, you can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-#include <isc/once.h>
-#include <isc/util.h>
-
-#include <dst/result.h>
-
-static const char *text[DST_R_NRESULTS] = {
- "algorithm is unsupported", /*%< 0 */
- "crypto failure", /*%< 1 */
- "built with no crypto support", /*%< 2 */
- "illegal operation for a null key", /*%< 3 */
- "public key is invalid", /*%< 4 */
- "private key is invalid", /*%< 5 */
- "external key", /*%< 6 */
- "error occurred writing key to disk", /*%< 7 */
- "invalid algorithm specific parameter", /*%< 8 */
- "UNUSED9", /*%< 9 */
- "UNUSED10", /*%< 10 */
- "sign failure", /*%< 11 */
- "UNUSED12", /*%< 12 */
- "UNUSED13", /*%< 13 */
- "verify failure", /*%< 14 */
- "not a public key", /*%< 15 */
- "not a private key", /*%< 16 */
- "not a key that can compute a secret", /*%< 17 */
- "failure computing a shared secret", /*%< 18 */
- "no randomness available", /*%< 19 */
- "bad key type", /*%< 20 */
- "no engine", /*%< 21 */
- "illegal operation for an external key", /*%< 22 */
-};
-
-static const char *ids[DST_R_NRESULTS] = {
- "DST_R_UNSUPPORTEDALG",
- "DST_R_CRYPTOFAILURE",
- "DST_R_NOCRYPTO",
- "DST_R_NULLKEY",
- "DST_R_INVALIDPUBLICKEY",
- "DST_R_INVALIDPRIVATEKEY",
- "UNUSED",
- "DST_R_WRITEERROR",
- "DST_R_INVALIDPARAM",
- "UNUSED",
- "UNUSED",
- "DST_R_SIGNFAILURE",
- "UNUSED",
- "UNUSED",
- "DST_R_VERIFYFAILURE",
- "DST_R_NOTPUBLICKEY",
- "DST_R_NOTPRIVATEKEY",
- "DST_R_KEYCANNOTCOMPUTESECRET",
- "DST_R_COMPUTESECRETFAILURE",
- "DST_R_NORANDOMNESS",
- "DST_R_BADKEYTYPE",
- "DST_R_NOENGINE",
- "DST_R_EXTERNALKEY",
-};
-
-#define DST_RESULT_RESULTSET 2
-
-static isc_once_t once = ISC_ONCE_INIT;
-
-static void
-initialize_action(void) {
- isc_result_t result;
-
- result = isc_result_register(ISC_RESULTCLASS_DST, DST_R_NRESULTS, text,
- DST_RESULT_RESULTSET);
- if (result != ISC_R_SUCCESS) {
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "isc_result_register() failed: %u", result);
- }
- result = isc_result_registerids(ISC_RESULTCLASS_DST, DST_R_NRESULTS,
- ids, DST_RESULT_RESULTSET);
- if (result != ISC_R_SUCCESS) {
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "isc_result_registerids() failed: %u", result);
- }
-}
-
-static void
-initialize(void) {
- RUNTIME_CHECK(isc_once_do(&once, initialize_action) == ISC_R_SUCCESS);
-}
-
-const char *
-dst_result_totext(isc_result_t result) {
- initialize();
-
- return (isc_result_totext(result));
-}
-
-void
-dst_result_register(void) {
- initialize();
-}
-
-/*! \file */
#include <isc/magic.h>
#include <isc/mem.h>
+#include <isc/result.h>
#include <isc/rwlock.h>
#include <isc/util.h>
#include <dns/forward.h>
#include <dns/rbt.h>
-#include <dns/result.h>
#include <dns/types.h>
struct dns_fwdtable {
#include <isc/buffer.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dst/gssapi.h>
-#include <dst/result.h>
#include "dst_internal.h"
#include "dst_parse.h"
#include <isc/once.h>
#include <isc/print.h>
#include <isc/random.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/time.h>
#include <isc/util.h>
#include <dns/name.h>
#include <dns/rdata.h>
#include <dns/rdataclass.h>
-#include <dns/result.h>
#include <dns/types.h>
#include <dst/gssapi.h>
-#include <dst/result.h>
#include "dst_internal.h"
#include <isc/mem.h>
#include <isc/nonce.h>
#include <isc/random.h>
+#include <isc/result.h>
#include <isc/safe.h>
#include <isc/string.h>
#include <isc/util.h>
-#include <dst/result.h>
-
#include "dst_internal.h"
#ifdef HAVE_FIPS_MODE
#include "dst_openssl.h" /* FIPS_mode() prototype */
/*! \file dns/result.h */
#include <isc/lang.h>
-#include <isc/resultclass.h>
+#include <isc/result.h>
#include <dns/types.h>
-/*
- * Nothing in this file truly depends on <isc/result.h>, but the
- * DNS result codes are considered to be publicly derived from
- * the ISC result codes, so including this file buys you the ISC_R_
- * namespace too.
- */
-#include <isc/result.h> /* Contractual promise. */
-
-/*
- * DNS library result codes
- */
-#define DNS_R_LABELTOOLONG (ISC_RESULTCLASS_DNS + 0)
-#define DNS_R_BADESCAPE (ISC_RESULTCLASS_DNS + 1)
-/*
- * Since we dropped the support of bitstring labels, deprecate the related
- * result codes too.
- *
- #define DNS_R_BADBITSTRING (ISC_RESULTCLASS_DNS + 2)
- #define DNS_R_BITSTRINGTOOLONG (ISC_RESULTCLASS_DNS + 3)
- */
-#define DNS_R_EMPTYLABEL (ISC_RESULTCLASS_DNS + 4)
-#define DNS_R_BADDOTTEDQUAD (ISC_RESULTCLASS_DNS + 5)
-#define DNS_R_INVALIDNS (ISC_RESULTCLASS_DNS + 6)
-#define DNS_R_UNKNOWN (ISC_RESULTCLASS_DNS + 7)
-#define DNS_R_BADLABELTYPE (ISC_RESULTCLASS_DNS + 8)
-#define DNS_R_BADPOINTER (ISC_RESULTCLASS_DNS + 9)
-#define DNS_R_TOOMANYHOPS (ISC_RESULTCLASS_DNS + 10)
-#define DNS_R_DISALLOWED (ISC_RESULTCLASS_DNS + 11)
-#define DNS_R_EXTRATOKEN (ISC_RESULTCLASS_DNS + 12)
-#define DNS_R_EXTRADATA (ISC_RESULTCLASS_DNS + 13)
-#define DNS_R_TEXTTOOLONG (ISC_RESULTCLASS_DNS + 14)
-#define DNS_R_NOTZONETOP (ISC_RESULTCLASS_DNS + 15)
-#define DNS_R_SYNTAX (ISC_RESULTCLASS_DNS + 16)
-#define DNS_R_BADCKSUM (ISC_RESULTCLASS_DNS + 17)
-#define DNS_R_BADAAAA (ISC_RESULTCLASS_DNS + 18)
-#define DNS_R_NOOWNER (ISC_RESULTCLASS_DNS + 19)
-#define DNS_R_NOTTL (ISC_RESULTCLASS_DNS + 20)
-#define DNS_R_BADCLASS (ISC_RESULTCLASS_DNS + 21)
-#define DNS_R_NAMETOOLONG (ISC_RESULTCLASS_DNS + 22)
-#define DNS_R_PARTIALMATCH (ISC_RESULTCLASS_DNS + 23)
-#define DNS_R_NEWORIGIN (ISC_RESULTCLASS_DNS + 24)
-#define DNS_R_UNCHANGED (ISC_RESULTCLASS_DNS + 25)
-#define DNS_R_BADTTL (ISC_RESULTCLASS_DNS + 26)
-#define DNS_R_NOREDATA (ISC_RESULTCLASS_DNS + 27)
-#define DNS_R_CONTINUE (ISC_RESULTCLASS_DNS + 28)
-#define DNS_R_DELEGATION (ISC_RESULTCLASS_DNS + 29)
-#define DNS_R_GLUE (ISC_RESULTCLASS_DNS + 30)
-#define DNS_R_DNAME (ISC_RESULTCLASS_DNS + 31)
-#define DNS_R_CNAME (ISC_RESULTCLASS_DNS + 32)
-#define DNS_R_BADDB (ISC_RESULTCLASS_DNS + 33)
-#define DNS_R_ZONECUT (ISC_RESULTCLASS_DNS + 34)
-#define DNS_R_BADZONE (ISC_RESULTCLASS_DNS + 35)
-#define DNS_R_MOREDATA (ISC_RESULTCLASS_DNS + 36)
-#define DNS_R_UPTODATE (ISC_RESULTCLASS_DNS + 37)
-#define DNS_R_TSIGVERIFYFAILURE (ISC_RESULTCLASS_DNS + 38)
-#define DNS_R_TSIGERRORSET (ISC_RESULTCLASS_DNS + 39)
-#define DNS_R_SIGINVALID (ISC_RESULTCLASS_DNS + 40)
-#define DNS_R_SIGEXPIRED (ISC_RESULTCLASS_DNS + 41)
-#define DNS_R_SIGFUTURE (ISC_RESULTCLASS_DNS + 42)
-#define DNS_R_KEYUNAUTHORIZED (ISC_RESULTCLASS_DNS + 43)
-#define DNS_R_INVALIDTIME (ISC_RESULTCLASS_DNS + 44)
-#define DNS_R_EXPECTEDTSIG (ISC_RESULTCLASS_DNS + 45)
-#define DNS_R_UNEXPECTEDTSIG (ISC_RESULTCLASS_DNS + 46)
-#define DNS_R_INVALIDTKEY (ISC_RESULTCLASS_DNS + 47)
-#define DNS_R_HINT (ISC_RESULTCLASS_DNS + 48)
-#define DNS_R_DROP (ISC_RESULTCLASS_DNS + 49)
-#define DNS_R_NOTLOADED (ISC_RESULTCLASS_DNS + 50)
-#define DNS_R_NCACHENXDOMAIN (ISC_RESULTCLASS_DNS + 51)
-#define DNS_R_NCACHENXRRSET (ISC_RESULTCLASS_DNS + 52)
-#define DNS_R_WAIT (ISC_RESULTCLASS_DNS + 53)
-#define DNS_R_NOTVERIFIEDYET (ISC_RESULTCLASS_DNS + 54)
-#define DNS_R_NOIDENTITY (ISC_RESULTCLASS_DNS + 55)
-#define DNS_R_NOJOURNAL (ISC_RESULTCLASS_DNS + 56)
-#define DNS_R_ALIAS (ISC_RESULTCLASS_DNS + 57)
-#define DNS_R_USETCP (ISC_RESULTCLASS_DNS + 58)
-#define DNS_R_NOVALIDSIG (ISC_RESULTCLASS_DNS + 59)
-#define DNS_R_NOVALIDNSEC (ISC_RESULTCLASS_DNS + 60)
-#define DNS_R_NOTINSECURE (ISC_RESULTCLASS_DNS + 61)
-#define DNS_R_UNKNOWNSERVICE (ISC_RESULTCLASS_DNS + 62)
-#define DNS_R_RECOVERABLE (ISC_RESULTCLASS_DNS + 63)
-#define DNS_R_UNKNOWNOPT (ISC_RESULTCLASS_DNS + 64)
-#define DNS_R_UNEXPECTEDID (ISC_RESULTCLASS_DNS + 65)
-#define DNS_R_SEENINCLUDE (ISC_RESULTCLASS_DNS + 66)
-#define DNS_R_NOTEXACT (ISC_RESULTCLASS_DNS + 67)
-#define DNS_R_BLACKHOLED (ISC_RESULTCLASS_DNS + 68)
-#define DNS_R_BADALG (ISC_RESULTCLASS_DNS + 69)
-#define DNS_R_METATYPE (ISC_RESULTCLASS_DNS + 70)
-#define DNS_R_CNAMEANDOTHER (ISC_RESULTCLASS_DNS + 71)
-#define DNS_R_SINGLETON (ISC_RESULTCLASS_DNS + 72)
-#define DNS_R_HINTNXRRSET (ISC_RESULTCLASS_DNS + 73)
-#define DNS_R_NOMASTERFILE (ISC_RESULTCLASS_DNS + 74)
-#define DNS_R_UNKNOWNPROTO (ISC_RESULTCLASS_DNS + 75)
-#define DNS_R_CLOCKSKEW (ISC_RESULTCLASS_DNS + 76)
-#define DNS_R_BADIXFR (ISC_RESULTCLASS_DNS + 77)
-#define DNS_R_NOTAUTHORITATIVE (ISC_RESULTCLASS_DNS + 78)
-#define DNS_R_NOVALIDKEY (ISC_RESULTCLASS_DNS + 79)
-#define DNS_R_OBSOLETE (ISC_RESULTCLASS_DNS + 80)
-#define DNS_R_FROZEN (ISC_RESULTCLASS_DNS + 81)
-#define DNS_R_UNKNOWNFLAG (ISC_RESULTCLASS_DNS + 82)
-#define DNS_R_EXPECTEDRESPONSE (ISC_RESULTCLASS_DNS + 83)
-#define DNS_R_NOVALIDDS (ISC_RESULTCLASS_DNS + 84)
-#define DNS_R_NSISADDRESS (ISC_RESULTCLASS_DNS + 85)
-#define DNS_R_REMOTEFORMERR (ISC_RESULTCLASS_DNS + 86)
-#define DNS_R_TRUNCATEDTCP (ISC_RESULTCLASS_DNS + 87)
-#define DNS_R_LAME (ISC_RESULTCLASS_DNS + 88)
-#define DNS_R_UNEXPECTEDRCODE (ISC_RESULTCLASS_DNS + 89)
-#define DNS_R_UNEXPECTEDOPCODE (ISC_RESULTCLASS_DNS + 90)
-#define DNS_R_CHASEDSSERVERS (ISC_RESULTCLASS_DNS + 91)
-#define DNS_R_EMPTYNAME (ISC_RESULTCLASS_DNS + 92)
-#define DNS_R_EMPTYWILD (ISC_RESULTCLASS_DNS + 93)
-#define DNS_R_BADBITMAP (ISC_RESULTCLASS_DNS + 94)
-#define DNS_R_FROMWILDCARD (ISC_RESULTCLASS_DNS + 95)
-#define DNS_R_BADOWNERNAME (ISC_RESULTCLASS_DNS + 96)
-#define DNS_R_BADNAME (ISC_RESULTCLASS_DNS + 97)
-#define DNS_R_DYNAMIC (ISC_RESULTCLASS_DNS + 98)
-#define DNS_R_UNKNOWNCOMMAND (ISC_RESULTCLASS_DNS + 99)
-#define DNS_R_MUSTBESECURE (ISC_RESULTCLASS_DNS + 100)
-#define DNS_R_COVERINGNSEC (ISC_RESULTCLASS_DNS + 101)
-#define DNS_R_MXISADDRESS (ISC_RESULTCLASS_DNS + 102)
-#define DNS_R_DUPLICATE (ISC_RESULTCLASS_DNS + 103)
-#define DNS_R_INVALIDNSEC3 (ISC_RESULTCLASS_DNS + 104)
-#define DNS_R_NOTMASTER (ISC_RESULTCLASS_DNS + 105)
-#define DNS_R_BROKENCHAIN (ISC_RESULTCLASS_DNS + 106)
-#define DNS_R_EXPIRED (ISC_RESULTCLASS_DNS + 107)
-#define DNS_R_NOTDYNAMIC (ISC_RESULTCLASS_DNS + 108)
-#define DNS_R_BADEUI (ISC_RESULTCLASS_DNS + 109)
-#define DNS_R_NTACOVERED (ISC_RESULTCLASS_DNS + 110)
-#define DNS_R_BADCDS (ISC_RESULTCLASS_DNS + 111)
-#define DNS_R_BADCDNSKEY (ISC_RESULTCLASS_DNS + 112)
-#define DNS_R_OPTERR (ISC_RESULTCLASS_DNS + 113)
-#define DNS_R_BADDNSTAP (ISC_RESULTCLASS_DNS + 114)
-#define DNS_R_BADTSIG (ISC_RESULTCLASS_DNS + 115)
-#define DNS_R_BADSIG0 (ISC_RESULTCLASS_DNS + 116)
-#define DNS_R_TOOMANYRECORDS (ISC_RESULTCLASS_DNS + 117)
-#define DNS_R_VERIFYFAILURE (ISC_RESULTCLASS_DNS + 118)
-#define DNS_R_ATZONETOP (ISC_RESULTCLASS_DNS + 119)
-#define DNS_R_NOKEYMATCH (ISC_RESULTCLASS_DNS + 120)
-#define DNS_R_TOOMANYKEYS (ISC_RESULTCLASS_DNS + 121)
-#define DNS_R_KEYNOTACTIVE (ISC_RESULTCLASS_DNS + 122)
-#define DNS_R_NSEC3ITERRANGE (ISC_RESULTCLASS_DNS + 123)
-#define DNS_R_NSEC3SALTRANGE (ISC_RESULTCLASS_DNS + 124)
-#define DNS_R_NSEC3BADALG (ISC_RESULTCLASS_DNS + 125)
-#define DNS_R_NSEC3RESALT (ISC_RESULTCLASS_DNS + 126)
-#define DNS_R_INCONSISTENTRR (ISC_RESULTCLASS_DNS + 127)
-
-#define DNS_R_NRESULTS 128 /*%< Number of results */
-
-/*
- * DNS wire format rcodes.
- *
- * By making these their own class we can easily convert them into the
- * wire-format rcode value simply by masking off the resultclass.
- */
-#define DNS_R_NOERROR (ISC_RESULTCLASS_DNSRCODE + 0)
-#define DNS_R_FORMERR (ISC_RESULTCLASS_DNSRCODE + 1)
-#define DNS_R_SERVFAIL (ISC_RESULTCLASS_DNSRCODE + 2)
-#define DNS_R_NXDOMAIN (ISC_RESULTCLASS_DNSRCODE + 3)
-#define DNS_R_NOTIMP (ISC_RESULTCLASS_DNSRCODE + 4)
-#define DNS_R_REFUSED (ISC_RESULTCLASS_DNSRCODE + 5)
-#define DNS_R_YXDOMAIN (ISC_RESULTCLASS_DNSRCODE + 6)
-#define DNS_R_YXRRSET (ISC_RESULTCLASS_DNSRCODE + 7)
-#define DNS_R_NXRRSET (ISC_RESULTCLASS_DNSRCODE + 8)
-#define DNS_R_NOTAUTH (ISC_RESULTCLASS_DNSRCODE + 9)
-#define DNS_R_NOTZONE (ISC_RESULTCLASS_DNSRCODE + 10)
-#define DNS_R_RCODE11 (ISC_RESULTCLASS_DNSRCODE + 11)
-#define DNS_R_RCODE12 (ISC_RESULTCLASS_DNSRCODE + 12)
-#define DNS_R_RCODE13 (ISC_RESULTCLASS_DNSRCODE + 13)
-#define DNS_R_RCODE14 (ISC_RESULTCLASS_DNSRCODE + 14)
-#define DNS_R_RCODE15 (ISC_RESULTCLASS_DNSRCODE + 15)
-#define DNS_R_BADVERS (ISC_RESULTCLASS_DNSRCODE + 16)
-
-#define DNS_R_NRCODERESULTS 17 /*%< Number of rcode results */
-
-#define DNS_RESULT_ISRCODE(result) \
- (ISC_RESULTCLASS_INCLASS(ISC_RESULTCLASS_DNSRCODE, (result)))
-
ISC_LANG_BEGINDECLS
-const char *dns_result_totext(isc_result_t);
-
-void
-dns_result_register(void);
-
dns_rcode_t
dns_result_torcode(isc_result_t result);
+isc_result_t
+dns_result_fromrcode(dns_rcode_t rcode);
+
ISC_LANG_ENDDECLS
#endif /* DNS_RESULT_H */
+++ /dev/null
-/*
- * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, you can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-#ifndef DST_RESULT_H
-#define DST_RESULT_H 1
-
-/*! \file dst/result.h */
-
-#include <isc/lang.h>
-#include <isc/resultclass.h>
-
-/*
- * Nothing in this file truly depends on <isc/result.h>, but the
- * DST result codes are considered to be publicly derived from
- * the ISC result codes, so including this file buys you the ISC_R_
- * namespace too.
- */
-#include <isc/result.h> /* Contractual promise. */
-
-#define DST_R_UNSUPPORTEDALG (ISC_RESULTCLASS_DST + 0)
-#define DST_R_CRYPTOFAILURE (ISC_RESULTCLASS_DST + 1)
-/* compat */
-#define DST_R_OPENSSLFAILURE DST_R_CRYPTOFAILURE
-#define DST_R_NOCRYPTO (ISC_RESULTCLASS_DST + 2)
-#define DST_R_NULLKEY (ISC_RESULTCLASS_DST + 3)
-#define DST_R_INVALIDPUBLICKEY (ISC_RESULTCLASS_DST + 4)
-#define DST_R_INVALIDPRIVATEKEY (ISC_RESULTCLASS_DST + 5)
-/* 6 is unused */
-#define DST_R_WRITEERROR (ISC_RESULTCLASS_DST + 7)
-#define DST_R_INVALIDPARAM (ISC_RESULTCLASS_DST + 8)
-/* 9 is unused */
-/* 10 is unused */
-#define DST_R_SIGNFAILURE (ISC_RESULTCLASS_DST + 11)
-/* 12 is unused */
-/* 13 is unused */
-#define DST_R_VERIFYFAILURE (ISC_RESULTCLASS_DST + 14)
-#define DST_R_NOTPUBLICKEY (ISC_RESULTCLASS_DST + 15)
-#define DST_R_NOTPRIVATEKEY (ISC_RESULTCLASS_DST + 16)
-#define DST_R_KEYCANNOTCOMPUTESECRET (ISC_RESULTCLASS_DST + 17)
-#define DST_R_COMPUTESECRETFAILURE (ISC_RESULTCLASS_DST + 18)
-#define DST_R_NORANDOMNESS (ISC_RESULTCLASS_DST + 19)
-#define DST_R_BADKEYTYPE (ISC_RESULTCLASS_DST + 20)
-#define DST_R_NOENGINE (ISC_RESULTCLASS_DST + 21)
-#define DST_R_EXTERNALKEY (ISC_RESULTCLASS_DST + 22)
-
-#define DST_R_NRESULTS 23 /* Number of results */
-
-ISC_LANG_BEGINDECLS
-
-const char *dst_result_totext(isc_result_t);
-
-void
-dst_result_register(void);
-
-ISC_LANG_ENDDECLS
-
-#endif /* DST_RESULT_H */
#include <isc/file.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/serial.h>
#include <isc/stdio.h>
#include <isc/string.h>
#include <dns/log.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
-#include <dns/result.h>
#include <dns/soa.h>
/*! \file
#include <isc/dir.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/keymgr.h>
#include <dns/keyvalues.h>
#include <dns/log.h>
-#include <dns/result.h>
#include <dst/dst.h>
-#include <dst/result.h>
#define RETERR(x) \
do { \
#include <isc/mem.h>
#include <isc/print.h>
#include <isc/refcount.h>
+#include <isc/result.h>
#include <isc/rwlock.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
#include <isc/util.h>
#include <dns/rdatalist.h>
#include <dns/rdataset.h>
#include <dns/rdatastruct.h>
-#include <dns/result.h>
#define KEYTABLE_MAGIC ISC_MAGIC('K', 'T', 'b', 'l')
#define VALID_KEYTABLE(kt) ISC_MAGIC_VALID(kt, KEYTABLE_MAGIC)
#include <isc/mem.h>
#include <isc/netaddr.h>
+#include <isc/result.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
#include <isc/task.h>
#include <isc/util.h>
#include <dns/rdataset.h>
#include <dns/rdatastruct.h>
#include <dns/resolver.h>
-#include <dns/result.h>
#include <dns/view.h>
struct dns_lookup {
#include <isc/mem.h>
#include <isc/print.h>
#include <isc/refcount.h>
+#include <isc/result.h>
#include <isc/serial.h>
#include <isc/stdio.h>
#include <isc/stdtime.h>
#include <dns/rdataset.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/soa.h>
#include <dns/time.h>
#include <dns/ttl.h>
result == ISC_R_NOPERM) \
(*callbacks->error)(callbacks, "%s: %s:%lu: %s: %s", \
"dns_master_load", source, line, filename, \
- dns_result_totext(result)); \
+ isc_result_totext(result)); \
else \
LOGIT(result)
#define LOGIT(result) \
if (result == ISC_R_NOMEMORY) \
(*callbacks->error)(callbacks, "dns_master_load: %s", \
- dns_result_totext(result)); \
+ isc_result_totext(result)); \
else \
(*callbacks->error)(callbacks, "%s: %s:%lu: %s", \
"dns_master_load", source, line, \
- dns_result_totext(result))
+ isc_result_totext(result))
static unsigned char in_addr_arpa_data[] = "\007IN-ADDR\004ARPA";
static unsigned char in_addr_arpa_offsets[] = { 0, 8, 13 };
error_cleanup:
if (result == ISC_R_NOMEMORY) {
(*callbacks->error)(callbacks, "$GENERATE: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
} else {
(*callbacks->error)(callbacks, "$GENERATE: %s:%lu: %s", source,
- line, dns_result_totext(result));
+ line, isc_result_totext(result));
}
insist_cleanup:
dns_rdatatype_format(type, typebuf, sizeof(typebuf));
(*callbacks->error)(callbacks, "%s:%lu: %s '%s': %s",
source, line, "type", typebuf,
- dns_result_totext(result));
+ isc_result_totext(result));
if (MANYERRS(lctx, result)) {
SETRESULT(lctx, result);
} else {
dns_rdatatype_format(type, typebuf, sizeof(typebuf));
(*callbacks->error)(callbacks, "%s:%lu: %s '%s': %s",
source, line, "type", typebuf,
- dns_result_totext(result));
+ isc_result_totext(result));
if (MANYERRS(lctx, result)) {
SETRESULT(lctx, result);
} else {
const char *desc;
dns_name_format(name, namebuf, sizeof(namebuf));
result = DNS_R_BADOWNERNAME;
- desc = dns_result_totext(result);
+ desc = isc_result_totext(result);
if (CHECKNAMESFAIL(lctx->options) ||
type == dns_rdatatype_nsec3) {
(*callbacks->error)(
}
if (result != ISC_R_SUCCESS && result != DNS_R_CONTINUE) {
(*callbacks->error)(callbacks, "dns_master_load: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
return (result);
&dataset));
if (result == ISC_R_NOMEMORY) {
(*error)(callbacks, "dns_master_load: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
} else if (result != ISC_R_SUCCESS) {
dns_name_format(owner, namebuf, sizeof(namebuf));
if (source != NULL) {
(*error)(callbacks, "%s: %s:%lu: %s: %s",
"dns_master_load", source, line,
- namebuf, dns_result_totext(result));
+ namebuf, isc_result_totext(result));
} else {
(*error)(callbacks, "%s: %s: %s",
"dns_master_load", namebuf,
- dns_result_totext(result));
+ isc_result_totext(result));
}
}
if (MANYERRS(lctx, result)) {
#include <isc/mem.h>
#include <isc/print.h>
#include <isc/refcount.h>
+#include <isc/result.h>
#include <isc/stdio.h>
#include <isc/string.h>
#include <isc/task.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/time.h>
#include <dns/ttl.h>
#include <isc/buffer.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
#include <isc/utf8.h>
#include <isc/util.h>
#include <dns/rdatalist.h>
#include <dns/rdataset.h>
#include <dns/rdatastruct.h>
-#include <dns/result.h>
#include <dns/tsig.h>
#include <dns/ttl.h>
#include <dns/view.h>
#include <isc/once.h>
#include <isc/print.h>
#include <isc/random.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/thread.h>
#include <isc/util.h>
#include <dns/compress.h>
#include <dns/fixedname.h>
#include <dns/name.h>
-#include <dns/result.h>
#define VALID_NAME(n) ISC_MAGIC_VALID(n, DNS_NAME_MAGIC)
#include <stdbool.h>
#include <isc/log.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatastruct.h>
-#include <dns/result.h>
#include <dst/dst.h>
#include <isc/iterated_hash.h>
#include <isc/md.h>
#include <isc/nonce.h>
+#include <isc/result.h>
#include <isc/safe.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatastruct.h>
-#include <dns/result.h>
#include <dns/zone.h>
#include <dst/dst.h>
#include <isc/log.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/rwlock.h>
#include <isc/string.h>
#include <isc/task.h>
#include <dns/rbt.h>
#include <dns/rdataset.h>
#include <dns/resolver.h>
-#include <dns/result.h>
#include <dns/time.h>
struct dns_nta {
#include <isc/mem.h>
#include <isc/mutex.h>
#include <isc/mutexblock.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/thread.h>
#include <isc/tls.h>
#include <dns/log.h>
-#include <dst/result.h>
-
#include "dst_internal.h"
#include "dst_openssl.h"
#include <openssl/opensslv.h>
#include <isc/mem.h>
+#include <isc/result.h>
#include <isc/safe.h>
#include <isc/string.h>
#include <isc/util.h>
-#include <dst/result.h>
-
#include "dst_internal.h"
#include "dst_openssl.h"
#include "dst_parse.h"
#endif
#include <isc/mem.h>
+#include <isc/result.h>
#include <isc/safe.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/keyvalues.h>
-#include <dst/result.h>
-
#include "dst_internal.h"
#include "dst_openssl.h"
#include "dst_parse.h"
#include <dns/keyvalues.h>
-#include <dst/result.h>
-
#include "dst_internal.h"
#include "dst_openssl.h"
#include "dst_parse.h"
#include <openssl/rsa.h>
#include <isc/mem.h>
+#include <isc/result.h>
#include <isc/safe.h>
#include <isc/string.h>
#include <isc/util.h>
-#include <dst/result.h>
-
#include "dst_internal.h"
#include "dst_openssl.h"
#include "dst_parse.h"
#include <unistd.h>
+#include <isc/result.h>
+
#include <dns/fixedname.h>
#include <dns/log.h>
#include <dns/rbt.h>
-#include <dns/result.h>
#define CHECK(x) \
do { \
dns_name_format(name, printname, size);
} else {
snprintf(printname, size, "<error building name: %s>",
- dns_result_totext(result));
+ isc_result_totext(result));
}
return (printname);
#include <isc/print.h>
#include <isc/random.h>
#include <isc/refcount.h>
+#include <isc/result.h>
#include <isc/rwlock.h>
#include <isc/serial.h>
#include <isc/socket.h>
#include <dns/rdatasetiter.h>
#include <dns/rdataslab.h>
#include <dns/rdatastruct.h>
-#include <dns/result.h>
#include <dns/stats.h>
#include <dns/time.h>
#include <dns/view.h>
DNS_LOGMODULE_ZONE, ISC_LOG_ERROR,
"Unable to reinsert header to "
"re-signing heap: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
}
decrement_reference(rbtdb, header->node, least_serial,
#include <dns/keyvalues.h>
#include <dns/rcode.h>
#include <dns/rdataclass.h>
-#include <dns/result.h>
#include <dns/secalg.h>
#include <dns/secproto.h>
#include <isc/mem.h>
#include <isc/parseint.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/rdataset.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/secalg.h>
#include <dns/secproto.h>
#include <dns/time.h>
line = isc_lex_getsourceline(lexer);
(*callbacks->warn)(callbacks, "%s:%u: warning: '%s': %s", file,
line, DNS_AS_STR(*token),
- dns_result_totext(DNS_R_MXISADDRESS));
+ isc_result_totext(DNS_R_MXISADDRESS));
}
}
dns_name_format(name, namebuf, sizeof(namebuf));
(*callbacks->warn)(callbacks, "%s:%u: warning: %s: %s", file,
line, namebuf,
- dns_result_totext(DNS_R_BADNAME));
+ isc_result_totext(DNS_R_BADNAME));
}
}
case isc_tokentype_eol:
(*callback)(callbacks, "%s: %s:%lu: near eol: %s",
"dns_rdata_fromtext", name, line,
- dns_result_totext(result));
+ isc_result_totext(result));
break;
case isc_tokentype_eof:
(*callback)(callbacks, "%s: %s:%lu: near eof: %s",
"dns_rdata_fromtext", name, line,
- dns_result_totext(result));
+ isc_result_totext(result));
break;
case isc_tokentype_number:
(*callback)(callbacks, "%s: %s:%lu: near %lu: %s",
"dns_rdata_fromtext", name, line,
token->value.as_ulong,
- dns_result_totext(result));
+ isc_result_totext(result));
break;
case isc_tokentype_string:
case isc_tokentype_qstring:
(*callback)(callbacks, "%s: %s:%lu: near '%s': %s",
"dns_rdata_fromtext", name, line,
DNS_AS_STR(*token),
- dns_result_totext(result));
+ isc_result_totext(result));
break;
default:
(*callback)(callbacks, "%s: %s:%lu: %s",
"dns_rdata_fromtext", name, line,
- dns_result_totext(result));
+ isc_result_totext(result));
break;
}
} else {
(*callback)(callbacks, "dns_rdata_fromtext: %s:%lu: %s", name,
- line, dns_result_totext(result));
+ line, isc_result_totext(result));
}
}
#include <isc/mem.h>
#include <isc/region.h>
+#include <isc/result.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
#include <isc/util.h>
#include <dns/rdata.h>
#include <dns/rdataset.h>
#include <dns/rdataslab.h>
-#include <dns/result.h>
/*
* The rdataslab structure allows iteration to occur in both load order
#include <isc/magic.h>
#include <isc/mem.h>
#include <isc/netmgr.h>
+#include <isc/result.h>
#include <isc/task.h>
#include <isc/util.h>
#include <dns/rdata.h>
#include <dns/rdatastruct.h>
#include <dns/request.h>
-#include <dns/result.h>
#include <dns/tsig.h>
#define REQUESTMGR_MAGIC ISC_MAGIC('R', 'q', 'u', 'M')
}
req_detach(&request);
req_log(ISC_LOG_DEBUG(3), "dns_request_createraw: failed %s",
- dns_result_totext(result));
+ isc_result_totext(result));
return (result);
}
}
req_detach(&request);
req_log(ISC_LOG_DEBUG(3), "dns_request_createvia: failed %s",
- dns_result_totext(result));
+ isc_result_totext(result));
return (result);
}
dns_request_t *request = (dns_request_t *)arg;
req_log(ISC_LOG_DEBUG(3), "req_response: request %p: %s", request,
- dns_result_totext(result));
+ isc_result_totext(result));
if (result == ISC_R_CANCELED || result == ISC_R_EOF) {
return;
#include <isc/print.h>
#include <isc/random.h>
#include <isc/refcount.h>
+#include <isc/result.h>
#include <isc/siphash.h>
#include <isc/stats.h>
#include <isc/string.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
#include <dns/resolver.h>
-#include <dns/result.h>
#include <dns/rootns.h>
#include <dns/stats.h>
#include <dns/tsig.h>
isc_log_write(
dns_lctx, DNS_LOGCATEGORY_LAME_SERVERS, DNS_LOGMODULE_RESOLVER,
ISC_LOG_INFO, "%s%s%s resolving '%s/%s/%s': %s", code, spc,
- dns_result_totext(reason), namebuf, typebuf, classbuf, addrbuf);
+ isc_result_totext(reason), namebuf, typebuf, classbuf, addrbuf);
}
/*
/*! \file */
#include <isc/once.h>
+#include <isc/result.h>
#include <isc/util.h>
#include <dns/result.h>
-static const char *text[DNS_R_NRESULTS] = {
- "label too long", /*%< 0 DNS_R_LABELTOOLONG */
- "bad escape", /*%< 1 DNS_R_BADESCAPE */
- /*!
- * Note that DNS_R_BADBITSTRING and DNS_R_BITSTRINGTOOLONG are
- * deprecated.
- */
- "bad bitstring", /*%< 2 DNS_R_BADBITSTRING */
- "bitstring too long", /*%< 3 DNS_R_BITSTRINGTOOLONG */
- "empty label", /*%< 4 DNS_R_EMPTYLABEL */
-
- "bad dotted quad", /*%< 5 DNS_R_BADDOTTEDQUAD */
- "invalid NS owner name (wildcard)", /*%< 6 DNS_R_INVALIDNS */
- "unknown class/type", /*%< 7 DNS_R_UNKNOWN */
- "bad label type", /*%< 8 DNS_R_BADLABELTYPE */
- "bad compression pointer", /*%< 9 DNS_R_BADPOINTER */
-
- "too many hops", /*%< 10 DNS_R_TOOMANYHOPS */
- "disallowed (by application policy)", /*%< 11 DNS_R_DISALLOWED */
- "extra input text", /*%< 12 DNS_R_EXTRATOKEN */
- "extra input data", /*%< 13 DNS_R_EXTRADATA */
- "text too long", /*%< 14 DNS_R_TEXTTOOLONG */
-
- "not at top of zone", /*%< 15 DNS_R_NOTZONETOP */
- "syntax error", /*%< 16 DNS_R_SYNTAX */
- "bad checksum", /*%< 17 DNS_R_BADCKSUM */
- "bad IPv6 address", /*%< 18 DNS_R_BADAAAA */
- "no owner", /*%< 19 DNS_R_NOOWNER */
-
- "no ttl", /*%< 20 DNS_R_NOTTL */
- "bad class", /*%< 21 DNS_R_BADCLASS */
- "name too long", /*%< 22 DNS_R_NAMETOOLONG */
- "partial match", /*%< 23 DNS_R_PARTIALMATCH */
- "new origin", /*%< 24 DNS_R_NEWORIGIN */
-
- "unchanged", /*%< 25 DNS_R_UNCHANGED */
- "bad ttl", /*%< 26 DNS_R_BADTTL */
- "more data needed/to be rendered", /*%< 27 DNS_R_NOREDATA */
- "continue", /*%< 28 DNS_R_CONTINUE */
- "delegation", /*%< 29 DNS_R_DELEGATION */
-
- "glue", /*%< 30 DNS_R_GLUE */
- "dname", /*%< 31 DNS_R_DNAME */
- "cname", /*%< 32 DNS_R_CNAME */
- "bad database", /*%< 33 DNS_R_BADDB */
- "zonecut", /*%< 34 DNS_R_ZONECUT */
-
- "bad zone", /*%< 35 DNS_R_BADZONE */
- "more data", /*%< 36 DNS_R_MOREDATA */
- "up to date", /*%< 37 DNS_R_UPTODATE */
- "tsig verify failure", /*%< 38 DNS_R_TSIGVERIFYFAILURE */
- "tsig indicates error", /*%< 39 DNS_R_TSIGERRORSET */
-
- "RRSIG failed to verify", /*%< 40 DNS_R_SIGINVALID */
- "RRSIG has expired", /*%< 41 DNS_R_SIGEXPIRED */
- "RRSIG validity period has not begun", /*%< 42 DNS_R_SIGFUTURE */
- "key is unauthorized to sign data", /*%< 43 DNS_R_KEYUNAUTHORIZED */
- "invalid time", /*%< 44 DNS_R_INVALIDTIME */
-
- "expected a TSIG or SIG(0)", /*%< 45 DNS_R_EXPECTEDTSIG */
- "did not expect a TSIG or SIG(0)", /*%< 46 DNS_R_UNEXPECTEDTSIG */
- "TKEY is unacceptable", /*%< 47 DNS_R_INVALIDTKEY */
- "hint", /*%< 48 DNS_R_HINT */
- "drop", /*%< 49 DNS_R_DROP */
-
- "zone not loaded", /*%< 50 DNS_R_NOTLOADED */
- "ncache nxdomain", /*%< 51 DNS_R_NCACHENXDOMAIN */
- "ncache nxrrset", /*%< 52 DNS_R_NCACHENXRRSET */
- "wait", /*%< 53 DNS_R_WAIT */
- "not verified yet", /*%< 54 DNS_R_NOTVERIFIEDYET */
-
- "no identity", /*%< 55 DNS_R_NOIDENTITY */
- "no journal", /*%< 56 DNS_R_NOJOURNAL */
- "alias", /*%< 57 DNS_R_ALIAS */
- "use TCP", /*%< 58 DNS_R_USETCP */
- "no valid RRSIG", /*%< 59 DNS_R_NOVALIDSIG */
-
- "no valid NSEC", /*%< 60 DNS_R_NOVALIDNSEC */
- "insecurity proof failed", /*%< 61 DNS_R_NOTINSECURE */
- "unknown service", /*%< 62 DNS_R_UNKNOWNSERVICE */
- "recoverable error occurred", /*%< 63 DNS_R_RECOVERABLE */
- "unknown opt attribute record", /*%< 64 DNS_R_UNKNOWNOPT */
-
- "unexpected message id", /*%< 65 DNS_R_UNEXPECTEDID */
- "seen include file", /*%< 66 DNS_R_SEENINCLUDE */
- "not exact", /*%< 67 DNS_R_NOTEXACT */
- "address blackholed", /*%< 68 DNS_R_BLACKHOLED */
- "bad algorithm", /*%< 69 DNS_R_BADALG */
-
- "invalid use of a meta type", /*%< 70 DNS_R_METATYPE */
- "CNAME and other data", /*%< 71 DNS_R_CNAMEANDOTHER */
- "multiple RRs of singleton type", /*%< 72 DNS_R_SINGLETON */
- "hint nxrrset", /*%< 73 DNS_R_HINTNXRRSET */
- "no master file configured", /*%< 74 DNS_R_NOMASTERFILE */
-
- "unknown protocol", /*%< 75 DNS_R_UNKNOWNPROTO */
- "clocks are unsynchronized", /*%< 76 DNS_R_CLOCKSKEW */
- "IXFR failed", /*%< 77 DNS_R_BADIXFR */
- "not authoritative", /*%< 78 DNS_R_NOTAUTHORITATIVE */
- "no valid KEY", /*%< 79 DNS_R_NOVALIDKEY */
-
- "obsolete", /*%< 80 DNS_R_OBSOLETE */
- "already frozen", /*%< 81 DNS_R_FROZEN */
- "unknown flag", /*%< 82 DNS_R_UNKNOWNFLAG */
- "expected a response", /*%< 83 DNS_R_EXPECTEDRESPONSE */
- "no valid DS", /*%< 84 DNS_R_NOVALIDDS */
-
- "NS is an address", /*%< 85 DNS_R_NSISADDRESS */
- "received FORMERR", /*%< 86 DNS_R_REMOTEFORMERR */
- "truncated TCP response", /*%< 87 DNS_R_TRUNCATEDTCP */
- "lame server detected", /*%< 88 DNS_R_LAME */
- "unexpected RCODE", /*%< 89 DNS_R_UNEXPECTEDRCODE */
-
- "unexpected OPCODE", /*%< 90 DNS_R_UNEXPECTEDOPCODE */
- "chase DS servers", /*%< 91 DNS_R_CHASEDSSERVERS */
- "empty name", /*%< 92 DNS_R_EMPTYNAME */
- "empty wild", /*%< 93 DNS_R_EMPTYWILD */
- "bad bitmap", /*%< 94 DNS_R_BADBITMAP */
-
- "from wildcard", /*%< 95 DNS_R_FROMWILDCARD */
- "bad owner name (check-names)", /*%< 96 DNS_R_BADOWNERNAME */
- "bad name (check-names)", /*%< 97 DNS_R_BADNAME */
- "dynamic zone", /*%< 98 DNS_R_DYNAMIC */
- "unknown command", /*%< 99 DNS_R_UNKNOWNCOMMAND */
-
- "must-be-secure", /*%< 100 DNS_R_MUSTBESECURE */
- "covering NSEC record returned", /*%< 101 DNS_R_COVERINGNSEC */
- "MX is an address", /*%< 102 DNS_R_MXISADDRESS */
- "duplicate query", /*%< 103 DNS_R_DUPLICATE */
- "invalid NSEC3 owner name (wildcard)", /*%< 104 DNS_R_INVALIDNSEC3 */
-
- "not master", /*%< 105 DNS_R_NOTMASTER */
- "broken trust chain", /*%< 106 DNS_R_BROKENCHAIN */
- "expired", /*%< 107 DNS_R_EXPIRED */
- "not dynamic", /*%< 108 DNS_R_NOTDYNAMIC */
- "bad EUI", /*%< 109 DNS_R_BADEUI */
-
- "covered by negative trust anchor", /*%< 110 DNS_R_NTACOVERED */
- "bad CDS", /*%< 111 DNS_R_BADCDS */
- "bad CDNSKEY", /*%< 112 DNS_R_BADCDNSKEY */
- "malformed OPT option", /*%< 113 DNS_R_OPTERR */
- "malformed DNSTAP data", /*%< 114 DNS_R_BADDNSTAP */
-
- "TSIG in wrong location", /*%< 115 DNS_R_BADTSIG */
- "SIG(0) in wrong location", /*%< 116 DNS_R_BADSIG0 */
- "too many records", /*%< 117 DNS_R_TOOMANYRECORDS */
- "verify failure", /*%< 118 DNS_R_VERIFYFAILURE */
- "at top of zone", /*%< 119 DNS_R_ATZONETOP */
-
- "no matching key found", /*%< 120 DNS_R_NOKEYMATCH */
- "too many keys matching", /*%< 121 DNS_R_TOOMANYKEYS */
- "key is not actively signing", /*%< 122 DNS_R_KEYNOTACTIVE */
- "NSEC3 iterations out of range", /*%< 123 DNS_R_NSEC3ITERRANGE */
- "NSEC3 salt length too high", /*%< 124 DNS_R_NSEC3SALTRANGE */
-
- "cannot use NSEC3 with key algorithm", /*%< 125 DNS_R_NSEC3BADALG */
- "NSEC3 resalt", /*%< 126 DNS_R_NSEC3RESALT */
- "inconsistent resource record", /*%< 127 DNS_R_INCONSISTENTRR */
-};
-
-static const char *ids[DNS_R_NRESULTS] = {
- "DNS_R_LABELTOOLONG",
- "DNS_R_BADESCAPE",
- /*!
- * Note that DNS_R_BADBITSTRING and DNS_R_BITSTRINGTOOLONG are
- * deprecated.
- */
- "DNS_R_BADBITSTRING",
- "DNS_R_BITSTRINGTOOLONG",
- "DNS_R_EMPTYLABEL",
- "DNS_R_BADDOTTEDQUAD",
- "DNS_R_INVALIDNS",
- "DNS_R_UNKNOWN",
- "DNS_R_BADLABELTYPE",
- "DNS_R_BADPOINTER",
- "DNS_R_TOOMANYHOPS",
- "DNS_R_DISALLOWED",
- "DNS_R_EXTRATOKEN",
- "DNS_R_EXTRADATA",
- "DNS_R_TEXTTOOLONG",
- "DNS_R_NOTZONETOP",
- "DNS_R_SYNTAX",
- "DNS_R_BADCKSUM",
- "DNS_R_BADAAAA",
- "DNS_R_NOOWNER",
- "DNS_R_NOTTL",
- "DNS_R_BADCLASS",
- "DNS_R_NAMETOOLONG",
- "DNS_R_PARTIALMATCH",
- "DNS_R_NEWORIGIN",
- "DNS_R_UNCHANGED",
- "DNS_R_BADTTL",
- "DNS_R_NOREDATA",
- "DNS_R_CONTINUE",
- "DNS_R_DELEGATION",
- "DNS_R_GLUE",
- "DNS_R_DNAME",
- "DNS_R_CNAME",
- "DNS_R_BADDB",
- "DNS_R_ZONECUT",
- "DNS_R_BADZONE",
- "DNS_R_MOREDATA",
- "DNS_R_UPTODATE",
- "DNS_R_TSIGVERIFYFAILURE",
- "DNS_R_TSIGERRORSET",
- "DNS_R_SIGINVALID",
- "DNS_R_SIGEXPIRED",
- "DNS_R_SIGFUTURE",
- "DNS_R_KEYUNAUTHORIZED",
- "DNS_R_INVALIDTIME",
- "DNS_R_EXPECTEDTSIG",
- "DNS_R_UNEXPECTEDTSIG",
- "DNS_R_INVALIDTKEY",
- "DNS_R_HINT",
- "DNS_R_DROP",
- "DNS_R_NOTLOADED",
- "DNS_R_NCACHENXDOMAIN",
- "DNS_R_NCACHENXRRSET",
- "DNS_R_WAIT",
- "DNS_R_NOTVERIFIEDYET",
- "DNS_R_NOIDENTITY",
- "DNS_R_NOJOURNAL",
- "DNS_R_ALIAS",
- "DNS_R_USETCP",
- "DNS_R_NOVALIDSIG",
- "DNS_R_NOVALIDNSEC",
- "DNS_R_NOTINSECURE",
- "DNS_R_UNKNOWNSERVICE",
- "DNS_R_RECOVERABLE",
- "DNS_R_UNKNOWNOPT",
- "DNS_R_UNEXPECTEDID",
- "DNS_R_SEENINCLUDE",
- "DNS_R_NOTEXACT",
- "DNS_R_BLACKHOLED",
- "DNS_R_BADALG",
- "DNS_R_METATYPE",
- "DNS_R_CNAMEANDOTHER",
- "DNS_R_SINGLETON",
- "DNS_R_HINTNXRRSET",
- "DNS_R_NOMASTERFILE",
- "DNS_R_UNKNOWNPROTO",
- "DNS_R_CLOCKSKEW",
- "DNS_R_BADIXFR",
- "DNS_R_NOTAUTHORITATIVE",
- "DNS_R_NOVALIDKEY",
- "DNS_R_OBSOLETE",
- "DNS_R_FROZEN",
- "DNS_R_UNKNOWNFLAG",
- "DNS_R_EXPECTEDRESPONSE",
- "DNS_R_NOVALIDDS",
- "DNS_R_NSISADDRESS",
- "DNS_R_REMOTEFORMERR",
- "DNS_R_TRUNCATEDTCP",
- "DNS_R_LAME",
- "DNS_R_UNEXPECTEDRCODE",
- "DNS_R_UNEXPECTEDOPCODE",
- "DNS_R_CHASEDSSERVERS",
- "DNS_R_EMPTYNAME",
- "DNS_R_EMPTYWILD",
- "DNS_R_BADBITMAP",
- "DNS_R_FROMWILDCARD",
- "DNS_R_BADOWNERNAME",
- "DNS_R_BADNAME",
- "DNS_R_DYNAMIC",
- "DNS_R_UNKNOWNCOMMAND",
- "DNS_R_MUSTBESECURE",
- "DNS_R_COVERINGNSEC",
- "DNS_R_MXISADDRESS",
- "DNS_R_DUPLICATE",
- "DNS_R_INVALIDNSEC3",
- "DNS_R_NOTMASTER",
- "DNS_R_BROKENCHAIN",
- "DNS_R_EXPIRED",
- "DNS_R_NOTDYNAMIC",
- "DNS_R_BADEUI",
- "DNS_R_NTACOVERED",
- "DNS_R_BADCDS",
- "DNS_R_BADCDNSKEY",
- "DNS_R_OPTERR",
- "DNS_R_BADDNSTAP",
- "DNS_R_BADTSIG",
- "DNS_R_BADSIG0",
- "DNS_R_TOOMANYRECORDS",
- "DNS_R_VERIFYFAILURE",
- "DNS_R_ATZONETOP",
- "DNS_R_NOKEYMATCH",
- "DNS_R_TOOMANYKEYS",
- "DNS_R_KEYNOTACTIVE",
- "DNS_R_NSEC3ITERRANGE",
- "DNS_R_NSEC3SALTRANGE",
- "DNS_R_NSEC3BADALG",
- "DNS_R_NSEC3RESALT",
- "DNS_R_INCONSISTENTRR",
-};
-
-static const char *rcode_text[DNS_R_NRCODERESULTS] = {
- "NOERROR", /*%< 0 DNS_R_NOERROR */
- "FORMERR", /*%< 1 DNS_R_FORMERR */
- "SERVFAIL", /*%< 2 DNS_R_SERVFAIL */
- "NXDOMAIN", /*%< 3 DNS_R_NXDOMAIN */
- "NOTIMP", /*%< 4 DNS_R_NOTIMP */
-
- "REFUSED", /*%< 5 DNS_R_REFUSED */
- "YXDOMAIN", /*%< 6 DNS_R_YXDOMAIN */
- "YXRRSET", /*%< 7 DNS_R_YXRRSET */
- "NXRRSET", /*%< 8 DNS_R_NXRRSET */
- "NOTAUTH", /*%< 9 DNS_R_NOTAUTH */
-
- "NOTZONE", /*%< 10 DNS_R_NOTZONE */
- "<rcode 11>", /*%< 11 DNS_R_RCODE11 */
- "<rcode 12>", /*%< 12 DNS_R_RCODE12 */
- "<rcode 13>", /*%< 13 DNS_R_RCODE13 */
- "<rcode 14>", /*%< 14 DNS_R_RCODE14 */
-
- "<rcode 15>", /*%< 15 DNS_R_RCODE15 */
- "BADVERS", /*%< 16 DNS_R_BADVERS */
-};
-
-static const char *rcode_ids[DNS_R_NRCODERESULTS] = {
- "DNS_R_NOERROR", "DNS_R_FORMERR", "DNS_R_SERVFAIL", "DNS_R_NXDOMAIN",
- "DNS_R_NOTIMP", "DNS_R_REFUSED", "DNS_R_YXDOMAIN", "DNS_R_YXRRSET",
- "DNS_R_NXRRSET", "DNS_R_NOTAUTH", "DNS_R_NOTZONE", "DNS_R_RCODE11",
- "RNS_R_RCODE12", "DNS_R_RCODE13", "DNS_R_RCODE14", "DNS_R_RCODE15",
- "DNS_R_BADVERS",
-};
-
-#define DNS_RESULT_RESULTSET 2
-#define DNS_RESULT_RCODERESULTSET 3
-
-static isc_once_t once = ISC_ONCE_INIT;
-
-static void
-initialize_action(void) {
- isc_result_t result;
-
- result = isc_result_register(ISC_RESULTCLASS_DNS, DNS_R_NRESULTS, text,
- DNS_RESULT_RESULTSET);
- if (result == ISC_R_SUCCESS) {
- result = isc_result_register(ISC_RESULTCLASS_DNSRCODE,
- DNS_R_NRCODERESULTS, rcode_text,
- DNS_RESULT_RCODERESULTSET);
- }
- if (result != ISC_R_SUCCESS) {
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "isc_result_register() failed: %u", result);
- }
-
- result = isc_result_registerids(ISC_RESULTCLASS_DNS, DNS_R_NRESULTS,
- ids, DNS_RESULT_RESULTSET);
- if (result == ISC_R_SUCCESS) {
- result = isc_result_registerids(ISC_RESULTCLASS_DNSRCODE,
- DNS_R_NRCODERESULTS, rcode_ids,
- DNS_RESULT_RCODERESULTSET);
- }
- if (result != ISC_R_SUCCESS) {
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "isc_result_registerids() failed: %u", result);
- }
-}
-
-static void
-initialize(void) {
- RUNTIME_CHECK(isc_once_do(&once, initialize_action) == ISC_R_SUCCESS);
-}
-
-const char *
-dns_result_totext(isc_result_t result) {
- initialize();
-
- return (isc_result_totext(result));
-}
-
-void
-dns_result_register(void) {
- initialize();
-}
+#define DNS_RESULT_ISRCODE(result) (DNS_R_NOERROR == ((result)&0xFFFF0000))
dns_rcode_t
dns_result_torcode(isc_result_t result) {
return (rcode);
}
+
+isc_result_t
+dns_result_fromrcode(dns_rcode_t rcode) {
+ /*
+ * Rcodes can't be bigger than 12 bits, which is why we
+ * AND with 0xFFF instead of 0xFFFF.
+ */
+ REQUIRE((rcode & 0xFFF) == rcode);
+
+ return ((isc_result_t)rcode + DNS_R_NOERROR);
+}
#include <stdbool.h>
#include <isc/buffer.h>
+#include <isc/result.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
#include <isc/util.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/rootns.h>
#include <dns/view.h>
DNS_LOGMODULE_HINTS, ISC_LOG_WARNING,
"checkhints%s%s: unable to get root NS rrset "
"from hints: %s",
- sep, viewname, dns_result_totext(result));
+ sep, viewname, isc_result_totext(result));
goto cleanup;
}
DNS_LOGMODULE_HINTS, ISC_LOG_WARNING,
"checkhints%s%s: unable to get root NS rrset "
"from cache: %s",
- sep, viewname, dns_result_totext(result));
+ sep, viewname, isc_result_totext(result));
goto cleanup;
}
#include <isc/net.h>
#include <isc/netaddr.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/rwlock.h>
#include <isc/string.h>
#include <isc/task.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatastruct.h>
-#include <dns/result.h>
#include <dns/rpz.h>
#include <dns/view.h>
#include <inttypes.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/rdata.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
-#include <dns/result.h>
#include <dns/rriterator.h>
/***
#include <isc/net.h>
#include <isc/netaddr.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/util.h>
#include <dns/log.h>
#include <dns/rcode.h>
#include <dns/rdataclass.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/rrl.h>
#include <dns/view.h>
#include <isc/print.h>
#include <isc/refcount.h>
#include <isc/region.h>
+#include <isc/result.h>
#include <isc/util.h>
#include <dns/callbacks.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/sdb.h>
#include <dns/types.h>
#include <isc/once.h>
#include <isc/print.h>
#include <isc/region.h>
+#include <isc/result.h>
#include <isc/rwlock.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/sdlz.h>
#include <dns/types.h>
rdataset_test \
rdatasetstats_test \
resolver_test \
- result_test \
rsa_test \
sigs_test \
time_test \
#define UNIT_TESTING
#include <cmocka.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/name.h>
-#include <dst/result.h>
-
#include "../dst_internal.h"
#include "dnstest.h"
#include <isc/netmgr.h>
#include <isc/os.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/socket.h>
#include <isc/stdio.h>
#include <isc/string.h>
#include <dns/fixedname.h>
#include <dns/log.h>
#include <dns/name.h>
-#include <dns/result.h>
#include <dns/view.h>
#include <dns/zone.h>
CHECK(isc_log_usechannel(logconfig, "stderr", NULL, NULL));
}
- dns_result_register();
-
if (start_managers) {
CHECK(create_managers());
}
#include <isc/hash.h>
#include <isc/log.h>
#include <isc/mem.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/task.h>
#include <isc/timer.h>
#include <isc/util.h>
#include <dns/diff.h>
-#include <dns/result.h>
#include <dns/zone.h>
typedef struct {
#include <isc/file.h>
#include <isc/hex.h>
+#include <isc/result.h>
#include <isc/stdio.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dst/dst.h>
-#include <dst/result.h>
#include "../dst_internal.h"
#include "dnstest.h"
#include <cmocka.h>
#include <isc/hex.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/db.h>
#include <dns/nsec3.h>
-#include <dns/result.h>
#include "../zone_p.h"
#include "dnstest.h"
#include <isc/os.h>
#include <isc/print.h>
#include <isc/random.h>
+#include <isc/result.h>
#include <isc/socket.h>
#include <isc/stdio.h>
#include <isc/string.h>
#include <dns/log.h>
#include <dns/name.h>
#include <dns/rbt.h>
-#include <dns/result.h>
#include <dst/dst.h>
if (debug && result != ISC_R_SUCCESS) {
fprintf(stdout, "# '%s'\n", text_ok->text_in);
fprintf(stdout, "# result=%s\n",
- dns_result_totext(result));
+ isc_result_totext(result));
}
assert_int_equal(result, ISC_R_SUCCESS);
} else {
if (result != ISC_R_SUCCESS && debug) {
size_t i;
fprintf(stdout, "# dns_rdata_totext -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
for (i = 0; i < rdata.length; i++) {
if ((i % 16) == 0) {
fprintf(stdout, "\n#");
buf_fromtext, sizeof(buf_fromtext),
buf_totext, false);
if (debug && result != ISC_R_SUCCESS) {
- fprintf(stdout, "# result = %s\n", dns_result_totext(result));
+ fprintf(stdout, "# result = %s\n", isc_result_totext(result));
fprintf(stdout, "# '%s'\n", buf_fromtext);
}
assert_int_equal(result, ISC_R_SUCCESS);
false);
if (debug && result != ISC_R_SUCCESS) {
fprintf(stdout, "# '%s'\n", textvsunknown->text1);
- fprintf(stdout, "# result=%s\n", dns_result_totext(result));
+ fprintf(stdout, "# result=%s\n", isc_result_totext(result));
}
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_test_rdatafromstring(&rdata2, rdclass, type, buf2,
false);
if (debug && result != ISC_R_SUCCESS) {
fprintf(stdout, "# '%s'\n", textvsunknown->text2);
- fprintf(stdout, "# result=%s\n", dns_result_totext(result));
+ fprintf(stdout, "# result=%s\n", isc_result_totext(result));
}
assert_int_equal(result, ISC_R_SUCCESS);
if (debug && rdata1.length != rdata2.length) {
+++ /dev/null
-/*
- * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, you can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-#if HAVE_CMOCKA
-
-#include <setjmp.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define UNIT_TESTING
-#include <cmocka.h>
-
-#include <isc/result.h>
-#include <isc/util.h>
-
-#include <dns/result.h>
-
-#include <dst/result.h>
-
-/*
- * Check ids array is populated.
- */
-static void
-ids(void **state) {
- const char *str;
- isc_result_t result;
-
- UNUSED(state);
-
- dns_result_register();
- dst_result_register();
-
- for (result = ISC_RESULTCLASS_DNS;
- result < (ISC_RESULTCLASS_DNS + DNS_R_NRESULTS); result++)
- {
- str = isc_result_toid(result);
- assert_non_null(str);
- assert_string_not_equal(str, "(result code text not "
- "available)");
-
- str = isc_result_totext(result);
- assert_non_null(str);
- assert_string_not_equal(str, "(result code text not "
- "available)");
- }
-
- str = isc_result_toid(result);
- assert_non_null(str);
- assert_string_equal(str, "(result code text not available)");
-
- str = isc_result_totext(result);
- assert_non_null(str);
- assert_string_equal(str, "(result code text not available)");
-
- for (result = ISC_RESULTCLASS_DST;
- result < (ISC_RESULTCLASS_DST + DST_R_NRESULTS); result++)
- {
- str = isc_result_toid(result);
- assert_non_null(str);
- assert_string_not_equal(str, "(result code text not "
- "available)");
-
- str = isc_result_totext(result);
- assert_non_null(str);
- assert_string_not_equal(str, "(result code text not "
- "available)");
- }
-
- str = isc_result_toid(result);
- assert_non_null(str);
- assert_string_equal(str, "(result code text not available)");
-
- str = isc_result_totext(result);
- assert_non_null(str);
- assert_string_equal(str, "(result code text not available)");
-
- for (result = ISC_RESULTCLASS_DNSRCODE;
- result < (ISC_RESULTCLASS_DNSRCODE + DNS_R_NRCODERESULTS);
- result++)
- {
- str = isc_result_toid(result);
- assert_non_null(str);
- assert_string_not_equal(str, "(result code text not "
- "available)");
-
- str = isc_result_totext(result);
- assert_non_null(str);
- assert_string_not_equal(str, "(result code text not "
- "available)");
- }
-
- str = isc_result_toid(result);
- assert_non_null(str);
- assert_string_equal(str, "(result code text not available)");
-
- str = isc_result_totext(result);
- assert_non_null(str);
- assert_string_equal(str, "(result code text not available)");
-}
-
-int
-main(void) {
- const struct CMUnitTest tests[] = {
- cmocka_unit_test(ids),
- };
-
- return (cmocka_run_group_tests(tests, NULL, NULL));
-}
-
-#else /* HAVE_CMOCKA */
-
-#include <stdio.h>
-
-int
-main(void) {
- printf("1..0 # Skipped: cmocka not available\n");
- return (SKIPPED_TEST_EXIT_CODE);
-}
-
-#endif /* if HAVE_CMOCKA */
#include <dns/rdata.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/types.h>
#include <dns/zone.h>
#include <isc/print.h>
#include <isc/region.h>
+#include <isc/result.h>
#include <isc/serial.h>
#include <isc/stdtime.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
#include <isc/util.h>
-#include <dns/result.h>
#include <dns/time.h>
static const int days[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
#include <isc/nonce.h>
#include <isc/print.h>
#include <isc/random.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
(char *)isc_buffer_base(&outbuf));
} else {
tkey_log("Warning: dns_message_totext: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
break;
}
}
if (rmsg->rcode != dns_rcode_noerror) {
- return (ISC_RESULTCLASS_DNSRCODE + rmsg->rcode);
+ return (dns_result_fromrcode(rmsg->rcode));
}
RETERR(find_tkey(rmsg, &tkeyname, &rtkeyrdata, DNS_SECTION_ANSWER));
RETERR(dns_rdata_tostruct(&rtkeyrdata, &rtkey, NULL));
}
if (rmsg->rcode != dns_rcode_noerror) {
- return (ISC_RESULTCLASS_DNSRCODE + rmsg->rcode);
+ return (dns_result_fromrcode(rmsg->rcode));
}
RETERR(find_tkey(rmsg, &tkeyname, &rtkeyrdata, DNS_SECTION_ANSWER));
RETERR(dns_rdata_tostruct(&rtkeyrdata, &rtkey, NULL));
REQUIRE(rmsg != NULL);
if (rmsg->rcode != dns_rcode_noerror) {
- return (ISC_RESULTCLASS_DNSRCODE + rmsg->rcode);
+ return (dns_result_fromrcode(rmsg->rcode));
}
RETERR(find_tkey(rmsg, &tkeyname, &rtkeyrdata, DNS_SECTION_ANSWER));
}
if (rmsg->rcode != dns_rcode_noerror) {
- return (ISC_RESULTCLASS_DNSRCODE + rmsg->rcode);
+ return (dns_result_fromrcode(rmsg->rcode));
}
RETERR(find_tkey(rmsg, &tkeyname, &rtkeyrdata, DNS_SECTION_ANSWER));
#include <dns/name.h>
#include <dns/rbt.h>
-#include <dns/result.h>
#include <dns/transport.h>
#define TRANSPORT_MAGIC ISC_MAGIC('T', 'r', 'n', 's')
*/
#include <isc/mem.h>
+#include <isc/result.h>
#include <isc/util.h>
-#include <dns/result.h>
#include <dns/tsec.h>
#include <dns/tsig.h>
#include <isc/mem.h>
#include <isc/print.h>
#include <isc/refcount.h>
+#include <isc/result.h>
#include <isc/serial.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
#include <isc/time.h>
#include <dns/rdatalist.h>
#include <dns/rdataset.h>
#include <dns/rdatastruct.h>
-#include <dns/result.h>
#include <dns/tsig.h>
-#include <dst/result.h>
-
#include "tsig_p.h"
#define TSIG_MAGIC ISC_MAGIC('T', 'S', 'I', 'G')
#include <isc/parseint.h>
#include <isc/print.h>
#include <isc/region.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
-#include <dns/result.h>
#include <dns/ttl.h>
#define RETERR(x) \
#include <isc/netaddr.h>
#include <isc/print.h>
#include <isc/random.h>
+#include <isc/result.h>
#include <isc/serial.h>
#include <isc/stats.h>
#include <isc/stdtime.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/soa.h>
#include <dns/ssu.h>
#include <dns/stats.h>
#include <isc/md.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/task.h>
#include <isc/util.h>
#include <dns/rdataset.h>
#include <dns/rdatatype.h>
#include <dns/resolver.h>
-#include <dns/result.h>
#include <dns/validator.h>
#include <dns/view.h>
*/
validator_log(val, ISC_LOG_DEBUG(3),
"falling back to insecurity proof (%s)",
- dns_result_totext(eresult));
+ isc_result_totext(eresult));
result = proveunsecure(val, false, false);
if (result != DNS_R_WAIT) {
validator_done(val, result);
#include <isc/hash.h>
#include <isc/lex.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/stats.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
#include <isc/task.h>
#include <dns/rdataset.h>
#include <dns/request.h>
#include <dns/resolver.h>
-#include <dns/result.h>
#include <dns/rpz.h>
#include <dns/rrl.h>
#include <dns/stats.h>
#include <isc/netmgr.h>
#include <isc/print.h>
#include <isc/random.h>
+#include <isc/result.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
#include <isc/util.h>
xfr->mctx);
} else {
xfrin_log(xfr, ISC_LOG_DEBUG(10), "dns_message_parse: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
if (result != ISC_R_SUCCESS || msg->rcode != dns_rcode_noerror ||
{
if (result == ISC_R_SUCCESS && msg->rcode != dns_rcode_noerror)
{
- result = ISC_RESULTCLASS_DNSRCODE + msg->rcode; /*XXX*/
+ result = dns_result_fromrcode(msg->rcode);
} else if (result == ISC_R_SUCCESS &&
msg->opcode != dns_opcode_query) {
result = DNS_R_UNEXPECTEDOPCODE;
#include <isc/random.h>
#include <isc/ratelimiter.h>
#include <isc/refcount.h>
+#include <isc/result.h>
#include <isc/rwlock.h>
#include <isc/serial.h>
#include <isc/stats.h>
#include <dns/rdatatype.h>
#include <dns/request.h>
#include <dns/resolver.h>
-#include <dns/result.h>
#include <dns/rriterator.h>
#include <dns/soa.h>
#include <dns/ssu.h>
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_signwithkey failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
dns_rdata_reset(&rdata);
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_addnsec3chain failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
}
}
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"nsec3param lookup failure: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
return (result);
}
dns_db_currentversion(db, &version);
INSIST(!dns_rdataset_isassociated(&rdataset));
dns_zone_log(zone, ISC_LOG_ERROR,
"nsec3param lookup failure: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"%s:dns_journal_open -> %s", caller,
- dns_result_totext(result));
+ isc_result_totext(result));
return (result);
}
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"%s:dns_journal_write_transaction -> %s",
- caller, dns_result_totext(result));
+ caller, isc_result_totext(result));
}
dns_journal_destroy(&journal);
}
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"add_soa:dns_db_newversion -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"add_soa:dns_soa_buildrdata -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"sync_keyzone:dns_db_newversion -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
{
dnssec_log(zone, ISC_LOG_ERROR,
"unable to synchronize managed keys: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
isc_time_settoepoch(&zone->refreshkeytime);
}
if (keynode != NULL) {
"loading from master file %s "
"failed: %s",
zone->masterfile,
- dns_result_totext(result));
+ isc_result_totext(result));
}
} else if (zone->type == dns_zone_primary &&
inline_secure(zone) && result == ISC_R_FILENOTFOUND)
dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, level,
"loading from master file %s failed: %s",
zone->masterfile,
- dns_result_totext(result));
+ isc_result_totext(result));
nomaster = true;
}
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"zone_resigninc:dns_db_newversion -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"zone_resigninc:dns__zone_findkeys -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND) {
dns_zone_log(zone, ISC_LOG_ERROR,
"zone_resigninc:dns_db_getsigningtime -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
i = 0;
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"zone_resigninc:del_sigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
break;
}
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"zone_resigninc:add_sigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
break;
}
result = dns_db_getsigningtime(db, &rdataset, name);
dns_zone_log(zone, ISC_LOG_ERROR,
"zone_resigninc:dns_db_getsigningtime -> "
"%s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
}
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"zone_resigninc:del_sigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"zone_resigninc:update_soa_serial -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"zone_resigninc:add_sigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"dns__zone_updatesigs:del_sigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
return (result);
}
result = add_sigs(db, version, &tuple->name, zone,
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"dns__zone_updatesigs:add_sigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
return (result);
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:dns_db_newversion -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:dns__zone_findkeys -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:"
"dns_nsec3_addnsec3 -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:"
"dns_dbiterator_next -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
} else if (delegation) {
dns_dbiterator_current(nsec3chain->dbiterator,
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:"
"need_nsec_chain -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
}
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:"
"fixup_nsec3param -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
}
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:"
"deletematchingnsec3 -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
goto next_removenode;
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:"
"fixup_nsec3param -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
goto next_removechain;
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:"
"dns_dbiterator_next -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
} else if (delegation) {
dns_dbiterator_current(nsec3chain->dbiterator,
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:dns_db_allrdatasets -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
for (result = dns_rdatasetiter_first(iterator);
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:updatesecure -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
}
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:"
"dns_nsec3_addnsec3s -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:dns__zone_updatesigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:dns__zone_updatesigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:updatesecure -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:dns__zone_updatesigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:del_sigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:update_soa_serial -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_nsec3chain:add_sigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
failure:
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR, "zone_nsec3chain: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
/*
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_sign:dns_db_newversion -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_sign:dns__zone_findkeys -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"updatesecure -> %s",
- dns_result_totext(
+ isc_result_totext(
result));
goto cleanup;
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"updatesignwithkey -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
build_nsec = false;
dnssec_log(zone, ISC_LOG_ERROR,
"zone_sign:"
"dns_dbiterator_next -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
} else if (is_bottom_of_zone) {
dns_dbiterator_current(signing->dbiterator,
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_sign:dns__zone_updatesigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
}
&zonediff, zone_keys, nkeys, now, false);
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR, "zone_sign:del_sigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_sign:update_soa_serial -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
inception, soaexpire, check_ksk, keyset_kskonly);
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR, "zone_sign:add_sigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
failure:
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR, "zone_sign: failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
cleanup:
dnssec_log(kfetch->zone, ISC_LOG_DEBUG(3),
"Confirm revoked DNSKEY is self-signed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
if (result == ISC_R_SUCCESS) {
answer = true;
dnssec_log(zone, ISC_LOG_DEBUG(3),
"Returned from key fetch in keyfetch_done() for '%s': %s",
- namebuf, dns_result_totext(eresult));
+ namebuf, isc_result_totext(eresult));
/* Fetch failed */
if (eresult != ISC_R_SUCCESS || !dns_rdataset_isassociated(dnskeys)) {
dnssec_log(zone, ISC_LOG_WARNING,
"Unable to fetch DNSKEY set '%s': %s", namebuf,
- dns_result_totext(eresult));
+ isc_result_totext(eresult));
CHECK(minimal_update(kfetch, ver, &diff));
goto done;
}
if (!dns_rdataset_isassociated(dnskeysigs)) {
dnssec_log(zone, ISC_LOG_WARNING,
"No DNSKEY RRSIGs found for '%s': %s", namebuf,
- dns_result_totext(eresult));
+ isc_result_totext(eresult));
CHECK(minimal_update(kfetch, ver, &diff));
goto done;
}
"Verifying DNSKEY set for zone "
"'%s' using DS %d/%d: %s",
namebuf, sig.keyid, sig.algorithm,
- dns_result_totext(result));
+ isc_result_totext(result));
if (result == ISC_R_SUCCESS) {
dnskeys->trust = dns_trust_secure;
"Cannot compute tag for key in zone %s: "
"%s "
"(skipping)",
- namebuf, dns_result_totext(result));
+ namebuf, isc_result_totext(result));
continue;
}
RUNTIME_CHECK(result == ISC_R_SUCCESS);
"Cannot compute tag for key in zone %s: "
"%s "
"(skipping)",
- namebuf, dns_result_totext(result));
+ namebuf, isc_result_totext(result));
continue;
}
RUNTIME_CHECK(result == ISC_R_SUCCESS);
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_WARNING,
"dump failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
}
break;
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_WARNING,
"isc_time_nowplusinterval() failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
/*
} else if (result != ISC_R_SUCCESS) {
dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR,
"journal open failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
return (result);
}
ISC_LOG_DEBUG(1),
"journal rollforward completed successfully "
"using old journal format: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
} else {
dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD,
ISC_LOG_DEBUG(1),
"journal rollforward completed "
"successfully: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
dns_journal_destroy(&journal);
default:
dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR,
"journal rollforward failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
dns_journal_destroy(&journal);
return (result);
}
case ISC_R_NOSPACE:
case ISC_R_NOTFOUND:
dns_zone_log(zone, ISC_LOG_DEBUG(3), "dns_journal_compact: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
break;
default:
dns_zone_log(zone, ISC_LOG_ERROR,
"dns_journal_compact failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
break;
}
}
dns_zone_log(zone, ISC_LOG_INFO,
"could not refresh stub from master %s"
" (source %s): %s",
- master, source, dns_result_totext(revent->result));
+ master, source, isc_result_totext(revent->result));
goto cleanup;
}
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: "
"dns_db_findnode() failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: "
"dns_db_addrdataset() failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
dns_db_detachnode(stub->db, &node);
if (result != ISC_R_SUCCESS) {
zone_debuglog(zone, "stub_send_query", 1,
"unable to add opt record: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto fail;
}
}
1) > 1);
zone_debuglog(zone, "stub_send_query", 1,
"dns_request_createvia() failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto fail;
}
dns_zone_log(zone, ISC_LOG_INFO,
"could not refresh stub from master %s"
" (source %s): %s",
- master, source, dns_result_totext(revent->result));
+ master, source, isc_result_totext(revent->result));
goto next_master;
}
dns_zone_log(zone, ISC_LOG_ERROR,
"refresh: could not set "
"file modification time of '%s': %s",
- zone->masterfile, dns_result_totext(result));
+ zone->masterfile, isc_result_totext(result));
}
}
"refresh: failure trying master "
"%s (source %s): %s",
master, source,
- dns_result_totext(revent->result));
+ isc_result_totext(revent->result));
}
goto next_master;
}
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: unable to get response, master "
"%s, source %s: %s",
- master, source, dns_result_totext(result));
+ master, source, isc_result_totext(result));
goto next_master;
}
if (result != ISC_R_SUCCESS) {
zone_debuglog(zone, me, 1,
"unable to add opt record: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
}
if (result != ISC_R_SUCCESS) {
zone_idetach(&dummy);
zone_debuglog(zone, me, 1, "dns_request_createvia() failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto skip_master;
} else {
if (isc_sockaddr_pf(&zone->masteraddr) == PF_INET) {
"refreshing stub: "
"could not create "
"database: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
dns_db_settask(stub->db, zone->task);
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: "
"dns_db_newversion() failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: "
"dns_db_findnode() failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: "
"dns_db_addrdataset() failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
}
if (result != ISC_R_SUCCESS) {
zone_debuglog(zone, me, 1,
"unable to add opt record: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
}
timeout, 0, zone->task, stub_callback, cb_args, &zone->request);
if (result != ISC_R_SUCCESS) {
zone_debuglog(zone, me, 1, "dns_request_createvia() failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto cleanup;
}
dns_message_detach(&message);
} else {
notify_log(notify->zone, ISC_LOG_DEBUG(2),
"notify to %s failed: %s", addrbuf,
- dns_result_totext(result));
+ isc_result_totext(result));
}
/*
level = ISC_LOG_INFO;
}
dns_zone_log(zone, level, "receive_secure_serial: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
if (tuple != NULL) {
dns_difftuple_free(&tuple);
}
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR, "receive_secure_db: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
while (!ISC_LIST_EMPTY(nsec3list)) {
} else {
dns_zone_log(zone, ISC_LOG_ERROR,
"retrieving SOA and NS records failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
return (result);
}
REQUIRE(DNS_ZONE_VALID(zone));
dns_zone_logc(zone, DNS_LOGCATEGORY_XFER_IN, ISC_LOG_DEBUG(1),
- "zone transfer finished: %s", dns_result_totext(result));
+ "zone transfer finished: %s", isc_result_totext(result));
/*
* Obtaining a lock on the zone->secure (see zone_send_secureserial)
"transfer: could not set file "
"modification time of '%s': %s",
zone->masterfile,
- dns_result_totext(result));
+ isc_result_totext(result));
}
}
DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NODELAY);
if (revent->result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_INFO,
"could not forward dynamic update to %s: %s",
- master, dns_result_totext(revent->result));
+ master, isc_result_totext(revent->result));
goto next_master;
}
dns_name_format(name, namebuf, sizeof(namebuf));
dns_rdatatype_format(rdata->type, typebuf, sizeof(typebuf));
dns_zone_log(zone, level, "%s/%s: %s", namebuf, typebuf,
- dns_result_totext(DNS_R_BADOWNERNAME));
+ isc_result_totext(DNS_R_BADOWNERNAME));
if (fail) {
return (DNS_R_BADOWNERNAME);
}
dns_name_format(&bad, namebuf2, sizeof(namebuf2));
dns_rdatatype_format(rdata->type, typebuf, sizeof(typebuf));
dns_zone_log(zone, level, "%s/%s: %s: %s ", namebuf, typebuf,
- namebuf2, dns_result_totext(DNS_R_BADNAME));
+ namebuf2, isc_result_totext(DNS_R_BADNAME));
if (fail) {
return (DNS_R_BADNAME);
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"sign_apex:del_sigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
return (result);
}
result = add_sigs(db, ver, &zone->origin, zone, rrtype,
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"sign_apex:add_sigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
return (result);
}
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"sign_apex:dns__zone_findkeys -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
return (result);
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"sign_apex:dns__zone_updatesigs -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
dns_zone_log(
checkds->zone, ISC_LOG_DEBUG(3),
"checkds: dns_request_createvia() to %s failed: %s",
- addrbuf, dns_result_totext(result));
+ addrbuf, isc_result_totext(result));
}
cleanup_key:
dnssec_log(zone, ISC_LOG_ERROR,
"zone_signwithkey failed: "
"%s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
/* Clear DNSSEC sign statistics. */
dnssec_log(zone, ISC_LOG_ERROR,
"zone_signwithkey failed: "
"%s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
}
} else if (newalg) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_signwithkey failed: "
"%s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
}
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"zone_addnsec3chain failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"keydone:dns_db_newversion -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
if (result != ISC_R_SUCCESS) {
dnssec_log(zone, ISC_LOG_ERROR,
"setnsec3param:dns_db_newversion -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
dns_zone_log(zone, ISC_LOG_ERROR,
"dns__zone_lookup_nsec3param:"
"dns_db_findnode -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
result = ISC_R_FAILURE;
goto setparam;
}
dns_zone_log(zone, ISC_LOG_ERROR,
"dns__zone_lookup_nsec3param:"
"dns_db_findrdataset -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
goto setparam;
}
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"setserial:dns_db_newversion -> %s",
- dns_result_totext(result));
+ isc_result_totext(result));
goto failure;
}
#include <dns/rdatasetiter.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
-#include <dns/result.h>
#include <dns/secalg.h>
#include <dns/types.h>
#include <dns/zone.h>
result = vresult;
if (result != ISC_R_SUCCESS) {
report("DNSSEC completeness test failed (%s).",
- dns_result_totext(result));
+ isc_result_totext(result));
goto done;
}
#include <isc/file.h>
#include <isc/magic.h>
#include <isc/mem.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/task.h>
#include <isc/util.h>
#include <dns/name.h>
#include <dns/rbt.h>
#include <dns/rdataclass.h>
-#include <dns/result.h>
#include <dns/view.h>
#include <dns/zone.h>
#include <dns/zt.h>
include/isc/region.h \
include/isc/resource.h \
include/isc/result.h \
- include/isc/resultclass.h \
include/isc/rwlock.h \
include/isc/safe.h \
include/isc/serial.h \
#include <isc/lang.h>
#include <isc/magic.h>
#include <isc/result.h>
+#include <isc/types.h>
/***
*** Types
#include <isc/lang.h>
#include <isc/result.h>
+#include <isc/types.h>
/*% Index into parent argv vector. */
extern int isc_commandline_index;
/*! \file isc/result.h */
+#include <inttypes.h>
+
#include <isc/lang.h>
-#include <isc/types.h>
-#define ISC_R_SUCCESS 0 /*%< success */
-#define ISC_R_NOMEMORY 1 /*%< out of memory */
-#define ISC_R_TIMEDOUT 2 /*%< timed out */
-#define ISC_R_NOTHREADS 3 /*%< no available threads */
-#define ISC_R_ADDRNOTAVAIL 4 /*%< address not available */
-#define ISC_R_ADDRINUSE 5 /*%< address in use */
-#define ISC_R_NOPERM 6 /*%< permission denied */
-#define ISC_R_NOCONN 7 /*%< no pending connections */
-#define ISC_R_NETUNREACH 8 /*%< network unreachable */
-#define ISC_R_HOSTUNREACH 9 /*%< host unreachable */
-#define ISC_R_NETDOWN 10 /*%< network down */
-#define ISC_R_HOSTDOWN 11 /*%< host down */
-#define ISC_R_CONNREFUSED 12 /*%< connection refused */
-#define ISC_R_NORESOURCES 13 /*%< not enough free resources */
-#define ISC_R_EOF 14 /*%< end of file */
-#define ISC_R_BOUND 15 /*%< socket already bound */
-#define ISC_R_RELOAD 16 /*%< reload */
-#define ISC_R_SUSPEND ISC_R_RELOAD /*%< alias of 'reload' */
-#define ISC_R_LOCKBUSY 17 /*%< lock busy */
-#define ISC_R_EXISTS 18 /*%< already exists */
-#define ISC_R_NOSPACE 19 /*%< ran out of space */
-#define ISC_R_CANCELED 20 /*%< operation canceled */
-#define ISC_R_NOTBOUND 21 /*%< socket is not bound */
-#define ISC_R_SHUTTINGDOWN 22 /*%< shutting down */
-#define ISC_R_NOTFOUND 23 /*%< not found */
-#define ISC_R_UNEXPECTEDEND 24 /*%< unexpected end of input */
-#define ISC_R_FAILURE 25 /*%< generic failure */
-#define ISC_R_IOERROR 26 /*%< I/O error */
-#define ISC_R_NOTIMPLEMENTED 27 /*%< not implemented */
-#define ISC_R_UNBALANCED 28 /*%< unbalanced parentheses */
-#define ISC_R_NOMORE 29 /*%< no more */
-#define ISC_R_INVALIDFILE 30 /*%< invalid file */
-#define ISC_R_BADBASE64 31 /*%< bad base64 encoding */
-#define ISC_R_UNEXPECTEDTOKEN 32 /*%< unexpected token */
-#define ISC_R_QUOTA 33 /*%< quota reached */
-#define ISC_R_UNEXPECTED 34 /*%< unexpected error */
-#define ISC_R_ALREADYRUNNING 35 /*%< already running */
-#define ISC_R_IGNORE 36 /*%< ignore */
-#define ISC_R_MASKNONCONTIG 37 /*%< addr mask not contiguous */
-#define ISC_R_FILENOTFOUND 38 /*%< file not found */
-#define ISC_R_FILEEXISTS 39 /*%< file already exists */
-#define ISC_R_NOTCONNECTED 40 /*%< socket is not connected */
-#define ISC_R_RANGE 41 /*%< out of range */
-#define ISC_R_NOENTROPY 42 /*%< out of entropy */
-#define ISC_R_MULTICAST 43 /*%< invalid use of multicast */
-#define ISC_R_NOTFILE 44 /*%< not a file */
-#define ISC_R_NOTDIRECTORY 45 /*%< not a directory */
-#define ISC_R_EMPTY 46 /*%< queue is empty */
-#define ISC_R_FAMILYMISMATCH 47 /*%< address family mismatch */
-#define ISC_R_FAMILYNOSUPPORT 48 /*%< AF not supported */
-#define ISC_R_BADHEX 49 /*%< bad hex encoding */
-#define ISC_R_TOOMANYOPENFILES 50 /*%< too many open files */
-#define ISC_R_NOTBLOCKING 51 /*%< not blocking */
-#define ISC_R_UNBALANCEDQUOTES 52 /*%< unbalanced quotes */
-#define ISC_R_INPROGRESS 53 /*%< operation in progress */
-#define ISC_R_CONNECTIONRESET 54 /*%< connection reset */
-#define ISC_R_SOFTQUOTA 55 /*%< soft quota reached */
-#define ISC_R_BADNUMBER 56 /*%< not a valid number */
-#define ISC_R_DISABLED 57 /*%< disabled */
-#define ISC_R_MAXSIZE 58 /*%< max size */
-#define ISC_R_BADADDRESSFORM 59 /*%< invalid address format */
-#define ISC_R_BADBASE32 60 /*%< bad base32 encoding */
-#define ISC_R_UNSET 61 /*%< unset */
-#define ISC_R_MULTIPLE 62 /*%< multiple */
-#define ISC_R_WOULDBLOCK 63 /*%< would block */
-#define ISC_R_COMPLETE 64 /*%< complete */
-#define ISC_R_CRYPTOFAILURE 65 /*%< cryptography library failure */
-#define ISC_R_DISCQUOTA 66 /*%< disc quota */
-#define ISC_R_DISCFULL 67 /*%< disc full */
-#define ISC_R_DEFAULT 68 /*%< default */
-#define ISC_R_IPV4PREFIX 69 /*%< IPv4 prefix */
-#define ISC_R_TLSERROR 70 /*%< TLS error */
-#define ISC_R_HTTP2ALPNERROR 71 /*%< ALPN for HTTP/2 failed */
+typedef enum isc_result {
+ ISC_R_SUCCESS, /*%< success */
+ ISC_R_NOMEMORY, /*%< out of memory */
+ ISC_R_TIMEDOUT, /*%< timed out */
+ ISC_R_NOTHREADS, /*%< no available threads */
+ ISC_R_ADDRNOTAVAIL, /*%< address not available */
+ ISC_R_ADDRINUSE, /*%< address in use */
+ ISC_R_NOPERM, /*%< permission denied */
+ ISC_R_NOCONN, /*%< no pending connections */
+ ISC_R_NETUNREACH, /*%< network unreachable */
+ ISC_R_HOSTUNREACH, /*%< host unreachable */
+ ISC_R_NETDOWN, /*%< network down */
+ ISC_R_HOSTDOWN, /*%< host down */
+ ISC_R_CONNREFUSED, /*%< connection refused */
+ ISC_R_NORESOURCES, /*%< not enough free resources */
+ ISC_R_EOF, /*%< end of file */
+ ISC_R_BOUND, /*%< socket already bound */
+ ISC_R_RELOAD, /*%< reload */
+ ISC_R_SUSPEND = ISC_R_RELOAD, /*%< alias of 'reload' */
+ ISC_R_LOCKBUSY, /*%< lock busy */
+ ISC_R_EXISTS, /*%< already exists */
+ ISC_R_NOSPACE, /*%< ran out of space */
+ ISC_R_CANCELED, /*%< operation canceled */
+ ISC_R_NOTBOUND, /*%< socket is not bound */
+ ISC_R_SHUTTINGDOWN, /*%< shutting down */
+ ISC_R_NOTFOUND, /*%< not found */
+ ISC_R_UNEXPECTEDEND, /*%< unexpected end of input */
+ ISC_R_FAILURE, /*%< generic failure */
+ ISC_R_IOERROR, /*%< I/O error */
+ ISC_R_NOTIMPLEMENTED, /*%< not implemented */
+ ISC_R_UNBALANCED, /*%< unbalanced parentheses */
+ ISC_R_NOMORE, /*%< no more */
+ ISC_R_INVALIDFILE, /*%< invalid file */
+ ISC_R_BADBASE64, /*%< bad base64 encoding */
+ ISC_R_UNEXPECTEDTOKEN, /*%< unexpected token */
+ ISC_R_QUOTA, /*%< quota reached */
+ ISC_R_UNEXPECTED, /*%< unexpected error */
+ ISC_R_ALREADYRUNNING, /*%< already running */
+ ISC_R_IGNORE, /*%< ignore */
+ ISC_R_MASKNONCONTIG, /*%< addr mask not contiguous */
+ ISC_R_FILENOTFOUND, /*%< file not found */
+ ISC_R_FILEEXISTS, /*%< file already exists */
+ ISC_R_NOTCONNECTED, /*%< socket is not connected */
+ ISC_R_RANGE, /*%< out of range */
+ ISC_R_NOENTROPY, /*%< out of entropy */
+ ISC_R_MULTICAST, /*%< invalid use of multicast */
+ ISC_R_NOTFILE, /*%< not a file */
+ ISC_R_NOTDIRECTORY, /*%< not a directory */
+ ISC_R_EMPTY, /*%< queue is empty */
+ ISC_R_FAMILYMISMATCH, /*%< address family mismatch */
+ ISC_R_FAMILYNOSUPPORT, /*%< AF not supported */
+ ISC_R_BADHEX, /*%< bad hex encoding */
+ ISC_R_TOOMANYOPENFILES, /*%< too many open files */
+ ISC_R_NOTBLOCKING, /*%< not blocking */
+ ISC_R_UNBALANCEDQUOTES, /*%< unbalanced quotes */
+ ISC_R_INPROGRESS, /*%< operation in progress */
+ ISC_R_CONNECTIONRESET, /*%< connection reset */
+ ISC_R_SOFTQUOTA, /*%< soft quota reached */
+ ISC_R_BADNUMBER, /*%< not a valid number */
+ ISC_R_DISABLED, /*%< disabled */
+ ISC_R_MAXSIZE, /*%< max size */
+ ISC_R_BADADDRESSFORM, /*%< invalid address format */
+ ISC_R_BADBASE32, /*%< bad base32 encoding */
+ ISC_R_UNSET, /*%< unset */
+ ISC_R_MULTIPLE, /*%< multiple */
+ ISC_R_WOULDBLOCK, /*%< would block */
+ ISC_R_COMPLETE, /*%< complete */
+ ISC_R_CRYPTOFAILURE, /*%< cryptography library failure */
+ ISC_R_DISCQUOTA, /*%< disc quota */
+ ISC_R_DISCFULL, /*%< disc full */
+ ISC_R_DEFAULT, /*%< default */
+ ISC_R_IPV4PREFIX, /*%< IPv4 prefix */
+ ISC_R_TLSERROR, /*%< TLS error */
+ ISC_R_HTTP2ALPNERROR, /*%< ALPN for HTTP/2 failed */
+
+ DNS_R_LABELTOOLONG = 1 << 16,
+ DNS_R_BADESCAPE,
+ DNS_R_EMPTYLABEL,
+ DNS_R_BADDOTTEDQUAD,
+ DNS_R_INVALIDNS,
+ DNS_R_UNKNOWN,
+ DNS_R_BADLABELTYPE,
+ DNS_R_BADPOINTER,
+ DNS_R_TOOMANYHOPS,
+ DNS_R_DISALLOWED,
+ DNS_R_EXTRATOKEN,
+ DNS_R_EXTRADATA,
+ DNS_R_TEXTTOOLONG,
+ DNS_R_NOTZONETOP,
+ DNS_R_SYNTAX,
+ DNS_R_BADCKSUM,
+ DNS_R_BADAAAA,
+ DNS_R_NOOWNER,
+ DNS_R_NOTTL,
+ DNS_R_BADCLASS,
+ DNS_R_NAMETOOLONG,
+ DNS_R_PARTIALMATCH,
+ DNS_R_NEWORIGIN,
+ DNS_R_UNCHANGED,
+ DNS_R_BADTTL,
+ DNS_R_NOREDATA,
+ DNS_R_CONTINUE,
+ DNS_R_DELEGATION,
+ DNS_R_GLUE,
+ DNS_R_DNAME,
+ DNS_R_CNAME,
+ DNS_R_BADDB,
+ DNS_R_ZONECUT,
+ DNS_R_BADZONE,
+ DNS_R_MOREDATA,
+ DNS_R_UPTODATE,
+ DNS_R_TSIGVERIFYFAILURE,
+ DNS_R_TSIGERRORSET,
+ DNS_R_SIGINVALID,
+ DNS_R_SIGEXPIRED,
+ DNS_R_SIGFUTURE,
+ DNS_R_KEYUNAUTHORIZED,
+ DNS_R_INVALIDTIME,
+ DNS_R_EXPECTEDTSIG,
+ DNS_R_UNEXPECTEDTSIG,
+ DNS_R_INVALIDTKEY,
+ DNS_R_HINT,
+ DNS_R_DROP,
+ DNS_R_NOTLOADED,
+ DNS_R_NCACHENXDOMAIN,
+ DNS_R_NCACHENXRRSET,
+ DNS_R_WAIT,
+ DNS_R_NOTVERIFIEDYET,
+ DNS_R_NOIDENTITY,
+ DNS_R_NOJOURNAL,
+ DNS_R_ALIAS,
+ DNS_R_USETCP,
+ DNS_R_NOVALIDSIG,
+ DNS_R_NOVALIDNSEC,
+ DNS_R_NOTINSECURE,
+ DNS_R_UNKNOWNSERVICE,
+ DNS_R_RECOVERABLE,
+ DNS_R_UNKNOWNOPT,
+ DNS_R_UNEXPECTEDID,
+ DNS_R_SEENINCLUDE,
+ DNS_R_NOTEXACT,
+ DNS_R_BLACKHOLED,
+ DNS_R_BADALG,
+ DNS_R_METATYPE,
+ DNS_R_CNAMEANDOTHER,
+ DNS_R_SINGLETON,
+ DNS_R_HINTNXRRSET,
+ DNS_R_NOMASTERFILE,
+ DNS_R_UNKNOWNPROTO,
+ DNS_R_CLOCKSKEW,
+ DNS_R_BADIXFR,
+ DNS_R_NOTAUTHORITATIVE,
+ DNS_R_NOVALIDKEY,
+ DNS_R_OBSOLETE,
+ DNS_R_FROZEN,
+ DNS_R_UNKNOWNFLAG,
+ DNS_R_EXPECTEDRESPONSE,
+ DNS_R_NOVALIDDS,
+ DNS_R_NSISADDRESS,
+ DNS_R_REMOTEFORMERR,
+ DNS_R_TRUNCATEDTCP,
+ DNS_R_LAME,
+ DNS_R_UNEXPECTEDRCODE,
+ DNS_R_UNEXPECTEDOPCODE,
+ DNS_R_CHASEDSSERVERS,
+ DNS_R_EMPTYNAME,
+ DNS_R_EMPTYWILD,
+ DNS_R_BADBITMAP,
+ DNS_R_FROMWILDCARD,
+ DNS_R_BADOWNERNAME,
+ DNS_R_BADNAME,
+ DNS_R_DYNAMIC,
+ DNS_R_UNKNOWNCOMMAND,
+ DNS_R_MUSTBESECURE,
+ DNS_R_COVERINGNSEC,
+ DNS_R_MXISADDRESS,
+ DNS_R_DUPLICATE,
+ DNS_R_INVALIDNSEC3,
+ DNS_R_NOTMASTER,
+ DNS_R_BROKENCHAIN,
+ DNS_R_EXPIRED,
+ DNS_R_NOTDYNAMIC,
+ DNS_R_BADEUI,
+ DNS_R_NTACOVERED,
+ DNS_R_BADCDS,
+ DNS_R_BADCDNSKEY,
+ DNS_R_OPTERR,
+ DNS_R_BADDNSTAP,
+ DNS_R_BADTSIG,
+ DNS_R_BADSIG0,
+ DNS_R_TOOMANYRECORDS,
+ DNS_R_VERIFYFAILURE,
+ DNS_R_ATZONETOP,
+ DNS_R_NOKEYMATCH,
+ DNS_R_TOOMANYKEYS,
+ DNS_R_KEYNOTACTIVE,
+ DNS_R_NSEC3ITERRANGE,
+ DNS_R_NSEC3SALTRANGE,
+ DNS_R_NSEC3BADALG,
+ DNS_R_NSEC3RESALT,
+ DNS_R_INCONSISTENTRR,
+
+ DST_R_UNSUPPORTEDALG = 2 << 16,
+ DST_R_CRYPTOFAILURE,
+ /* compat */
+ DST_R_OPENSSLFAILURE = DST_R_CRYPTOFAILURE,
+ DST_R_NOCRYPTO,
+ DST_R_NULLKEY,
+ DST_R_INVALIDPUBLICKEY,
+ DST_R_INVALIDPRIVATEKEY,
+ DST_R_WRITEERROR,
+ DST_R_INVALIDPARAM,
+ DST_R_SIGNFAILURE,
+ DST_R_VERIFYFAILURE,
+ DST_R_NOTPUBLICKEY,
+ DST_R_NOTPRIVATEKEY,
+ DST_R_KEYCANNOTCOMPUTESECRET,
+ DST_R_COMPUTESECRETFAILURE,
+ DST_R_NORANDOMNESS,
+ DST_R_BADKEYTYPE,
+ DST_R_NOENGINE,
+ DST_R_EXTERNALKEY,
+
+ DNS_R_NOERROR = 3 << 16,
+ DNS_R_FORMERR,
+ DNS_R_SERVFAIL,
+ DNS_R_NXDOMAIN,
+ DNS_R_NOTIMP,
+ DNS_R_REFUSED,
+ DNS_R_YXDOMAIN,
+ DNS_R_YXRRSET,
+ DNS_R_NXRRSET,
+ DNS_R_NOTAUTH,
+ DNS_R_NOTZONE,
+ DNS_R_RCODE11,
+ DNS_R_RCODE12,
+ DNS_R_RCODE13,
+ DNS_R_RCODE14,
+ DNS_R_RCODE15,
+ DNS_R_BADVERS,
-/*% Not a result code: the number of results. */
-#define ISC_R_NRESULTS 72
+ ISCCC_R_UNKNOWNVERSION = 5 << 16,
+ ISCCC_R_SYNTAX,
+ ISCCC_R_BADAUTH,
+ ISCCC_R_EXPIRED,
+ ISCCC_R_CLOCKSKEW,
+ ISCCC_R_DUPLICATE,
+
+ ISC_R_NRESULTS = ISCCC_R_DUPLICATE + 1, /*% The number of results. */
+ ISC_R_MAKE_ENUM_32BIT = INT32_MAX,
+} isc_result_t;
ISC_LANG_BEGINDECLS
* "ISC_R_SUCCESS".
*/
-isc_result_t
-isc_result_register(unsigned int base, unsigned int nresults, const char **text,
- int set);
-
-isc_result_t
-isc_result_registerids(unsigned int base, unsigned int nresults,
- const char **ids, int set);
-
ISC_LANG_ENDDECLS
#endif /* ISC_RESULT_H */
+++ /dev/null
-/*
- * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, you can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-#ifndef ISC_RESULTCLASS_H
-#define ISC_RESULTCLASS_H 1
-
-/*! \file isc/resultclass.h
- * \brief Registry of Predefined Result Type Classes
- *
- * A result class number is an unsigned 16 bit number. Each class may
- * contain up to 65536 results. A result code is formed by adding the
- * result number within the class to the class number multiplied by 65536.
- *
- * Classes < 1024 are reserved for ISC use.
- * Result classes >= 1024 and <= 65535 are reserved for application use.
- */
-
-#define ISC_RESULTCLASS_FROMNUM(num) ((num) << 16)
-#define ISC_RESULTCLASS_TONUM(rclass) ((rclass) >> 16)
-#define ISC_RESULTCLASS_SIZE 65536
-#define ISC_RESULTCLASS_INCLASS(rclass, result) \
- ((rclass) == ((result)&0xFFFF0000))
-
-#define ISC_RESULTCLASS_ISC ISC_RESULTCLASS_FROMNUM(0)
-#define ISC_RESULTCLASS_DNS ISC_RESULTCLASS_FROMNUM(1)
-#define ISC_RESULTCLASS_DST ISC_RESULTCLASS_FROMNUM(2)
-#define ISC_RESULTCLASS_DNSRCODE ISC_RESULTCLASS_FROMNUM(3)
-#define ISC_RESULTCLASS_OMAPI ISC_RESULTCLASS_FROMNUM(4)
-#define ISC_RESULTCLASS_ISCCC ISC_RESULTCLASS_FROMNUM(5)
-#define ISC_RESULTCLASS_DHCP ISC_RESULTCLASS_FROMNUM(6)
-#define ISC_RESULTCLASS_PK11 ISC_RESULTCLASS_FROMNUM(7)
-
-#endif /* ISC_RESULTCLASS_H */
#define ISC_TYPES_H 1
#include <isc/bind9.h>
+#include <isc/result.h>
/*! \file isc/types.h
* \brief
typedef struct isc_ratelimiter isc_ratelimiter_t; /*%< Rate Limiter */
typedef struct isc_region isc_region_t; /*%< Region */
typedef uint64_t isc_resourcevalue_t; /*%< Resource Value */
-typedef unsigned int isc_result_t; /*%< Result */
typedef struct isc_rwlock isc_rwlock_t; /*%< Read Write Lock */
typedef struct isc_sockaddr isc_sockaddr_t; /*%< Socket Address */
typedef ISC_LIST(isc_sockaddr_t) isc_sockaddrlist_t; /*%< Socket Address List
#include <stdlib.h>
#include <isc/once.h>
-#include <isc/resultclass.h>
-#include <isc/rwlock.h>
#include <isc/util.h>
-typedef struct resulttable {
- unsigned int base;
- unsigned int last;
- const char **text;
- int set;
- ISC_LINK(struct resulttable) link;
-} resulttable;
-
-typedef ISC_LIST(resulttable) resulttable_list_t;
-
static const char *description[ISC_R_NRESULTS] = {
- "success", /*%< 0 */
- "out of memory", /*%< 1 */
- "timed out", /*%< 2 */
- "no available threads", /*%< 3 */
- "address not available", /*%< 4 */
- "address in use", /*%< 5 */
- "permission denied", /*%< 6 */
- "no pending connections", /*%< 7 */
- "network unreachable", /*%< 8 */
- "host unreachable", /*%< 9 */
- "network down", /*%< 10 */
- "host down", /*%< 11 */
- "connection refused", /*%< 12 */
- "not enough free resources", /*%< 13 */
- "end of file", /*%< 14 */
- "socket already bound", /*%< 15 */
- "reload", /*%< 16 */
- "lock busy", /*%< 17 */
- "already exists", /*%< 18 */
- "ran out of space", /*%< 19 */
- "operation canceled", /*%< 20 */
- "socket is not bound", /*%< 21 */
- "shutting down", /*%< 22 */
- "not found", /*%< 23 */
- "unexpected end of input", /*%< 24 */
- "failure", /*%< 25 */
- "I/O error", /*%< 26 */
- "not implemented", /*%< 27 */
- "unbalanced parentheses", /*%< 28 */
- "no more", /*%< 29 */
- "invalid file", /*%< 30 */
- "bad base64 encoding", /*%< 31 */
- "unexpected token", /*%< 32 */
- "quota reached", /*%< 33 */
- "unexpected error", /*%< 34 */
- "already running", /*%< 35 */
- "ignore", /*%< 36 */
- "address mask not contiguous", /*%< 37 */
- "file not found", /*%< 38 */
- "file already exists", /*%< 39 */
- "socket is not connected", /*%< 40 */
- "out of range", /*%< 41 */
- "out of entropy", /*%< 42 */
- "invalid use of multicast address", /*%< 43 */
- "not a file", /*%< 44 */
- "not a directory", /*%< 45 */
- "queue is empty", /*%< 46 */
- "address family mismatch", /*%< 47 */
- "address family not supported", /*%< 48 */
- "bad hex encoding", /*%< 49 */
- "too many open files", /*%< 50 */
- "not blocking", /*%< 51 */
- "unbalanced quotes", /*%< 52 */
- "operation in progress", /*%< 53 */
- "connection reset", /*%< 54 */
- "soft quota reached", /*%< 55 */
- "not a valid number", /*%< 56 */
- "disabled", /*%< 57 */
- "max size", /*%< 58 */
- "invalid address format", /*%< 59 */
- "bad base32 encoding", /*%< 60 */
- "unset", /*%< 61 */
- "multiple", /*%< 62 */
- "would block", /*%< 63 */
- "complete", /*%< 64 */
- "crypto failure", /*%< 65 */
- "disc quota", /*%< 66 */
- "disc full", /*%< 67 */
- "default", /*%< 68 */
- "IPv4 prefix", /*%< 69 */
- "TLS error", /*%< 70 */
- "ALPN for HTTP/2 failed" /*%< 71 */
+ [ISC_R_SUCCESS] = "success",
+ [ISC_R_NOMEMORY] = "out of memory",
+ [ISC_R_TIMEDOUT] = "timed out",
+ [ISC_R_NOTHREADS] = "no available threads",
+ [ISC_R_ADDRNOTAVAIL] = "address not available",
+ [ISC_R_ADDRINUSE] = "address in use",
+ [ISC_R_NOPERM] = "permission denied",
+ [ISC_R_NOCONN] = "no pending connections",
+ [ISC_R_NETUNREACH] = "network unreachable",
+ [ISC_R_HOSTUNREACH] = "host unreachable",
+ [ISC_R_NETDOWN] = "network down",
+ [ISC_R_HOSTDOWN] = "host down",
+ [ISC_R_CONNREFUSED] = "connection refused",
+ [ISC_R_NORESOURCES] = "not enough free resources",
+ [ISC_R_EOF] = "end of file",
+ [ISC_R_BOUND] = "socket already bound",
+ [ISC_R_RELOAD] = "reload",
+ [ISC_R_LOCKBUSY] = "lock busy",
+ [ISC_R_EXISTS] = "already exists",
+ [ISC_R_NOSPACE] = "ran out of space",
+ [ISC_R_CANCELED] = "operation canceled",
+ [ISC_R_NOTBOUND] = "socket is not bound",
+ [ISC_R_SHUTTINGDOWN] = "shutting down",
+ [ISC_R_NOTFOUND] = "not found",
+ [ISC_R_UNEXPECTEDEND] = "unexpected end of input",
+ [ISC_R_FAILURE] = "failure",
+ [ISC_R_IOERROR] = "I/O error",
+ [ISC_R_NOTIMPLEMENTED] = "not implemented",
+ [ISC_R_UNBALANCED] = "unbalanced parentheses",
+ [ISC_R_NOMORE] = "no more",
+ [ISC_R_INVALIDFILE] = "invalid file",
+ [ISC_R_BADBASE64] = "bad base64 encoding",
+ [ISC_R_UNEXPECTEDTOKEN] = "unexpected token",
+ [ISC_R_QUOTA] = "quota reached",
+ [ISC_R_UNEXPECTED] = "unexpected error",
+ [ISC_R_ALREADYRUNNING] = "already running",
+ [ISC_R_IGNORE] = "ignore",
+ [ISC_R_MASKNONCONTIG] = "address mask not contiguous",
+ [ISC_R_FILENOTFOUND] = "file not found",
+ [ISC_R_FILEEXISTS] = "file already exists",
+ [ISC_R_NOTCONNECTED] = "socket is not connected",
+ [ISC_R_RANGE] = "out of range",
+ [ISC_R_NOENTROPY] = "out of entropy",
+ [ISC_R_MULTICAST] = "invalid use of multicast address",
+ [ISC_R_NOTFILE] = "not a file",
+ [ISC_R_NOTDIRECTORY] = "not a directory",
+ [ISC_R_EMPTY] = "queue is empty",
+ [ISC_R_FAMILYMISMATCH] = "address family mismatch",
+ [ISC_R_FAMILYNOSUPPORT] = "address family not supported",
+ [ISC_R_BADHEX] = "bad hex encoding",
+ [ISC_R_TOOMANYOPENFILES] = "too many open files",
+ [ISC_R_NOTBLOCKING] = "not blocking",
+ [ISC_R_UNBALANCEDQUOTES] = "unbalanced quotes",
+ [ISC_R_INPROGRESS] = "operation in progress",
+ [ISC_R_CONNECTIONRESET] = "connection reset",
+ [ISC_R_SOFTQUOTA] = "soft quota reached",
+ [ISC_R_BADNUMBER] = "not a valid number",
+ [ISC_R_DISABLED] = "disabled",
+ [ISC_R_MAXSIZE] = "max size",
+ [ISC_R_BADADDRESSFORM] = "invalid address format",
+ [ISC_R_BADBASE32] = "bad base32 encoding",
+ [ISC_R_UNSET] = "unset",
+ [ISC_R_MULTIPLE] = "multiple",
+ [ISC_R_WOULDBLOCK] = "would block",
+ [ISC_R_COMPLETE] = "complete",
+ [ISC_R_CRYPTOFAILURE] = "crypto failure",
+ [ISC_R_DISCQUOTA] = "disc quota",
+ [ISC_R_DISCFULL] = "disc full",
+ [ISC_R_DEFAULT] = "default",
+ [ISC_R_IPV4PREFIX] = "IPv4 prefix",
+ [ISC_R_TLSERROR] = "TLS error",
+ [ISC_R_HTTP2ALPNERROR] = "ALPN for HTTP/2 failed",
+
+ [DNS_R_LABELTOOLONG] = "label too long",
+ [DNS_R_BADESCAPE] = "bad escape",
+ [DNS_R_EMPTYLABEL] = "empty label",
+ [DNS_R_BADDOTTEDQUAD] = "bad dotted quad",
+ [DNS_R_INVALIDNS] = "invalid NS owner name (wildcard)",
+ [DNS_R_UNKNOWN] = "unknown class/type",
+ [DNS_R_BADLABELTYPE] = "bad label type",
+ [DNS_R_BADPOINTER] = "bad compression pointer",
+ [DNS_R_TOOMANYHOPS] = "too many hops",
+ [DNS_R_DISALLOWED] = "disallowed (by application policy)",
+ [DNS_R_EXTRATOKEN] = "extra input text",
+ [DNS_R_EXTRADATA] = "extra input data",
+ [DNS_R_TEXTTOOLONG] = "text too long",
+ [DNS_R_NOTZONETOP] = "not at top of zone",
+ [DNS_R_SYNTAX] = "syntax error",
+ [DNS_R_BADCKSUM] = "bad checksum",
+ [DNS_R_BADAAAA] = "bad IPv6 address",
+ [DNS_R_NOOWNER] = "no owner",
+ [DNS_R_NOTTL] = "no ttl",
+ [DNS_R_BADCLASS] = "bad class",
+ [DNS_R_NAMETOOLONG] = "name too long",
+ [DNS_R_PARTIALMATCH] = "partial match",
+ [DNS_R_NEWORIGIN] = "new origin",
+ [DNS_R_UNCHANGED] = "unchanged",
+ [DNS_R_BADTTL] = "bad ttl",
+ [DNS_R_NOREDATA] = "more data needed/to be rendered",
+ [DNS_R_CONTINUE] = "continue",
+ [DNS_R_DELEGATION] = "delegation",
+ [DNS_R_GLUE] = "glue",
+ [DNS_R_DNAME] = "dname",
+ [DNS_R_CNAME] = "cname",
+ [DNS_R_BADDB] = "bad database",
+ [DNS_R_ZONECUT] = "zonecut",
+ [DNS_R_BADZONE] = "bad zone",
+ [DNS_R_MOREDATA] = "more data",
+ [DNS_R_UPTODATE] = "up to date",
+ [DNS_R_TSIGVERIFYFAILURE] = "tsig verify failure",
+ [DNS_R_TSIGERRORSET] = "tsig indicates error",
+ [DNS_R_SIGINVALID] = "RRSIG failed to verify",
+ [DNS_R_SIGEXPIRED] = "RRSIG has expired",
+ [DNS_R_SIGFUTURE] = "RRSIG validity period has not begun",
+ [DNS_R_KEYUNAUTHORIZED] = "key is unauthorized to sign data",
+ [DNS_R_INVALIDTIME] = "invalid time",
+ [DNS_R_EXPECTEDTSIG] = "expected a TSIG or SIG(0)",
+ [DNS_R_UNEXPECTEDTSIG] = "did not expect a TSIG or SIG(0)",
+ [DNS_R_INVALIDTKEY] = "TKEY is unacceptable",
+ [DNS_R_HINT] = "hint",
+ [DNS_R_DROP] = "drop",
+ [DNS_R_NOTLOADED] = "zone not loaded",
+ [DNS_R_NCACHENXDOMAIN] = "ncache nxdomain",
+ [DNS_R_NCACHENXRRSET] = "ncache nxrrset",
+ [DNS_R_WAIT] = "wait",
+ [DNS_R_NOTVERIFIEDYET] = "not verified yet",
+ [DNS_R_NOIDENTITY] = "no identity",
+ [DNS_R_NOJOURNAL] = "no journal",
+ [DNS_R_ALIAS] = "alias",
+ [DNS_R_USETCP] = "use TCP",
+ [DNS_R_NOVALIDSIG] = "no valid RRSIG",
+ [DNS_R_NOVALIDNSEC] = "no valid NSEC",
+ [DNS_R_NOTINSECURE] = "insecurity proof failed",
+ [DNS_R_UNKNOWNSERVICE] = "unknown service",
+ [DNS_R_RECOVERABLE] = "recoverable error occurred",
+ [DNS_R_UNKNOWNOPT] = "unknown opt attribute record",
+ [DNS_R_UNEXPECTEDID] = "unexpected message id",
+ [DNS_R_SEENINCLUDE] = "seen include file",
+ [DNS_R_NOTEXACT] = "not exact",
+ [DNS_R_BLACKHOLED] = "address blackholed",
+ [DNS_R_BADALG] = "bad algorithm",
+ [DNS_R_METATYPE] = "invalid use of a meta type",
+ [DNS_R_CNAMEANDOTHER] = "CNAME and other data",
+ [DNS_R_SINGLETON] = "multiple RRs of singleton type",
+ [DNS_R_HINTNXRRSET] = "hint nxrrset",
+ [DNS_R_NOMASTERFILE] = "no master file configured",
+ [DNS_R_UNKNOWNPROTO] = "unknown protocol",
+ [DNS_R_CLOCKSKEW] = "clocks are unsynchronized",
+ [DNS_R_BADIXFR] = "IXFR failed",
+ [DNS_R_NOTAUTHORITATIVE] = "not authoritative",
+ [DNS_R_NOVALIDKEY] = "no valid KEY",
+ [DNS_R_OBSOLETE] = "obsolete",
+ [DNS_R_FROZEN] = "already frozen",
+ [DNS_R_UNKNOWNFLAG] = "unknown flag",
+ [DNS_R_EXPECTEDRESPONSE] = "expected a response",
+ [DNS_R_NOVALIDDS] = "no valid DS",
+ [DNS_R_NSISADDRESS] = "NS is an address",
+ [DNS_R_REMOTEFORMERR] = "received FORMERR",
+ [DNS_R_TRUNCATEDTCP] = "truncated TCP response",
+ [DNS_R_LAME] = "lame server detected",
+ [DNS_R_UNEXPECTEDRCODE] = "unexpected RCODE",
+ [DNS_R_UNEXPECTEDOPCODE] = "unexpected OPCODE",
+ [DNS_R_CHASEDSSERVERS] = "chase DS servers",
+ [DNS_R_EMPTYNAME] = "empty name",
+ [DNS_R_EMPTYWILD] = "empty wild",
+ [DNS_R_BADBITMAP] = "bad bitmap",
+ [DNS_R_FROMWILDCARD] = "from wildcard",
+ [DNS_R_BADOWNERNAME] = "bad owner name (check-names)",
+ [DNS_R_BADNAME] = "bad name (check-names)",
+ [DNS_R_DYNAMIC] = "dynamic zone",
+ [DNS_R_UNKNOWNCOMMAND] = "unknown command",
+ [DNS_R_MUSTBESECURE] = "must-be-secure",
+ [DNS_R_COVERINGNSEC] = "covering NSEC record returned",
+ [DNS_R_MXISADDRESS] = "MX is an address",
+ [DNS_R_DUPLICATE] = "duplicate query",
+ [DNS_R_INVALIDNSEC3] = "invalid NSEC3 owner name (wildcard)",
+ [DNS_R_NOTMASTER] = "not master",
+ [DNS_R_BROKENCHAIN] = "broken trust chain",
+ [DNS_R_EXPIRED] = "expired",
+ [DNS_R_NOTDYNAMIC] = "not dynamic",
+ [DNS_R_BADEUI] = "bad EUI",
+ [DNS_R_NTACOVERED] = "covered by negative trust anchor",
+ [DNS_R_BADCDS] = "bad CDS",
+ [DNS_R_BADCDNSKEY] = "bad CDNSKEY",
+ [DNS_R_OPTERR] = "malformed OPT option",
+ [DNS_R_BADDNSTAP] = "malformed DNSTAP data",
+ [DNS_R_BADTSIG] = "TSIG in wrong location",
+ [DNS_R_BADSIG0] = "SIG(0) in wrong location",
+ [DNS_R_TOOMANYRECORDS] = "too many records",
+ [DNS_R_VERIFYFAILURE] = "verify failure",
+ [DNS_R_ATZONETOP] = "at top of zone",
+ [DNS_R_NOKEYMATCH] = "no matching key found",
+ [DNS_R_TOOMANYKEYS] = "too many keys matching",
+ [DNS_R_KEYNOTACTIVE] = "key is not actively signing",
+ [DNS_R_NSEC3ITERRANGE] = "NSEC3 iterations out of range",
+ [DNS_R_NSEC3SALTRANGE] = "NSEC3 salt length too high",
+ [DNS_R_NSEC3BADALG] = "cannot use NSEC3 with key algorithm",
+ [DNS_R_NSEC3RESALT] = "NSEC3 resalt",
+ [DNS_R_INCONSISTENTRR] = "inconsistent resource record",
+
+ [DST_R_UNSUPPORTEDALG] = "algorithm is unsupported",
+ [DST_R_CRYPTOFAILURE] = "crypto failure",
+ [DST_R_NOCRYPTO] = "built with no crypto support",
+ [DST_R_NULLKEY] = "illegal operation for a null key",
+ [DST_R_INVALIDPUBLICKEY] = "public key is invalid",
+ [DST_R_INVALIDPRIVATEKEY] = "private key is invalid",
+ [DST_R_WRITEERROR] = "error occurred writing key to disk",
+ [DST_R_INVALIDPARAM] = "invalid algorithm specific parameter",
+ [DST_R_SIGNFAILURE] = "sign failure",
+ [DST_R_VERIFYFAILURE] = "verify failure",
+ [DST_R_NOTPUBLICKEY] = "not a public key",
+ [DST_R_NOTPRIVATEKEY] = "not a private key",
+ [DST_R_KEYCANNOTCOMPUTESECRET] = "not a key that can compute a secret",
+ [DST_R_COMPUTESECRETFAILURE] = "failure computing a shared secret",
+ [DST_R_NORANDOMNESS] = "no randomness available",
+ [DST_R_BADKEYTYPE] = "bad key type",
+ [DST_R_NOENGINE] = "no engine",
+ [DST_R_EXTERNALKEY] = "illegal operation for an external key",
+
+ [DNS_R_NOERROR] = "NOERROR",
+ [DNS_R_FORMERR] = "FORMERR",
+ [DNS_R_SERVFAIL] = "SERVFAIL",
+ [DNS_R_NXDOMAIN] = "NXDOMAIN",
+ [DNS_R_NOTIMP] = "NOTIMP",
+ [DNS_R_REFUSED] = "REFUSED",
+ [DNS_R_YXDOMAIN] = "YXDOMAIN",
+ [DNS_R_YXRRSET] = "YXRRSET",
+ [DNS_R_NXRRSET] = "NXRRSET",
+ [DNS_R_NOTAUTH] = "NOTAUTH",
+ [DNS_R_NOTZONE] = "NOTZONE",
+ [DNS_R_RCODE11] = "<rcode 11>",
+ [DNS_R_RCODE12] = "<rcode 12>",
+ [DNS_R_RCODE13] = "<rcode 13>",
+ [DNS_R_RCODE14] = "<rcode 14>",
+ [DNS_R_RCODE15] = "<rcode 15>",
+ [DNS_R_BADVERS] = "BADVERS",
+
+ [ISCCC_R_UNKNOWNVERSION] = "unknown version",
+ [ISCCC_R_SYNTAX] = "syntax error",
+ [ISCCC_R_BADAUTH] = "bad auth",
+ [ISCCC_R_EXPIRED] = "expired",
+ [ISCCC_R_CLOCKSKEW] = "clock skew",
+ [ISCCC_R_DUPLICATE] = "duplicate",
};
-static const char *identifier[ISC_R_NRESULTS] = { "ISC_R_SUCCESS",
- "ISC_R_NOMEMORY",
- "ISC_R_TIMEDOUT",
- "ISC_R_NOTHREADS",
- "ISC_R_ADDRNOTAVAIL",
- "ISC_R_ADDRINUSE",
- "ISC_R_NOPERM",
- "ISC_R_NOCONN",
- "ISC_R_NETUNREACH",
- "ISC_R_HOSTUNREACH",
- "ISC_R_NETDOWN",
- "ISC_R_HOSTDOWN",
- "ISC_R_CONNREFUSED",
- "ISC_R_NORESOURCES",
- "ISC_R_EOF",
- "ISC_R_BOUND",
- "ISC_R_RELOAD",
- "ISC_R_LOCKBUSY",
- "ISC_R_EXISTS",
- "ISC_R_NOSPACE",
- "ISC_R_CANCELED",
- "ISC_R_NOTBOUND",
- "ISC_R_SHUTTINGDOWN",
- "ISC_R_NOTFOUND",
- "ISC_R_UNEXPECTEDEND",
- "ISC_R_FAILURE",
- "ISC_R_IOERROR",
- "ISC_R_NOTIMPLEMENTED",
- "ISC_R_UNBALANCED",
- "ISC_R_NOMORE",
- "ISC_R_INVALIDFILE",
- "ISC_R_BADBASE64",
- "ISC_R_UNEXPECTEDTOKEN",
- "ISC_R_QUOTA",
- "ISC_R_UNEXPECTED",
- "ISC_R_ALREADYRUNNING",
- "ISC_R_IGNORE",
- "ISC_R_MASKNONCONTIG",
- "ISC_R_FILENOTFOUND",
- "ISC_R_FILEEXISTS",
- "ISC_R_NOTCONNECTED",
- "ISC_R_RANGE",
- "ISC_R_NOENTROPY",
- "ISC_R_MULTICAST",
- "ISC_R_NOTFILE",
- "ISC_R_NOTDIRECTORY",
- "ISC_R_EMPTY",
- "ISC_R_FAMILYMISMATCH",
- "ISC_R_FAMILYNOSUPPORT",
- "ISC_R_BADHEX",
- "ISC_R_TOOMANYOPENFILES",
- "ISC_R_NOTBLOCKING",
- "ISC_R_UNBALANCEDQUOTES",
- "ISC_R_INPROGRESS",
- "ISC_R_CONNECTIONRESET",
- "ISC_R_SOFTQUOTA",
- "ISC_R_BADNUMBER",
- "ISC_R_DISABLED",
- "ISC_R_MAXSIZE",
- "ISC_R_BADADDRESSFORM",
- "ISC_R_BADBASE32",
- "ISC_R_UNSET",
- "ISC_R_MULTIPLE",
- "ISC_R_WOULDBLOCK",
- "ISC_R_COMPLETE",
- "ISC_R_CRYPTOFAILURE",
- "ISC_R_DISCQUOTA",
- "ISC_R_DISCFULL",
- "ISC_R_DEFAULT",
- "ISC_R_IPV4PREFIX",
- "ISC_R_TLSERROR",
- "ISC_R_HTTP2ALPNERROR" };
-
-#define ISC_RESULT_RESULTSET 2
-#define ISC_RESULT_UNAVAILABLESET 3
-
-static isc_once_t once = ISC_ONCE_INIT;
-static resulttable_list_t description_tables;
-static resulttable_list_t identifier_tables;
-static isc_rwlock_t lock;
-
-static isc_result_t
-register_table(resulttable_list_t *tables, unsigned int base,
- unsigned int nresults, const char **text, int set) {
- resulttable *table;
-
- REQUIRE(base % ISC_RESULTCLASS_SIZE == 0);
- REQUIRE(nresults <= ISC_RESULTCLASS_SIZE);
- REQUIRE(text != NULL);
-
- /*
- * We use malloc() here because we we want to be able to use
- * isc_result_totext() even if there is no memory context.
- */
- table = malloc(sizeof(*table));
- if (table == NULL) {
- return (ISC_R_NOMEMORY);
- }
- table->base = base;
- table->last = base + nresults - 1;
- table->text = text;
- table->set = set;
- ISC_LINK_INIT(table, link);
-
- RWLOCK(&lock, isc_rwlocktype_write);
-
- ISC_LIST_APPEND(*tables, table, link);
-
- RWUNLOCK(&lock, isc_rwlocktype_write);
-
- return (ISC_R_SUCCESS);
-}
-
-static void
-initialize_action(void) {
- isc_result_t result;
-
- isc_rwlock_init(&lock, 0, 0);
- ISC_LIST_INIT(description_tables);
- ISC_LIST_INIT(identifier_tables);
-
- result = register_table(&description_tables, ISC_RESULTCLASS_ISC,
- ISC_R_NRESULTS, description,
- ISC_RESULT_RESULTSET);
- if (result != ISC_R_SUCCESS) {
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "register_table() failed: %u", result);
- }
-
- result = register_table(&identifier_tables, ISC_RESULTCLASS_ISC,
- ISC_R_NRESULTS, identifier,
- ISC_RESULT_RESULTSET);
- if (result != ISC_R_SUCCESS) {
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "register_table() failed: %u", result);
- }
-}
-
-static void
-initialize(void) {
- RUNTIME_CHECK(isc_once_do(&once, initialize_action) == ISC_R_SUCCESS);
-}
-
-static const char *
-isc_result_tomany_helper(resulttable_list_t *tables, isc_result_t result) {
- resulttable *table;
- const char *text;
- int index;
-
- initialize();
+static const char *identifier[ISC_R_NRESULTS] = {
+ [ISC_R_SUCCESS] = "ISC_R_SUCCESS",
+ [ISC_R_NOMEMORY] = "ISC_R_NOMEMORY",
+ [ISC_R_TIMEDOUT] = "ISC_R_TIMEDOUT",
+ [ISC_R_NOTHREADS] = "ISC_R_NOTHREADS",
+ [ISC_R_ADDRNOTAVAIL] = "ISC_R_ADDRNOTAVAIL",
+ [ISC_R_ADDRINUSE] = "ISC_R_ADDRINUSE",
+ [ISC_R_NOPERM] = "ISC_R_NOPERM",
+ [ISC_R_NOCONN] = "ISC_R_NOCONN",
+ [ISC_R_NETUNREACH] = "ISC_R_NETUNREACH",
+ [ISC_R_HOSTUNREACH] = "ISC_R_HOSTUNREACH",
+ [ISC_R_NETDOWN] = "ISC_R_NETDOWN",
+ [ISC_R_HOSTDOWN] = "ISC_R_HOSTDOWN",
+ [ISC_R_CONNREFUSED] = "ISC_R_CONNREFUSED",
+ [ISC_R_NORESOURCES] = "ISC_R_NORESOURCES",
+ [ISC_R_EOF] = "ISC_R_EOF",
+ [ISC_R_BOUND] = "ISC_R_BOUND",
+ [ISC_R_RELOAD] = "ISC_R_RELOAD",
+ [ISC_R_LOCKBUSY] = "ISC_R_LOCKBUSY",
+ [ISC_R_EXISTS] = "ISC_R_EXISTS",
+ [ISC_R_NOSPACE] = "ISC_R_NOSPACE",
+ [ISC_R_CANCELED] = "ISC_R_CANCELED",
+ [ISC_R_NOTBOUND] = "ISC_R_NOTBOUND",
+ [ISC_R_SHUTTINGDOWN] = "ISC_R_SHUTTINGDOWN",
+ [ISC_R_NOTFOUND] = "ISC_R_NOTFOUND",
+ [ISC_R_UNEXPECTEDEND] = "ISC_R_UNEXPECTEDEND",
+ [ISC_R_FAILURE] = "ISC_R_FAILURE",
+ [ISC_R_IOERROR] = "ISC_R_IOERROR",
+ [ISC_R_NOTIMPLEMENTED] = "ISC_R_NOTIMPLEMENTED",
+ [ISC_R_UNBALANCED] = "ISC_R_UNBALANCED",
+ [ISC_R_NOMORE] = "ISC_R_NOMORE",
+ [ISC_R_INVALIDFILE] = "ISC_R_INVALIDFILE",
+ [ISC_R_BADBASE64] = "ISC_R_BADBASE64",
+ [ISC_R_UNEXPECTEDTOKEN] = "ISC_R_UNEXPECTEDTOKEN",
+ [ISC_R_QUOTA] = "ISC_R_QUOTA",
+ [ISC_R_UNEXPECTED] = "ISC_R_UNEXPECTED",
+ [ISC_R_ALREADYRUNNING] = "ISC_R_ALREADYRUNNING",
+ [ISC_R_IGNORE] = "ISC_R_IGNORE",
+ [ISC_R_MASKNONCONTIG] = "ISC_R_MASKNONCONTIG",
+ [ISC_R_FILENOTFOUND] = "ISC_R_FILENOTFOUND",
+ [ISC_R_FILEEXISTS] = "ISC_R_FILEEXISTS",
+ [ISC_R_NOTCONNECTED] = "ISC_R_NOTCONNECTED",
+ [ISC_R_RANGE] = "ISC_R_RANGE",
+ [ISC_R_NOENTROPY] = "ISC_R_NOENTROPY",
+ [ISC_R_MULTICAST] = "ISC_R_MULTICAST",
+ [ISC_R_NOTFILE] = "ISC_R_NOTFILE",
+ [ISC_R_NOTDIRECTORY] = "ISC_R_NOTDIRECTORY",
+ [ISC_R_EMPTY] = "ISC_R_EMPTY",
+ [ISC_R_FAMILYMISMATCH] = "ISC_R_FAMILYMISMATCH",
+ [ISC_R_FAMILYNOSUPPORT] = "ISC_R_FAMILYNOSUPPORT",
+ [ISC_R_BADHEX] = "ISC_R_BADHEX",
+ [ISC_R_TOOMANYOPENFILES] = "ISC_R_TOOMANYOPENFILES",
+ [ISC_R_NOTBLOCKING] = "ISC_R_NOTBLOCKING",
+ [ISC_R_UNBALANCEDQUOTES] = "ISC_R_UNBALANCEDQUOTES",
+ [ISC_R_INPROGRESS] = "ISC_R_INPROGRESS",
+ [ISC_R_CONNECTIONRESET] = "ISC_R_CONNECTIONRESET",
+ [ISC_R_SOFTQUOTA] = "ISC_R_SOFTQUOTA",
+ [ISC_R_BADNUMBER] = "ISC_R_BADNUMBER",
+ [ISC_R_DISABLED] = "ISC_R_DISABLED",
+ [ISC_R_MAXSIZE] = "ISC_R_MAXSIZE",
+ [ISC_R_BADADDRESSFORM] = "ISC_R_BADADDRESSFORM",
+ [ISC_R_BADBASE32] = "ISC_R_BADBASE32",
+ [ISC_R_UNSET] = "ISC_R_UNSET",
+ [ISC_R_MULTIPLE] = "ISC_R_MULTIPLE",
+ [ISC_R_WOULDBLOCK] = "ISC_R_WOULDBLOCK",
+ [ISC_R_COMPLETE] = "ISC_R_COMPLETE",
+ [ISC_R_CRYPTOFAILURE] = "ISC_R_CRYPTOFAILURE",
+ [ISC_R_DISCQUOTA] = "ISC_R_DISCQUOTA",
+ [ISC_R_DISCFULL] = "ISC_R_DISCFULL",
+ [ISC_R_DEFAULT] = "ISC_R_DEFAULT",
+ [ISC_R_IPV4PREFIX] = "ISC_R_IPV4PREFIX",
+ [ISC_R_TLSERROR] = "ISC_R_TLSERROR",
+ [ISC_R_HTTP2ALPNERROR] = "ISC_R_HTTP2ALPNERROR",
+ [DNS_R_LABELTOOLONG] = "DNS_R_LABELTOOLONG",
+ [DNS_R_BADESCAPE] = "DNS_R_BADESCAPE",
+ [DNS_R_EMPTYLABEL] = "DNS_R_EMPTYLABEL",
+ [DNS_R_BADDOTTEDQUAD] = "DNS_R_BADDOTTEDQUAD",
+ [DNS_R_INVALIDNS] = "DNS_R_INVALIDNS",
+ [DNS_R_UNKNOWN] = "DNS_R_UNKNOWN",
+ [DNS_R_BADLABELTYPE] = "DNS_R_BADLABELTYPE",
+ [DNS_R_BADPOINTER] = "DNS_R_BADPOINTER",
+ [DNS_R_TOOMANYHOPS] = "DNS_R_TOOMANYHOPS",
+ [DNS_R_DISALLOWED] = "DNS_R_DISALLOWED",
+ [DNS_R_EXTRATOKEN] = "DNS_R_EXTRATOKEN",
+ [DNS_R_EXTRADATA] = "DNS_R_EXTRADATA",
+ [DNS_R_TEXTTOOLONG] = "DNS_R_TEXTTOOLONG",
+ [DNS_R_NOTZONETOP] = "DNS_R_NOTZONETOP",
+ [DNS_R_SYNTAX] = "DNS_R_SYNTAX",
+ [DNS_R_BADCKSUM] = "DNS_R_BADCKSUM",
+ [DNS_R_BADAAAA] = "DNS_R_BADAAAA",
+ [DNS_R_NOOWNER] = "DNS_R_NOOWNER",
+ [DNS_R_NOTTL] = "DNS_R_NOTTL",
+ [DNS_R_BADCLASS] = "DNS_R_BADCLASS",
+ [DNS_R_NAMETOOLONG] = "DNS_R_NAMETOOLONG",
+ [DNS_R_PARTIALMATCH] = "DNS_R_PARTIALMATCH",
+ [DNS_R_NEWORIGIN] = "DNS_R_NEWORIGIN",
+ [DNS_R_UNCHANGED] = "DNS_R_UNCHANGED",
+ [DNS_R_BADTTL] = "DNS_R_BADTTL",
+ [DNS_R_NOREDATA] = "DNS_R_NOREDATA",
+ [DNS_R_CONTINUE] = "DNS_R_CONTINUE",
+ [DNS_R_DELEGATION] = "DNS_R_DELEGATION",
+ [DNS_R_GLUE] = "DNS_R_GLUE",
+ [DNS_R_DNAME] = "DNS_R_DNAME",
+ [DNS_R_CNAME] = "DNS_R_CNAME",
+ [DNS_R_BADDB] = "DNS_R_BADDB",
+ [DNS_R_ZONECUT] = "DNS_R_ZONECUT",
+ [DNS_R_BADZONE] = "DNS_R_BADZONE",
+ [DNS_R_MOREDATA] = "DNS_R_MOREDATA",
+ [DNS_R_UPTODATE] = "DNS_R_UPTODATE",
+ [DNS_R_TSIGVERIFYFAILURE] = "DNS_R_TSIGVERIFYFAILURE",
+ [DNS_R_TSIGERRORSET] = "DNS_R_TSIGERRORSET",
+ [DNS_R_SIGINVALID] = "DNS_R_SIGINVALID",
+ [DNS_R_SIGEXPIRED] = "DNS_R_SIGEXPIRED",
+ [DNS_R_SIGFUTURE] = "DNS_R_SIGFUTURE",
+ [DNS_R_KEYUNAUTHORIZED] = "DNS_R_KEYUNAUTHORIZED",
+ [DNS_R_INVALIDTIME] = "DNS_R_INVALIDTIME",
+ [DNS_R_EXPECTEDTSIG] = "DNS_R_EXPECTEDTSIG",
+ [DNS_R_UNEXPECTEDTSIG] = "DNS_R_UNEXPECTEDTSIG",
+ [DNS_R_INVALIDTKEY] = "DNS_R_INVALIDTKEY",
+ [DNS_R_HINT] = "DNS_R_HINT",
+ [DNS_R_DROP] = "DNS_R_DROP",
+ [DNS_R_NOTLOADED] = "DNS_R_NOTLOADED",
+ [DNS_R_NCACHENXDOMAIN] = "DNS_R_NCACHENXDOMAIN",
+ [DNS_R_NCACHENXRRSET] = "DNS_R_NCACHENXRRSET",
+ [DNS_R_WAIT] = "DNS_R_WAIT",
+ [DNS_R_NOTVERIFIEDYET] = "DNS_R_NOTVERIFIEDYET",
+ [DNS_R_NOIDENTITY] = "DNS_R_NOIDENTITY",
+ [DNS_R_NOJOURNAL] = "DNS_R_NOJOURNAL",
+ [DNS_R_ALIAS] = "DNS_R_ALIAS",
+ [DNS_R_USETCP] = "DNS_R_USETCP",
+ [DNS_R_NOVALIDSIG] = "DNS_R_NOVALIDSIG",
+ [DNS_R_NOVALIDNSEC] = "DNS_R_NOVALIDNSEC",
+ [DNS_R_NOTINSECURE] = "DNS_R_NOTINSECURE",
+ [DNS_R_UNKNOWNSERVICE] = "DNS_R_UNKNOWNSERVICE",
+ [DNS_R_RECOVERABLE] = "DNS_R_RECOVERABLE",
+ [DNS_R_UNKNOWNOPT] = "DNS_R_UNKNOWNOPT",
+ [DNS_R_UNEXPECTEDID] = "DNS_R_UNEXPECTEDID",
+ [DNS_R_SEENINCLUDE] = "DNS_R_SEENINCLUDE",
+ [DNS_R_NOTEXACT] = "DNS_R_NOTEXACT",
+ [DNS_R_BLACKHOLED] = "DNS_R_BLACKHOLED",
+ [DNS_R_BADALG] = "DNS_R_BADALG",
+ [DNS_R_METATYPE] = "DNS_R_METATYPE",
+ [DNS_R_CNAMEANDOTHER] = "DNS_R_CNAMEANDOTHER",
+ [DNS_R_SINGLETON] = "DNS_R_SINGLETON",
+ [DNS_R_HINTNXRRSET] = "DNS_R_HINTNXRRSET",
+ [DNS_R_NOMASTERFILE] = "DNS_R_NOMASTERFILE",
+ [DNS_R_UNKNOWNPROTO] = "DNS_R_UNKNOWNPROTO",
+ [DNS_R_CLOCKSKEW] = "DNS_R_CLOCKSKEW",
+ [DNS_R_BADIXFR] = "DNS_R_BADIXFR",
+ [DNS_R_NOTAUTHORITATIVE] = "DNS_R_NOTAUTHORITATIVE",
+ [DNS_R_NOVALIDKEY] = "DNS_R_NOVALIDKEY",
+ [DNS_R_OBSOLETE] = "DNS_R_OBSOLETE",
+ [DNS_R_FROZEN] = "DNS_R_FROZEN",
+ [DNS_R_UNKNOWNFLAG] = "DNS_R_UNKNOWNFLAG",
+ [DNS_R_EXPECTEDRESPONSE] = "DNS_R_EXPECTEDRESPONSE",
+ [DNS_R_NOVALIDDS] = "DNS_R_NOVALIDDS",
+ [DNS_R_NSISADDRESS] = "DNS_R_NSISADDRESS",
+ [DNS_R_REMOTEFORMERR] = "DNS_R_REMOTEFORMERR",
+ [DNS_R_TRUNCATEDTCP] = "DNS_R_TRUNCATEDTCP",
+ [DNS_R_LAME] = "DNS_R_LAME",
+ [DNS_R_UNEXPECTEDRCODE] = "DNS_R_UNEXPECTEDRCODE",
+ [DNS_R_UNEXPECTEDOPCODE] = "DNS_R_UNEXPECTEDOPCODE",
+ [DNS_R_CHASEDSSERVERS] = "DNS_R_CHASEDSSERVERS",
+ [DNS_R_EMPTYNAME] = "DNS_R_EMPTYNAME",
+ [DNS_R_EMPTYWILD] = "DNS_R_EMPTYWILD",
+ [DNS_R_BADBITMAP] = "DNS_R_BADBITMAP",
+ [DNS_R_FROMWILDCARD] = "DNS_R_FROMWILDCARD",
+ [DNS_R_BADOWNERNAME] = "DNS_R_BADOWNERNAME",
+ [DNS_R_BADNAME] = "DNS_R_BADNAME",
+ [DNS_R_DYNAMIC] = "DNS_R_DYNAMIC",
+ [DNS_R_UNKNOWNCOMMAND] = "DNS_R_UNKNOWNCOMMAND",
+ [DNS_R_MUSTBESECURE] = "DNS_R_MUSTBESECURE",
+ [DNS_R_COVERINGNSEC] = "DNS_R_COVERINGNSEC",
+ [DNS_R_MXISADDRESS] = "DNS_R_MXISADDRESS",
+ [DNS_R_DUPLICATE] = "DNS_R_DUPLICATE",
+ [DNS_R_INVALIDNSEC3] = "DNS_R_INVALIDNSEC3",
+ [DNS_R_NOTMASTER] = "DNS_R_NOTMASTER",
+ [DNS_R_BROKENCHAIN] = "DNS_R_BROKENCHAIN",
+ [DNS_R_EXPIRED] = "DNS_R_EXPIRED",
+ [DNS_R_NOTDYNAMIC] = "DNS_R_NOTDYNAMIC",
+ [DNS_R_BADEUI] = "DNS_R_BADEUI",
+ [DNS_R_NTACOVERED] = "DNS_R_NTACOVERED",
+ [DNS_R_BADCDS] = "DNS_R_BADCDS",
+ [DNS_R_BADCDNSKEY] = "DNS_R_BADCDNSKEY",
+ [DNS_R_OPTERR] = "DNS_R_OPTERR",
+ [DNS_R_BADDNSTAP] = "DNS_R_BADDNSTAP",
+ [DNS_R_BADTSIG] = "DNS_R_BADTSIG",
+ [DNS_R_BADSIG0] = "DNS_R_BADSIG0",
+ [DNS_R_TOOMANYRECORDS] = "DNS_R_TOOMANYRECORDS",
+ [DNS_R_VERIFYFAILURE] = "DNS_R_VERIFYFAILURE",
+ [DNS_R_ATZONETOP] = "DNS_R_ATZONETOP",
+ [DNS_R_NOKEYMATCH] = "DNS_R_NOKEYMATCH",
+ [DNS_R_TOOMANYKEYS] = "DNS_R_TOOMANYKEYS",
+ [DNS_R_KEYNOTACTIVE] = "DNS_R_KEYNOTACTIVE",
+ [DNS_R_NSEC3ITERRANGE] = "DNS_R_NSEC3ITERRANGE",
+ [DNS_R_NSEC3SALTRANGE] = "DNS_R_NSEC3SALTRANGE",
+ [DNS_R_NSEC3BADALG] = "DNS_R_NSEC3BADALG",
+ [DNS_R_NSEC3RESALT] = "DNS_R_NSEC3RESALT",
+ [DNS_R_INCONSISTENTRR] = "DNS_R_INCONSISTENTRR",
+
+ [DST_R_UNSUPPORTEDALG] = "DST_R_UNSUPPORTEDALG",
+ [DST_R_CRYPTOFAILURE] = "DST_R_CRYPTOFAILURE",
+ [DST_R_NOCRYPTO] = "DST_R_NOCRYPTO",
+ [DST_R_NULLKEY] = "DST_R_NULLKEY",
+ [DST_R_INVALIDPUBLICKEY] = "DST_R_INVALIDPUBLICKEY",
+ [DST_R_INVALIDPRIVATEKEY] = "DST_R_INVALIDPRIVATEKEY",
+ [DST_R_WRITEERROR] = "DST_R_WRITEERROR",
+ [DST_R_INVALIDPARAM] = "DST_R_INVALIDPARAM",
+ [DST_R_SIGNFAILURE] = "DST_R_SIGNFAILURE",
+ [DST_R_VERIFYFAILURE] = "DST_R_VERIFYFAILURE",
+ [DST_R_NOTPUBLICKEY] = "DST_R_NOTPUBLICKEY",
+ [DST_R_NOTPRIVATEKEY] = "DST_R_NOTPRIVATEKEY",
+ [DST_R_KEYCANNOTCOMPUTESECRET] = "DST_R_KEYCANNOTCOMPUTESECRET",
+ [DST_R_COMPUTESECRETFAILURE] = "DST_R_COMPUTESECRETFAILURE",
+ [DST_R_NORANDOMNESS] = "DST_R_NORANDOMNESS",
+ [DST_R_BADKEYTYPE] = "DST_R_BADKEYTYPE",
+ [DST_R_NOENGINE] = "DST_R_NOENGINE",
+ [DST_R_EXTERNALKEY] = "DST_R_EXTERNALKEY",
+
+ [DNS_R_NOERROR] = "DNS_R_NOERROR",
+ [DNS_R_FORMERR] = "DNS_R_FORMERR",
+ [DNS_R_SERVFAIL] = "DNS_R_SERVFAIL",
+ [DNS_R_NXDOMAIN] = "DNS_R_NXDOMAIN",
+ [DNS_R_NOTIMP] = "DNS_R_NOTIMP",
+ [DNS_R_REFUSED] = "DNS_R_REFUSED",
+ [DNS_R_YXDOMAIN] = "DNS_R_YXDOMAIN",
+ [DNS_R_YXRRSET] = "DNS_R_YXRRSET",
+ [DNS_R_NXRRSET] = "DNS_R_NXRRSET",
+ [DNS_R_NOTAUTH] = "DNS_R_NOTAUTH",
+ [DNS_R_NOTZONE] = "DNS_R_NOTZONE",
+ [DNS_R_RCODE11] = "DNS_R_RCODE11",
+ [DNS_R_RCODE12] = "RNS_R_RCODE12",
+ [DNS_R_RCODE13] = "DNS_R_RCODE13",
+ [DNS_R_RCODE14] = "DNS_R_RCODE14",
+ [DNS_R_RCODE15] = "DNS_R_RCODE15",
+ [DNS_R_BADVERS] = "DNS_R_BADVERS",
+
+ [ISCCC_R_UNKNOWNVERSION] = "ISCCC_R_UNKNOWNVERSION",
+ [ISCCC_R_SYNTAX] = "ISCCC_R_SYNTAX",
+ [ISCCC_R_BADAUTH] = "ISCCC_R_BADAUTH",
+ [ISCCC_R_EXPIRED] = "ISCCC_R_EXPIRED",
+ [ISCCC_R_CLOCKSKEW] = "ISCCC_R_CLOCKSKEW",
+ [ISCCC_R_DUPLICATE] = "ISCCC_R_DUPLICATE",
+};
- RWLOCK(&lock, isc_rwlocktype_read);
+STATIC_ASSERT((DNS_R_SERVFAIL - DNS_R_NOERROR == 2),
+ "DNS_R_NOERROR has wrong value");
- text = NULL;
- for (table = ISC_LIST_HEAD(*tables); table != NULL;
- table = ISC_LIST_NEXT(table, link))
- {
- if (result >= table->base && result <= table->last) {
- index = (int)(result - table->base);
- text = table->text[index];
- break;
- }
- }
- if (text == NULL) {
- text = "(result code text not available)";
- }
+STATIC_ASSERT((DNS_R_BADVERS - DNS_R_NOERROR == 16),
+ "DNS_R_BADVERS has wrong value");
- RWUNLOCK(&lock, isc_rwlocktype_read);
-
- return (text);
-}
+STATIC_ASSERT((ISC_R_NRESULTS < INT32_MAX), "result.h enum too big");
const char *
isc_result_totext(isc_result_t result) {
- return (isc_result_tomany_helper(&description_tables, result));
+ return (description[result]);
}
const char *
isc_result_toid(isc_result_t result) {
- return (isc_result_tomany_helper(&identifier_tables, result));
-}
-
-isc_result_t
-isc_result_register(unsigned int base, unsigned int nresults, const char **text,
- int set) {
- initialize();
-
- return (register_table(&description_tables, base, nresults, text, set));
-}
-
-isc_result_t
-isc_result_registerids(unsigned int base, unsigned int nresults,
- const char **ids, int set) {
- initialize();
-
- return (register_table(&identifier_tables, base, nresults, ids, set));
+ return (identifier[result]);
}
assert_string_equal("failure", str);
}
-/* check tables are populated */
-static void
-tables(void **state) {
- const char *str;
- isc_result_t result;
-
- UNUSED(state);
-
- for (result = 0; result < ISC_R_NRESULTS; result++) {
- str = isc_result_toid(result);
- assert_non_null(str);
- assert_string_not_equal(str, "(result code text not "
- "available)");
-
- str = isc_result_totext(result);
- assert_non_null(str);
- assert_string_not_equal(str, "(result code text not "
- "available)");
- fprintf(stderr, "%u < %u\n", result, (unsigned)ISC_R_NRESULTS);
- }
-
- str = isc_result_toid(result);
- assert_non_null(str);
- assert_string_equal(str, "(result code text not available)");
-
- str = isc_result_totext(result);
- assert_non_null(str);
- assert_string_equal(str, "(result code text not available)");
-}
-
int
main(void) {
const struct CMUnitTest tests[] = {
cmocka_unit_test(isc_result_toid_test),
cmocka_unit_test(isc_result_totext_test),
- cmocka_unit_test(tables),
};
return (cmocka_run_group_tests(tests, NULL, NULL));
include/isccc/cc.h \
include/isccc/ccmsg.h \
include/isccc/events.h \
- include/isccc/result.h \
include/isccc/sexpr.h \
include/isccc/symtab.h \
include/isccc/symtype.h \
base64.c \
cc.c \
ccmsg.c \
- result.c \
sexpr.c \
symtab.c
libisccc_la_LDFLAGS = \
$(AM_LDFLAGS) \
-release "$(PACKAGE_VERSION)"
-
-if HAVE_CMOCKA
-SUBDIRS = tests
-endif
#include <isc/assertions.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isccc/alist.h>
-#include <isccc/result.h>
#include <isccc/sexpr.h>
#include <isccc/util.h>
#include <isc/result.h>
#include <isccc/base64.h>
-#include <isccc/result.h>
#include <isccc/util.h>
isc_result_t
#include <isc/assertions.h>
#include <isc/hmac.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/safe.h>
#include <isccc/alist.h>
#include <isccc/base64.h>
#include <isccc/cc.h>
-#include <isccc/result.h>
#include <isccc/sexpr.h>
#include <isccc/symtab.h>
#include <isccc/symtype.h>
+++ /dev/null
-/*
- * Portions Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, you can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- *
- * Portions Copyright (C) 2001 Nominum, Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND ISC AND NOMINUM DISCLAIMS ALL
- * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef ISCCC_RESULT_H
-#define ISCCC_RESULT_H 1
-
-/*! \file isccc/result.h */
-
-#include <isc/lang.h>
-#include <isc/result.h>
-#include <isc/resultclass.h>
-
-#include <isccc/types.h>
-
-/*% Unknown Version */
-#define ISCCC_R_UNKNOWNVERSION (ISC_RESULTCLASS_ISCCC + 0)
-/*% Syntax Error */
-#define ISCCC_R_SYNTAX (ISC_RESULTCLASS_ISCCC + 1)
-/*% Bad Authorization */
-#define ISCCC_R_BADAUTH (ISC_RESULTCLASS_ISCCC + 2)
-/*% Expired */
-#define ISCCC_R_EXPIRED (ISC_RESULTCLASS_ISCCC + 3)
-/*% Clock Skew */
-#define ISCCC_R_CLOCKSKEW (ISC_RESULTCLASS_ISCCC + 4)
-/*% Duplicate */
-#define ISCCC_R_DUPLICATE (ISC_RESULTCLASS_ISCCC + 5)
-
-#define ISCCC_R_NRESULTS 6 /*%< Number of results */
-
-ISC_LANG_BEGINDECLS
-
-const char *
-isccc_result_totext(isc_result_t result);
-/*%
- * Convert a isccc_result_t into a string message describing the result.
- */
-
-void
-isccc_result_register(void);
-
-ISC_LANG_ENDDECLS
-
-#endif /* ISCCC_RESULT_H */
+++ /dev/null
-/*
- * Portions Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, you can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- *
- * Portions Copyright (C) 2001 Nominum, Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND ISC AND NOMINUM DISCLAIMS ALL
- * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-/*! \file */
-
-#include <isc/once.h>
-#include <isc/util.h>
-
-#include <isccc/result.h>
-
-static const char *text[ISCCC_R_NRESULTS] = {
- "unknown version", /* 1 */
- "syntax error", /* 2 */
- "bad auth", /* 3 */
- "expired", /* 4 */
- "clock skew", /* 5 */
- "duplicate" /* 6 */
-};
-
-static const char *ids[ISCCC_R_NRESULTS] = {
- "ISCCC_R_UNKNOWNVERSION", "ISCCC_R_SYNTAX", "ISCCC_R_BADAUTH",
- "ISCCC_R_EXPIRED", "ISCCC_R_CLOCKSKEW", "ISCCC_R_DUPLICATE",
-};
-
-#define ISCCC_RESULT_RESULTSET 2
-
-static isc_once_t once = ISC_ONCE_INIT;
-
-static void
-initialize_action(void) {
- isc_result_t result;
-
- result = isc_result_register(ISC_RESULTCLASS_ISCCC, ISCCC_R_NRESULTS,
- text, ISCCC_RESULT_RESULTSET);
- if (result != ISC_R_SUCCESS) {
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "isc_result_register() failed: %u", result);
- }
-
- result = isc_result_registerids(ISC_RESULTCLASS_ISCCC, ISCCC_R_NRESULTS,
- ids, ISCCC_RESULT_RESULTSET);
- if (result != ISC_R_SUCCESS) {
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "isc_result_registerids() failed: %u", result);
- }
-}
-
-static void
-initialize(void) {
- RUNTIME_CHECK(isc_once_do(&once, initialize_action) == ISC_R_SUCCESS);
-}
-
-const char *
-isccc_result_totext(isc_result_t result) {
- initialize();
-
- return (isc_result_totext(result));
-}
-
-void
-isccc_result_register(void) {
- initialize();
-}
#include <isc/assertions.h>
#include <isc/magic.h>
+#include <isc/result.h>
#include <isc/string.h>
-#include <isccc/result.h>
#include <isccc/symtab.h>
#include <isccc/util.h>
+++ /dev/null
-include $(top_srcdir)/Makefile.top
-
-AM_CPPFLAGS += \
- $(LIBISC_CFLAGS) \
- $(LIBISCCC_CFLAGS)
-
-LDADD += \
- $(LIBISC_LIBS) \
- $(LIBISCCC_LIBS)
-
-check_PROGRAMS = \
- result_test
-
-include $(top_srcdir)/Makefile.tests
+++ /dev/null
-/*
- * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, you can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-#if HAVE_CMOCKA
-
-#include <setjmp.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define UNIT_TESTING
-#include <cmocka.h>
-
-#include <isc/result.h>
-#include <isc/util.h>
-
-#include <isccc/result.h>
-
-/*
- * Check tables are populated.
- */
-static void
-tables(void **state) {
- const char *str;
- isc_result_t result;
-
- UNUSED(state);
-
- isccc_result_register();
-
- for (result = ISC_RESULTCLASS_ISCCC;
- result < (ISC_RESULTCLASS_ISCCC + ISCCC_R_NRESULTS); result++)
- {
- str = isc_result_toid(result);
- assert_non_null(str);
- assert_string_not_equal(str, "(result code text not "
- "available)");
-
- str = isc_result_totext(result);
- assert_non_null(str);
- assert_string_not_equal(str, "(result code text not "
- "available)");
- }
-
- str = isc_result_toid(result);
- assert_non_null(str);
- assert_string_equal(str, "(result code text not available)");
-
- str = isc_result_totext(result);
- assert_non_null(str);
- assert_string_equal(str, "(result code text not available)");
-}
-
-int
-main(void) {
- const struct CMUnitTest tests[] = {
- cmocka_unit_test(tables),
- };
-
- return (cmocka_run_group_tests(tests, NULL, NULL));
-}
-
-#else /* HAVE_CMOCKA */
-
-#include <stdio.h>
-
-int
-main(void) {
- printf("1..0 # Skipped: cmocka not available\n");
- return (SKIPPED_TEST_EXIT_CODE);
-}
-
-#endif /* if HAVE_CMOCKA */
#include <isc/mem.h>
#include <isc/print.h>
#include <isc/region.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <dns/keyvalues.h>
#include <dns/log.h>
#include <dns/nsec3.h>
-#include <dns/result.h>
#include <dns/secalg.h>
#include <isccfg/cfg.h>
#include <isc/string.h>
#include <isc/util.h>
-#include <dns/result.h>
#include <dns/ttl.h>
#include <isccfg/cfg.h>
#include <dns/rdatalist.h>
#include <dns/rdataset.h>
#include <dns/resolver.h>
+#include <dns/result.h>
#include <dns/stats.h>
#include <dns/tsig.h>
#include <dns/view.h>
#include <isc/mem.h>
#include <isc/netmgr.h>
#include <isc/refcount.h>
+#include <isc/result.h>
#include <dns/geoip.h>
-#include <dns/result.h>
#include <ns/listenlist.h>
#include <ns/types.h>
*** Imports
***/
-#include <dns/result.h>
+#include <isc/result.h>
+
#include <dns/types.h>
/***
#include <isc/log.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <dns/message.h>
#include <dns/rdataset.h>
#include <isc/once.h>
#include <isc/print.h>
#include <isc/random.h>
+#include <isc/result.h>
#include <isc/rwlock.h>
#include <isc/serial.h>
#include <isc/stats.h>
/*! \file */
#include <isc/mem.h>
+#include <isc/result.h>
#include <isc/util.h>
#include <dns/acl.h>
#include <dns/message.h>
-#include <dns/result.h>
#include <ns/server.h>
#include <ns/sortlist.h>
#include <isc/print.h>
#include <isc/random.h>
#include <isc/resource.h>
+#include <isc/result.h>
#include <isc/socket.h>
#include <isc/stdio.h>
#include <isc/string.h>
#include <dns/fixedname.h>
#include <dns/log.h>
#include <dns/name.h>
-#include <dns/result.h>
#include <dns/view.h>
#include <dns/zone.h>
CHECK(isc_log_usechannel(logconfig, "stderr", NULL, NULL));
}
- dns_result_register();
-
if (start_managers) {
CHECK(create_managers());
}
#include <isc/hash.h>
#include <isc/log.h>
#include <isc/mem.h>
+#include <isc/result.h>
#include <isc/string.h>
#include <isc/task.h>
#include <isc/timer.h>
#include <isc/util.h>
-#include <dns/result.h>
#include <dns/zone.h>
#include <ns/client.h>
#include <dns/rdatasetiter.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
+#include <dns/result.h>
#include <dns/soa.h>
#include <dns/ssu.h>
#include <dns/tsig.h>
case DNS_R_YXRRSET: \
case DNS_R_NXRRSET: \
_what = "unsuccessful"; \
+ default: \
+ break; \
} \
update_log(client, zone, LOGLEVEL_PROTOCOL, \
"update %s: %s (%s)", _what, msg, \
case DNS_R_YXRRSET: \
case DNS_R_NXRRSET: \
_what = "unsuccessful"; \
+ default: \
+ break; \
} \
if (isc_log_wouldlog(ns_lctx, LOGLEVEL_PROTOCOL)) { \
char _nbuf[DNS_NAME_FORMATSIZE]; \
case DNS_R_YXRRSET: \
case DNS_R_NXRRSET: \
_what = "unsuccessful"; \
+ default: \
+ break; \
} \
if (isc_log_wouldlog(ns_lctx, LOGLEVEL_PROTOCOL)) { \
char _nbuf[DNS_NAME_FORMATSIZE]; \
if (isaddress && (options & DNS_ZONEOPT_CHECKMXFAIL) != 0) {
update_log(client, zone, ISC_LOG_ERROR,
"%s/MX: '%s': %s", ownerbuf, namebuf,
- dns_result_totext(DNS_R_MXISADDRESS));
+ isc_result_totext(DNS_R_MXISADDRESS));
ok = false;
} else if (isaddress) {
update_log(client, zone, ISC_LOG_WARNING,
"%s/MX: warning: '%s': %s", ownerbuf,
namebuf,
- dns_result_totext(DNS_R_MXISADDRESS));
+ isc_result_totext(DNS_R_MXISADDRESS));
}
/*
UNEXPECTED_ERROR(__FILE__, __LINE__,
"temp entry creation failed: "
"%s",
- dns_result_totext(result));
+ isc_result_totext(result));
FAIL(ISC_R_UNEXPECTED);
}
} else {
snprintf(rdstr, sizeof(rdstr),
"[dns_"
"rdata_totext failed: %s]",
- dns_result_totext(result));
+ isc_result_totext(result));
len = strlen(rdstr);
} else {
len = (int)isc_buffer_usedlength(&buf);
if (result != ISC_R_SUCCESS) {
update_log(client, zone, ISC_LOG_ERROR,
"dns_zone_signwithkey failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
}
if (result != ISC_R_SUCCESS) {
update_log(client, zone, ISC_LOG_ERROR,
"dns_zone_addnsec3chain failed: %s",
- dns_result_totext(result));
+ isc_result_totext(result));
}
}
} else {
#include <isc/formatcheck.h>
#include <isc/mem.h>
#include <isc/print.h>
+#include <isc/result.h>
#include <isc/stats.h>
#include <isc/util.h>
#include <dns/rdatalist.h>
#include <dns/rdataset.h>
#include <dns/rdatasetiter.h>
-#include <dns/result.h>
#include <dns/rriterator.h>
#include <dns/soa.h>
#include <dns/stats.h>
unless $file =~ m%isc/eventclass.h%;
}
- if (/$nocomment.*ISC_RESULTCLASS_/m &&
- ! m%^#include <isc/resultclass\.h>%m) {
- print "$file has ISC_RESULTCLASS_ without <isc/resultclass.h>\n"
- unless $file =~ m%isc/resultclass.h%;
- }
-
if ($file !~ m%isc/magic\.h$%) {
print "$file has ISC_MAGIC_VALID without <isc/magic.h>\n"
if /$nocomment.*ISC_MAGIC_VALID/m && ! m%^#include <isc/magic.h>%m;
./lib/dns/dst_openssl.h C 2002,2004,2005,2007,2008,2009,2011,2012,2015,2016,2018,2019,2020,2021
./lib/dns/dst_parse.c C.NAI 1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021
./lib/dns/dst_parse.h C.NAI 2000,2001,2002,2004,2005,2006,2007,2008,2009,2010,2012,2014,2016,2017,2018,2019,2020,2021
-./lib/dns/dst_result.c C 1999,2000,2001,2004,2005,2007,2008,2012,2013,2014,2015,2016,2018,2019,2020,2021
./lib/dns/dyndb.c C 2015,2016,2017,2018,2019,2020,2021
./lib/dns/ecs.c C 2017,2018,2019,2020,2021
./lib/dns/fixedname.c C 2018,2019,2020,2021
./lib/dns/include/dns/zt.h C 1999,2000,2001,2002,2004,2005,2006,2007,2011,2016,2017,2018,2019,2020,2021
./lib/dns/include/dst/dst.h C 2000,2001,2002,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021
./lib/dns/include/dst/gssapi.h C 2000,2001,2004,2005,2006,2007,2009,2010,2011,2013,2016,2017,2018,2019,2020,2021
-./lib/dns/include/dst/result.h C 1999,2000,2001,2004,2005,2006,2007,2008,2012,2014,2016,2018,2019,2020,2021
./lib/dns/ipkeylist.c C 2016,2018,2019,2020,2021
./lib/dns/iptable.c C 2007,2008,2009,2013,2014,2016,2017,2018,2019,2020,2021
./lib/dns/journal.c C 1999,2000,2001,2002,2004,2005,2007,2008,2009,2010,2011,2013,2014,2015,2016,2017,2018,2019,2020,2021
./lib/dns/tests/rdataset_test.c C 2012,2016,2018,2019,2020,2021
./lib/dns/tests/rdatasetstats_test.c C 2012,2015,2016,2018,2019,2020,2021
./lib/dns/tests/resolver_test.c C 2018,2019,2020,2021
-./lib/dns/tests/result_test.c C 2018,2019,2020,2021
./lib/dns/tests/rsa_test.c C 2016,2018,2019,2020,2021
./lib/dns/tests/sigs_test.c C 2018,2019,2020,2021
./lib/dns/tests/testdata/dbiterator/zone2.data X 2011,2018,2019
./lib/isc/include/isc/region.h C 1998,1999,2000,2001,2002,2004,2005,2006,2007,2013,2016,2018,2019,2020,2021
./lib/isc/include/isc/resource.h C 2000,2001,2004,2005,2006,2007,2008,2016,2018,2019,2020,2021
./lib/isc/include/isc/result.h C 1998,1999,2000,2001,2003,2004,2005,2006,2007,2008,2009,2012,2014,2015,2016,2017,2018,2019,2020,2021
-./lib/isc/include/isc/resultclass.h C 1999,2000,2001,2004,2005,2006,2007,2009,2014,2016,2018,2019,2020,2021
./lib/isc/include/isc/rwlock.h C 1998,1999,2000,2001,2003,2004,2005,2006,2007,2016,2017,2018,2019,2020,2021
./lib/isc/include/isc/safe.h C 2013,2015,2016,2017,2018,2019,2020,2021
./lib/isc/include/isc/serial.h C 1999,2000,2001,2004,2005,2006,2007,2009,2016,2018,2019,2020,2021
./lib/isccc/include/isccc/cc.h C.NOM 2001,2004,2005,2006,2007,2013,2014,2016,2018,2019,2020,2021
./lib/isccc/include/isccc/ccmsg.h C.NOM 2001,2004,2005,2006,2007,2016,2018,2019,2020,2021
./lib/isccc/include/isccc/events.h C.NOM 2001,2004,2005,2006,2007,2016,2018,2019,2020,2021
-./lib/isccc/include/isccc/result.h C.NOM 2001,2003,2004,2005,2006,2007,2016,2018,2019,2020,2021
./lib/isccc/include/isccc/sexpr.h C.NOM 2001,2004,2005,2006,2007,2016,2018,2019,2020,2021
./lib/isccc/include/isccc/symtab.h C.NOM 2001,2004,2005,2006,2007,2016,2018,2019,2020,2021
./lib/isccc/include/isccc/symtype.h C.NOM 2001,2004,2005,2006,2007,2016,2018,2019,2020,2021
./lib/isccc/include/isccc/types.h C.NOM 2001,2004,2005,2006,2007,2016,2018,2019,2020,2021
./lib/isccc/include/isccc/util.h C.NOM 2001,2004,2005,2006,2007,2014,2016,2018,2019,2020,2021
-./lib/isccc/result.c C.NOM 2001,2003,2004,2005,2007,2015,2016,2018,2019,2020,2021
./lib/isccc/sexpr.c C.NOM 2001,2004,2005,2007,2014,2015,2016,2018,2019,2020,2021
./lib/isccc/symtab.c C.NOM 2001,2004,2005,2007,2016,2018,2019,2020,2021
-./lib/isccc/tests/result_test.c C 2018,2019,2020,2021
./lib/isccfg/aclconf.c C 1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021
./lib/isccfg/dnsconf.c C 2009,2016,2018,2019,2020,2021
./lib/isccfg/include/isccfg/aclconf.h C 1999,2000,2001,2004,2005,2006,2007,2010,2011,2012,2013,2014,2016,2018,2019,2020,2021
projects / thirdparty / bind9.git / commitdiff
