 @@ -1,14 +1,14 @@
-/*	$NetBSD: sysctl.c,v 1.150 2014/01/10 09:38:56 pooka Exp $ */
+/*	$NetBSD: sysctl.c,v 1.151 2014/01/10 18:37:18 christos Exp $ */
 /*-
  * Copyright (c) 2003 The NetBSD Foundation, Inc.
  *	All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Brown.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -58,27 +58,27 @@
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 __COPYRIGHT("@(#) Copyright (c) 1993\
  The Regents of the University of California.  All rights reserved.");
 #endif /* not lint */
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)sysctl.c	8.1 (Berkeley) 6/6/93";
 #else
-__RCSID("$NetBSD: sysctl.c,v 1.150 2014/01/10 09:38:56 pooka Exp $");
+__RCSID("$NetBSD: sysctl.c,v 1.151 2014/01/10 18:37:18 christos Exp $");
 #endif
 #endif /* not lint */
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/sysctl.h>
 #include <sys/mount.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
 #include <sys/sched.h>
 #include <sys/socket.h>
 #include <sys/bitops.h>
 #include <netinet/in.h>
 @@ -327,106 +327,106 @@ main(int argc, char *argv[])
 	if (xflag && rflag)
 		usage();
 	/* if ((xflag || rflag) && wflag)
 		usage(); */
 	/* if (aflag && (Mflag || qflag))
 		usage(); */
 	if ((aflag || Aflag) && qflag)
 		usage();
 	if ((Aflag || Mflag || dflag) && argc == 0 && fn == NULL)
 		aflag = 1;
 	if (prog_init && prog_init() == -1)
-		err(1, "prog init failed");
+		err(EXIT_FAILURE, "prog init failed");
 	if (Aflag)
 		warnfp = stdout;
 	stale = req = 0;
 	if ((re = malloc(sizeof(*re) * __arraycount(handlers))) == NULL)
-		err(1, "malloc regex");
+		err(EXIT_FAILURE, "malloc regex");
 	if (aflag) {
 		print_tree(&name[0], 0, NULL, CTLTYPE_NODE, 1,
 		    re, &lastcompiled);
 		/* if (argc == 0) */
 		return (0);
+	}
 	if (fn) {
 		FILE *fp;
 		char *l;
 		fp = fopen(fn, "r");
 		if (fp == NULL) {
-			err(1, "%s", fn);
+			err(EXIT_FAILURE, "%s", fn);
 		} else {
 			nr = 0;
 			while ((l = fparseln(fp, NULL, &nr, NULL, 0)) != NULL)
+			{
 				if (*l) {
 					parse(l, re, &lastcompiled);
 					free(l);
+				}
+			}
 			fclose(fp);
+		}
 		return errs ? 1 : 0;
+	}
 	if (argc == 0)
 		usage();
 	while (argc-- > 0)
 		parse(*argv++, re, &lastcompiled);
-	return errs ? 1 : 0;
+	return errs ? EXIT_FAILURE : EXIT_SUCCESS;
+}
 /*
  * ********************************************************************
  * how to find someone special to handle the reading (or maybe even
  * writing) of a particular node
  * ********************************************************************
  */
 static const struct handlespec *
 findhandler(const char *s, regex_t *re, size_t *lastcompiled)
+{
 	const struct handlespec *p;
 	size_t i, l;
 	int j;
 	char eb[64];
 	regmatch_t match;
 	p = &handlers[0];
 	l = strlen(s);
 	for (i = 0; p[i].ps_re != NULL; i++) {
 		if (i >= *lastcompiled) {
 			j = regcomp(&re[i], p[i].ps_re, REG_EXTENDED);
 			if (j != 0) {
 				regerror(j, &re[i], eb, sizeof(eb));
-				errx(1, "regcomp: %s: %s", p[i].ps_re, eb);
+				errx(EXIT_FAILURE, "regcomp: %s: %s", p[i].ps_re, eb);
+			}
 			*lastcompiled = i + 1;
+		}
 		j = regexec(&re[i], s, 1, &match, 0);
 		if (j == 0) {
 			if (match.rm_so == 0 && match.rm_eo == (int)l)
 				return &p[i];
+		}
 		else if (j != REG_NOMATCH) {
 			regerror(j, &re[i], eb, sizeof(eb));
-			errx(1, "regexec: %s: %s", p[i].ps_re, eb);
+			errx(EXIT_FAILURE, "regexec: %s: %s", p[i].ps_re, eb);
+		}
+	}
 	return NULL;
+}
 /*
  * after sysctlgetmibinfo is done with the name, we convert all
  * separators to / and stuff one at the front if it was missing
  */
 static void
 canonicalize(const char *i, char *o)
