]> Zhao Yanbai Git Server - minix.git/commitdiff
Import NetBSD sysctl(8) 49/3249/2
authorDavid van Moolenbroek <david@minix3.org>
Wed, 28 Oct 2015 13:02:34 +0000 (13:02 +0000)
committerLionel Sambuc <lionel.sambuc@gmail.com>
Wed, 13 Jan 2016 19:32:48 +0000 (20:32 +0100)
Change-Id: Idc3a9138521de1329daaab3bd0907a0db0d37775

distrib/sets/lists/minix-base/mi
distrib/sets/lists/minix-man/mi
minix/tests/testsh2.sh
sbin/Makefile
sbin/sysctl/Makefile [new file with mode: 0644]
sbin/sysctl/pathconf.c [new file with mode: 0644]
sbin/sysctl/prog_ops.h [new file with mode: 0644]
sbin/sysctl/sysctl.8 [new file with mode: 0644]
sbin/sysctl/sysctl.c [new file with mode: 0644]
sbin/sysctl/sysctl_hostops.c [new file with mode: 0644]
sbin/sysctl/sysctl_rumpops.c [new file with mode: 0644]

index c010fbb60a9892dc963c5839d74d418f383d9c6d..267a606b8daac3dcc4c9198203b4339c09bbfa0f 100644 (file)
 ./sbin/poweroff                                         minix-base
 ./sbin/reboot                                           minix-base
 ./sbin/shutdown                                         minix-base
+./sbin/sysctl                                           minix-base
 ./service                                               minix-base
 ./service/asr                                           minix-base
 ./service/devman                                        minix-base
index 088046b24a2330b6d1b0a91b1a137bf47d4491ed..392acc80d7cd068e2fef79a9552ddf0cbbb613ba 100644 (file)
 ./usr/man/man8/srccrc.8                                 minix-man
 ./usr/man/man8/strfile.8                                minix-man
 ./usr/man/man8/sync.8                                   minix-man
+./usr/man/man8/sysctl.8                                 minix-man
 ./usr/man/man8/syslogd.8                                minix-man
 ./usr/man/man8/tcpd.8                                   minix-man
 ./usr/man/man8/traceroute.8                             minix-man
index ab385812defb2201d1c72626e9f2ed2fe5565d25..c95884981591d70d525d9c0479caea3b5bf2bbc4 100755 (executable)
@@ -28,8 +28,6 @@ else  echo "Can't find a compiler, skipping test"
        exit 0
 fi
 
-ARCH=`uname -p`
-
 echo -n  "Shell test  2 "
 rm -rf $TESTDIR
 mkdir $TESTDIR                 # all files are created here
@@ -113,7 +111,7 @@ if test -r x; then : ; else bomb "Error in du Test 1"; fi
 
 #Test od                       
 head -1 $f |od >x              # see if od converts ascii to octal ok
-if [ $ARCH = i386 -o $ARCH = evbarm ]
+if [ $(/sbin/sysctl -n hw.byteorder) = "1234" ]
 then
 cat >answer <<END
 0000000   064124  020145  064564  062555  064040  071541  061440  066557
@@ -135,7 +133,7 @@ fi
 if cmp -s x answer; then : ; else bomb "Error in od test 1"; fi
 
 head -1 $f |od -d >x           # see if od converts ascii to decimal ok
-if [ $ARCH = i386 -o $ARCH = evbarm ]
+if [ $(/sbin/sysctl -n hw.byteorder) = "1234" ]
 then
 cat >answer <<END
 0000000    26708   08293   26996   25965   26656   29537   25376   28015
index 5b4631f2d1f227648170e77db164faf2645b0f32..40f8cea7cf816e23c82b95def844eda85b8ee6ab 100644 (file)
@@ -12,7 +12,7 @@ SUBDIR= \
        mknod nologin \
        ping \
        reboot \
-       shutdown \
+       shutdown sysctl \
 
 # support for various file systems
 SUBDIR+= newfs_ext2fs fsck_ext2fs newfs_msdos newfs_udf newfs_v7fs
