"usage: %s [-achijlvz] [-p [-x]] [-t directory] "
"[named.conf]\n",
program);
- exit(1);
+ exit(EXIT_SUCCESS);
}
/*% directory callback */
case 'v':
printf("%s\n", PACKAGE_VERSION);
- exit(0);
+ exit(EXIT_SUCCESS);
case 'w':
workdir = isc_commandline_argument;
keyfile = isc_commandline_argument;
break;
case 'h':
- usage(0);
+ usage(EXIT_SUCCESS);
+ break;
case 'k':
case 'y': /* Compatible with rndc -y. */
keyname = isc_commandline_argument;
if (isc_commandline_option != '?') {
fprintf(stderr, "%s: invalid argument -%c\n",
program, isc_commandline_option);
- usage(1);
+ usage(EXIT_FAILURE);
} else {
- usage(0);
+ usage(EXIT_SUCCESS);
}
break;
default:
fprintf(stderr, "%s: unhandled option -%c\n", program,
isc_commandline_option);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
POST(argv);
if (argc > 0) {
- usage(1);
+ usage(EXIT_FAILURE);
}
if (alg == DST_ALG_HMACMD5) {
keysize = alg_bits(alg);
break;
case 'h':
- usage(0);
+ usage(EXIT_SUCCESS);
case 'k':
case 'y':
if (progmode == progmode_confgen) {
keyname = isc_commandline_argument;
} else {
- usage(1);
+ usage(EXIT_FAILURE);
}
break;
case 'M':
if (progmode == progmode_confgen) {
quiet = true;
} else {
- usage(1);
+ usage(EXIT_FAILURE);
}
break;
case 'r':
if (progmode == progmode_confgen) {
self_domain = isc_commandline_argument;
} else {
- usage(1);
+ usage(EXIT_FAILURE);
}
break;
case 'z':
if (progmode == progmode_confgen) {
zone = isc_commandline_argument;
} else {
- usage(1);
+ usage(EXIT_FAILURE);
}
break;
case '?':
if (isc_commandline_option != '?') {
fprintf(stderr, "%s: invalid argument -%c\n",
program, isc_commandline_option);
- usage(1);
+ usage(EXIT_FAILURE);
} else {
- usage(0);
+ usage(EXIT_SUCCESS);
}
break;
default:
fprintf(stderr, "%s: unhandled option -%c\n", program,
isc_commandline_option);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
POST(argv);
if (self_domain != NULL && zone != NULL) {
- usage(1); /* -s and -z cannot coexist */
+ usage(EXIT_FAILURE); /* -s and -z cannot coexist */
}
if (argc > isc_commandline_index) {
- usage(1);
+ usage(EXIT_FAILURE);
}
/* Use canonical algorithm name */
"process)\n"
" +[no]yaml (Present the results as "
"YAML)\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
noreturn static void
if (state) {
fprintf(stderr, "Invalid option: "
"+dlv is obsolete\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
case 'n': /* dnssec */
break;
case 'h':
usage();
- exit(0);
+ exit(EXIT_SUCCESS);
case 'i':
no_sigs = true;
root_validation = false;
break;
case 'v':
printf("delv %s\n", PACKAGE_VERSION);
- exit(0);
+ exit(EXIT_SUCCESS);
default:
UNREACHABLE();
}
typeset = true;
} else {
fprintf(stderr, "Invalid IP address %s\n", value);
- exit(1);
+ exit(EXIT_FAILURE);
}
return (value_from_next);
invalid_option:
print_usage(stderr);
fprintf(stderr, "\nUse \"dig -h\" (or \"dig -h | more\") "
"for complete list of options\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
#endif /* if TARGET_OS_IPHONE */
break;
case 'h':
help();
- exit(0);
+ exit(EXIT_SUCCESS);
break;
case 'i':
fatal("-%c removed", option[0]);
break;
case 'v':
printf("DiG %s\n", PACKAGE_VERSION);
- exit(0);
+ exit(EXIT_SUCCESS);
break;
}
if (strlen(option) > 1U) {
ISC_LIST_APPEND(lookup_list, *lookup, link);
} else {
fprintf(stderr, "Invalid IP address %s\n", value);
- exit(1);
+ exit(EXIT_FAILURE);
}
return (value_from_next);
invalid_option:
" -W specifies how long to wait for a reply\n"
" -4 use IPv4 query transport only\n"
" -6 use IPv6 query transport only\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
static void
break;
case 'V':
printf("host %s\n", PACKAGE_VERSION);
- exit(0);
+ exit(EXIT_SUCCESS);
break;
case 'w':
break;
"'host' using default server\n");
fprintf(stderr, " nslookup [-opt ...] host server # just look up "
"'host' using 'server'\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
static void
if (argv[0][0] == '-') {
if (strncasecmp(argv[0], "-ver", 4) == 0) {
printf("nslookup %s\n", PACKAGE_VERSION);
- exit(0);
+ exit(EXIT_SUCCESS);
} else if (argv[0][1] != 0) {
setoption(&argv[0][1]);
} else {
" -T <ttl> TTL of DS records\n"
" -V print version\n"
" -v <verbosity>\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
static void
cleanup:
print_mem_stats = true;
cleanup();
- exit(0);
+
+ return (0);
}
" -V: print version information\n");
fprintf(stderr, "Output: DS or CDS RRs\n");
- exit(-1);
+ exit(EXIT_FAILURE);
}
int
default:
fprintf(stderr, "%s: unhandled option -%c\n", program,
isc_commandline_option);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
fprintf(stderr, " -D sync date/[+-]offset/none: set/unset "
"CDS and CDNSKEY deletion date\n");
- exit(-1);
+ exit(EXIT_FAILURE);
}
int
default:
fprintf(stderr, "%s: unhandled option -%c\n", program,
isc_commandline_option);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
fprintf(stderr, " K<name>+<alg>+<id>.key, "
"K<name>+<alg>+<id>.private\n");
- exit(-1);
+ exit(EXIT_FAILURE);
}
int
default:
fprintf(stderr, "%s: unhandled option -%c\n", program,
isc_commandline_option);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
fatal("failed to get key %s/%s: %s", namestr, algstr,
isc_result_totext(ret));
UNREACHABLE();
- exit(-1);
+ exit(EXIT_FAILURE);
}
/*
fprintf(stderr, " K<name>+<alg>+<id>.key, "
"K<name>+<alg>+<id>.private\n");
- exit(-1);
+ exit(EXIT_FAILURE);
}
static void
default:
fprintf(stderr, "%s: unhandled option -%c\n", program,
isc_commandline_option);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
fprintf(stderr, " K<name>+<alg>+<new id>.key, "
"K<name>+<alg>+<new id>.private\n");
- exit(-1);
+ exit(EXIT_FAILURE);
}
int
default:
fprintf(stderr, "%s: unhandled option -%c\n", program,
isc_commandline_option);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
fprintf(stderr, " K<name>+<alg>+<new id>.key, "
"K<name>+<alg>+<new id>.private\n");
- exit(-1);
+ exit(EXIT_FAILURE);
}
static void
default:
fprintf(stderr, "%s: unhandled option -%c\n", program,
isc_commandline_option);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
fprintf(stderr, "(default: all zone keys that have private keys)\n");
fprintf(stderr, "\tkeyfile (Kname+alg+tag)\n");
- exit(0);
+ exit(EXIT_FAILURE);
}
static void
if (*endp != '\0') {
fprintf(stderr, "source serial number "
"must be numeric");
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
if (*endp != '\0') {
fprintf(stderr, "maximum TTL "
"must be numeric");
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
default:
fprintf(stderr, "%s: unhandled option -%c\n", program,
isc_commandline_option);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
rawversion > 1U)
{
fprintf(stderr, "unknown raw format version\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
} else {
fatal("unknown file format: %s", outputformatstr);
fprintf(stderr, "\t-x:\tDNSKEY record signed with KSKs only, "
"not ZSKs\n");
fprintf(stderr, "\t-z:\tAll records signed with KSKs\n");
- exit(0);
+ exit(EXIT_SUCCESS);
}
int
default:
fprintf(stderr, "%s: unhandled option -%c\n", program,
isc_commandline_option);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
void
version(const char *name) {
printf("%s %s\n", name, PACKAGE_VERSION);
- exit(0);
+ exit(EXIT_SUCCESS);
}
void
printf("# Built-in default values. "
"This is NOT the run-time configuration!\n");
printf("%s", named_config_getdefault());
- exit(0);
+ exit(EXIT_SUCCESS);
case 'd':
named_g_debuglevel = parse_int(isc_commandline_argument,
"debug "
break;
case 'v':
printversion(false);
- exit(0);
+ exit(EXIT_SUCCESS);
case 'V':
printversion(true);
- exit(0);
+ exit(EXIT_SUCCESS);
case 'x':
/* Obsolete. No longer in use. Ignore. */
break;
case '?':
usage();
if (isc_commandline_option == '?') {
- exit(0);
+ exit(EXIT_SUCCESS);
}
p = strchr(NAMED_MAIN_ARGS, isc_commandline_option);
if (p == NULL || *++p != ':') {
char buf;
n = read(dfd[0], &buf, 1);
if (n == 1) {
- _exit(0);
+ _exit(EXIT_SUCCESS);
}
} while (n == -1 && errno == EINTR);
- _exit(1);
+ _exit(EXIT_FAILURE);
}
(void)close(dfd[0]);
name = secretstr;
secretstr = n + 1;
if (!parse_hmac(keystr, s - keystr, &hmac_alg, &digestbits)) {
- exit(1);
+ exit(EXIT_FAILURE);
}
} else {
hmac_alg = DST_ALG_HMACMD5;
"[-A tlscafile] [-H tlshostname] "
"[-O] ] [-v] [-V] [-P] [-T] [-4 | -6] "
"[filename]\n");
- exit(1);
+ exit(EXIT_FAILURE);
case 'P':
for (t = 0xff00; t <= 0xfffe; t++) {
}
}
if (doexit) {
- exit(0);
+ exit(EXIT_SUCCESS);
}
isc_commandline_reset = true;
isc_commandline_index = 1;
"bad library debug value "
"'%s'\n",
isc_commandline_argument);
- exit(1);
+ exit(EXIT_FAILURE);
}
logdebuglevel = i;
break;
"bad port number "
"'%s'\n",
isc_commandline_argument);
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
case 'S':
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "bad timeout '%s'\n",
isc_commandline_argument);
- exit(1);
+ exit(EXIT_FAILURE);
}
if (timeout == 0) {
timeout = UINT_MAX;
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "bad udp timeout '%s'\n",
isc_commandline_argument);
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
case 'r':
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "bad udp retries '%s'\n",
isc_commandline_argument);
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
default:
fprintf(stderr, "%s: unhandled option: %c\n", argv[0],
isc_commandline_option);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
if (keyfile != NULL && keystr != NULL) {
fprintf(stderr, "%s: cannot specify both -k and -y\n", argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
}
#if HAVE_GSSAPI
if (usegsstsig && (keyfile != NULL || keystr != NULL)) {
fprintf(stderr, "%s: cannot specify -g with -k or -y\n",
argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
}
#else /* HAVE_GSSAPI */
if (usegsstsig) {
"%s: cannot specify -g or -o, "
"program not linked with GSS API Library\n",
argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
}
#endif /* HAVE_GSSAPI */
"%s: cannot specify the -K option without"
"the -E option, and vice versa.\n",
argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
}
if (tls_ca_file != NULL && tls_always_verify_remote == false) {
fprintf(stderr,
"%s: cannot specify the -A option in "
"conjuction with the -O option.\n",
argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
fprintf(stderr, "could not open '%s': %s\n",
argv[isc_commandline_index],
isc_result_totext(result));
- exit(1);
+ exit(EXIT_FAILURE);
}
}
if (!force_interactive) {
if (bufsz > MAXTEXT) {
fprintf(stderr, "could not allocate large enough "
"buffer to display message\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
if (buf != NULL) {
isc_buffer_free(&buf);
if (seenerror) {
return (2);
- } else {
- return (0);
}
+
+ return (0);
}
default:
fprintf(stderr, "%s: unhandled option -%c\n", program,
isc_commandline_option);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
if ((x) != ISC_R_SUCCESS) { \
fprintf(stderr, "I:%s: %s\n", (str), \
isc_result_totext(x)); \
- exit(-1); \
+ exit(EXIT_FAILURE); \
} \
}
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "I:request event result: %s\n",
isc_result_totext(result));
- exit(-1);
+ exit(EXIT_FAILURE);
}
dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
result = dns_result_fromrcode(response->rcode);
fprintf(stderr, "I:response rcode: %s\n",
isc_result_totext(result));
- exit(-1);
+ exit(EXIT_FAILURE);
}
if (response->counts[DNS_SECTION_ANSWER] != 1U) {
fprintf(stderr, "I:response answer count (%u!=1)\n",
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "bad port '%s'\n",
isc_commandline_argument);
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
case 'r':
*/
/*
- * -a exit(0) if dnsrps is available or dlopen() msg if not
+ * -a exit(EXIT_SUCCESS) if dnsrps is available or dlopen() msg if not
* -n domain print the serial number of a domain to check if a new
* version of a policy zone is ready.
* Exit(1) if dnsrps is not available
msg, isc_result_totext(result), __FILE__, \
__LINE__); \
ERR_clear_error(); \
- exit(1); \
+ exit(EXIT_FAILURE); \
} \
} while (0)
{
fprintf(stderr, "fatal error: basic OpenSSL failure\n");
ERR_clear_error();
- exit(1);
+ exit(EXIT_FAILURE);
}
/* e = 0x1000000000001 */
"at file %s line %d\n",
__FILE__, __LINE__);
ERR_clear_error();
- exit(1);
+ exit(EXIT_FAILURE);
}
isc_mem_create(&mctx);
teardown();
- exit(EXIT_SUCCESS);
+ return (EXIT_SUCCESS);
}
teardown();
- exit(EXIT_SUCCESS);
+ return (EXIT_SUCCESS);
}
if (result != ISC_R_SUCCESS) {
printf("%s: %s\n", msg, isc_result_totext(result));
- exit(1);
+ exit(EXIT_FAILURE);
}
}
break;
default:
usage();
- exit(1);
+ exit(EXIT_FAILURE);
}
}
f = fopen(argv[0], "r");
if (f == NULL) {
fprintf(stderr, "%s: fopen failed\n", argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
}
need_close = true;
} else {
if (len % 2 != 0U) {
fprintf(stderr, "bad input format: %lu\n",
(unsigned long)len);
- exit(1);
+ exit(EXIT_FAILURE);
}
rp = s;
if (isc_buffer_remaininglength(input) < 2) {
fprintf(stderr, "premature end of packet\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
tcplen = isc_buffer_getuint16(input);
if (isc_buffer_remaininglength(input) < tcplen) {
fprintf(stderr, "premature end of packet\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
process_message(input);
}
break;
default:
usage();
- exit(1);
+ exit(EXIT_FAILURE);
}
}
if ((x) != ISC_R_SUCCESS) { \
fprintf(stderr, "mdig: %s failed with %s\n", (str), \
isc_result_totext(x)); \
- exit(-1); \
+ exit(EXIT_FAILURE); \
} \
}
if (continue_on_error) {
goto cleanup;
} else {
- exit(-1);
+ exit(EXIT_FAILURE);
}
}
" {local-opt} [ host {local-opt} [...]]\n"
"\nUse \"mdig -h\" (or \"mdig -h | more\") "
"for complete list of options\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
/*% help */
break;
case 'h':
help();
- exit(0);
+ exit(EXIT_SUCCESS);
break;
case 'i':
fatal("-%c removed", opt);
break;
case 'v':
printf("mDiG %s\n", PACKAGE_VERSION);
- exit(0);
+ exit(EXIT_SUCCESS);
break;
}
if (strlen(option) > 1U) {
static void
usage(void) {
fprintf(stderr, "Usage: %s [-dux] journal\n", progname);
- exit(1);
+ exit(EXIT_FAILURE);
}
/*
if (endp == isc_commandline_argument || *endp != 0) {
fprintf(stderr, "invalid serial: %s\n",
isc_commandline_argument);
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
case 'd':
if (argc != 2) {
fprintf(stderr, "Usage: named-nzd2nzf <nzd-path>\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
path = argv[1];
if (status != MDB_SUCCESS) {
fprintf(stderr, "named-nzd2nzf: mdb_env_create: %s",
mdb_strerror(status));
- exit(1);
+ exit(EXIT_FAILURE);
}
status = mdb_env_open(env, path, DNS_LMDB_FLAGS, 0600);
if (status != MDB_SUCCESS) {
fprintf(stderr, "named-nzd2nzf: mdb_env_open: %s",
mdb_strerror(status));
- exit(1);
+ exit(EXIT_FAILURE);
}
status = mdb_txn_begin(env, 0, MDB_RDONLY, &txn);
if (status != MDB_SUCCESS) {
fprintf(stderr, "named-nzd2nzf: mdb_txn_begin: %s",
mdb_strerror(status));
- exit(1);
+ exit(EXIT_FAILURE);
}
status = mdb_dbi_open(txn, NULL, 0, &dbi);
if (status != MDB_SUCCESS) {
fprintf(stderr, "named-nzd2nzf: mdb_dbi_open: %s",
mdb_strerror(status));
- exit(1);
+ exit(EXIT_FAILURE);
}
status = mdb_cursor_open(txn, dbi, &cursor);
if (status != MDB_SUCCESS) {
fprintf(stderr, "named-nzd2nzf: mdb_cursor_open: %s",
mdb_strerror(status));
- exit(1);
+ exit(EXIT_FAILURE);
}
for (status = mdb_cursor_get(cursor, &key, &data, MDB_FIRST);
"named-nzd2nzf: empty column found in "
"database '%s'",
path);
- exit(1);
+ exit(EXIT_FAILURE);
}
/* zone zonename { config; }; */
mdb_cursor_close(cursor);
mdb_txn_abort(txn);
mdb_env_close(env);
- exit(0);
+
+ return (0);
}
fprintf(stderr, "\t-P: list the supported private type names\n");
fprintf(stderr, "\t-T: list the supported standard type names\n");
fprintf(stderr, "\t-u: print the record in unknown record format\n");
- exit(0);
+ exit(EXIT_SUCCESS);
}
static void
fprintf(stdout, "%s\n", text);
}
}
- exit(0);
+ exit(EXIT_SUCCESS);
case 'P':
for (t = 0xff00; t <= 0xfffeu; t++) {
default:
fprintf(stderr, "%s: unhandled option -%c\n", argv[0],
isc_commandline_option);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
if (doexit) {
- exit(0);
+ exit(EXIT_SUCCESS);
}
isc_mem_create(&mctx);
va_end(args);
fprintf(stderr, "\n");
isc__tls_setfatalmode();
- _exit(1);
+ _exit(EXIT_FAILURE);
}
static void
program);
fprintf(stderr, " %s -r algorithm flags iterations salt domain\n",
program);
- exit(1);
+ exit(EXIT_FAILURE);
}
typedef void
vfprintf(stderr, format, args);
va_end(args);
fprintf(stderr, ": %s\n", isc_result_totext(result));
- exit(1);
+ exit(EXIT_FAILURE);
}
static void
fprintf(stderr, "usage: cfg_test --rndc|--named "
"[--grammar] [--zonegrammar] [--active] "
"[--memstats] conffile\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
int
fprintf(stderr, "read config: %s\n", isc_result_totext(result));
if (result != ISC_R_SUCCESS) {
- exit(1);
+ exit(EXIT_FAILURE);
}
cfg_print(cfg, output, NULL);
if (ferror(stdout)) {
fprintf(stderr, "write error\n");
return (1);
- } else {
- return (0);
}
+
+ return (0);
}
fprintf(stderr,
"Error: reading directory: %s\n",
strerror(errno));
- exit(1);
+ exit(EXIT_FAILURE);
}
}
}
fprintf(stderr,
"Error: type %d has two names: %s, %s\n", type,
typenames[i].typebuf, typebuf);
- exit(1);
+ exit(EXIT_FAILURE);
}
ttn = &typenames[i];
}
/* Subtract one to leave an empty sentinel entry at the end */
if (i >= TYPENAMES - 1) {
fprintf(stderr, "Error: typenames array too small\n");
- exit(1);
+ exit(EXIT_FAILURE);
} else if (ttn == NULL) {
ttn = &typenames[i];
ttnam_count = i + 1;
/* XXXMUKS: This is redundant due to the INSIST above. */
if (strlen(typebuf) > sizeof(ttn->typebuf) - 1) {
fprintf(stderr, "Error: type name %s is too long\n", typebuf);
- exit(1);
+ exit(EXIT_FAILURE);
}
strncpy(ttn->typebuf, typebuf, sizeof(ttn->typebuf));
"Error: type %d has different attributes: "
"%s, %s\n",
type, ttn->attr, attr);
- exit(1);
+ exit(EXIT_FAILURE);
}
if (strlen(attr) > sizeof(ttn->attr) - 1) {
fprintf(stderr, "Error: attr (%s) [name %s] is too long\n",
attr, typebuf);
- exit(1);
+ exit(EXIT_FAILURE);
}
strncpy(ttn->attr, attr, sizeof(ttn->attr));
if (newtt == NULL) {
fprintf(stderr, "malloc() failed\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
newtt->next = NULL;
newcc = (struct cc *)malloc(sizeof(*newcc));
if (newcc == NULL) {
fprintf(stderr, "malloc() failed\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
newcc->rdclass = rdclass;
strncpy(newcc->classbuf, classbuf, sizeof(newcc->classbuf));
if (type > 65535) {
fprintf(stderr, "Error: type value > 65535 (%s)\n",
dir.filename);
- exit(1);
+ exit(EXIT_FAILURE);
}
add(rdclass, classbuf, type, typebuf, dirbuf);
}
sizeof("/rdata/_65535_65535"))
{
fprintf(stderr, "\"%s\" too long\n", optarg);
- exit(1);
+ exit(EXIT_FAILURE);
}
n = snprintf(srcdir, sizeof(srcdir), "%s/", optarg);
INSIST(n > 0 && (unsigned int)n < sizeof(srcdir));
suffix = optarg;
break;
case '?':
- exit(1);
+ exit(EXIT_FAILURE);
}
}
if (rdclass > 65535) {
fprintf(stderr, "Error: class value > 65535 (%s)\n",
dir.filename);
- exit(1);
+ exit(EXIT_FAILURE);
}
sd(rdclass, classbuf, buf, filetype);
}
}
if (ferror(stdout) != 0) {
- exit(1);
+ exit(EXIT_FAILURE);
}
return (0);
if (isc_fips_set_mode(1) != ISC_R_SUCCESS) {
dst__openssl_toresult2("FIPS_mode_set", DST_R_OPENSSLFAILURE);
- exit(1);
+ exit(EXIT_FAILURE);
}
#endif
}
CHECKRESULT(isc_result_t result, const char *msg) {
if (result != ISC_R_SUCCESS) {
printf("%s: %s\n", msg, isc_result_totext(result));
- exit(1);
+ exit(EXIT_FAILURE);
}
}
dns_name_format(name, buf, sizeof(buf)); \
fprintf(stderr, "%s: %s\n", buf, \
isc_result_totext(result)); \
- exit(1); \
+ exit(EXIT_FAILURE); \
} \
} while (0)
do { \
if (!(check)) { \
fprintf(stderr, "%s:%zu: %s\n", filename, lines, msg); \
- exit(1); \
+ exit(EXIT_FAILURE); \
} \
} while (0)
if (argc != 2) {
fprintf(stderr,
"usage: load-names <filename.csv> <nthreads>\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
filename = argv[1];
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "stat(%s): %s\n", filename,
isc_result_totext(result));
- exit(1);
+ exit(EXIT_FAILURE);
}
filesize = (size_t)fileoff;
fp = fopen(filename, "r");
if (fp == NULL || fread(filetext, 1, filesize, fp) < filesize) {
fprintf(stderr, "read(%s): %s\n", filename, strerror(errno));
- exit(1);
+ exit(EXIT_FAILURE);
}
fclose(fp);
filetext[filesize] = '\0';
continue;
default:
usage();
- exit(1);
+ exit(EXIT_FAILURE);
continue;
}
}
if (argc != 1) {
/* must exit 0 to appease test runner */
usage();
- exit(0);
+ exit(EXIT_SUCCESS);
}
isc_mem_create(&mctx);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "stat(%s): %s\n", filename,
isc_result_totext(result));
- exit(1);
+ exit(EXIT_FAILURE);
}
filesize = (size_t)fileoff;
fp = fopen(filename, "r");
if (fp == NULL || fread(filetext, 1, filesize, fp) < filesize) {
fprintf(stderr, "read(%s): %s\n", filename, strerror(errno));
- exit(1);
+ exit(EXIT_FAILURE);
}
fclose(fp);
filetext[filesize] = '\0';
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "%s:%zu: %s %s\n", filename, names,
domain, isc_result_totext(result));
- exit(1);
+ exit(EXIT_FAILURE);
}
wirebytes += name->length;
static void
usage(void) {
fprintf(stderr, "usage: lookups <filename>\n");
- exit(0);
+ exit(EXIT_FAILURE);
}
static size_t
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "stat(%s): %s\n", filename,
isc_result_totext(result));
- exit(1);
+ exit(EXIT_FAILURE);
}
filesize = (size_t)fileoff;
fp = fopen(filename, "r");
if (fp == NULL || fread(filetext, 1, filesize, fp) < filesize) {
fprintf(stderr, "read(%s): %s\n", filename, strerror(errno));
- exit(1);
+ exit(EXIT_FAILURE);
}
fclose(fp);
filetext[filesize] = '\0';
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "%s:%zu: %s %s\n", filename, names,
domain, isc_result_totext(result));
- exit(1);
+ exit(EXIT_FAILURE);
}
names++;