+{
 @@ -669,27 +669,27 @@ print_tree(int *name, u_int namelen, str
 	 * name specifically.
 	 */
 	if (SYSCTL_FLAGS(pnode->sysctl_flags) & CTLFLAG_ALIAS && add) {
 		*sp = *dp = '\0';
 		return;
+	}
 	canonicalize(gsname, canonname);
 	p = findhandler(canonname, re, lastcompiled);
 	if (type != CTLTYPE_NODE && p != NULL) {
 		if (p->ps_p == NULL) {
 			sysctlperror("Cannot print `%s': %s\n", gsname,
 			    strerror(EOPNOTSUPP));
-			exit(1);
+			exit(EXIT_FAILURE);
+		}
 		(*p->ps_p)(gsname, gdname, NULL, name, namelen, pnode, type,
 			   __UNCONST(p->ps_d));
 		*sp = *dp = '\0';
 		return;
+	}
 	if (type != CTLTYPE_NODE && pnode->sysctl_size == 0) {
 		rc = prog_sysctl(&name[0], namelen, NULL, &sz, NULL, 0);
 		if (rc == -1) {
 			sysctlerror(1);
 			*sp = *dp = '\0';
 			return;
 @@ -880,56 +880,56 @@ parse(char *l, regex_t *re, size_t *last
 	if (stale) {
 		purge_tree(&my_root);
 		stale = 0;
+	}
 	node = &my_root;
 	namelen = CTL_MAXNAME;
 	sz = sizeof(gsname);
 	if (sysctlgetmibinfo(key, &name[0], &namelen, gsname, &sz, &node,
 			     SYSCTL_VERSION) == -1) {
 		if (optional)
 			return;
 		sysctlparseerror(namelen, l);
-		EXIT(1);
+		EXIT(EXIT_FAILURE);
+	}
 	type = SYSCTL_TYPE(node->sysctl_flags);
 	if (value == NULL) {
 		if (dodesc)
 			dflag = 1;
 		print_tree(&name[0], namelen, node, type, 0, re, lastcompiled);
 		if (dodesc)
 			dflag = 0;
 		gsname[0] = '\0';
 		return;
+	}
 	if (fn)
 		trim_whitespace(value, 1);
 	if (!wflag) {
 		sysctlperror("Must specify -w to set variables\n");
-		exit(1);
+		exit(EXIT_FAILURE);
+	}
 	canonicalize(gsname, canonname);
 	if (type != CTLTYPE_NODE && (w = findhandler(canonname, re,
 	    lastcompiled)) != NULL) {
 		if (w->ps_w == NULL) {
 			sysctlperror("Cannot write `%s': %s\n", gsname,
 			    strerror(EOPNOTSUPP));
-			exit(1);
+			exit(EXIT_FAILURE);
+		}
 		(*w->ps_w)(gsname, gdname, value, name, namelen, node, type,
 			   __UNCONST(w->ps_d));
 		gsname[0] = '\0';
 		return;
+	}
 	switch (type) {
 	case CTLTYPE_NODE:
 		/*
 		 * XXX old behavior is to print.  should we error instead?
 		 */
 		print_tree(&name[0], namelen, node, CTLTYPE_NODE, 1, re,
 @@ -977,27 +977,27 @@ static void
 parse_create(char *l)
+{
 	struct sysctlnode node;
 	size_t sz;
 	char *nname, *key, *value, *data, *addr, *c, *t;
 	int name[CTL_MAXNAME], i, rc, method, flags, rw;
 	u_int namelen, type;
 	u_quad_t uq;
 	quad_t q;
 	bool b;
 	if (!wflag) {
 		sysctlperror("Must specify -w to create nodes\n");
-		exit(1);
+		exit(EXIT_FAILURE);
+	}
 	/*
 	 * these are the pieces that make up the description of a new
 	 * node
 	 */
 	memset(&node, 0, sizeof(node));
 	node.sysctl_num = CTL_CREATE;  /* any number is fine */
 	flags = 0;
 	rw = -1;
 	type = 0;
 	sz = 0;
 	data = addr = NULL;
 @@ -1058,122 +1058,122 @@ parse_create(char *l)
 		 * other to make sure it makes some sort of sense.
 		 */
 		if (strcmp(key, "addr") == 0) {
 			/*
 			 * we can't check these two.  only the kernel
 			 * can tell us when it fails to find the name
 			 * (or if the address is invalid).
 			 */
 			if (method != 0) {
 				sysctlperror(
 				    "%s: already have %s for new node\n",
 				    nname,
 				    method == CTL_CREATE ? "addr" : "symbol");
-				EXIT(1);
+				EXIT(EXIT_FAILURE);
+			}
 			if (value == NULL) {
 				sysctlperror("%s: missing value\n", nname);
-				EXIT(1);
+				EXIT(EXIT_FAILURE);
+			}
 			errno = 0;
 			addr = (void*)strtoul(value, &t, 0);
 			if (t == value || *t != '\0' || errno != 0) {
 				sysctlperror(
 				    "%s: '%s' is not a valid address\n",
 				    nname, value);
-				EXIT(1);
+				EXIT(EXIT_FAILURE);
+			}
 			method = CTL_CREATE;
+		}
 		else if (strcmp(key, "symbol") == 0) {
 			if (method != 0) {
 				sysctlperror(
 				    "%s: already have %s for new node\n",
 				    nname,
 				    method == CTL_CREATE ? "addr" : "symbol");
-				EXIT(1);
+				EXIT(EXIT_FAILURE);
+			}
 			addr = value;
 			method = CTL_CREATESYM;
+		}
 		else if (strcmp(key, "type") == 0) {
 			if (value == NULL) {
 				sysctlperror("%s: missing value\n", nname);
-				EXIT(1);
+				EXIT(EXIT_FAILURE);
+			}
 			if (strcmp(value, "node") == 0)
 				type = CTLTYPE_NODE;
 			else if (strcmp(value, "int") == 0) {
 				sz = sizeof(int);
 				type = CTLTYPE_INT;
+			}
 			else if (strcmp(value, "bool") == 0) {
 				sz = sizeof(bool);
 				type = CTLTYPE_BOOL;
+			}
 			else if (strcmp(value, "string") == 0)
 				type = CTLTYPE_STRING;
 			else if (strcmp(value, "quad") == 0) {
 				sz = sizeof(u_quad_t);
 				type = CTLTYPE_QUAD;
+			}
 			else if (strcmp(value, "struct") == 0)
 				type = CTLTYPE_STRUCT;
 			else {
 				sysctlperror(
 					"%s: '%s' is not a valid type\n",
 					nname, value);
-				EXIT(1);
+				EXIT(EXIT_FAILURE);
+			}
+		}
 		else if (strcmp(key, "size") == 0) {
 			if (value == NULL) {
 				sysctlperror("%s: missing value\n", nname);
-				EXIT(1);
+				EXIT(EXIT_FAILURE);
+			}
 			errno = 0;
 			/*
 			 * yes, i know size_t is not an unsigned long,
 			 * but we can all agree that it ought to be,
 			 * right?
 			 */
 			sz = strtoul(value, &t, 0);
 			if (t == value || *t != '\0' || errno != 0) {
 				sysctlperror(
 					"%s: '%s' is not a valid size\n",
 					nname, value);
-				EXIT(1);
+				EXIT(EXIT_FAILURE);
+			}
+		}
 		else if (strcmp(key, "n") == 0) {
 			if (value == NULL) {
 				sysctlperror("%s: missing value\n", nname);
-				EXIT(1);
+				EXIT(EXIT_FAILURE);
+			}
 			errno = 0;
 			q = strtoll(value, &t, 0);
 			if (t == value || *t != '\0' || errno != 0 ||
 			    q < INT_MIN || q > UINT_MAX) {
 				sysctlperror(
 				    "%s: '%s' is not a valid mib number\n",
 				    nname, value);
-				EXIT(1);
+				EXIT(EXIT_FAILURE);
+			}
 			node.sysctl_num = (int)q;
+		}
 		else if (strcmp(key, "flags") == 0) {
 			if (value == NULL) {
 				sysctlperror("%s: missing value\n", nname);
-				EXIT(1);
+				EXIT(EXIT_FAILURE);
+			}
 			t = value;
 			while (*t != '\0') {
 				switch (*t) {
 				case 'a':
 					flags |= CTLFLAG_ANYWRITE;
 					break;
 				case 'h':
 					flags |= CTLFLAG_HIDDEN;
 					break;
 				case 'i':
 					flags |= CTLFLAG_IMMEDIATE;
 					break;
 @@ -1190,87 +1190,87 @@ parse_create(char *l)
 					flags |= CTLFLAG_HEX;
 					break;
 				case 'r':
 					rw = CTLFLAG_READONLY;
 					break;
 				case 'w':
 					rw = CTLFLAG_READWRITE;
 					break;
 				default:
 					sysctlperror(
 					   "%s: '%c' is not a valid flag\n",
 					    nname, *t);
-					EXIT(1);
+					EXIT(EXIT_FAILURE);
+				}
 				t++;
+			}
+		}
 		else {
 			sysctlperror("%s: unrecognized keyword '%s'\n",
 				     nname, key);
-			EXIT(1);
+			EXIT(EXIT_FAILURE);
+		}
+	}
 	/*
 	 * now that we've finished parsing the given string, fill in
 	 * anything they didn't specify
 	 */
 	if (type == 0)
 		type = CTLTYPE_NODE;
 	/*
 	 * the "data" can be interpreted various ways depending on the
 	 * type of node we're creating, as can the size
 	 */
 	if (data != NULL) {
 		if (addr != NULL) {
 			sysctlperror(
 				"%s: cannot specify both value and "
 				"address\n", nname);
-			EXIT(1);
+			EXIT(EXIT_FAILURE);
+		}
 		switch (type) {
 		case CTLTYPE_INT:
 			errno = 0;
 			q = strtoll(data, &t, 0);
 			if (t == data || *t != '\0' || errno != 0 ||
 				q < INT_MIN || q > UINT_MAX) {
 				sysctlperror(
 				    "%s: '%s' is not a valid integer\n",
 				    nname, value);
-				EXIT(1);
+				EXIT(EXIT_FAILURE);
+			}
 			i = (int)q;
 			if (!(flags & CTLFLAG_OWNDATA)) {
 				flags |= CTLFLAG_IMMEDIATE;
 				node.sysctl_idata = i;
+			}
 			else
 				node.sysctl_data = &i;
 			if (sz == 0)
 				sz = sizeof(int);
 			break;
 		case CTLTYPE_BOOL:
 			errno = 0;
 			q = strtoll(data, &t, 0);
 			if (t == data || *t != '\0' || errno != 0 ||
 				(q != 0 && q != 1)) {
 				sysctlperror(
 				    "%s: '%s' is not a valid bool\n",
 				    nname, value);
-				EXIT(1);
+				EXIT(EXIT_FAILURE);
+			}
 			b = q == 1;
 			if (!(flags & CTLFLAG_OWNDATA)) {
 				flags |= CTLFLAG_IMMEDIATE;
 				node.sysctl_idata = b;
+			}
 			else
 				node.sysctl_data = &b;
 			if (sz == 0)
 				sz = sizeof(bool);
 			break;
 		case CTLTYPE_STRING:
 			flags |= CTLFLAG_OWNDATA;
 @@ -1281,123 +1281,123 @@ parse_create(char *l)
 				sysctlperror("%s: ignoring size=%zu for "
 					"string node, too small for given "
 					"value\n", nname, sz);
 				sz = strlen(data) + 1;
+			}
 			break;
 		case CTLTYPE_QUAD:
 			errno = 0;
 			uq = strtouq(data, &t, 0);
 			if (t == data || *t != '\0' || errno != 0) {
 				sysctlperror(
 					"%s: '%s' is not a valid quad\n",
 					nname, value);
-				EXIT(1);
+				EXIT(EXIT_FAILURE);
+			}
 			if (!(flags & CTLFLAG_OWNDATA)) {
 				flags |= CTLFLAG_IMMEDIATE;
 				node.sysctl_qdata = uq;
+			}
 			else
 				node.sysctl_data = &uq;
 			if (sz == 0)
 				sz = sizeof(u_quad_t);
 			break;
 		case CTLTYPE_STRUCT:
 			sysctlperror("%s: struct not initializable\n",
 				     nname);
-			EXIT(1);
+			EXIT(EXIT_FAILURE);
+		}
 		/*
 		 * these methods have all provided local starting
 		 * values that the kernel must copy in
 		 */
+	}
 	/*
 	 * hmm...no data, but we have an address of data.  that's
 	 * fine.
 	 */
 	else if (addr != 0)
 		node.sysctl_data = (void*)addr;
 	/*
 	 * no data and no address?  well...okay.  we might be able to
 	 * manage that.
 	 */
 	else if (type != CTLTYPE_NODE) {
 		if (sz == 0) {
 			sysctlperror(
 			    "%s: need a size or a starting value\n",
 			    nname);
-                        EXIT(1);
+                        EXIT(EXIT_FAILURE);
+                }
 		if (!(flags & CTLFLAG_IMMEDIATE))
 			flags |= CTLFLAG_OWNDATA;
+	}
 	/*
 	 * now we do a few sanity checks on the description we've
 	 * assembled
 	 */
 	if ((flags & CTLFLAG_IMMEDIATE) &&
 	    (type == CTLTYPE_STRING || type == CTLTYPE_STRUCT)) {
 		sysctlperror("%s: cannot make an immediate %s\n",
 			     nname,
 			     (type == CTLTYPE_STRING) ? "string" : "struct");
-		EXIT(1);
+		EXIT(EXIT_FAILURE);
+	}
 	if (type == CTLTYPE_NODE && node.sysctl_data != NULL) {
 		sysctlperror("%s: nodes do not have data\n", nname);
-		EXIT(1);
+		EXIT(EXIT_FAILURE);
+	}
 	/*
 	 * some types must have a particular size
 	 */
 	if (sz != 0) {
 		if ((type == CTLTYPE_INT && sz != sizeof(int)) ||
 		    (type == CTLTYPE_BOOL && sz != sizeof(bool)) ||
 		    (type == CTLTYPE_QUAD && sz != sizeof(u_quad_t)) ||
 		    (type == CTLTYPE_NODE && sz != 0)) {
 			sysctlperror("%s: wrong size for type\n", nname);
-			EXIT(1);
+			EXIT(EXIT_FAILURE);
+		}
+	}
 	else if (type == CTLTYPE_STRUCT) {
 		sysctlperror("%s: struct must have size\n", nname);
-		EXIT(1);
+		EXIT(EXIT_FAILURE);
+	}
 	/*
 	 * now...if no one said anything yet, we default nodes or
 	 * any type that owns data being writeable, and everything
 	 * else being readonly.
 	 */
 	if (rw == -1) {
 		if (type == CTLTYPE_NODE ||
 		    (flags & (CTLFLAG_OWNDATA|CTLFLAG_IMMEDIATE)))
 			rw = CTLFLAG_READWRITE;
 		else
 			rw = CTLFLAG_READONLY;
+	}
 	/*
 	 * if a kernel address was specified, that can't be made
 	 * writeable by us.
 	if (rw != CTLFLAG_READONLY && addr) {
 		sysctlperror("%s: kernel data can only be readable\n", nname);
-		EXIT(1);
+		EXIT(EXIT_FAILURE);
+	}
 	 */
 	/*
 	 * what separator were they using in the full name of the new
 	 * node?
 	 */
 	if ((t = strpbrk(nname, "./")) == NULL)
 		sep[0] = '.';
 	else
 		sep[0] = t[0];
 	sep[1] = '\0';
 @@ -1425,123 +1425,123 @@ parse_create(char *l)
 	/*
 	 * on the other hand, if it's not a top-level node...
 	 */
 	else {
 		namelen = sizeof(name) / sizeof(name[0]);
 		sz = sizeof(gsname);
 		*t = '\0';
 		rc = sysctlgetmibinfo(nname, &name[0], &namelen,
 				      gsname, &sz, NULL, SYSCTL_VERSION);
 		*t = sep[0];
 		if (rc == -1) {
 			sysctlparseerror(namelen, nname);
-			EXIT(1);
+			EXIT(EXIT_FAILURE);
+		}
+	}
 	/*
 	 * yes, a new node is being created
 	 */
 	if (method != 0)
 		name[namelen++] = method;
 	else
 		name[namelen++] = CTL_CREATE;
 	sz = sizeof(node);
 	rc = prog_sysctl(&name[0], namelen, &node, &sz, &node, sizeof(node));
 	if (rc == -1) {
 		sysctlperror("%s: CTL_CREATE failed: %s\n",
 			     nname, strerror(errno));
-		EXIT(1);
+		EXIT(EXIT_FAILURE);
+	}
 	else {
 		if (!qflag && !nflag)
 			printf("%s(%s): (created)\n", nname, st(type));
 		stale = 1;
+	}
+}
 static void
 parse_destroy(char *l)
+{
 	struct sysctlnode node;
 	size_t sz;
 	int name[CTL_MAXNAME], rc;
 	u_int namelen;
 	if (!wflag) {
 		sysctlperror("Must specify -w to destroy nodes\n");
-		exit(1);
+		exit(EXIT_FAILURE);
+	}
 	memset(name, 0, sizeof(name));
 	namelen = sizeof(name) / sizeof(name[0]);
 	sz = sizeof(gsname);
 	rc = sysctlgetmibinfo(l, &name[0], &namelen, gsname, &sz, NULL,
 			      SYSCTL_VERSION);
 	if (rc == -1) {
 		sysctlparseerror(namelen, l);
-		EXIT(1);
+		EXIT(EXIT_FAILURE);
+	}
 	memset(&node, 0, sizeof(node));
 	node.sysctl_flags = SYSCTL_VERSION;
 	node.sysctl_num = name[namelen - 1];
 	name[namelen - 1] = CTL_DESTROY;
 	sz = sizeof(node);
 	rc = prog_sysctl(&name[0], namelen, &node, &sz, &node, sizeof(node));
 	if (rc == -1) {
 		sysctlperror("%s: CTL_DESTROY failed: %s\n",
 			     l, strerror(errno));
-		EXIT(1);
+		EXIT(EXIT_FAILURE);
+	}
 	else {
 		if (!qflag && !nflag)
 			printf("%s(%s): (destroyed)\n", gsname,
 			       st(SYSCTL_TYPE(node.sysctl_flags)));
 		stale = 1;
+	}
+}
 static void
 parse_describe(char *l)
+{
 	struct sysctlnode newdesc;
 	char buf[1024], *value;
 	struct sysctldesc *d = (void*)&buf[0];
 	int name[CTL_MAXNAME], rc;
 	u_int namelen;
 	size_t sz;
 	if (!wflag) {
 		sysctlperror("Must specify -w to set descriptions\n");
-		exit(1);
+		exit(EXIT_FAILURE);
+	}
 	value = strchr(l, '=');
 	*value++ = '\0';
 	memset(name, 0, sizeof(name));
 	namelen = sizeof(name) / sizeof(name[0]);
 	sz = sizeof(gsname);
 	rc = sysctlgetmibinfo(l, &name[0], &namelen, gsname, &sz, NULL,
 			      SYSCTL_VERSION);
 	if (rc == -1) {
 		sysctlparseerror(namelen, l);
-		EXIT(1);
+		EXIT(EXIT_FAILURE);
+	}
 	sz = sizeof(buf);
 	memset(&newdesc, 0, sizeof(newdesc));
 	newdesc.sysctl_flags = SYSCTL_VERSION|CTLFLAG_OWNDESC;
 	newdesc.sysctl_num = name[namelen - 1];
 	newdesc.sysctl_desc = value;
 	name[namelen - 1] = CTL_DESCRIBE;
 	rc = prog_sysctl(name, namelen, d, &sz, &newdesc, sizeof(newdesc));
 	if (rc == -1)
 		sysctlperror("%s: CTL_DESCRIBE failed: %s\n",
 			     gsname, strerror(errno));
 	else if (d->descr_len == 1)
 @@ -1563,27 +1563,27 @@ usage(void)
 	(void)fprintf(stderr,
 		      "usage:\t%s %s\n"
 		      "\t%s %s\n"
 		      "\t%s %s\n"
 		      "\t%s %s\n"
 		      "\t%s %s\n"
 		      "\t%s %s\n",
 		      progname, "[-dneq] [-x[x]|-r] variable ...",
 		      progname, "[-ne] [-q] -w variable=value ...",
 		      progname, "[-dne] -a",
 		      progname, "[-dne] -A",
 		      progname, "[-ne] -M",
 		      progname, "[-dne] [-q] -f file");
-	exit(1);
+	exit(EXIT_FAILURE);
+}
 static void
 getdesc1(int *name, u_int namelen, struct sysctlnode *pnode)
+{
 	struct sysctlnode node;
 	char buf[1024], *desc;
 	struct sysctldesc *d = (void*)buf;
 	size_t sz = sizeof(buf);
 	int rc;
 	memset(&node, 0, sizeof(node));
 	node.sysctl_flags = SYSCTL_VERSION;
 @@ -1698,27 +1698,27 @@ sysctlerror(int soft)
 		case EINVAL:
 		case EOPNOTSUPP:
 		case EPROTONOSUPPORT:
 			if (Aflag || req)
 				sysctlperror("%s: the value is not available\n",
 					     gsname);
 			return;
+		}
+	}
 	if (Aflag || req)
 		sysctlperror("%s: %s\n", gsname, strerror(errno));
 	if (!soft)
-		EXIT(1);
+		EXIT(EXIT_FAILURE);
+}
 void
 sysctlparseerror(u_int namelen, const char *pname)
+{
 	if (qflag) {
 		errs++;
 		return;
+	}
 	sysctlperror("%s level name '%s' in '%s' is invalid\n",
 		     lname[namelen], gsname, pname);
+}
 @@ -1754,40 +1754,40 @@ write_number(int *name, u_int namelen, s
 	void *i, *o;
 	char *t;
 	if (fn)
 		trim_whitespace(value, 3);
 	si = so = 0;
 	i = o = NULL;
 	bi = bo = false;
 	errno = 0;
 	qi = strtouq(value, &t, 0);
 	if (qi == UQUAD_MAX && errno == ERANGE) {
 		sysctlperror("%s: %s\n", value, strerror(errno));
-		EXIT(1);
+		EXIT(EXIT_FAILURE);
+	}
 	if (t == value || *t != '\0') {
 		sysctlperror("%s: not a number\n", value);
-		EXIT(1);
+		EXIT(EXIT_FAILURE);
+	}
 	switch (SYSCTL_TYPE(node->sysctl_flags)) {
 	case CTLTYPE_INT:
 		ii = (u_int)qi;
 		io = (u_int)(qi >> 32);
 		if (io != (u_int)-1 && io != 0) {
 			sysctlperror("%s: %s\n", value, strerror(ERANGE));
-			EXIT(1);
+			EXIT(EXIT_FAILURE);
+		}
 		o = &io;
 		so = sizeof(io);
 		i = &ii;
 		si = sizeof(ii);
 		break;
 	case CTLTYPE_BOOL:
 		bi = (bool)qi;
 		o = &bo;
 		so = sizeof(bo);
 		i = &bi;
 		si = sizeof(bi);
 		break;
 @@ -1823,32 +1823,32 @@ write_number(int *name, u_int namelen, s
 static void
 write_string(int *name, u_int namelen, struct sysctlnode *node, char *value)
+{
 	char *i, *o;
 	size_t si, so;
 	int rc;
 	i = value;
 	si = strlen(i) + 1;
 	so = node->sysctl_size;
 	if (si > so && so != 0) {
 		sysctlperror("%s: string too long\n", value);
-		EXIT(1);
+		EXIT(EXIT_FAILURE);
+	}
 	o = malloc(so);
 	if (o == NULL) {
 		sysctlperror("%s: !malloc failed!\n", gsname);
-		exit(1);
+		exit(EXIT_FAILURE);
+	}
 	rc = prog_sysctl(name, namelen, o, &so, i, si);
 	if (rc == -1) {
 		sysctlerror(0);
 		return;
+	}
 	display_string(node, gsname, o, so, DISPLAY_OLD);
 	display_string(node, gsname, i, si, DISPLAY_NEW);
 	free(o);
+}
 @@ -2141,27 +2141,27 @@ static void
 kern_clockrate(HANDLER_ARGS)
+{
 	struct clockinfo clkinfo;
 	size_t sz;
 	int rc;
 	sz = sizeof(clkinfo);
 	rc = prog_sysctl(name, namelen, &clkinfo, &sz, NULL, 0);
 	if (rc == -1) {
 		sysctlerror(1);
 		return;
+	}
 	if (sz != sizeof(clkinfo))
-		errx(1, "%s: !returned size wrong!", sname);
+		errx(EXIT_FAILURE, "%s: !returned size wrong!", sname);
 	if (xflag || rflag) {
 		display_struct(pnode, sname, &clkinfo, sz,
 			       DISPLAY_VALUE);
 		return;
+	}
 	else if (!nflag)
 		printf("%s: ", sname);
 	printf("tick = %d, tickadj = %d, hz = %d, profhz = %d, stathz = %d\n",
 	       clkinfo.tick, clkinfo.tickadj,
 	       clkinfo.hz, clkinfo.profhz, clkinfo.stathz);
+}
 @@ -2171,27 +2171,27 @@ kern_boottime(HANDLER_ARGS)
+{
 	struct timeval timeval;
 	time_t boottime;
 	size_t sz;
 	int rc;
 	sz = sizeof(timeval);
 	rc = prog_sysctl(name, namelen, &timeval, &sz, NULL, 0);
 	if (rc == -1) {
 		sysctlerror(1);
 		return;
+	}
 	if (sz != sizeof(timeval))
-		errx(1, "%s: !returned size wrong!", sname);
+		errx(EXIT_FAILURE, "%s: !returned size wrong!", sname);
 	boottime = timeval.tv_sec;
 	if (xflag || rflag)
 		display_struct(pnode, sname, &timeval, sz,
 			       DISPLAY_VALUE);
 	else if (!nflag)
 		/* ctime() provides the \n */
 		printf("%s%s%s", sname, eq, ctime(&boottime));
 	else if (nflag == 1)
 		printf("%ld\n", (long)boottime);
 	else
 		printf("%ld.%06ld\n", (long)timeval.tv_sec,
 		       (long)timeval.tv_usec);
 @@ -2202,27 +2202,27 @@ static void
 kern_consdev(HANDLER_ARGS)
+{
 	dev_t cons;
 	size_t sz;
 	int rc;
 	sz = sizeof(cons);
 	rc = prog_sysctl(name, namelen, &cons, &sz, NULL, 0);
 	if (rc == -1) {
 		sysctlerror(1);
 		return;
+	}
 	if (sz != sizeof(cons))
-		errx(1, "%s: !returned size wrong!", sname);
+		errx(EXIT_FAILURE, "%s: !returned size wrong!", sname);
 	if (xflag || rflag)
 		display_struct(pnode, sname, &cons, sz,
 			       DISPLAY_VALUE);
 	else {
 		if (!nflag)
 			printf("%s%s", sname, eq);
 		if (nflag < 2 && (sname = devname(cons, S_IFCHR)) != NULL)
 			printf("%s\n", sname);
 		else
 			printf("0x%llx\n", (unsigned long long)cons);
+	}
+}
 @@ -2267,27 +2267,27 @@ kern_cp_time(HANDLER_ARGS)
 	rc = prog_sysctl(name, namelen, cp_time + (n != -1) * CPUSTATES, &osz,
 		    NULL, 0);
 	if (rc == -1) {
 		sysctlerror(1);
 		free(cp_time);
 		return;
+	}
 	/*
 	 * Check, but account for space we'll occupy with the sum.
 	 */
 	if (osz != sz - (n != -1) * CPUSTATES * sizeof(u_int64_t))
-		errx(1, "%s: !returned size wrong!", sname);
+		errx(EXIT_FAILURE, "%s: !returned size wrong!", sname);
 	/*
 	 * Compute the actual sum.  Two calls would be easier (we
 	 * could just call ourselves recursively above), but the
 	 * numbers wouldn't add up.
 	 */
 	if (n != -1) {
 		memset(cp_time, 0, sizeof(u_int64_t) * CPUSTATES);
 		for (i = 1; i < n; i++) {
 			cp_time[CP_USER] += cp_time[i * CPUSTATES + CP_USER];
                         cp_time[CP_NICE] += cp_time[i * CPUSTATES + CP_NICE];
                         cp_time[CP_SYS] += cp_time[i * CPUSTATES + CP_SYS];
                         cp_time[CP_INTR] += cp_time[i * CPUSTATES + CP_INTR];
 @@ -2337,27 +2337,27 @@ kern_drivers(HANDLER_ARGS)
+{
 	struct kinfo_drivers *kd;
 	size_t sz, i;
 	int rc;
 	const char *comma;
 	rc = prog_sysctl(name, namelen, NULL, &sz, NULL, 0);
 	if (rc == -1) {
 		sysctlerror(1);
 		return;
+	}
 	if (sz % sizeof(*kd))
-		err(1, "bad size %zu for kern.drivers", sz);
+		err(EXIT_FAILURE, "bad size %zu for kern.drivers", sz);
 	kd = malloc(sz);
 	if (kd == NULL) {
 		sysctlerror(1);
 		return;
+	}
 	rc = prog_sysctl(name, namelen, kd, &sz, NULL, 0);
 	if (rc == -1) {
 		sysctlerror(1);
 		free(kd);
 		return;
+	}
 @@ -2412,27 +2412,27 @@ kern_cp_id(HANDLER_ARGS)
 	osz = sz;
 	rc = prog_sysctl(name, namelen, cp_id, &osz, NULL, 0);
 	if (rc == -1) {
 		sysctlerror(1);
 		free(cp_id);
 		return;
+	}
 	/*
 	 * Check that we got back what we asked for.
 	 */
 	if (osz != sz)
-		errx(1, "%s: !returned size wrong!", sname);
+		errx(EXIT_FAILURE, "%s: !returned size wrong!", sname);
 	/* pretend for output purposes */
 	node.sysctl_flags = SYSCTL_FLAGS(pnode->sysctl_flags) |
 		SYSCTL_TYPE(CTLTYPE_QUAD);
 	tname = sname;
 	if (namelen == 3)
 		display_number(&node, tname, cp_id,
 			       sizeof(u_int64_t),
 			       DISPLAY_VALUE);
 	else if (Aflag) {
 		for (i = 0; i < n; i++)
 			(void)snprintf(s, sizeof(s), "%s%s%d", sname, sep, i);
 @@ -2464,27 +2464,27 @@ static void
 vm_loadavg(HANDLER_ARGS)
+{
 	struct loadavg loadavg;
 	size_t sz;
 	int rc;
 	sz = sizeof(loadavg);
 	rc = prog_sysctl(name, namelen, &loadavg, &sz, NULL, 0);
 	if (rc == -1) {
 		sysctlerror(1);
 		return;
+	}
 	if (sz != sizeof(loadavg))
-		errx(1, "%s: !returned size wrong!", sname);
+		errx(EXIT_FAILURE, "%s: !returned size wrong!", sname);
 	if (xflag || rflag) {
 		display_struct(pnode, sname, &loadavg, sz,
 			       DISPLAY_VALUE);
 		return;
+	}
 	if (!nflag)
 		printf("%s: ", sname);
 	printf("%.2f %.2f %.2f\n",
 	       (double) loadavg.ldavg[0] / loadavg.fscale,
 	       (double) loadavg.ldavg[1] / loadavg.fscale,
 	       (double) loadavg.ldavg[2] / loadavg.fscale);
+}
 @@ -2503,27 +2503,27 @@ proc_limit(HANDLER_ARGS)
 	osz = sizeof(olim);
 	if (value != NULL) {
 		nsz = sizeof(nlim);
 		newp = &nlim;
 		if (strcmp(value, "unlimited") == 0)
 			nlim = RLIM_INFINITY;
 		else {
 			errno = 0;
 			nlim = strtouq(value, &t, 0);
 			if (t == value || *t != '\0' || errno != 0) {
 				sysctlperror("%s: '%s' is not a valid limit\n",
 					     sname, value);
-				EXIT(1);
+				EXIT(EXIT_FAILURE);
+			}
+		}
+	}
 	else {
 		nsz = 0;
 		newp = NULL;
+	}
 	rc = prog_sysctl(name, namelen, &olim, &osz, newp, nsz);
 	if (rc == -1) {
 		sysctlerror(newp == NULL);
 		return;
+	}
 @@ -2632,35 +2632,35 @@ mode_bits(HANDLER_ARGS)
 		errno = 0;
 		rc = prog_sysctl(name, namelen, &tt, &ttsz, NULL, 0);
 		if (rc == -1) {
 			sysctlperror("%s: failed query\n", sname);
 			return;
+		}
 		old_umask = umask(0);
 		foo = setmode(value);
 		umask(old_umask);
 		if (foo == NULL) {
 			sysctlperror("%s: '%s' is an invalid mode\n", sname,
 				     value);
-			EXIT(1);
+			EXIT(EXIT_FAILURE);
+		}
 		old_umask = umask(0);
 		m = getmode(foo, (mode_t)tt);
 		umask(old_umask);
 		if (errno) {
 			sysctlperror("%s: '%s' is an invalid mode\n", sname,
 				     value);
-			EXIT(1);
+			EXIT(EXIT_FAILURE);
+		}
+	}
 	else {
 		nsz = 0;
 		newp = NULL;
+	}
 	rc = prog_sysctl(name, namelen, &o, &osz, newp, nsz);
 	if (rc == -1) {
 		sysctlerror(newp == NULL);
 		return;
+	}
 @@ -2700,51 +2700,51 @@ bitmask_print(const bitmap *o)
+{
 	char *s, *os;
 	s = os = NULL;
 	for (size_t i = 0; i < MAXPORTS; i++)
 		if (__BITMAP_ISSET(i, o)) {
 			int rv;
 			if (os)
 			    	rv = asprintf(&s, "%s,%zu", os, i);
 			else
 			    	rv = asprintf(&s, "%zu", i);
 			if (rv == -1)
-				err(1, "bitmask_print 1");
+				err(EXIT_FAILURE, "%s 1", __func__);
 			free(os);
 			os = s;
+		}
 	if (s == NULL && (s = strdup("")) == NULL)
-		err(1, "bitmask_print 2");
+		err(EXIT_FAILURE, "%s 2", __func__);
 	return s;
+}
 static void
 bitmask_scan(const void *v, bitmap *o)
+{
 	char *s = strdup(v);
 	if (s == NULL)
-		err(1, "bitmask_scan");
+		err(EXIT_FAILURE, "%s", __func__);
 	__BITMAP_ZERO(o);
 	for (s = strtok(s, ","); s; s = strtok(NULL, ",")) {
 		char *e;
 		errno = 0;
 		unsigned long l = strtoul(s, &e, 0);
 		if ((l == ULONG_MAX && errno == ERANGE) || s == e || *e)
-			errx(1, "Invalid port: %s", s);
+			errx(EXIT_FAILURE, "Invalid port: %s", s);
 		if (l >= MAXPORTS)
-			errx(1, "Port out of range: %s", s);
+			errx(EXIT_FAILURE, "Port out of range: %s", s);
 		__BITMAP_SET(l, o);
+	}
+}
 static void
 reserve(HANDLER_ARGS)
+{
 	int rc;
 	size_t osz, nsz;
 	bitmap o, n;
 	if (fn)