diff --git a/sbin/sysctl/Makefile b/sbin/sysctl/Makefile
new file mode 100644 (file)
index 0000000..8fb0a14
--- /dev/null
@@ -0,0 +1,16 @@
+#      $NetBSD: Makefile,v 1.21 2012/11/29 02:05:38 christos Exp $
+#      @(#)Makefile    8.1 (Berkeley) 6/6/93
+
+.include <bsd.own.mk>
+#DBG=-g
+
+RUMPPRG=sysctl
+MAN=   sysctl.8
+
+SRCS=  sysctl.c
+
+.PATH: ${.CURDIR}/../../lib/libc/gen
+CPPFLAGS+= -DRUMP_ACTION
+RUMPSRCS+= sysctlbyname.c sysctlgetmibinfo.c
+
+.include <bsd.prog.mk>
diff --git a/sbin/sysctl/pathconf.c b/sbin/sysctl/pathconf.c
new file mode 100644 (file)
index 0000000..dd7bd4c
--- /dev/null
@@ -0,0 +1,229 @@
+/*     $NetBSD: pathconf.c,v 1.7 2004/03/25 19:36:27 atatat Exp $      */
+
+/*
+ * Copyright (c) 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * 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.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef lint
+static char copyright[] =
+"@(#) Copyright (c) 1993\n\
+       The Regents of the University of California.  All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+#if 0
+static char sccsid[] = "@(#)pathconf.c 8.1 (Berkeley) 6/6/93";
+#else
+static char rcsid[] = "$NetBSD: pathconf.c,v 1.7 2004/03/25 19:36:27 atatat Exp $";
+#endif
+#endif /* not lint */
+
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#include <sys/unistd.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define PC_NAMES { \
+       { 0, 0 }, \
+       { "link_max", CTLTYPE_INT }, \
+       { "max_canon", CTLTYPE_INT }, \
+       { "max_input", CTLTYPE_INT }, \
+       { "name_max", CTLTYPE_INT }, \
+       { "path_max", CTLTYPE_INT }, \
+       { "pipe_buf", CTLTYPE_INT }, \
+       { "chown_restricted", CTLTYPE_INT }, \
+       { "no_trunc", CTLTYPE_INT }, \
+       { "vdisable", CTLTYPE_INT }, \
+}
+#define PC_MAXID 10
+
+struct ctlname pcnames[] = PC_NAMES;
+char names[BUFSIZ];
+
+struct list {
+       struct  ctlname *list;
+       int     size;
+};
+struct list pclist = { pcnames, PC_MAXID };
+
+int    Aflag, aflag, nflag, wflag, stdinflag;
+
+int
+main(argc, argv)
+       int argc;
+       char *argv[];
+{
+       char *path;
+       int ch;
+
+       while ((ch = getopt(argc, argv, "Aan")) != -1) {
+               switch (ch) {
+
+               case 'A':
+                       Aflag = 1;
+                       break;
+
+               case 'a':
+                       aflag = 1;
+                       break;
+
+               case 'n':
+                       nflag = 1;
+                       break;
+
+               default:
+                       usage();
+               }
+       }
+       argc -= optind;
+       argv += optind;
+
+       if (argc == 0)
+               usage();
+       path = *argv++;
+       if (strcmp(path, "-") == 0)
+               stdinflag = 1;
+       argc--;
+       if (Aflag || aflag) {
+               listall(path, &pclist);
+               exit(0);
+       }
+       if (argc == 0)
+               usage();
+       while (argc-- > 0)
+               parse(path, *argv, 1);
+       exit(0);
+}
+
+/*
+ * List all variables known to the system.
+ */
+listall(path, lp)
+       char *path;
+       struct list *lp;
+{
+       int lvl2;
+
+       if (lp->list == 0)
+               return;
+       for (lvl2 = 0; lvl2 < lp->size; lvl2++) {
+               if (lp->list[lvl2].ctl_name == 0)
+                       continue;
+               parse(path, lp->list[lvl2].ctl_name, Aflag);
+       }
+}
+
+/*
+ * Parse a name into an index.
+ * Lookup and print out the attribute if it exists.
+ */
+parse(pathname, string, flags)
+       char *pathname;
+       char *string;
+       int flags;
+{
+       int indx, value;
+       char *bufp, buf[BUFSIZ];
+
+       bufp = buf;
+       snprintf(buf, BUFSIZ, "%s", string);
+       if ((indx = findname(string, "top", &bufp, &pclist)) == -1)
+               return;
+       if (bufp) {
+               fprintf(stderr, "name %s in %s is unknown\n", *bufp, string);
+               return;
+       }
+       if (stdinflag)
+               value = fpathconf(0, indx);
+       else
+               value = pathconf(pathname, indx);
+       if (value == -1) {
+               if (flags == 0)
+                       return;
+               switch (errno) {
+               case EOPNOTSUPP:
+                       fprintf(stderr, "%s: value is not available\n", string);
+                       return;
+               case ENOTDIR:
+                       fprintf(stderr, "%s: specification is incomplete\n",
+                           string);
+                       return;
+               case ENOMEM:
+                       fprintf(stderr, "%s: type is unknown to this program\n",
+                           string);
+                       return;
+               default:
+                       perror(string);
+                       return;
+               }
+       }
+       if (!nflag)
+               fprintf(stdout, "%s = ", string);
+       fprintf(stdout, "%d\n", value);
+}
+
+/*
+ * Scan a list of names searching for a particular name.
+ */
+findname(string, level, bufp, namelist)
+       char *string;
+       const char *level;
+       char **bufp;
+       struct list *namelist;
+{
+       char *name;
+       int i;
+
+       if (namelist->list == 0 || (name = strsep(bufp, ".")) == NULL) {
+               fprintf(stderr, "%s: incomplete specification\n", string);
+               return (-1);
+       }
+       for (i = 0; i < namelist->size; i++)
+               if (namelist->list[i].ctl_name != NULL &&
+                   strcmp(name, namelist->list[i].ctl_name) == 0)
+                       break;
+       if (i == namelist->size) {
+               fprintf(stderr, "%s level name %s in %s is invalid\n",
+                   level, name, string);
+               return (-1);
+       }
+       return (i);
+}
+
+usage()
+{
+
+       (void)fprintf(stderr, "usage:\t%s\n\t%s\n\t%s\n",
+           "pathname [-n] variable ...",
+           "pathname [-n] -a", "pathname [-n] -A");
+       exit(1);
+}
diff --git a/sbin/sysctl/prog_ops.h b/sbin/sysctl/prog_ops.h
new file mode 100644 (file)
index 0000000..f574268
--- /dev/null
@@ -0,0 +1,50 @@
+/*      $NetBSD: prog_ops.h,v 1.2 2010/12/13 21:48:01 pooka Exp $      */
+
+/*
+ * Copyright (c) 2010 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * 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.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _PROG_OPS_H_
+#define _PROG_OPS_H_
+
+#include <sys/types.h>
+
+#ifndef CRUNCHOPS
+struct prog_ops {
+       int (*op_init)(void);
+
+       int (*op_sysctl)(const int *, u_int, void *, size_t *,
+                        const void *, size_t);
+};
+extern const struct prog_ops prog_ops;
+
+#define prog_init prog_ops.op_init
+#define prog_sysctl prog_ops.op_sysctl
+#else
+#define prog_init ((int (*)(void))NULL)
+#define prog_sysctl sysctl
+#endif
+
+#endif /* _PROG_OPS_H_ */
diff --git a/sbin/sysctl/sysctl.8 b/sbin/sysctl/sysctl.8
new file mode 100644 (file)
index 0000000..a16aa4f
--- /dev/null
@@ -0,0 +1,527 @@
+.\"    $NetBSD: sysctl.8,v 1.162 2011/08/03 01:47:40 christos Exp $
+.\"
+.\" Copyright (c) 2004 The NetBSD Foundation, Inc.
+.\" All rights reserved.
+.\"
+.\" 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.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+.\" ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+.\" TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+.\" PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+.\" BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+.\" CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+.\" SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+.\" INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+.\" CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+.\" ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+.\" POSSIBILITY OF SUCH DAMAGE.
+.\"
+.\"
+.\" Copyright (c) 1993
+.\"    The Regents of the University of California.  All rights reserved.
+.\"
+.\" 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.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. Neither the name of the University nor the names of its contributors
+.\"    may be used to endorse or promote products derived from this software
+.\"    without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\"    @(#)sysctl.8    8.1 (Berkeley) 6/6/93
+.\"
+.Dd August 2, 2011
+.Dt SYSCTL 8
+.Os
+.Sh NAME
+.Nm sysctl
+.Nd get or set kernel state
+.Sh SYNOPSIS
+.Nm sysctl
+.Op Fl AdeMnq
+.Oo
+.Fl r |
+.Fl x
+.Oc
+.Op Ar name ...
+.Nm sysctl
+.Op Fl nq
+.Oo
+.Fl r |
+.Fl x
+.Oc
+.Fl w
+.Ar name Ns Li [?]= Ns Ar value ...
+.Nm sysctl
+.Op Fl en
+.Oo
+.Fl r |
+.Fl x
+.Oc
+.Fl a
+.Nm sysctl
+.Op Fl nq
+.Oo
+.Fl r |
+.Fl x
+.Oc
+.Fl f
+.Ar file
+.Sh DESCRIPTION
+The
+.Nm sysctl
+utility retrieves kernel state and allows processes with
+appropriate privilege to set kernel state.
+The state to be retrieved or set is described using a
+``Management Information Base'' (``MIB'') style name,
+described as a dotted set of components.
+The
+.Sq /
+character may also be used as a separator and a leading separator
+character is accepted.
+If
+.Ar name
+specifies a non-leaf node in the MIB, all the nodes underneath
+.Ar name
+will be printed.
+.Pp
+The following options are available:
+.Bl -tag -width indent
+.It Fl A
+List all the known MIB names including tables, unless any MIB
+arguments or
+.Fl f Ar file
+are given.
+Those with string or integer values will be printed as with the
+.Fl a
+flag; for table or structure values that
+.Nm
+is not able to print,
+the name of the utility to retrieve them is given.
+Errors in retrieving or setting values will be directed to stdout
+instead of stderr.
+.It Fl a
+List all the currently available string or integer values.
+The use of a solitary separator character (either
+.Sq \&.
+or
+.Sq / )
+by
+itself has the same effect.
+Any given
+.Ar name
+arguments are ignored if this option is specified.
+.It Fl d
+Descriptions of each of the nodes selected will be printed instead of
+their values.
+.It Fl e
+Separate the name and the value of the variable(s) with
+.Ql = .
+This is useful for producing output which can be fed back to the
+.Nm
+utility.
+This option is ignored if
+.Fl n
+is specified or a variable is being set.
+.It Fl f
+Specifies the name of a file to read and process.
+Blank lines and comments (beginning with
+.Ql # )
+are ignored.
+Line continuations with
+.Ql \e
+are permitted.
+Remaining lines are processed similarly to
+command line arguments of the form
+.Ar name
+or
+.Ar name Ns Li = Ns Ar value .
+The
+.Fl w
+flag is implied by
+.Fl f .
+Any
+.Ar name
+arguments are ignored.
+.It Fl M
+Makes
+.Nm
+print the MIB instead of any of the actual values contained in the
+MIB.
+This causes the entire MIB to be printed unless specific MIB arguments
+or
+.Fl f Ar file
+are also given.
+.It Fl n
+Specifies that the printing of the field name should be
+suppressed and that only its value should be output.
+This flag is useful for setting shell variables.
+For example, to save the pagesize in variable psize, use:
+.Bd -literal -offset indent -compact
+set psize=`sysctl -n hw.pagesize`
+.Ed
+.It Fl q
+Used to indicate that nothing should be printed for reads or writes unless an
+error is detected.
+For reads, not finding a variable does not print an error, but exits with
+an error code.
+This is useful just for testing that a variable exists.
+.It Fl r
+Raw output form.
+Values printed are in their raw binary forms as retrieved directly
+from the kernel.
+Some additional nodes that
+.Nm
+cannot print directly can be retrieved with this flag.
+This option conflicts with the
+.Fl x
+option.
+.It Fl w
+Sets the MIB style name given to the value given.
+The MIB style name and value must be separated by
+.Ql =
+with no whitespace.
+To prevent an error if the MIB style name does not exist (as would be the
+case with optional kernel components), one can separate the MIB style name
+and the value with
+.Ql ?= .
+Only integral and string values can be set via this method.
+.It Fl x
+Makes
+.Nm
+print the requested value in a hexadecimal representation instead of
+its regular form.
+If specified more than once, the output for each value resembles that of
+.Xr hexdump 1
+when given the
+.Fl C
+flag.
+This option conflicts with the
+.Fl r
+option.
+.Pp
+.El
+The
+.Ql proc
+top-level MIB has a special semantic: it represent per-process values
+and as such may differ from one process to another.
+The second-level name is the pid of the process (in decimal form),
+or the special word
+.Ql curproc .
+For variables below
+.Ql proc. Ns Ao pid Ac Ns .rlimit ,
+the integer value may be replaced
+with the string
+.Ql unlimited
+if it matches the magic value used to disable
+a limit.
+.Pp
+The information available from
+.Nm sysctl
+consists of integers, strings, and tables.
+The tabular information can only be retrieved by special
+purpose programs such as
+.Nm ps ,
+.Nm systat ,
+and
+.Nm netstat .
+See
+.Xr sysctl 7
+for description of available MIBs.
+.Sh CREATION AND DELETION
+New nodes are allowed to be created by the superuser when the kernel
+is running at security level 0.
+These new nodes may refer to existing kernel data or to new data that
+is only instrumented by
+.Xr sysctl 3
+itself.
+.Pp
+The syntax for creating new nodes is
+.Dq //create=new.node.path
+followed by one or more of the following attributes separated by
+commas.
+The use of a double separator (both
+.Sq /
+and
+.Sq \&.
+can be used as
+separators) as the prefix tells sysctl that the first series of tokens
+is not a MIB name, but a command.
+It is recommended that the double separator preceding the command not
+be the same as the separator used in naming the MIB entry so as to
+avoid possible parse conflicts.
+The
+.Dq value
+assigned, if one is given, must be last.
+.Pp
+.Bl -bullet -compact
+.It
+.Ar type= Ns Aq Ar T
+where
+.Ar T
+must be one of
+.Dq node ,
+.Dq int ,
+.Dq string ,
+.Dq quad ,
+or
+.Dq struct .
+If the type is omitted, the
+.Dq node
+type is assumed.
+.It
+.Ar size= Ns Aq Ar S
+here,
+.Ar S
+asserts the size of the new node.
+Nodes of type
+.Dq node
+should not have a size set.
+The size may be omitted for nodes of types
+.Dq int
+or
+.Dq quad .
+If the size is omitted for a node of type
+.Dq string ,
+the size will be determined by the length of the given value, or by
+the kernel for kernel strings.
+Nodes of type
+.Dq struct
+must have their size explicitly set.
+.It
+.Ar addr= Ns Aq Ar A
+or
+.Ar symbol= Ns Aq Ar A
+The kernel address of the data being instrumented.
+If
+.Dq symbol
+is used, the symbol must be globally visible to the in-kernel
+.Xr ksyms 4
+driver.
+.It
+.Ar n= Ns Aq Ar N
+The MIB number to be assigned to the new node.
+If no number is specified, the kernel will assign a value.
+.It
+.Ar flags= Ns Aq Ar F
+A concatenated string of single letters that govern the behavior of
+the node.
+Flags currently available are:
+.Bl -tag -width www
+.It a
+Allow anyone to write to the node, if it is writable.
+.It h
+.Dq Hidden .
+.Nm
+must be invoked with
+.Fl A
+or the hidden node must be specifically requested in order to see it
+.It i
+.Dq Immediate .
+Makes the node store data in itself, rather than allocating new space
+for it.
+This is the default for nodes of type
+.Dq int
+and
+.Dq quad .
+This is the opposite of owning data.
+.It o
+.Dq Own .
+When the node is created, separate space will be allocated to store
+the data to be instrumented.
+This is the default for nodes of type
+.Dq string
+and
+.Dq struct
+where it is not possible to guarantee sufficient space to store the
+data in the node itself.
+.It p
+.Dq Private .
+Nodes that are marked private, and children of nodes so marked, are
+only viewable by the superuser.
+Be aware that the immediate data that some nodes may store is not
+necessarily protected by this.
+.It x
+.Dq Hexadecimal .
+Make
+.Nm
+default to hexadecimal display of the retrieved value
+.It r
+.Dq Read-only .
+The data instrumented by the given node is read-only.
+Note that other mechanisms may still exist for changing the data.
+This is the default for nodes that instrument data.
+.It w
+.Dq Writable .
+The data instrumented by the given node is writable at any time.
+This is the default for nodes that can have children.
+.El
+.Pp
+.It
+.Ar value= Ns Aq Ar V
+An initial starting value for a new node that does not reference
+existing kernel data.
+Initial values can only be assigned for nodes of the
+.Dq int ,
+.Dq quad ,
+and
+.Dq string
+types.
+.El
+.Pp
+New nodes must fit the following set of criteria:
+.Pp
+.Bl -bullet -compact
+.It
+If the new node is to address an existing kernel object, only one of the
+.Dq symbol
+or
+.Dq addr
+arguments may be given.
+.It
+The size for a
+.Dq struct
+type node must be specified; no initial value is expected or permitted.
+.It
+Either the size or the initial value for a
+.Dq string
+node must be given.
+.It
+The node which will be the parent of the new node must be writable.
+.El
+.Pp
+If any of the given parameters describes an invalid configuration,
+.Nm
+will emit a diagnostic message to the standard error and exit.
+.Pp
+Descriptions can be added by the super-user to any node that does not
+have one, provided that the node is not marked with the
+.Dq PERMANENT
+flag.
+The syntax is similar to the syntax for creating new nodes with the
+exception of the keyword that follows the double separator at the
+start of the command:
+.Dq //describe=new.node.path=new node description .
+Once a description has been added, it cannot be changed or removed.
+.Pp
+When destroying nodes, only the path to the node is necessary, i.e.,
+.Dq //destroy=old.node.path .
+No other parameters are expected or permitted.
+Nodes being destroyed must have no children, and their parent must be
+writable.
+Nodes that are marked with the
+.Dq Dv PERMANENT
+flag (as assigned by the kernel) may not be deleted.
+.Pp
+In all cases, the initial
+.Sq =
+that follows the command (eg,
+.Dq create ,
+.Dq destroy ,
+or
+.Dq describe )
+may be replaced with another instance of the separator character,
+provided that the same separator character is used for the length of
+the name specification.
+.Sh FILES
+.Bl -tag -width /etc/sysctl.conf -compact
+.It Pa /etc/sysctl.conf
+.Nm
+variables set at boot time
+.El
+.Sh EXAMPLES
+For example, to retrieve the maximum number of processes allowed
+in the system, one would use the following request:
+.Bd -literal -offset indent -compact
+sysctl kern.maxproc
+.Ed
+.Pp
+To set the maximum number of processes allowed
+in the system to 1000, one would use the following request:
+.Bd -literal -offset indent -compact
+sysctl -w kern.maxproc=1000
+.Ed
+.Pp
+Information about the system clock rate may be obtained with:
+.Bd -literal -offset indent -compact
+sysctl kern.clockrate
+.Ed
+.Pp
+Information about the load average history may be obtained with:
+.Bd -literal -offset indent -compact
+sysctl vm.loadavg
+.Ed
+.Pp
+To view the values of the per-process variables of the current shell,
+the request:
+.Bd -literal -offset indent -compact
+sysctl proc.$$
+.Ed
+can be used if the shell interpreter replaces $$ with its pid (this is true
+for most shells).
+.Pp
+To redirect core dumps to the
+.Pa /var/tmp/ Ns Aq username
+directory,
+.Bd -literal -offset indent -compact
+sysctl -w proc.$$.corename=/var/tmp/%u/%n.core
+.Ed
+should be used.
+.Bd -literal -offset indent -compact
+sysctl -w proc.curproc.corename=/var/tmp/%u/%n.core
+.Ed
+changes the value for the sysctl process itself, and will not have the desired
+effect.
+.Pp
+To create the root of a new sub-tree called
+.Dq local
+add some children to the new node, and some descriptions:
+.Bd -literal -offset indent -compact
+sysctl -w //create=local
+sysctl -w //describe=local=my local sysctl tree
+sysctl -w //create=local.esm_debug,type=int,symbol=esm_debug,flags=w
+sysctl -w //describe=local.esm_debug=esm driver debug knob
+sysctl -w //create=local.audiodebug,type=int,symbol=audiodebug,flags=w
+sysctl -w //describe=local.audiodebug=generic audio debug knob
+.Ed
+Note that the children are made writable so that the two debug
+settings in question can be tuned arbitrarily.
+.Pp
+To destroy that same subtree:
+.Bd -literal -offset indent -compact
+sysctl -w //destroy=local.esm_debug
+sysctl -w //destroy=local.audiodebug
+sysctl -w //destroy=local
+.Ed
+.Sh SEE ALSO
+.Xr sysctl 3 ,
+.Xr ksyms 4 ,
+.Xr sysctl 7
+.Sh HISTORY
+.Nm sysctl
+first appeared in
+.Bx 4.4 .
diff --git a/sbin/sysctl/sysctl.c b/sbin/sysctl/sysctl.c
new file mode 100644 (file)
index 0000000..925d6e6
--- /dev/null
@@ -0,0 +1,2800 @@
+/*     $NetBSD: sysctl.c,v 1.156 2015/08/17 06:42:46 knakahara 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.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Copyright (c) 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * 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.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * 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.156 2015/08/17 06:42:46 knakahara 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>
+#include <netinet/ip_var.h>
+#include <netinet/tcp.h>
+#ifndef __minix
+#include <netinet/tcp_timer.h>
+#include <netinet/tcp_var.h>
+#include <netinet/icmp6.h>
+#include <nfs/rpcv2.h>
+#include <nfs/nfsproto.h>
+#include <nfs/nfs.h>
+#endif /* !__minix */
+#include <machine/cpu.h>
+
+#include <assert.h>
+#include <ctype.h>
+#include <err.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <regex.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "prog_ops.h"
+
+/*
+ * this needs to be able to do the printing and the setting
+ */
+#define HANDLER_PROTO const char *, const char *, char *, \
+       int *, u_int, const struct sysctlnode *, \
+       u_int, void *
+#define HANDLER_ARGS const char *sname, const char *dname, char *value, \
+       int *name, u_int namelen, const struct sysctlnode *pnode, \
+       u_int type, void *v
+#define DISPLAY_VALUE  0
+#define DISPLAY_OLD    1
+#define DISPLAY_NEW    2
+
+/*
+ * generic routines
+ */
+static const struct handlespec *findhandler(const char *, regex_t *, size_t *);
+static void canonicalize(const char *, char *);
+static void purge_tree(struct sysctlnode *);
+static void print_tree(int *, u_int, struct sysctlnode *, u_int, int, regex_t *,
+    size_t *);
+static void write_number(int *, u_int, struct sysctlnode *, char *);
+static void write_string(int *, u_int, struct sysctlnode *, char *);
+static void display_number(const struct sysctlnode *, const char *,
+                          const void *, size_t, int);
+static void display_string(const struct sysctlnode *, const char *,
+                          const void *, size_t, int);
+static void display_struct(const struct sysctlnode *, const char *,
+                          const void *, size_t, int);
+static void hex_dump(const unsigned char *, size_t);
+__dead static void usage(void);
+static void parse(char *, regex_t *, size_t *);
+static void parse_create(char *);
+static void parse_destroy(char *);
+static void parse_describe(char *);
+static void getdesc1(int *, u_int, struct sysctlnode *);
+static void getdesc(int *, u_int, struct sysctlnode *);
+static void trim_whitespace(char *, int);
+static void sysctlerror(int);
+static void sysctlparseerror(u_int, const char *);
+static void sysctlperror(const char *, ...) __printflike(1, 2);
+#define EXIT(n) do { \
+       if (fn == NULL) exit(n); else return; } while (/*CONSTCOND*/0)
+
+/*
+ * "borrowed" from libc:sysctlgetmibinfo.c
+ */
+int __learn_tree(int *, u_int, struct sysctlnode *);
+
+/*
+ * "handlers"
+ */
+static void printother(HANDLER_PROTO);
+static void kern_clockrate(HANDLER_PROTO);
+static void kern_boottime(HANDLER_PROTO);
+static void kern_consdev(HANDLER_PROTO);
+static void kern_cp_time(HANDLER_PROTO);
+static void kern_cp_id(HANDLER_PROTO);
+static void kern_drivers(HANDLER_PROTO);
+static void vm_loadavg(HANDLER_PROTO);
+static void proc_limit(HANDLER_PROTO);
+#ifdef CPU_DISKINFO
+static void machdep_diskinfo(HANDLER_PROTO);
+#endif /* CPU_DISKINFO */
+static void mode_bits(HANDLER_PROTO);
+static void reserve(HANDLER_PROTO);
+
+static const struct handlespec {
+       const char *ps_re;
+       void (*ps_p)(HANDLER_PROTO);
+       void (*ps_w)(HANDLER_PROTO);
+       const void *ps_d;
+} handlers[] = {
+       { "/kern/clockrate",                    kern_clockrate, NULL, NULL },
+       { "/kern/evcnt",                        printother, NULL, "vmstat -e" },
+       { "/kern/vnode",                        printother, NULL, "pstat" },
+       { "/kern/proc(2|_args)?",               printother, NULL, "ps" },
+       { "/kern/file2?",                       printother, NULL, "pstat" },
+       { "/kern/ntptime",                      printother, NULL,
+                                               "ntpdc -c kerninfo" },
+       { "/kern/msgbuf",                       printother, NULL, "dmesg" },
+       { "/kern/boottime",                     kern_boottime, NULL, NULL },
+       { "/kern/consdev",                      kern_consdev, NULL, NULL },
+       { "/kern/cp_time(/[0-9]+)?",            kern_cp_time, NULL, NULL },
+       { "/kern/sysvipc_info",                 printother, NULL, "ipcs" },
+       { "/kern/cp_id(/[0-9]+)?",              kern_cp_id, NULL, NULL },
+
+       { "/kern/coredump/setid/mode",          mode_bits, mode_bits, NULL },
+       { "/kern/drivers",                      kern_drivers, NULL, NULL },
+
+       { "/kern/intr/list",                    printother, NULL, "intrctl" },
+       { "/kern/intr/affinity",                printother, NULL, "intrctl" },
+       { "/kern/intr/intr",                    printother, NULL, "intrctl" },
+       { "/kern/intr/nointr",                  printother, NULL, "intrctl" },
+
+       { "/vm/vmmeter",                        printother, NULL,
+                                               "vmstat' or 'systat" },
+       { "/vm/loadavg",                        vm_loadavg, NULL, NULL },
+       { "/vm/uvmexp2?",                       printother, NULL,
+                                               "vmstat' or 'systat" },
+
+       { "/vfs/nfs/nfsstats",                  printother, NULL, "nfsstat" },
+
+       { "/net/inet6?/tcp6?/ident",            printother, NULL, "identd" },
+       { "/net/inet6/icmp6/nd6_[dp]rlist",     printother, NULL, "ndp" },
+       { "/net/key/dumps[ap]",                 printother, NULL, "setkey" },
+       { "/net/[^/]+/[^/]+/pcblist",           printother, NULL,
+                                               "netstat' or 'sockstat" },
+       { "/net/(inet|inet6)/[^/]+/stats",      printother, NULL, "netstat"},
+       { "/net/bpf/(stats|peers)",             printother, NULL, "netstat"},
+
+       { "/net/inet.*/tcp.*/deb.*",            printother, NULL, "trpt" },
+
+       { "/net/inet.*/ip.*/anonportalgo/reserve", reserve, reserve, NULL },
+
+       { "/net/ns/spp/deb.*",                  printother, NULL, "trsp" },
+
+       { "/hw/diskstats",                      printother, NULL, "iostat" },
+
+#ifdef CPU_CONSDEV
+       { "/machdep/consdev",                   kern_consdev, NULL, NULL },
+#endif /* CPU_CONSDEV */
+#ifdef CPU_DISKINFO
+       { "/machdep/diskinfo",                  machdep_diskinfo, NULL, NULL },
+#endif /* CPU_CONSDEV */
+
+       { "/proc/[^/]+/rlimit/[^/]+/[^/]+",     proc_limit, proc_limit, NULL },
+
+       /*
+        * these will only be called when the given node has no children
+        */
+       { "/net/[^/]+",                         printother, NULL, NULL },
+       { "/debug",                             printother, NULL, NULL },
+       { "/ddb",                               printother, NULL, NULL },
+       { "/vendor",                            printother, NULL, NULL },
+
+       { NULL,                                 NULL, NULL, NULL },
+};
+
+struct sysctlnode my_root = {
+       .sysctl_flags = SYSCTL_VERSION|CTLFLAG_ROOT|CTLTYPE_NODE,
+       .sysctl_size = sizeof(struct sysctlnode),
+       .sysctl_num = 0,
+       .sysctl_name = "(prog_root)",
+};
+
+int    Aflag, aflag, dflag, Mflag, nflag, qflag, rflag, wflag, xflag;
+size_t nr;
+char   *fn;
+int    req, stale, errs;
+FILE   *warnfp = stderr;
+
+#define MAXPORTS       0x10000
+
+/*
+ * vah-riables n stuff
+ */
+char gsname[SYSCTL_NAMELEN * CTL_MAXNAME + CTL_MAXNAME],
+       canonname[SYSCTL_NAMELEN * CTL_MAXNAME + CTL_MAXNAME],
+       gdname[10 * CTL_MAXNAME + CTL_MAXNAME];
+char sep[] = ".";
+const char *eq = " = ";
+const char *lname[] = {
+       "top", "second", "third", "fourth", "fifth", "sixth",
+       "seventh", "eighth", "ninth", "tenth", "eleventh", "twelfth"
+};
+
+/*
+ * you've heard of main, haven't you?
+ */
+int
+main(int argc, char *argv[])
+{
+       int name[CTL_MAXNAME];
+       int ch;
+       size_t lastcompiled = 0;
+       regex_t *re;
+
+       setprogname(argv[0]);
+       while ((ch = getopt(argc, argv, "Aabdef:Mnqrwx")) != -1) {
+               switch (ch) {
+               case 'A':
+                       Aflag++;
+                       break;
+               case 'a':
+                       aflag++;
+                       break;
+               case 'd':
+                       dflag++;
+                       break;
+               case 'e':
+                       eq = "=";
+                       break;
+               case 'f':
+                       fn = optarg;
+                       wflag++;
+                       break;
+               case 'M':
+                       Mflag++;
+                       break;
+               case 'n':
+                       nflag++;
+                       break;
+               case 'q':
+                       qflag++;
+                       break;
+               case 'b':       /* FreeBSD compat */
+               case 'r':
+                       rflag++; 
+                       break;
+               case 'w':
+                       wflag++;
+                       break;
+               case 'x':
+                       xflag++;
+                       break;
+               default:
+                       usage();
+               }
+       }
+
+       argc -= optind;
+       argv += optind;
+
+       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(EXIT_FAILURE, "prog init failed");
+
+       if (Aflag)
+               warnfp = stdout;
+       stale = req = 0;
+
+       if ((re = malloc(sizeof(*re) * __arraycount(handlers))) == NULL)
+               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(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 ? 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(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(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)
+{
+       const char *t;
+       char p[SYSCTL_NAMELEN + 1];
+       int l;
+
+       if (i[0] != *sep) {
+               o[0] = '/';
+               o[1] = '\0';
+       }
+       else
+               o[0] = '\0';
+
+       t = i;
+       do {
+               i = t;
+               t = strchr(i, sep[0]);
+               if (t == NULL)
+                       strcat(o, i);
+               else {
+                       l = t - i;
+                       t++;
+                       memcpy(p, i, l);
+                       p[l] = '\0';
+                       strcat(o, p);
+                       strcat(o, "/");
+               }
+       } while (t != NULL);
+}
+
+/*
+ * ********************************************************************
+ * convert this special number to a special string so we can print the
+ * mib
+ * ********************************************************************
+ */
+static const char *
+sf(u_int f)
+{
+       static char s[256];
+       const char *c;
+
+       s[0] = '\0';
+       c = "";
+
+#define print_flag(_f, _s, _c, _q, _x) \
+       if (((_f) & (__CONCAT(CTLFLAG_,_x))) == (__CONCAT(CTLFLAG_,_q))) { \
+               strlcat((_s), (_c), sizeof(_s)); \
+               strlcat((_s), __STRING(_q), sizeof(_s)); \
+               (_c) = ","; \
+               (_f) &= ~(__CONCAT(CTLFLAG_,_x)); \
+       }
+       print_flag(f, s, c, READONLY,  READWRITE);
+       print_flag(f, s, c, READWRITE, READWRITE);
+       print_flag(f, s, c, ANYWRITE,  ANYWRITE);
+       print_flag(f, s, c, PRIVATE,   PRIVATE);
+       print_flag(f, s, c, PERMANENT, PERMANENT);
+       print_flag(f, s, c, OWNDATA,   OWNDATA);
+       print_flag(f, s, c, IMMEDIATE, IMMEDIATE);
+       print_flag(f, s, c, HEX,       HEX);
+       print_flag(f, s, c, ROOT,      ROOT);
+       print_flag(f, s, c, ANYNUMBER, ANYNUMBER);
+       print_flag(f, s, c, HIDDEN,    HIDDEN);
+       print_flag(f, s, c, ALIAS,     ALIAS);
+#undef print_flag
+
+       if (f) {
+               char foo[9];
+               snprintf(foo, sizeof(foo), "%x", f);
+               strlcat(s, c, sizeof(s));
+               strlcat(s, foo, sizeof(s));
+       }
+
+       return (s);
+}
+
+static const char *
+st(u_int t)
+{
+
+       switch (t) {
+       case CTLTYPE_NODE:
+               return "NODE";
+       case CTLTYPE_INT:
+               return "INT";
+       case CTLTYPE_STRING:
+               return "STRING";
+       case CTLTYPE_QUAD:
+                return "QUAD";
+       case CTLTYPE_STRUCT:
+               return "STRUCT";
+       case CTLTYPE_BOOL:
+               return "BOOL";
+       }
+
+       return "???";
+}
+
+/*
+ * ********************************************************************
+ * recursively eliminate all data belonging to the given node
+ * ********************************************************************
+ */
+static void
+purge_tree(struct sysctlnode *rnode)
+{
+       struct sysctlnode *node;
+
+       if (rnode == NULL ||
+           SYSCTL_TYPE(rnode->sysctl_flags) != CTLTYPE_NODE ||
+           rnode->sysctl_child == NULL)
+               return;
+
+       for (node = rnode->sysctl_child;
+            node < &rnode->sysctl_child[rnode->sysctl_clen];
+            node++)
+               purge_tree(node);
+       free(rnode->sysctl_child);
+       rnode->sysctl_csize = 0;
+       rnode->sysctl_clen = 0;
+       rnode->sysctl_child = NULL;
+
+       if (rnode->sysctl_desc == (const char*)-1)
+               rnode->sysctl_desc = NULL;
+       if (rnode->sysctl_desc != NULL)
+               free(__UNCONST(rnode->sysctl_desc));
+       rnode->sysctl_desc = NULL;
+}
+
+static void __attribute__((__format__(__printf__, 3, 4)))
+appendprintf(char **bp, size_t *lbp, const char *fmt, ...)
+{
+       int r;
+       va_list ap;
+
+       va_start(ap, fmt);
+       r = vsnprintf(*bp, *lbp, fmt, ap);
+       va_end(ap);
+       if (r < 0 || (size_t)r > *lbp)
+               r = *lbp;
+       *bp += r;
+       *lbp -= r;
+}
+
+/*
+ * ********************************************************************
+ * print this node and any others underneath it
+ * ********************************************************************
+ */
+static void
+print_tree(int *name, u_int namelen, struct sysctlnode *pnode, u_int type,
+   int add, regex_t *re, size_t *lastcompiled)
+{
+       struct sysctlnode *node;
+       int rc;
+       size_t ni, sz, ldp, lsp;
+       char *sp, *dp, *tsp, *tdp;
+       const struct handlespec *p;
+
+       sp = tsp = &gsname[strlen(gsname)];
+       dp = tdp = &gdname[strlen(gdname)];
+       ldp = sizeof(gdname) - (dp - gdname);
+       lsp = sizeof(gsname) - (sp - gsname);
+
+       if (sp != &gsname[0] && dp == &gdname[0]) {
+               /*
+                * aw...shucks.  now we must play catch up
+                */
+               for (ni = 0; ni < namelen; ni++)
+                       appendprintf(&tdp, &ldp, "%s%d", ni > 0 ? "." : "",
+                           name[ni]);
+       }
+
+       if (pnode == NULL)
+               pnode = &my_root;
+       else if (add) {
+               appendprintf(&tsp, &lsp, "%s%s", namelen > 1 ? sep : "", 
+                       pnode->sysctl_name);
+               appendprintf(&tdp, &ldp, "%s%d", namelen > 1 ? "." : "", 
+                       pnode->sysctl_num);
+       }
+
+       if (Mflag && pnode != &my_root) {
+               if (nflag)
+                       printf("%s: ", gdname);
+               else
+                       printf("%s (%s): ", gsname, gdname);
+               printf("CTLTYPE_%s", st(type));
+               if (type == CTLTYPE_NODE) {
+                       if (SYSCTL_FLAGS(pnode->sysctl_flags) & CTLFLAG_ALIAS)
+                               printf(", alias %d",
+                                      pnode->sysctl_alias);
+                       else
+                               printf(", children %d/%d",
+                                      pnode->sysctl_clen,
+                                      pnode->sysctl_csize);
+               }
+               printf(", size %zu", pnode->sysctl_size);
+               printf(", flags 0x%x<%s>",
+                      SYSCTL_FLAGS(pnode->sysctl_flags),
+                      sf(SYSCTL_FLAGS(pnode->sysctl_flags)));
+               if (pnode->sysctl_func)
+                       printf(", func=%p", pnode->sysctl_func);
+               printf(", ver=%d", pnode->sysctl_ver);
+               printf("\n");
+               if (type != CTLTYPE_NODE) {
+                       *sp = *dp = '\0';
+                       return;
+               }
+       }
+
+       if (dflag && pnode != &my_root) {
+               if (Aflag || type != CTLTYPE_NODE) {
+                       if (pnode->sysctl_desc == NULL)
+                               getdesc1(name, namelen, pnode);
+                       if (Aflag || !add ||
+                           (pnode->sysctl_desc != NULL &&
+                            pnode->sysctl_desc != (const char*)-1)) {
+                               if (!nflag)
+                                       printf("%s: ", gsname);
+                               if (pnode->sysctl_desc == NULL ||
+                                   pnode->sysctl_desc == (const char*)-1)
+                                       printf("(no description)\n");
+                               else
+                                       printf("%s\n", pnode->sysctl_desc);
+                       }
+               }
+
+               if (type != CTLTYPE_NODE) {
+                       *sp = *dp = '\0';
+                       return;
+               }
+       }
+
+       /*
+        * if this is an alias and we added our name, that means we
+        * got here by recursing down into the tree, so skip it.  The
+        * only way to print an aliased node is with either -M or by
+        * 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(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;
+               }
+               if (sz == 0) {
+                       if ((Aflag || req) && !Mflag)
+                               printf("%s: node contains no data\n", gsname);
+                       *sp = *dp = '\0';
+                       return;
+               }
+       }
+       else
+               sz = pnode->sysctl_size;
+
+       switch (type) {
+       case CTLTYPE_NODE: {
+               __learn_tree(name, namelen, pnode);
+               node = pnode->sysctl_child;
+               if (node == NULL) {
+                       if (dflag)
+                               /* do nothing */;
+                       else if (p != NULL)
+                               (*p->ps_p)(gsname, gdname, NULL, name, namelen,
+                                          pnode, type, __UNCONST(p->ps_d));
+                       else if ((Aflag || req) && !Mflag)
+                               printf("%s: no children\n", gsname);
+               }
+               else {
+                       if (dflag)
+                               /*
+                                * get all descriptions for next level
+                                * in one chunk
+                                */
+                               getdesc(name, namelen, pnode);
+                       req = 0;
+                       for (ni = 0; ni < pnode->sysctl_clen; ni++) {
+                               name[namelen] = node[ni].sysctl_num;
+                               if ((node[ni].sysctl_flags & CTLFLAG_HIDDEN) &&
+                                   !(Aflag || req))
+                                       continue;
+                               print_tree(name, namelen + 1, &node[ni],
+                                          SYSCTL_TYPE(node[ni].sysctl_flags),
+                                          1, re, lastcompiled);
+                       }
+               }
+               break;
+       }
+       case CTLTYPE_INT: {
+               int i;
+               rc = prog_sysctl(name, namelen, &i, &sz, NULL, 0);
+               if (rc == -1) {
+                       sysctlerror(1);
+                       break;
+               }
+               display_number(pnode, gsname, &i, sizeof(i), DISPLAY_VALUE);
+               break;
+       }
+       case CTLTYPE_BOOL: {
+               bool b;
+               rc = prog_sysctl(name, namelen, &b, &sz, NULL, 0);
+               if (rc == -1) {
+                       sysctlerror(1);
+                       break;
+               }
+               display_number(pnode, gsname, &b, sizeof(b), DISPLAY_VALUE);
+               break;
+       }
+       case CTLTYPE_STRING: {
+               unsigned char buf[1024], *tbuf;
+               tbuf = buf;
+               sz = sizeof(buf);
+               rc = prog_sysctl(&name[0], namelen, tbuf, &sz, NULL, 0);
+               if (rc == -1 && errno == ENOMEM) {
+                       tbuf = malloc(sz);
+                       if (tbuf == NULL) {
+                               sysctlerror(1);
+                               break;
+                       }
+                       rc = prog_sysctl(&name[0], namelen, tbuf, &sz, NULL, 0);
+               }
+               if (rc == -1)
+                       sysctlerror(1);
+               else
+                       display_string(pnode, gsname, tbuf, sz, DISPLAY_VALUE);
+               if (tbuf != buf)
+                       free(tbuf);
+               break;
+       }
+       case CTLTYPE_QUAD: {
+               u_quad_t q;
+               sz = sizeof(q);
+               rc = prog_sysctl(&name[0], namelen, &q, &sz, NULL, 0);
+               if (rc == -1) {
+                       sysctlerror(1);
+                       break;
+               }
+               display_number(pnode, gsname, &q, sizeof(q), DISPLAY_VALUE);
+               break;
+       }
+       case CTLTYPE_STRUCT: {
+               /*
+                * we shouldn't actually get here, but if we
+                * do, would it be nice to have *something* to
+                * do other than completely ignore the
+                * request.
+                */
+               unsigned char *d;
+               if ((d = malloc(sz)) == NULL) {
+                       fprintf(warnfp, "%s: !malloc failed!\n", gsname);
+                       break;
+               }
+               rc = prog_sysctl(&name[0], namelen, d, &sz, NULL, 0);
+               if (rc == -1) {
+                       sysctlerror(1);
+                       break;
+               }
+               display_struct(pnode, gsname, d, sz, DISPLAY_VALUE);
+               free(d);
+               break;
+       }
+       default:
+               /* should i print an error here? */
+               break;
+       }
+
+       *sp = *dp = '\0';
+}
+
+/*
+ * ********************************************************************
+ * parse a request, possibly determining that it's a create or destroy
+ * request
+ * ********************************************************************
+ */
+static void
+parse(char *l, regex_t *re, size_t *lastcompiled)
+{
+       struct sysctlnode *node;
+       const struct handlespec *w;
+       int name[CTL_MAXNAME], dodesc = 0;
+       u_int namelen, type;
+       char *key, *value, *dot;
+       size_t sz;
+       bool optional = false;
+
+       req = 1;
+       key = l;
+
+       if ((value = strchr(l, '=')) != NULL) {
+               if (value > l && value[-1] == '?') {
+                       value[-1] = '\0';
+                       optional = true;
+               }
+               *value++ = '\0';
+       }
+
+       if ((dot = strpbrk(key, "./")) == NULL)
+               sep[0] = '.';
+       else
+               sep[0] = dot[0];
+       sep[1] = '\0';
+
+       while (key[0] == sep[0] && key[1] == sep[0]) {
+               if (value != NULL)
+                       value[-1] = '=';
+               if (strncmp(key + 2, "create", 6) == 0 &&
+                   (key[8] == '=' || key[8] == sep[0]))
+                       parse_create(key + 8 + (key[8] == '=' ? 1 : 0));
+               else if (strncmp(key + 2, "destroy", 7) == 0 &&
+                        (key[9] == '=' || key[9] == sep[0]))
+                       parse_destroy(key + 9 + (key[9] == '=' ? 1 : 0));
+               else if (strncmp(key + 2, "describe", 8) == 0 &&
+                        (key[10] == '=' || key[10] == sep[0])) {
+                       key += 10 + (key[10] == '=');
+                       if ((value = strchr(key, '=')) != NULL)
+                               parse_describe(key);
+                       else {
+                               if (!dflag)
+                                       dodesc = 1;
+                               break;
+                       }
+               }
+               else
+                       sysctlperror("unable to parse '%s'\n", key);
+               return;
+       }
+
+       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(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(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(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,
+                   lastcompiled);
+               break;
+       case CTLTYPE_INT:
+       case CTLTYPE_BOOL:
+       case CTLTYPE_QUAD:
+               write_number(&name[0], namelen, node, value);
+               break;
+       case CTLTYPE_STRING:
+               write_string(&name[0], namelen, node, value);
+               break;
+       case CTLTYPE_STRUCT:
+               /*
+                * XXX old behavior is to print.  should we error instead?
+                */
+               /* fprintf(warnfp, "you can't write to %s\n", gsname); */
+               print_tree(&name[0], namelen, node, type, 0, re, lastcompiled);
+               break;
+       }
+}
+
+/*
+
+  //create=foo.bar.whatever...,
+  [type=(int|quad|string|struct|node),]
+  [size=###,]
+  [n=###,]
+  [flags=(iohxparw12),]
+  [addr=0x####,|symbol=...|value=...]
+
+  size is optional for some types.  type must be set before anything
+  else.  nodes can have [rwhp], but nothing else applies.  if no
+  size or type is given, node is asserted.  writeable is the default,
+  with [rw] being read-only and unconditionally writeable
+  respectively.  if you specify addr, it is assumed to be the name of
+  a kernel symbol, if value, CTLFLAG_OWNDATA will be asserted for
+  strings, CTLFLAG_IMMEDIATE for ints and u_quad_ts.  you cannot
+  specify both value and addr.
+
+*/
+
+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(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;
+       memset(name, 0, sizeof(name));
+       namelen = 0;
+       method = 0;
+
+       /*
+        * misc stuff used when constructing
+        */
+       i = 0;
+       b = false;
+       uq = 0;
+       key = NULL;
+       value = NULL;
+
+       /*
+        * the name of the thing we're trying to create is first, so
+        * pick it off.
+        */
+       nname = l;
+       if ((c = strchr(nname, ',')) != NULL)
+               *c++ = '\0';
+
+       while (c != NULL) {
+
+               /*
+                * pull off the next "key=value" pair
+                */
+               key = c;
+               if ((t = strchr(key, '=')) != NULL) {
+                       *t++ = '\0';
+                       value = t;
+               }
+               else
+                       value = NULL;
+
+               /*
+                * if the "key" is "value", then that eats the rest of
+                * the string, so we're done, otherwise bite it off at
+                * the next comma.
+                */
+               if (strcmp(key, "value") == 0) {
+                       c = NULL;
+                       data = value;
+                       break;
+               }
+               else if (value) {
+                       if ((c = strchr(value, ',')) != NULL)
+                               *c++ = '\0';
+               }
+
+               /*
+                * note that we (mostly) let the invoker of prog_sysctl(8)
+                * play rampant here and depend on the kernel to tell
+                * them that they were wrong.  well...within reason.
+                * we later check the various parameters against each
+                * 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(EXIT_FAILURE);
+                       }
+                       if (value == NULL) {
+                               sysctlperror("%s: missing value\n", nname);
+                               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(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(EXIT_FAILURE);
+                       }
+                       addr = value;
+                       method = CTL_CREATESYM;
+               }
+               else if (strcmp(key, "type") == 0) {
+                       if (value == NULL) {
+                               sysctlperror("%s: missing value\n", nname);
+                               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(EXIT_FAILURE);
+                       }
+               }
+               else if (strcmp(key, "size") == 0) {
+                       if (value == NULL) {
+                               sysctlperror("%s: missing value\n", nname);
+                               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(EXIT_FAILURE);
+                       }
+               }
+               else if (strcmp(key, "n") == 0) {
+                       if (value == NULL) {
+                               sysctlperror("%s: missing value\n", nname);
+                               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(EXIT_FAILURE);
+                       }
+                       node.sysctl_num = (int)q;
+               }
+               else if (strcmp(key, "flags") == 0) {
+                       if (value == NULL) {
+                               sysctlperror("%s: missing value\n", nname);
+                               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;
+                               case 'o':
+                                       flags |= CTLFLAG_OWNDATA;
+                                       break;
+                               case 'p':
+                                       flags |= CTLFLAG_PRIVATE;
+                                       break;
+                               case 'u':
+                                       flags |= CTLFLAG_UNSIGNED;
+                                       break;
+                               case 'x':
+                                       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(EXIT_FAILURE);
+                               }
+                               t++;
+                       }
+               }
+               else {
+                       sysctlperror("%s: unrecognized keyword '%s'\n",
+                                    nname, key);
+                       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(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(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(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;
+                       node.sysctl_data = data;
+                       if (sz == 0)
+                               sz = strlen(data) + 1;
+                       else if (sz < strlen(data) + 1) {
+                               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(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(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(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(EXIT_FAILURE);
+       }
+       if (type == CTLTYPE_NODE && node.sysctl_data != NULL) {
+               sysctlperror("%s: nodes do not have data\n", nname);
+               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(EXIT_FAILURE);
+               }
+       }
+       else if (type == CTLTYPE_STRUCT) {
+               sysctlperror("%s: struct must have size\n", nname);
+               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(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';
+
+       /*
+        * put it all together, now.  t'ain't much, is it?
+        */
+       node.sysctl_flags = SYSCTL_VERSION|flags|rw|type;
+       node.sysctl_size = sz;
+       t = strrchr(nname, sep[0]);
+       if (t != NULL)
+               strlcpy(node.sysctl_name, t + 1, sizeof(node.sysctl_name));
+       else
+               strlcpy(node.sysctl_name, nname, sizeof(node.sysctl_name));
+       if (t == nname)
+               t = NULL;
+
+       /*
+        * if this is a new top-level node, then we don't need to find
+        * the mib for its parent
+        */
+       if (t == NULL) {
+               namelen = 0;
+               gsname[0] = '\0';
+       }
+
+       /*
+        * 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(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(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(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(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(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(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(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)
+               sysctlperror("%s: description not set\n", gsname);
+       else if (!qflag && !nflag)
+               printf("%s: %s\n", gsname, d->descr_str);
+}
+
+/*
+ * ********************************************************************
+ * when things go wrong...
+ * ********************************************************************
+ */
+static void
+usage(void)
+{
+       const char *progname = getprogname();
+
+       (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(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;
+       node.sysctl_num = name[namelen - 1];
+       name[namelen - 1] = CTL_DESCRIBE;
+       rc = prog_sysctl(name, namelen, d, &sz, &node, sizeof(node));
+
+       if (rc == -1 ||
+           d->descr_len == 1 ||
+           d->descr_num != pnode->sysctl_num ||
+           d->descr_ver != pnode->sysctl_ver)
+               desc = (char *)-1;
+       else
+               desc = malloc(d->descr_len);
+
+       if (desc == NULL)
+               desc = (char *)-1;
+       if (desc != (char *)-1)
+               memcpy(desc, &d->descr_str[0], d->descr_len);
+       name[namelen - 1] = node.sysctl_num;
+       if (pnode->sysctl_desc != NULL &&
+           pnode->sysctl_desc != (const char *)-1)
+               free(__UNCONST(pnode->sysctl_desc));
+       pnode->sysctl_desc = desc;
+}
+
+static void
+getdesc(int *name, u_int namelen, struct sysctlnode *pnode)
+{
+       struct sysctlnode *node = pnode->sysctl_child;
+       struct sysctldesc *d, *p, *plim;
+       char *desc;
+       size_t i, sz, child_cnt;
+       int rc;
+
+       sz = 128 * pnode->sysctl_clen;
+       name[namelen] = CTL_DESCRIBE;
+
+       /*
+        * attempt *twice* to get the description chunk.  if two tries
+        * doesn't work, give up.
+        */
+       i = 0;
+       do {
+               d = malloc(sz);
+               if (d == NULL)
+                       return;
+               rc = prog_sysctl(name, namelen + 1, d, &sz, NULL, 0);
+               if (rc == -1) {
+                       free(d);
+                       d = NULL;
+                       if (i == 0 && errno == ENOMEM)
+                               i = 1;
+                       else
+                               return;
+               }
+       } while (d == NULL);
+
+       /*
+        * hokey nested loop here, giving O(n**2) behavior, but should
+        * suffice for now
+        */
+       plim = /*LINTED ptr cast*/(struct sysctldesc *)((char*)d + sz);
+       child_cnt = (pnode->sysctl_flags & CTLTYPE_NODE) ? pnode->sysctl_clen
+           : 0;
+       for (i = 0; i < child_cnt; i++) {
+               node = &pnode->sysctl_child[i];
+               for (p = d; p < plim; p = NEXT_DESCR(p))
+                       if (node->sysctl_num == p->descr_num)
+                               break;
+               if (p < plim && node->sysctl_ver == p->descr_ver) {
+                       /*
+                        * match found, attempt to attach description
+                        */
+                       if (p->descr_len == 1)
+                               desc = NULL;
+                       else
+                               desc = malloc(p->descr_len);
+                       if (desc == NULL)
+                               desc = (char *)-1;
+                       else
+                               memcpy(desc, &p->descr_str[0], p->descr_len);
+                       node->sysctl_desc = desc;
+               }
+       }
+
+       free(d);
+}
+
+static void
+trim_whitespace(char *s, int dir)
+{
+       char *i, *o;
+
+       i = o = s;
+       if (dir & 1)
+               while (isspace((unsigned char)*i))
+                       i++;
+       while ((*o++ = *i++) != '\0');
+       o -= 2; /* already past nul, skip back to before it */
+       if (dir & 2)
+               while (o > s && isspace((unsigned char)*o))
+                       *o-- = '\0';
+}
+
+void
+sysctlerror(int soft)
+{
+       if (soft) {
+               switch (errno) {
+               case ENOENT:
+               case ENOPROTOOPT:
+               case ENOTDIR:
+               case EINVAL:
+               case EOPNOTSUPP:
+               case EPROTONOSUPPORT:
+                       if (Aflag || req)
+                               sysctlperror("%s: the value is not available "
+                                   "(%s)\n", gsname, strerror(errno));
+                       return;
+               }
+       }
+
+       if (Aflag || req)
+               sysctlperror("%s: %s\n", gsname, strerror(errno));
+       if (!soft)
+               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);
+}
+
+static void
+sysctlperror(const char *fmt, ...)
+{
+       va_list ap;
+
+       (void)fprintf(warnfp, "%s: ", getprogname());
+       if (fn)
+               (void)fprintf(warnfp, "%s#%zu: ", fn, nr);
+       va_start(ap, fmt);
+       (void)vfprintf(warnfp, fmt, ap);
+       va_end(ap);
+       errs++;
+}
+
+
+/*
+ * ********************************************************************
+ * how to write to a "simple" node
+ * ********************************************************************
+ */
+static void
+write_number(int *name, u_int namelen, struct sysctlnode *node, char *value)
+{
+       u_int ii, io;
+       u_quad_t qi, qo;
+       size_t si, so;
+       bool bi, bo;
+       int rc;
+       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(EXIT_FAILURE);
+       }
+       if (t == value || *t != '\0') {
+               sysctlperror("%s: not a number\n", value);
+               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(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;
+       case CTLTYPE_QUAD:
+               o = &qo;
+               so = sizeof(qo);
+               i = &qi;
+               si = sizeof(qi);
+               break;
+       }
+
+       rc = prog_sysctl(name, namelen, o, &so, i, si);
+       if (rc == -1) {
+               sysctlerror(0);
+               return;
+       }
+
+       switch (SYSCTL_TYPE(node->sysctl_flags)) {
+       case CTLTYPE_INT:
+               display_number(node, gsname, &io, sizeof(io), DISPLAY_OLD);
+               display_number(node, gsname, &ii, sizeof(ii), DISPLAY_NEW);
+               break;
+       case CTLTYPE_BOOL:
+               display_number(node, gsname, &bo, sizeof(bo), DISPLAY_OLD);
+               display_number(node, gsname, &bi, sizeof(bi), DISPLAY_NEW);
+               break;
+       case CTLTYPE_QUAD:
+               display_number(node, gsname, &qo, sizeof(qo), DISPLAY_OLD);
+               display_number(node, gsname, &qi, sizeof(qi), DISPLAY_NEW);
+               break;
+       }
+}
+
+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(EXIT_FAILURE);
+       }
+       o = malloc(so);
+       if (o == NULL) {
+               sysctlperror("%s: !malloc failed!\n", gsname);
+               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);
+}
+
+/*
+ * ********************************************************************
+ * simple ways to print stuff consistently
+ * ********************************************************************
+ */
+static void
+display_number(const struct sysctlnode *node, const char *name,
+              const void *data, size_t sz, int n)
+{
+       u_quad_t q;
+       bool b;
+       int i;
+
+       if (qflag)
+               return;
+       if ((nflag || rflag) && (n == DISPLAY_OLD))
+               return;
+
+       if (rflag && n != DISPLAY_OLD) {
+               fwrite(data, sz, 1, stdout);
+               return;
+       }
+
+       if (!nflag) {
+               if (n == DISPLAY_VALUE)
+                       printf("%s%s", name, eq);
+               else if (n == DISPLAY_OLD)
+                       printf("%s: ", name);
+       }
+
+       if (xflag > 1) {
+               if (n != DISPLAY_NEW)
+                       printf("\n");
+               hex_dump(data, sz);
+               return;
+       }
+
+       switch (SYSCTL_TYPE(node->sysctl_flags)) {
+       case CTLTYPE_INT:
+               memcpy(&i, data, sz);
+               if (xflag)
+                       printf("0x%0*x", (int)sz * 2, i);
+               else if (node->sysctl_flags & CTLFLAG_HEX)
+                       printf("%#x", i);
+               else if (node->sysctl_flags & CTLFLAG_UNSIGNED)
+                       printf("%u", i);
+               else
+                       printf("%d", i);
+               break;
+       case CTLTYPE_BOOL:
+               memcpy(&b, data, sz);
+               if (xflag)
+                       printf("0x%0*x", (int)sz * 2, b);
+               else if (node->sysctl_flags & CTLFLAG_HEX)
+                       printf("%#x", b);
+               else
+                       printf("%d", b);
+               break;
+       case CTLTYPE_QUAD:
+               memcpy(&q, data, sz);
+               if (xflag)
+                       printf("0x%0*" PRIx64, (int)sz * 2, q);
+               else if (node->sysctl_flags & CTLFLAG_HEX)
+                       printf("%#" PRIx64, q);
+               else if (node->sysctl_flags & CTLFLAG_UNSIGNED)
+                       printf("%" PRIu64, q);
+               else
+                       printf("%" PRIu64, q);
+               break;
+       }
+
+       if (n == DISPLAY_OLD)
+               printf(" -> ");
+       else
+               printf("\n");
+}
+
+static void
+display_string(const struct sysctlnode *node, const char *name,
+              const void *data, size_t sz, int n)
+{
+       const unsigned char *buf = data;
+       int ni;
+
+       if (qflag)
+               return;
+       if ((nflag || rflag) && (n == DISPLAY_OLD))
+               return;
+
+       if (rflag && n != DISPLAY_OLD) {
+               fwrite(data, sz, 1, stdout);
+               return;
+       }
+
+       if (!nflag) {
+               if (n == DISPLAY_VALUE)
+                       printf("%s%s", name, eq);
+               else if (n == DISPLAY_OLD)
+                       printf("%s: ", name);
+       }
+
+       if (xflag > 1) {
+               if (n != DISPLAY_NEW)
+                       printf("\n");
+               hex_dump(data, sz);
+               return;
+       }
+
+       if (xflag || node->sysctl_flags & CTLFLAG_HEX) {
+               for (ni = 0; ni < (int)sz; ni++) {
+                       if (xflag)
+                               printf("%02x", buf[ni]);
+                       if (buf[ni] == '\0')
+                               break;
+                       if (!xflag)
+                               printf("\\x%2.2x", buf[ni]);
+               }
+       }
+       else
+               printf("%.*s", (int)sz, buf);
+
+       if (n == DISPLAY_OLD)
+               printf(" -> ");
+       else
+               printf("\n");
+}
+
+/*ARGSUSED*/
+static void
+display_struct(const struct sysctlnode *node, const char *name,
+              const void *data, size_t sz, int n)
+{
+       const unsigned char *buf = data;
+       int ni;
+       size_t more;
+
+       if (qflag)
+               return;
+       if (!(xflag || rflag)) {
+               if (Aflag || req)
+                       sysctlperror(
+                           "%s: this type is unknown to this program\n",
+                           gsname);
+               return;
+       }
+       if ((nflag || rflag) && (n == DISPLAY_OLD))
+               return;
+
+       if (rflag && n != DISPLAY_OLD) {
+               fwrite(data, sz, 1, stdout);
+               return;
+       }
+
+        if (!nflag) {
+                if (n == DISPLAY_VALUE)
+                        printf("%s%s", name, eq);
+                else if (n == DISPLAY_OLD)
+                        printf("%s: ", name);
+        }
+
+       if (xflag > 1) {
+               if (n != DISPLAY_NEW)
+                       printf("\n");
+               hex_dump(data, sz);
+               return;
+       }
+
+       if (sz > 16) {
+               more = sz - 16;
+               sz = 16;
+       }
+       else
+               more = 0;
+       for (ni = 0; ni < (int)sz; ni++)
+               printf("%02x", buf[ni]);
+       if (more)
+               printf("...(%zu more bytes)", more);
+       printf("\n");
+}
+
+static void
+hex_dump(const unsigned char *buf, size_t len)
+{
+       unsigned int i;
+       int j;
+       char line[80], tmp[12];
+
+       memset(line, ' ', sizeof(line));
+       for (i = 0, j = 15; i < len; i++) {
+               j = i % 16;
+               /* reset line */
+               if (j == 0) {
+                       line[58] = '|';
+                       line[77] = '|';
+                       line[78] = 0;
+                       snprintf(tmp, sizeof(tmp), "%07x", i);
+                       memcpy(&line[0], tmp, 7);
+               }
+               /* copy out hex version of byte */
+               snprintf(tmp, sizeof(tmp), "%02x", buf[i]);
+               memcpy(&line[9 + j * 3], tmp, 2);
+               /* copy out plain version of byte */
+               line[60 + j] = (isprint(buf[i])) ? buf[i] : '.';
+               /* print a full line and erase it */
+               if (j == 15) {
+                       printf("%s\n", line);
+                       memset(line, ' ', sizeof(line));
+               }
+       }
+       if (line[0] != ' ')
+               printf("%s\n", line);
+       printf("%07zu bytes\n", len);
+}
+
+/*
+ * ********************************************************************
+ * functions that handle particular nodes
+ * ********************************************************************
+ */
+/*ARGSUSED*/
+static void
+printother(HANDLER_ARGS)
+{
+       int rc;
+       void *p;
+       size_t sz1, sz2;
+
+       if (!(Aflag || req) || Mflag)
+               return;
+
+       /*
+        * okay...you asked for it, so let's give it a go
+        */
+       while (type != CTLTYPE_NODE && (xflag || rflag)) {
+               rc = prog_sysctl(name, namelen, NULL, &sz1, NULL, 0);
+               if (rc == -1 || sz1 == 0)
+                       break;
+               p = malloc(sz1);
+               if (p == NULL)
+                       break;
+               sz2 = sz1;
+               rc = prog_sysctl(name, namelen, p, &sz2, NULL, 0);
+               if (rc == -1 || sz1 != sz2) {
+                       free(p);
+                       break;
+               }
+               display_struct(pnode, gsname, p, sz1, DISPLAY_VALUE);
+               free(p);
+               return;
+       }
+
+       /*
+        * that didn't work...do we have a specific message for this
+        * thing?
+        */
+       if (v != NULL) {
+               sysctlperror("%s: use '%s' to view this information\n",
+                            gsname, (const char *)v);
+               return;
+       }
+
+       /*
+        * hmm...i wonder if we have any generic hints?
+        */
+       switch (name[0]) {
+       case CTL_NET:
+               sysctlperror("%s: use 'netstat' to view this information\n",
+                            sname);
+               break;
+       case CTL_DEBUG:
+               sysctlperror("%s: missing 'options DEBUG' from kernel?\n",
+                            sname);
+               break;
+       case CTL_DDB:
+               sysctlperror("%s: missing 'options DDB' from kernel?\n",
+                            sname);
+               break;
+       case CTL_VENDOR:
+               sysctlperror("%s: no vendor extensions installed\n",
+                            sname);
+               break;
+       }
+}
+
+/*ARGSUSED*/
+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(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);
+}
+
+/*ARGSUSED*/
+static void
+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(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);
+}
+
+/*ARGSUSED*/
+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(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);
+       }
+}
+
+/*ARGSUSED*/
+static void
+kern_cp_time(HANDLER_ARGS)
+{
+       u_int64_t *cp_time;
+       size_t sz, osz;
+       int rc, i, n;
+       char s[sizeof("kern.cp_time.nnnnnn")];
+       const char *tname;
+
+       /*
+        * three things to do here.
+        * case 1: get sum (no Aflag and namelen == 2)
+        * case 2: get specific processor (namelen == 3)
+        * case 3: get all processors (Aflag and namelen == 2)
+        */
+
+       if (namelen == 2 && Aflag) {
+               sz = sizeof(n);
+               rc = sysctlbyname("hw.ncpu", &n, &sz, NULL, 0);
+               if (rc != 0)
+                       return; /* XXX print an error, eh? */
+               n++; /* Add on space for the sum. */
+               sz = n * sizeof(u_int64_t) * CPUSTATES;
+       }
+       else {
+               n = -1; /* Just print one data set. */
+               sz = sizeof(u_int64_t) * CPUSTATES;
+       }
+
+       cp_time = malloc(sz);
+       if (cp_time == NULL) {
+               sysctlerror(1);
+               return;
+       }
+
+       osz = sz;
+       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(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];
+                        cp_time[CP_IDLE] += cp_time[i * CPUSTATES + CP_IDLE];
+               }
+       }
+
+       tname = sname;
+       for (i = 0; n == -1 || i < n; i++) {
+               if (i > 0) {
+                       (void)snprintf(s, sizeof(s), "%s%s%d", sname, sep,
+                                      i - 1);
+                       tname = s;
+               }
+               if (xflag || rflag)
+                       display_struct(pnode, tname, cp_time + (i * CPUSTATES),
+                                      sizeof(u_int64_t) * CPUSTATES,
+                                      DISPLAY_VALUE);
+               else {
+                       if (!nflag)
+                               printf("%s: ", tname);
+                       printf("user = %" PRIu64
+                              ", nice = %" PRIu64
+                              ", sys = %" PRIu64
+                              ", intr = %" PRIu64
+                              ", idle = %" PRIu64
+                              "\n",
+                              cp_time[i * CPUSTATES + CP_USER],
+                              cp_time[i * CPUSTATES + CP_NICE],
+                              cp_time[i * CPUSTATES + CP_SYS],
+                              cp_time[i * CPUSTATES + CP_INTR],
+                              cp_time[i * CPUSTATES + CP_IDLE]);
+               }
+               /*
+                * Just printing the one node.
+                */
+               if (n == -1)
+                       break;
+       }
+
+       free(cp_time);
+}
+
+/*ARGSUSED*/
+static void
+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(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;
+       }
+
+       comma = "";
+       if (!nflag)
+               printf("%s%s", sname, eq);
+       for (i = 0, sz /= sizeof(*kd); i < sz; i++) {
+               (void)printf("%s[%d %d %s]", comma, kd[i].d_cmajor,
+                   kd[i].d_bmajor, kd[i].d_name);
+               comma = ", ";
+       }
+       (void)printf("\n");
+       free(kd);
+}
+
+/*ARGSUSED*/
+static void
+kern_cp_id(HANDLER_ARGS)
+{
+       u_int64_t *cp_id;
+       size_t sz, osz;
+       int rc, i, n;
+       char s[sizeof("kern.cp_id.nnnnnn")];
+       const char *tname;
+       struct sysctlnode node = *pnode;
+
+       /*
+        * three things to do here.
+        * case 1: print a specific cpu id (namelen == 3)
+        * case 2: print all cpu ids separately (Aflag set)
+        * case 3: print all cpu ids on one line
+        */
+
+       if (namelen == 2) {
+               sz = sizeof(n);
+               rc = sysctlbyname("hw.ncpu", &n, &sz, NULL, 0);
+               if (rc != 0)
+                       return; /* XXX print an error, eh? */
+               sz = n * sizeof(u_int64_t);
+       }
+       else {
+               n = -1; /* Just print one cpu id. */
+               sz = sizeof(u_int64_t);
+       }
+
+       cp_id = malloc(sz);
+       if (cp_id == NULL) {
+               sysctlerror(1);
+               return;
+       }
+
+       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(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);
+                       tname = s;
+                       display_number(&node, tname, &cp_id[i],
+                                      sizeof(u_int64_t),
+                                      DISPLAY_VALUE);
+       }
+       else {
+               if (xflag || rflag)
+                       display_struct(pnode, tname, cp_id, sz, DISPLAY_VALUE);
+               else {
+                       if (!nflag)
+                               printf("%s: ", tname);
+                       for (i = 0; i < n; i++) {
+                               if (i)
+                                       printf(", ");
+                               printf("%d = %" PRIu64, i, cp_id[i]);
+                       }
+                       printf("\n");
+               }
+       }
+
+       free(cp_id);
+}
+
+/*ARGSUSED*/
+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(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);
+}
+
+/*ARGSUSED*/
+static void
+proc_limit(HANDLER_ARGS)
+{
+       u_quad_t olim, *newp, nlim;
+       size_t osz, nsz;
+       char *t;
+       int rc;
+
+       if (fn)
+               trim_whitespace(value, 3);
+
+       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(EXIT_FAILURE);
+                       }
+               }
+       }
+       else {
+               nsz = 0;
+               newp = NULL;
+       }
+
+       rc = prog_sysctl(name, namelen, &olim, &osz, newp, nsz);
+       if (rc == -1) {
+               sysctlerror(newp == NULL);
+               return;
+       }
+
+       if (newp && qflag)
+               return;
+
+       if (rflag || xflag || olim != RLIM_INFINITY)
+               display_number(pnode, sname, &olim, sizeof(olim),
+                              newp ? DISPLAY_OLD : DISPLAY_VALUE);
+       else
+               display_string(pnode, sname, "unlimited", 10,
+                              newp ? DISPLAY_OLD : DISPLAY_VALUE);
+
+       if (newp) {
+               if (rflag || xflag || nlim != RLIM_INFINITY)
+                       display_number(pnode, sname, &nlim, sizeof(nlim),
+                                      DISPLAY_NEW);
+               else
+                       display_string(pnode, sname, "unlimited", 10,
+                                      DISPLAY_NEW);
+       }
+}
+
+#ifdef CPU_DISKINFO
+/*ARGSUSED*/
+static void
+machdep_diskinfo(HANDLER_ARGS)
+{
+       struct disklist *dl;
+       struct biosdisk_info *bi;
+       struct nativedisk_info *ni;
+       int rc;
+       size_t sz;
+       uint i, b, lim;
+
+       rc = prog_sysctl(name, namelen, NULL, &sz, NULL, 0);
+       if (rc == -1) {
+               sysctlerror(1);
+               return;
+       }
+       dl = malloc(sz);
+       if (dl == NULL) {
+               sysctlerror(1);
+               return;
+       }
+       rc = prog_sysctl(name, namelen, dl, &sz, NULL, 0);
+       if (rc == -1) {
+               sysctlerror(1);
+               return;
+       }
+
+       if (!nflag)
+               printf("%s: ", sname);
+       lim = dl->dl_nbiosdisks;
+       if (lim > MAX_BIOSDISKS)
+               lim = MAX_BIOSDISKS;
+       for (bi = dl->dl_biosdisks, i = 0; i < lim; bi++, i++)
+               printf("%x:%" PRIu64 "(%d/%d/%d),%x ",
+                      bi->bi_dev, bi->bi_lbasecs,
+                      bi->bi_cyl, bi->bi_head, bi->bi_sec,
+                      bi->bi_flags);
+       lim = dl->dl_nnativedisks;
+       ni = dl->dl_nativedisks;
+       bi = dl->dl_biosdisks;
+       /* LINTED -- pointer casts are tedious */
+       if ((char *)&ni[lim] != (char *)dl + sz) {
+               sysctlperror("%s: size mismatch\n", gsname);
+               return;
+       }
+       for (i = 0; i < lim; ni++, i++) {
+               char t = ':';
+               printf(" %.*s", (int)sizeof ni->ni_devname,
+                      ni->ni_devname);
+               for (b = 0; b < (unsigned int)ni->ni_nmatches; t = ',', b++)
+                       printf("%c%x", t,
+                              bi[ni->ni_biosmatches[b]].bi_dev);
+       }
+       printf("\n");
+       free(dl);
+}
+#endif /* CPU_DISKINFO */
+
+/*ARGSUSED*/
+static void
+mode_bits(HANDLER_ARGS)
+{
+       char buf[12], outbuf[100];
+       int o, m, *newp, rc;
+       size_t osz, nsz;
+       mode_t om, mm;
+
+       if (fn)
+               trim_whitespace(value, 3);
+
+       newp = NULL;
+       osz = sizeof(o);
+       if (value != NULL) {
+               void *foo;
+               int tt;
+               size_t ttsz = sizeof(tt);
+               mode_t old_umask;
+
+               nsz = sizeof(m);
+               newp = &m;
+               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(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(EXIT_FAILURE);
+               }
+       }
+       else {
+               nsz = 0;
+               newp = NULL;
+       }
+
+       rc = prog_sysctl(name, namelen, &o, &osz, newp, nsz);
+       if (rc == -1) {
+               sysctlerror(newp == NULL);
+               return;
+       }
+
+       if (newp && qflag)
+               return;
+
+       om = (mode_t)o;
+       mm = (mode_t)m;
+
+       if (rflag || xflag)
+               display_number(pnode, sname, &o, sizeof(o),
+                              newp ? DISPLAY_OLD : DISPLAY_VALUE);
+       else {
+               memset(buf, 0, sizeof(buf));
+               strmode(om, buf);
+               rc = snprintf(outbuf, sizeof(outbuf), "%04o (%s)", om, buf + 1);
+               display_string(pnode, sname, outbuf, rc, newp ? DISPLAY_OLD : DISPLAY_VALUE);
+       }
+
+       if (newp) {
+               if (rflag || xflag)
+                       display_number(pnode, sname, &m, sizeof(m),
+                                      DISPLAY_NEW);
+               else {
+                       memset(buf, 0, sizeof(buf));
+                       strmode(mm, buf);
+                       rc = snprintf(outbuf, sizeof(outbuf), "%04o (%s)", mm, buf + 1);
+                       display_string(pnode, sname, outbuf, rc, DISPLAY_NEW);
+               }
+       }
+}
+
+typedef __BITMAP_TYPE(, uint32_t, 0x10000) bitmap;
+
+static char *
+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(EXIT_FAILURE, "%s 1", __func__);
+                       free(os);
+                       os = s;
+               }
+       if (s == NULL && (s = strdup("")) == NULL)
+               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(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(EXIT_FAILURE, "Invalid port: %s", s);
+               if (l >= MAXPORTS)
+                       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)
+               trim_whitespace(value, 3);
+
+       osz = sizeof(o);
+       if (value) {
+               bitmask_scan(value, &n);
+               value = (char *)&n;
+               nsz = sizeof(n);
+       } else
+               nsz = 0;
+
+       rc = prog_sysctl(name, namelen, &o, &osz, value, nsz);
+       if (rc == -1) {
+               sysctlerror(value == NULL);
+               return;
+       }
+
+       if (value && qflag)
+               return;
+
+       if (rflag || xflag)
+               display_struct(pnode, sname, &o, sizeof(o),
+                   value ? DISPLAY_OLD : DISPLAY_VALUE);
+       else {
+               char *s = bitmask_print(&o);
+               display_string(pnode, sname, s, strlen(s),
+                   value ? DISPLAY_OLD : DISPLAY_VALUE);
+               free(s);
+       }
+
+       if (value) {
+               if (rflag || xflag)
+                       display_struct(pnode, sname, &n, sizeof(n),
+                           DISPLAY_NEW);
+               else {
+                       char *s = bitmask_print(&n);
+                       display_string(pnode, sname, s, strlen(s), DISPLAY_NEW);
+                       free(s);
+               }
+       }
+}
diff --git a/sbin/sysctl/sysctl_hostops.c b/sbin/sysctl/sysctl_hostops.c
new file mode 100644 (file)
index 0000000..9f1b25a
--- /dev/null
@@ -0,0 +1,41 @@
+/*     $NetBSD: sysctl_hostops.c,v 1.1 2010/12/13 17:47:40 pooka Exp $ */
+
+/*
+ * Copyright (c) 2010 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * 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.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+#ifndef lint
+__RCSID("$NetBSD: sysctl_hostops.c,v 1.1 2010/12/13 17:47:40 pooka Exp $");
+#endif /* !lint */
+
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+#include "prog_ops.h"
+
+const struct prog_ops prog_ops = {
+       .op_sysctl = sysctl,
+};
diff --git a/sbin/sysctl/sysctl_rumpops.c b/sbin/sysctl/sysctl_rumpops.c
new file mode 100644 (file)
index 0000000..c00b67b
--- /dev/null
@@ -0,0 +1,47 @@
+/*     $NetBSD: sysctl_rumpops.c,v 1.1 2010/12/13 17:47:40 pooka Exp $ */
+
+/*
+ * Copyright (c) 2010 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * 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.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+#ifndef lint
+__RCSID("$NetBSD: sysctl_rumpops.c,v 1.1 2010/12/13 17:47:40 pooka Exp $");
+#endif /* !lint */
+
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+#include <rump/rump.h>
+#include <rump/rump_syscalls.h>
+#include <rump/rumpclient.h>
+
+#include "prog_ops.h"
+
+const struct prog_ops prog_ops = {
+       .op_init =      rumpclient_init,
+
+       .op_sysctl =    rump_sys___sysctl,
+};