Home | History | Annotate | Line # | Download | only in sysctl
sysctl.c revision 1.141
      1  1.141  christos /*	$NetBSD: sysctl.c,v 1.141 2012/03/11 23:33:00 christos Exp $ */
      2   1.75    atatat 
      3   1.75    atatat /*-
      4   1.75    atatat  * Copyright (c) 2003 The NetBSD Foundation, Inc.
      5   1.75    atatat  *	All rights reserved.
      6   1.75    atatat  *
      7   1.75    atatat  * This code is derived from software contributed to The NetBSD Foundation
      8   1.75    atatat  * by Andrew Brown.
      9   1.75    atatat  *
     10   1.75    atatat  * Redistribution and use in source and binary forms, with or without
     11   1.75    atatat  * modification, are permitted provided that the following conditions
     12   1.75    atatat  * are met:
     13   1.75    atatat  * 1. Redistributions of source code must retain the above copyright
     14   1.75    atatat  *    notice, this list of conditions and the following disclaimer.
     15   1.75    atatat  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.75    atatat  *    notice, this list of conditions and the following disclaimer in the
     17   1.75    atatat  *    documentation and/or other materials provided with the distribution.
     18   1.75    atatat  *
     19   1.75    atatat  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20   1.75    atatat  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21   1.75    atatat  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22   1.75    atatat  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23   1.75    atatat  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24   1.75    atatat  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25   1.75    atatat  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26   1.75    atatat  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27   1.75    atatat  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28   1.75    atatat  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29   1.75    atatat  * POSSIBILITY OF SUCH DAMAGE.
     30   1.75    atatat  */
     31    1.9   thorpej 
     32    1.1       cgd /*
     33    1.1       cgd  * Copyright (c) 1993
     34    1.1       cgd  *	The Regents of the University of California.  All rights reserved.
     35    1.1       cgd  *
     36    1.1       cgd  * Redistribution and use in source and binary forms, with or without
     37    1.1       cgd  * modification, are permitted provided that the following conditions
     38    1.1       cgd  * are met:
     39    1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     40    1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     41    1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     42    1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     43    1.1       cgd  *    documentation and/or other materials provided with the distribution.
     44   1.71       agc  * 3. Neither the name of the University nor the names of its contributors
     45    1.1       cgd  *    may be used to endorse or promote products derived from this software
     46    1.1       cgd  *    without specific prior written permission.
     47    1.1       cgd  *
     48    1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     49    1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     50    1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     51    1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     52    1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     53    1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     54    1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     55    1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     56    1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     57    1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     58    1.1       cgd  * SUCH DAMAGE.
     59    1.1       cgd  */
     60    1.1       cgd 
     61   1.14  christos #include <sys/cdefs.h>
     62    1.1       cgd #ifndef lint
     63  1.124     lukem __COPYRIGHT("@(#) Copyright (c) 1993\
     64  1.124     lukem  The Regents of the University of California.  All rights reserved.");
     65    1.1       cgd #endif /* not lint */
     66    1.1       cgd 
     67    1.1       cgd #ifndef lint
     68    1.9   thorpej #if 0
     69    1.9   thorpej static char sccsid[] = "@(#)sysctl.c	8.1 (Berkeley) 6/6/93";
     70    1.9   thorpej #else
     71  1.141  christos __RCSID("$NetBSD: sysctl.c,v 1.141 2012/03/11 23:33:00 christos Exp $");
     72    1.9   thorpej #endif
     73    1.1       cgd #endif /* not lint */
     74    1.1       cgd 
     75   1.75    atatat #include <sys/types.h>
     76    1.1       cgd #include <sys/param.h>
     77    1.1       cgd #include <sys/sysctl.h>
     78   1.17   thorpej #include <sys/mount.h>
     79   1.22    bouyer #include <sys/resource.h>
     80   1.75    atatat #include <sys/stat.h>
     81   1.75    atatat #include <sys/sched.h>
     82   1.75    atatat #include <sys/socket.h>
     83    1.1       cgd #include <netinet/in.h>
     84    1.1       cgd #include <netinet/ip_var.h>
     85    1.8   thorpej #include <netinet/tcp.h>
     86    1.8   thorpej #include <netinet/tcp_timer.h>
     87    1.8   thorpej #include <netinet/tcp_var.h>
     88   1.24    itojun #include <netinet/icmp6.h>
     89   1.75    atatat #include <nfs/rpcv2.h>
     90   1.75    atatat #include <nfs/nfsproto.h>
     91   1.75    atatat #include <nfs/nfs.h>
     92   1.75    atatat #include <machine/cpu.h>
     93   1.20    itojun 
     94   1.75    atatat #include <assert.h>
     95   1.75    atatat #include <ctype.h>
     96   1.14  christos #include <err.h>
     97    1.1       cgd #include <errno.h>
     98   1.75    atatat #include <inttypes.h>
     99   1.98    atatat #include <regex.h>
    100   1.75    atatat #include <stdarg.h>
    101    1.1       cgd #include <stdio.h>
    102    1.1       cgd #include <stdlib.h>
    103    1.1       cgd #include <string.h>
    104   1.75    atatat #include <time.h>
    105   1.15      tron #include <unistd.h>
    106    1.1       cgd 
    107  1.133     pooka #include "prog_ops.h"
    108  1.132     pooka 
    109   1.75    atatat /*
    110   1.75    atatat  * this needs to be able to do the printing and the setting
    111   1.75    atatat  */
    112   1.75    atatat #define HANDLER_PROTO const char *, const char *, char *, \
    113   1.75    atatat 	int *, u_int, const struct sysctlnode *, \
    114   1.75    atatat 	u_int, void *
    115   1.75    atatat #define HANDLER_ARGS const char *sname, const char *dname, char *value, \
    116   1.75    atatat 	int *name, u_int namelen, const struct sysctlnode *pnode, \
    117   1.75    atatat 	u_int type, void *v
    118   1.75    atatat #define DISPLAY_VALUE	0
    119   1.75    atatat #define DISPLAY_OLD	1
    120   1.75    atatat #define DISPLAY_NEW	2
    121   1.75    atatat 
    122   1.75    atatat /*
    123   1.75    atatat  * generic routines
    124   1.75    atatat  */
    125  1.141  christos static const struct handlespec *findhandler(const char *, regex_t *, size_t *);
    126   1.98    atatat static void canonicalize(const char *, char *);
    127  1.100    atatat static void purge_tree(struct sysctlnode *);
    128  1.134  christos static void print_tree(int *, u_int, struct sysctlnode *, u_int, int, regex_t *,
    129  1.134  christos     size_t *);
    130   1.75    atatat static void write_number(int *, u_int, struct sysctlnode *, char *);
    131   1.75    atatat static void write_string(int *, u_int, struct sysctlnode *, char *);
    132   1.75    atatat static void display_number(const struct sysctlnode *, const char *,
    133   1.75    atatat 			   const void *, size_t, int);
    134   1.75    atatat static void display_string(const struct sysctlnode *, const char *,
    135   1.75    atatat 			   const void *, size_t, int);
    136   1.75    atatat static void display_struct(const struct sysctlnode *, const char *,
    137   1.75    atatat 			   const void *, size_t, int);
    138   1.75    atatat static void hex_dump(const unsigned char *, size_t);
    139  1.138     joerg __dead static void usage(void);
    140  1.134  christos static void parse(char *, regex_t *, size_t *);
    141   1.82    atatat static void parse_create(char *);
    142   1.82    atatat static void parse_destroy(char *);
    143   1.84    atatat static void parse_describe(char *);
    144   1.84    atatat static void getdesc1(int *, u_int, struct sysctlnode *);
    145   1.84    atatat static void getdesc(int *, u_int, struct sysctlnode *);
    146   1.92    atatat static void trim_whitespace(char *, int);
    147   1.75    atatat static void sysctlerror(int);
    148   1.92    atatat static void sysctlparseerror(u_int, const char *);
    149   1.92    atatat static void sysctlperror(const char *, ...);
    150   1.92    atatat #define EXIT(n) do { \
    151   1.92    atatat 	if (fn == NULL) exit(n); else return; } while (/*CONSTCOND*/0)
    152   1.56  christos 
    153   1.75    atatat /*
    154   1.85    atatat  * "borrowed" from libc:sysctlgetmibinfo.c
    155   1.75    atatat  */
    156   1.85    atatat int __learn_tree(int *, u_int, struct sysctlnode *);
    157   1.22    bouyer 
    158   1.75    atatat /*
    159   1.75    atatat  * "handlers"
    160   1.75    atatat  */
    161   1.75    atatat static void printother(HANDLER_PROTO);
    162   1.75    atatat static void kern_clockrate(HANDLER_PROTO);
    163   1.75    atatat static void kern_boottime(HANDLER_PROTO);
    164   1.75    atatat static void kern_consdev(HANDLER_PROTO);
    165   1.75    atatat static void kern_cp_time(HANDLER_PROTO);
    166  1.103  christos static void kern_cp_id(HANDLER_PROTO);
    167  1.118  christos static void kern_drivers(HANDLER_PROTO);
    168   1.75    atatat static void vm_loadavg(HANDLER_PROTO);
    169   1.75    atatat static void proc_limit(HANDLER_PROTO);
    170   1.75    atatat #ifdef CPU_DISKINFO
    171   1.75    atatat static void machdep_diskinfo(HANDLER_PROTO);
    172   1.75    atatat #endif /* CPU_DISKINFO */
    173  1.108      elad static void mode_bits(HANDLER_PROTO);
    174    1.1       cgd 
    175   1.95  jdolecek static const struct handlespec {
    176   1.98    atatat 	const char *ps_re;
    177   1.75    atatat 	void (*ps_p)(HANDLER_PROTO);
    178   1.75    atatat 	void (*ps_w)(HANDLER_PROTO);
    179  1.104  christos 	const void *ps_d;
    180   1.75    atatat } handlers[] = {
    181  1.118  christos 	{ "/kern/clockrate",			kern_clockrate, NULL, NULL },
    182   1.98    atatat 	{ "/kern/vnode",			printother, NULL, "pstat" },
    183   1.98    atatat 	{ "/kern/proc(2|_args)?",		printother, NULL, "ps" },
    184   1.98    atatat 	{ "/kern/file2?",			printother, NULL, "pstat" },
    185   1.98    atatat 	{ "/kern/ntptime",			printother, NULL,
    186   1.98    atatat 						"ntpdc -c kerninfo" },
    187   1.98    atatat 	{ "/kern/msgbuf",			printother, NULL, "dmesg" },
    188  1.118  christos 	{ "/kern/boottime",			kern_boottime, NULL, NULL },
    189  1.118  christos 	{ "/kern/consdev",			kern_consdev, NULL, NULL },
    190  1.118  christos 	{ "/kern/cp_time(/[0-9]+)?",		kern_cp_time, NULL, NULL },
    191   1.98    atatat 	{ "/kern/sysvipc_info",			printother, NULL, "ipcs" },
    192  1.118  christos 	{ "/kern/cp_id(/[0-9]+)?",		kern_cp_id, NULL, NULL },
    193   1.98    atatat 
    194  1.118  christos 	{ "/kern/coredump/setid/mode",		mode_bits, mode_bits, NULL },
    195  1.118  christos 	{ "/kern/drivers",			kern_drivers, NULL, NULL },
    196  1.116      elad 
    197   1.98    atatat 	{ "/vm/vmmeter",			printother, NULL,
    198   1.98    atatat 						"vmstat' or 'systat" },
    199  1.118  christos 	{ "/vm/loadavg",			vm_loadavg, NULL, NULL },
    200   1.98    atatat 	{ "/vm/uvmexp2?",			printother, NULL,
    201   1.98    atatat 						"vmstat' or 'systat" },
    202   1.98    atatat 
    203   1.98    atatat 	{ "/vfs/nfs/nfsstats",			printother, NULL, "nfsstat" },
    204   1.98    atatat 
    205   1.98    atatat 	{ "/net/inet6?/tcp6?/ident",		printother, NULL, "identd" },
    206   1.98    atatat 	{ "/net/inet6/icmp6/nd6_[dp]rlist",	printother, NULL, "ndp" },
    207   1.98    atatat 	{ "/net/key/dumps[ap]",			printother, NULL, "setkey" },
    208   1.98    atatat 	{ "/net/[^/]+/[^/]+/pcblist",		printother, NULL,
    209   1.98    atatat 						"netstat' or 'sockstat" },
    210  1.106    rpaulo 	{ "/net/(inet|inet6)/[^/]+/stats",	printother, NULL, "netstat"},
    211  1.105    rpaulo 	{ "/net/bpf/(stats|peers)",		printother, NULL, "netstat"},
    212   1.98    atatat 
    213  1.107    rpaulo 	{ "/net/inet.*/tcp.*/deb.*",		printother, NULL, "trpt" },
    214  1.107    rpaulo 
    215  1.107    rpaulo 	{ "/net/ns/spp/deb.*",			printother, NULL, "trsp" },
    216  1.107    rpaulo 
    217   1.98    atatat 	{ "/hw/diskstats",			printother, NULL, "iostat" },
    218   1.98    atatat 
    219   1.75    atatat #ifdef CPU_CONSDEV
    220  1.118  christos 	{ "/machdep/consdev",			kern_consdev, NULL, NULL },
    221   1.75    atatat #endif /* CPU_CONSDEV */
    222   1.75    atatat #ifdef CPU_DISKINFO
    223  1.118  christos 	{ "/machdep/diskinfo",			machdep_diskinfo, NULL, NULL },
    224   1.75    atatat #endif /* CPU_CONSDEV */
    225   1.98    atatat 
    226  1.118  christos 	{ "/proc/[^/]+/rlimit/[^/]+/[^/]+",	proc_limit, proc_limit, NULL },
    227   1.98    atatat 
    228   1.98    atatat 	/*
    229   1.98    atatat 	 * these will only be called when the given node has no children
    230   1.98    atatat 	 */
    231   1.98    atatat 	{ "/net/[^/]+",				printother, NULL, NULL },
    232   1.98    atatat 	{ "/debug",				printother, NULL, NULL },
    233   1.98    atatat 	{ "/ddb",				printother, NULL, NULL },
    234   1.98    atatat 	{ "/vendor",				printother, NULL, NULL },
    235   1.98    atatat 
    236  1.118  christos 	{ NULL,					NULL, NULL, NULL },
    237    1.1       cgd };
    238   1.56  christos 
    239   1.75    atatat struct sysctlnode my_root = {
    240   1.83    atatat 	.sysctl_flags = SYSCTL_VERSION|CTLFLAG_ROOT|CTLTYPE_NODE,
    241   1.86        he 	sysc_init_field(_sysctl_size, sizeof(struct sysctlnode)),
    242   1.75    atatat 	.sysctl_num = 0,
    243   1.75    atatat 	.sysctl_name = "(prog_root)",
    244    1.1       cgd };
    245    1.1       cgd 
    246   1.84    atatat int	Aflag, aflag, dflag, Mflag, nflag, qflag, rflag, wflag, xflag;
    247   1.92    atatat size_t	nr;
    248   1.92    atatat char	*fn;
    249  1.121  christos int	req, stale, errs;
    250   1.65     lukem FILE	*warnfp = stderr;
    251    1.1       cgd 
    252    1.1       cgd /*
    253   1.75    atatat  * vah-riables n stuff
    254    1.1       cgd  */
    255   1.75    atatat char gsname[SYSCTL_NAMELEN * CTL_MAXNAME + CTL_MAXNAME],
    256   1.98    atatat 	canonname[SYSCTL_NAMELEN * CTL_MAXNAME + CTL_MAXNAME],
    257   1.75    atatat 	gdname[10 * CTL_MAXNAME + CTL_MAXNAME];
    258  1.104  christos char sep[] = ".";
    259  1.104  christos const char *eq = " = ";
    260   1.75    atatat const char *lname[] = {
    261   1.75    atatat 	"top", "second", "third", "fourth", "fifth", "sixth",
    262   1.75    atatat 	"seventh", "eighth", "ninth", "tenth", "eleventh", "twelfth"
    263   1.75    atatat };
    264    1.1       cgd 
    265   1.22    bouyer /*
    266   1.75    atatat  * you've heard of main, haven't you?
    267   1.22    bouyer  */
    268    1.1       cgd int
    269   1.53    simonb main(int argc, char *argv[])
    270    1.1       cgd {
    271   1.75    atatat 	int name[CTL_MAXNAME];
    272   1.75    atatat 	int ch;
    273  1.134  christos 	size_t lastcompiled = 0;
    274  1.134  christos 	regex_t *re;
    275    1.1       cgd 
    276  1.134  christos 	setprogname(argv[0]);
    277   1.84    atatat 	while ((ch = getopt(argc, argv, "Aabdef:Mnqrwx")) != -1) {
    278    1.1       cgd 		switch (ch) {
    279    1.1       cgd 		case 'A':
    280   1.75    atatat 			Aflag++;
    281    1.1       cgd 			break;
    282    1.1       cgd 		case 'a':
    283   1.75    atatat 			aflag++;
    284    1.1       cgd 			break;
    285   1.84    atatat 		case 'd':
    286   1.84    atatat 			dflag++;
    287   1.84    atatat 			break;
    288   1.72     grant 		case 'e':
    289   1.75    atatat 			eq = "=";
    290   1.72     grant 			break;
    291   1.27    tsarna 		case 'f':
    292   1.27    tsarna 			fn = optarg;
    293   1.75    atatat 			wflag++;
    294   1.75    atatat 			break;
    295   1.75    atatat 		case 'M':
    296   1.75    atatat 			Mflag++;
    297   1.27    tsarna 			break;
    298    1.1       cgd 		case 'n':
    299   1.75    atatat 			nflag++;
    300    1.1       cgd 			break;
    301   1.58  sommerfe 		case 'q':
    302   1.75    atatat 			qflag++;
    303   1.75    atatat 			break;
    304   1.82    atatat 		case 'b':	/* FreeBSD compat */
    305   1.75    atatat 		case 'r':
    306   1.75    atatat 			rflag++;
    307   1.58  sommerfe 			break;
    308    1.1       cgd 		case 'w':
    309   1.75    atatat 			wflag++;
    310   1.75    atatat 			break;
    311   1.75    atatat 		case 'x':
    312   1.75    atatat 			xflag++;
    313    1.1       cgd 			break;
    314    1.1       cgd 		default:
    315    1.1       cgd 			usage();
    316    1.1       cgd 		}
    317    1.1       cgd 	}
    318   1.58  sommerfe 
    319   1.75    atatat 	argc -= optind;
    320   1.75    atatat 	argv += optind;
    321   1.75    atatat 
    322   1.75    atatat 	if (xflag && rflag)
    323   1.75    atatat 		usage();
    324   1.75    atatat 	/* if ((xflag || rflag) && wflag)
    325   1.75    atatat 		usage(); */
    326  1.136  christos 	/* if (aflag && (Mflag || qflag))
    327   1.75    atatat 		usage(); */
    328  1.136  christos 	if ((aflag || Aflag) && qflag)
    329  1.136  christos 		usage();
    330   1.84    atatat 	if ((Aflag || Mflag || dflag) && argc == 0 && fn == NULL)
    331   1.75    atatat 		aflag = 1;
    332   1.58  sommerfe 
    333  1.133     pooka 	if (prog_init && prog_init() == -1)
    334  1.133     pooka 		err(1, "prog init failed");
    335  1.133     pooka 
    336   1.75    atatat 	if (Aflag)
    337   1.75    atatat 		warnfp = stdout;
    338  1.100    atatat 	stale = req = 0;
    339    1.1       cgd 
    340  1.134  christos 	if ((re = malloc(sizeof(*re) * __arraycount(handlers))) == NULL)
    341  1.134  christos 		err(1, "malloc regex");
    342  1.134  christos 
    343   1.75    atatat 	if (aflag) {
    344  1.134  christos 		print_tree(&name[0], 0, NULL, CTLTYPE_NODE, 1,
    345  1.134  christos 		    re, &lastcompiled);
    346   1.75    atatat 		/* if (argc == 0) */
    347   1.75    atatat 		return (0);
    348    1.1       cgd 	}
    349   1.27    tsarna 
    350   1.27    tsarna 	if (fn) {
    351   1.27    tsarna 		FILE *fp;
    352   1.27    tsarna 		char *l;
    353   1.58  sommerfe 
    354   1.27    tsarna 		fp = fopen(fn, "r");
    355   1.27    tsarna 		if (fp == NULL) {
    356   1.27    tsarna 			err(1, "%s", fn);
    357   1.27    tsarna 		} else {
    358   1.92    atatat 			nr = 0;
    359   1.92    atatat 			while ((l = fparseln(fp, NULL, &nr, NULL, 0)) != NULL)
    360   1.75    atatat 			{
    361   1.75    atatat 				if (*l) {
    362  1.134  christos 					parse(l, re, &lastcompiled);
    363   1.75    atatat 					free(l);
    364   1.75    atatat 				}
    365   1.27    tsarna 			}
    366   1.27    tsarna 			fclose(fp);
    367   1.27    tsarna 		}
    368  1.121  christos 		return errs ? 1 : 0;
    369   1.27    tsarna 	}
    370   1.75    atatat 
    371   1.75    atatat 	if (argc == 0)
    372   1.75    atatat 		usage();
    373   1.75    atatat 
    374   1.75    atatat 	while (argc-- > 0)
    375  1.134  christos 		parse(*argv++, re, &lastcompiled);
    376   1.75    atatat 
    377  1.121  christos 	return errs ? 1 : 0;
    378    1.1       cgd }
    379    1.1       cgd 
    380    1.1       cgd /*
    381   1.75    atatat  * ********************************************************************
    382   1.75    atatat  * how to find someone special to handle the reading (or maybe even
    383   1.75    atatat  * writing) of a particular node
    384   1.75    atatat  * ********************************************************************
    385    1.1       cgd  */
    386   1.95  jdolecek static const struct handlespec *
    387  1.141  christos findhandler(const char *s, regex_t *re, size_t *lastcompiled)
    388   1.75    atatat {
    389   1.95  jdolecek 	const struct handlespec *p;
    390  1.134  christos 	size_t i, l;
    391  1.134  christos 	int j;
    392   1.98    atatat 	char eb[64];
    393  1.134  christos 	regmatch_t match;
    394   1.75    atatat 
    395   1.75    atatat 	p = &handlers[0];
    396   1.98    atatat 	l = strlen(s);
    397   1.98    atatat 	for (i = 0; p[i].ps_re != NULL; i++) {
    398  1.134  christos 		if (i >= *lastcompiled) {
    399  1.134  christos 			j = regcomp(&re[i], p[i].ps_re, REG_EXTENDED);
    400  1.134  christos 			if (j != 0) {
    401  1.134  christos 				regerror(j, &re[i], eb, sizeof(eb));
    402  1.134  christos 				errx(1, "regcomp: %s: %s", p[i].ps_re, eb);
    403  1.134  christos 			}
    404  1.134  christos 			*lastcompiled = i + 1;
    405   1.98    atatat 		}
    406  1.134  christos 		j = regexec(&re[i], s, 1, &match, 0);
    407   1.98    atatat 		if (j == 0) {
    408  1.141  christos 			if (match.rm_so == 0 && match.rm_eo == (int)l)
    409  1.134  christos 				return &p[i];
    410   1.98    atatat 		}
    411   1.98    atatat 		else if (j != REG_NOMATCH) {
    412  1.134  christos 			regerror(j, &re[i], eb, sizeof(eb));
    413   1.98    atatat 			errx(1, "regexec: %s: %s", p[i].ps_re, eb);
    414   1.98    atatat 		}
    415   1.75    atatat 	}
    416   1.75    atatat 
    417  1.134  christos 	return NULL;
    418   1.75    atatat }
    419   1.75    atatat 
    420   1.98    atatat /*
    421   1.98    atatat  * after sysctlgetmibinfo is done with the name, we convert all
    422   1.98    atatat  * separators to / and stuff one at the front if it was missing
    423   1.98    atatat  */
    424   1.98    atatat static void
    425   1.98    atatat canonicalize(const char *i, char *o)
    426    1.1       cgd {
    427   1.98    atatat 	const char *t;
    428   1.98    atatat 	char p[SYSCTL_NAMELEN + 1];
    429   1.98    atatat 	int l;
    430   1.98    atatat 
    431   1.98    atatat 	if (i[0] != *sep) {
    432   1.98    atatat 		o[0] = '/';
    433   1.98    atatat 		o[1] = '\0';
    434    1.1       cgd 	}
    435   1.98    atatat 	else
    436   1.98    atatat 		o[0] = '\0';
    437   1.75    atatat 
    438   1.98    atatat 	t = i;
    439   1.98    atatat 	do {
    440   1.98    atatat 		i = t;
    441   1.98    atatat 		t = strchr(i, sep[0]);
    442   1.98    atatat 		if (t == NULL)
    443   1.98    atatat 			strcat(o, i);
    444   1.98    atatat 		else {
    445   1.98    atatat 			l = t - i;
    446   1.98    atatat 			t++;
    447   1.98    atatat 			memcpy(p, i, l);
    448   1.98    atatat 			p[l] = '\0';
    449   1.98    atatat 			strcat(o, p);
    450   1.98    atatat 			strcat(o, "/");
    451   1.98    atatat 		}
    452   1.98    atatat 	} while (t != NULL);
    453    1.1       cgd }
    454    1.1       cgd 
    455    1.1       cgd /*
    456   1.75    atatat  * ********************************************************************
    457   1.75    atatat  * convert this special number to a special string so we can print the
    458   1.75    atatat  * mib
    459   1.75    atatat  * ********************************************************************
    460    1.1       cgd  */
    461   1.75    atatat static const char *
    462   1.75    atatat sf(u_int f)
    463    1.1       cgd {
    464   1.75    atatat 	static char s[256];
    465  1.104  christos 	const char *c;
    466   1.75    atatat 
    467   1.75    atatat 	s[0] = '\0';
    468   1.75    atatat 	c = "";
    469   1.75    atatat 
    470   1.75    atatat #define print_flag(_f, _s, _c, _q, _x) \
    471   1.83    atatat 	if (((_f) & (__CONCAT(CTLFLAG_,_x))) == (__CONCAT(CTLFLAG_,_q))) { \
    472   1.75    atatat 		strlcat((_s), (_c), sizeof(_s)); \
    473   1.75    atatat 		strlcat((_s), __STRING(_q), sizeof(_s)); \
    474   1.75    atatat 		(_c) = ","; \
    475   1.83    atatat 		(_f) &= ~(__CONCAT(CTLFLAG_,_x)); \
    476   1.75    atatat 	}
    477   1.83    atatat 	print_flag(f, s, c, READONLY,  READWRITE);
    478   1.83    atatat 	print_flag(f, s, c, READWRITE, READWRITE);
    479   1.83    atatat 	print_flag(f, s, c, ANYWRITE,  ANYWRITE);
    480   1.83    atatat 	print_flag(f, s, c, PRIVATE,   PRIVATE);
    481   1.83    atatat 	print_flag(f, s, c, PERMANENT, PERMANENT);
    482   1.83    atatat 	print_flag(f, s, c, OWNDATA,   OWNDATA);
    483   1.83    atatat 	print_flag(f, s, c, IMMEDIATE, IMMEDIATE);
    484   1.83    atatat 	print_flag(f, s, c, HEX,       HEX);
    485   1.83    atatat 	print_flag(f, s, c, ROOT,      ROOT);
    486   1.83    atatat 	print_flag(f, s, c, ANYNUMBER, ANYNUMBER);
    487   1.83    atatat 	print_flag(f, s, c, HIDDEN,    HIDDEN);
    488   1.83    atatat 	print_flag(f, s, c, ALIAS,     ALIAS);
    489   1.75    atatat #undef print_flag
    490   1.75    atatat 
    491   1.75    atatat 	if (f) {
    492   1.75    atatat 		char foo[9];
    493   1.75    atatat 		snprintf(foo, sizeof(foo), "%x", f);
    494   1.75    atatat 		strlcat(s, c, sizeof(s));
    495   1.75    atatat 		strlcat(s, foo, sizeof(s));
    496   1.75    atatat 	}
    497    1.1       cgd 
    498   1.75    atatat 	return (s);
    499   1.75    atatat }
    500   1.72     grant 
    501   1.75    atatat static const char *
    502   1.75    atatat st(u_int t)
    503   1.75    atatat {
    504    1.1       cgd 
    505   1.75    atatat 	switch (t) {
    506   1.75    atatat 	case CTLTYPE_NODE:
    507   1.75    atatat 		return "NODE";
    508   1.75    atatat 	case CTLTYPE_INT:
    509   1.75    atatat 		return "INT";
    510   1.75    atatat 	case CTLTYPE_STRING:
    511   1.75    atatat 		return "STRING";
    512   1.75    atatat 	case CTLTYPE_QUAD:
    513   1.75    atatat                 return "QUAD";
    514   1.75    atatat 	case CTLTYPE_STRUCT:
    515   1.75    atatat 		return "STRUCT";
    516  1.131       mrg 	case CTLTYPE_BOOL:
    517  1.131       mrg 		return "BOOL";
    518   1.75    atatat 	}
    519    1.1       cgd 
    520   1.75    atatat 	return "???";
    521   1.75    atatat }
    522   1.46       chs 
    523   1.75    atatat /*
    524   1.75    atatat  * ********************************************************************
    525  1.100    atatat  * recursively eliminate all data belonging to the given node
    526  1.100    atatat  * ********************************************************************
    527  1.100    atatat  */
    528  1.100    atatat static void
    529  1.100    atatat purge_tree(struct sysctlnode *rnode)
    530  1.100    atatat {
    531  1.100    atatat 	struct sysctlnode *node;
    532  1.100    atatat 
    533  1.100    atatat 	if (rnode == NULL ||
    534  1.100    atatat 	    SYSCTL_TYPE(rnode->sysctl_flags) != CTLTYPE_NODE ||
    535  1.100    atatat 	    rnode->sysctl_child == NULL)
    536  1.100    atatat 		return;
    537  1.100    atatat 
    538  1.100    atatat 	for (node = rnode->sysctl_child;
    539  1.100    atatat 	     node < &rnode->sysctl_child[rnode->sysctl_clen];
    540  1.100    atatat 	     node++)
    541  1.100    atatat 		purge_tree(node);
    542  1.100    atatat 	free(rnode->sysctl_child);
    543  1.100    atatat 	rnode->sysctl_csize = 0;
    544  1.100    atatat 	rnode->sysctl_clen = 0;
    545  1.100    atatat 	rnode->sysctl_child = NULL;
    546  1.100    atatat 
    547  1.100    atatat 	if (rnode->sysctl_desc == (const char*)-1)
    548  1.100    atatat 		rnode->sysctl_desc = NULL;
    549  1.100    atatat 	if (rnode->sysctl_desc != NULL)
    550  1.104  christos 		free(__UNCONST(rnode->sysctl_desc));
    551  1.100    atatat 	rnode->sysctl_desc = NULL;
    552  1.100    atatat }
    553  1.100    atatat 
    554  1.137  christos static void __attribute__((__format__(__printf__, 3, 4)))
    555  1.137  christos appendprintf(char **bp, size_t *lbp, const char *fmt, ...)
    556  1.137  christos {
    557  1.137  christos 	int r;
    558  1.137  christos 	va_list ap;
    559  1.137  christos 
    560  1.137  christos 	va_start(ap, fmt);
    561  1.137  christos 	r = vsnprintf(*bp, *lbp, fmt, ap);
    562  1.137  christos 	va_end(ap);
    563  1.137  christos 	if (r < 0 || (size_t)r > *lbp)
    564  1.137  christos 		r = *lbp;
    565  1.137  christos 	*bp += r;
    566  1.137  christos 	*lbp -= r;
    567  1.137  christos }
    568  1.137  christos 
    569  1.100    atatat /*
    570  1.100    atatat  * ********************************************************************
    571   1.75    atatat  * print this node and any others underneath it
    572   1.75    atatat  * ********************************************************************
    573   1.75    atatat  */
    574   1.75    atatat static void
    575   1.75    atatat print_tree(int *name, u_int namelen, struct sysctlnode *pnode, u_int type,
    576  1.134  christos    int add, regex_t *re, size_t *lastcompiled)
    577   1.75    atatat {
    578   1.75    atatat 	struct sysctlnode *node;
    579  1.128     lukem 	int rc;
    580  1.137  christos 	size_t ni, sz, ldp, lsp;
    581  1.137  christos 	char *sp, *dp, *tsp, *tdp;
    582   1.95  jdolecek 	const struct handlespec *p;
    583   1.75    atatat 
    584  1.137  christos 	sp = tsp = &gsname[strlen(gsname)];
    585  1.137  christos 	dp = tdp = &gdname[strlen(gdname)];
    586  1.137  christos 	ldp = sizeof(gdname) - (dp - gdname);
    587  1.137  christos 	lsp = sizeof(gsname) - (sp - gsname);
    588   1.75    atatat 
    589   1.75    atatat 	if (sp != &gsname[0] && dp == &gdname[0]) {
    590   1.75    atatat 		/*
    591   1.75    atatat 		 * aw...shucks.  now we must play catch up
    592   1.75    atatat 		 */
    593  1.137  christos 		for (ni = 0; ni < namelen; ni++)
    594  1.137  christos 			appendprintf(&tdp, &ldp, "%s%d", ni > 0 ? "." : "",
    595  1.137  christos 			    name[ni]);
    596   1.75    atatat 	}
    597    1.1       cgd 
    598   1.75    atatat 	if (pnode == NULL)
    599   1.75    atatat 		pnode = &my_root;
    600   1.75    atatat 	else if (add) {
    601  1.137  christos 		appendprintf(&tsp, &lsp, "%s%s", namelen > 1 ? sep : "",
    602  1.137  christos 			pnode->sysctl_name);
    603  1.137  christos 		appendprintf(&tdp, &ldp, "%s%d", namelen > 1 ? "." : "",
    604  1.137  christos 			pnode->sysctl_num);
    605   1.75    atatat 	}
    606   1.75    atatat 
    607   1.75    atatat 	if (Mflag && pnode != &my_root) {
    608   1.75    atatat 		if (nflag)
    609   1.75    atatat 			printf("%s: ", gdname);
    610   1.75    atatat 		else
    611   1.75    atatat 			printf("%s (%s): ", gsname, gdname);
    612   1.75    atatat 		printf("CTLTYPE_%s", st(type));
    613   1.75    atatat 		if (type == CTLTYPE_NODE) {
    614   1.83    atatat 			if (SYSCTL_FLAGS(pnode->sysctl_flags) & CTLFLAG_ALIAS)
    615   1.75    atatat 				printf(", alias %d",
    616   1.75    atatat 				       pnode->sysctl_alias);
    617   1.75    atatat 			else
    618   1.75    atatat 				printf(", children %d/%d",
    619   1.75    atatat 				       pnode->sysctl_clen,
    620   1.75    atatat 				       pnode->sysctl_csize);
    621   1.75    atatat 		}
    622   1.75    atatat 		printf(", size %zu", pnode->sysctl_size);
    623   1.75    atatat 		printf(", flags 0x%x<%s>",
    624   1.75    atatat 		       SYSCTL_FLAGS(pnode->sysctl_flags),
    625   1.75    atatat 		       sf(SYSCTL_FLAGS(pnode->sysctl_flags)));
    626   1.75    atatat 		if (pnode->sysctl_func)
    627   1.75    atatat 			printf(", func=%p", pnode->sysctl_func);
    628   1.75    atatat 		printf(", ver=%d", pnode->sysctl_ver);
    629   1.75    atatat 		printf("\n");
    630   1.75    atatat 		if (type != CTLTYPE_NODE) {
    631   1.75    atatat 			*sp = *dp = '\0';
    632    1.1       cgd 			return;
    633    1.1       cgd 		}
    634   1.75    atatat 	}
    635   1.75    atatat 
    636   1.84    atatat 	if (dflag && pnode != &my_root) {
    637   1.84    atatat 		if (Aflag || type != CTLTYPE_NODE) {
    638   1.84    atatat 			if (pnode->sysctl_desc == NULL)
    639   1.84    atatat 				getdesc1(name, namelen, pnode);
    640   1.91    atatat 			if (Aflag || !add ||
    641   1.84    atatat 			    (pnode->sysctl_desc != NULL &&
    642   1.84    atatat 			     pnode->sysctl_desc != (const char*)-1)) {
    643   1.84    atatat 				if (!nflag)
    644   1.84    atatat 					printf("%s: ", gsname);
    645   1.84    atatat 				if (pnode->sysctl_desc == NULL ||
    646   1.84    atatat 				    pnode->sysctl_desc == (const char*)-1)
    647   1.84    atatat 					printf("(no description)\n");
    648   1.84    atatat 				else
    649   1.84    atatat 					printf("%s\n", pnode->sysctl_desc);
    650   1.84    atatat 			}
    651   1.84    atatat 		}
    652   1.84    atatat 
    653   1.84    atatat 		if (type != CTLTYPE_NODE) {
    654   1.84    atatat 			*sp = *dp = '\0';
    655   1.84    atatat 			return;
    656   1.84    atatat 		}
    657   1.84    atatat 	}
    658   1.84    atatat 
    659   1.75    atatat 	/*
    660   1.75    atatat 	 * if this is an alias and we added our name, that means we
    661   1.75    atatat 	 * got here by recursing down into the tree, so skip it.  The
    662   1.75    atatat 	 * only way to print an aliased node is with either -M or by
    663   1.75    atatat 	 * name specifically.
    664   1.75    atatat 	 */
    665   1.83    atatat 	if (SYSCTL_FLAGS(pnode->sysctl_flags) & CTLFLAG_ALIAS && add) {
    666   1.75    atatat 		*sp = *dp = '\0';
    667    1.1       cgd 		return;
    668   1.75    atatat 	}
    669    1.1       cgd 
    670   1.98    atatat 	canonicalize(gsname, canonname);
    671  1.141  christos 	p = findhandler(canonname, re, lastcompiled);
    672   1.75    atatat 	if (type != CTLTYPE_NODE && p != NULL) {
    673  1.141  christos 		if (p->ps_p == NULL) {
    674  1.141  christos 			sysctlperror("Cannot print `%s': %s\n", gsname,
    675  1.141  christos 			    strerror(EOPNOTSUPP));
    676  1.141  christos 			exit(1);
    677  1.141  christos 		}
    678   1.75    atatat 		(*p->ps_p)(gsname, gdname, NULL, name, namelen, pnode, type,
    679  1.104  christos 			   __UNCONST(p->ps_d));
    680   1.75    atatat 		*sp = *dp = '\0';
    681   1.75    atatat 		return;
    682   1.75    atatat 	}
    683    1.1       cgd 
    684   1.75    atatat 	if (type != CTLTYPE_NODE && pnode->sysctl_size == 0) {
    685  1.133     pooka 		rc = prog_sysctl(&name[0], namelen, NULL, &sz, NULL, 0);
    686   1.75    atatat 		if (rc == -1) {
    687   1.75    atatat 			sysctlerror(1);
    688   1.75    atatat 			*sp = *dp = '\0';
    689   1.18   thorpej 			return;
    690   1.75    atatat 		}
    691   1.75    atatat 		if (sz == 0) {
    692   1.75    atatat 			if ((Aflag || req) && !Mflag)
    693   1.75    atatat 				printf("%s: node contains no data\n", gsname);
    694   1.75    atatat 			*sp = *dp = '\0';
    695   1.18   thorpej 			return;
    696   1.18   thorpej 		}
    697   1.75    atatat 	}
    698   1.75    atatat 	else
    699   1.75    atatat 		sz = pnode->sysctl_size;
    700   1.17   thorpej 
    701   1.75    atatat 	switch (type) {
    702   1.75    atatat 	case CTLTYPE_NODE: {
    703   1.85    atatat 		__learn_tree(name, namelen, pnode);
    704   1.75    atatat 		node = pnode->sysctl_child;
    705   1.75    atatat 		if (node == NULL) {
    706   1.88    atatat 			if (dflag)
    707   1.88    atatat 				/* do nothing */;
    708   1.88    atatat 			else if (p != NULL)
    709   1.75    atatat 				(*p->ps_p)(gsname, gdname, NULL, name, namelen,
    710  1.104  christos 					   pnode, type, __UNCONST(p->ps_d));
    711   1.88    atatat 			else if ((Aflag || req) && !Mflag)
    712   1.75    atatat 				printf("%s: no children\n", gsname);
    713   1.75    atatat 		}
    714   1.75    atatat 		else {
    715   1.84    atatat 			if (dflag)
    716   1.84    atatat 				/*
    717   1.84    atatat 				 * get all descriptions for next level
    718   1.84    atatat 				 * in one chunk
    719   1.84    atatat 				 */
    720   1.84    atatat 				getdesc(name, namelen, pnode);
    721   1.75    atatat 			req = 0;
    722   1.75    atatat 			for (ni = 0; ni < pnode->sysctl_clen; ni++) {
    723   1.75    atatat 				name[namelen] = node[ni].sysctl_num;
    724   1.83    atatat 				if ((node[ni].sysctl_flags & CTLFLAG_HIDDEN) &&
    725   1.75    atatat 				    !(Aflag || req))
    726   1.75    atatat 					continue;
    727   1.75    atatat 				print_tree(name, namelen + 1, &node[ni],
    728   1.75    atatat 					   SYSCTL_TYPE(node[ni].sysctl_flags),
    729  1.134  christos 					   1, re, lastcompiled);
    730   1.75    atatat 			}
    731   1.75    atatat 		}
    732    1.1       cgd 		break;
    733   1.75    atatat 	}
    734   1.75    atatat 	case CTLTYPE_INT: {
    735   1.75    atatat 		int i;
    736  1.133     pooka 		rc = prog_sysctl(name, namelen, &i, &sz, NULL, 0);
    737   1.75    atatat 		if (rc == -1) {
    738   1.75    atatat 			sysctlerror(1);
    739   1.75    atatat 			break;
    740   1.75    atatat 		}
    741   1.75    atatat 		display_number(pnode, gsname, &i, sizeof(i), DISPLAY_VALUE);
    742   1.22    bouyer 		break;
    743   1.75    atatat 	}
    744  1.131       mrg 	case CTLTYPE_BOOL: {
    745  1.131       mrg 		bool b;
    746  1.133     pooka 		rc = prog_sysctl(name, namelen, &b, &sz, NULL, 0);
    747  1.131       mrg 		if (rc == -1) {
    748  1.131       mrg 			sysctlerror(1);
    749  1.131       mrg 			break;
    750  1.131       mrg 		}
    751  1.131       mrg 		display_number(pnode, gsname, &b, sizeof(b), DISPLAY_VALUE);
    752  1.131       mrg 		break;
    753  1.131       mrg 	}
    754   1.75    atatat 	case CTLTYPE_STRING: {
    755   1.75    atatat 		unsigned char buf[1024], *tbuf;
    756   1.75    atatat 		tbuf = buf;
    757   1.75    atatat 		sz = sizeof(buf);
    758  1.133     pooka 		rc = prog_sysctl(&name[0], namelen, tbuf, &sz, NULL, 0);
    759   1.75    atatat 		if (rc == -1 && errno == ENOMEM) {
    760   1.75    atatat 			tbuf = malloc(sz);
    761   1.75    atatat 			if (tbuf == NULL) {
    762   1.75    atatat 				sysctlerror(1);
    763   1.75    atatat 				break;
    764   1.75    atatat 			}
    765  1.133     pooka 			rc = prog_sysctl(&name[0], namelen, tbuf, &sz, NULL, 0);
    766   1.56  christos 		}
    767   1.75    atatat 		if (rc == -1)
    768   1.75    atatat 			sysctlerror(1);
    769   1.75    atatat 		else
    770   1.96    atatat 			display_string(pnode, gsname, tbuf, sz, DISPLAY_VALUE);
    771   1.75    atatat 		if (tbuf != buf)
    772   1.75    atatat 			free(tbuf);
    773   1.56  christos 		break;
    774    1.1       cgd 	}
    775   1.75    atatat 	case CTLTYPE_QUAD: {
    776   1.75    atatat 		u_quad_t q;
    777   1.75    atatat 		sz = sizeof(q);
    778  1.133     pooka 		rc = prog_sysctl(&name[0], namelen, &q, &sz, NULL, 0);
    779   1.75    atatat 		if (rc == -1) {
    780   1.75    atatat 			sysctlerror(1);
    781   1.75    atatat 			break;
    782   1.75    atatat 		}
    783   1.75    atatat 		display_number(pnode, gsname, &q, sizeof(q), DISPLAY_VALUE);
    784   1.75    atatat 		break;
    785    1.1       cgd 	}
    786   1.75    atatat 	case CTLTYPE_STRUCT: {
    787   1.75    atatat 		/*
    788   1.75    atatat 		 * we shouldn't actually get here, but if we
    789   1.75    atatat 		 * do, would it be nice to have *something* to
    790   1.75    atatat 		 * do other than completely ignore the
    791   1.75    atatat 		 * request.
    792   1.75    atatat 		 */
    793   1.75    atatat 		unsigned char *d;
    794   1.75    atatat 		if ((d = malloc(sz)) == NULL) {
    795   1.75    atatat 			fprintf(warnfp, "%s: !malloc failed!\n", gsname);
    796    1.1       cgd 			break;
    797   1.75    atatat 		}
    798  1.133     pooka 		rc = prog_sysctl(&name[0], namelen, d, &sz, NULL, 0);
    799   1.75    atatat 		if (rc == -1) {
    800   1.75    atatat 			sysctlerror(1);
    801    1.1       cgd 			break;
    802    1.1       cgd 		}
    803   1.75    atatat 		display_struct(pnode, gsname, d, sz, DISPLAY_VALUE);
    804   1.75    atatat 		free(d);
    805   1.75    atatat 		break;
    806    1.1       cgd 	}
    807   1.75    atatat 	default:
    808   1.75    atatat 		/* should i print an error here? */
    809   1.75    atatat 		break;
    810   1.75    atatat 	}
    811   1.75    atatat 
    812   1.75    atatat 	*sp = *dp = '\0';
    813   1.75    atatat }
    814   1.75    atatat 
    815   1.75    atatat /*
    816   1.75    atatat  * ********************************************************************
    817   1.75    atatat  * parse a request, possibly determining that it's a create or destroy
    818   1.75    atatat  * request
    819   1.75    atatat  * ********************************************************************
    820   1.75    atatat  */
    821   1.75    atatat static void
    822  1.134  christos parse(char *l, regex_t *re, size_t *lastcompiled)
    823   1.75    atatat {
    824   1.75    atatat 	struct sysctlnode *node;
    825   1.95  jdolecek 	const struct handlespec *w;
    826   1.84    atatat 	int name[CTL_MAXNAME], dodesc = 0;
    827   1.75    atatat 	u_int namelen, type;
    828   1.75    atatat 	char *key, *value, *dot;
    829   1.75    atatat 	size_t sz;
    830  1.129  christos 	bool optional = false;
    831   1.75    atatat 
    832   1.75    atatat 	req = 1;
    833   1.75    atatat 	key = l;
    834  1.129  christos 
    835  1.129  christos 	if ((value = strchr(l, '=')) != NULL) {
    836  1.129  christos 		if (value > l && value[-1] == '?') {
    837  1.129  christos 			value[-1] = '\0';
    838  1.129  christos 			optional = true;
    839  1.129  christos 		}
    840   1.75    atatat 		*value++ = '\0';
    841  1.129  christos 	}
    842    1.1       cgd 
    843   1.75    atatat 	if ((dot = strpbrk(key, "./")) == NULL)
    844   1.75    atatat 		sep[0] = '.';
    845   1.75    atatat 	else
    846   1.75    atatat 		sep[0] = dot[0];
    847   1.75    atatat 	sep[1] = '\0';
    848    1.1       cgd 
    849   1.82    atatat 	while (key[0] == sep[0] && key[1] == sep[0]) {
    850   1.75    atatat 		if (value != NULL)
    851   1.75    atatat 			value[-1] = '=';
    852   1.82    atatat 		if (strncmp(key + 2, "create", 6) == 0 &&
    853   1.82    atatat 		    (key[8] == '=' || key[8] == sep[0]))
    854   1.92    atatat 			parse_create(key + 8 + (key[8] == '=' ? 1 : 0));
    855   1.82    atatat 		else if (strncmp(key + 2, "destroy", 7) == 0 &&
    856   1.82    atatat 			 (key[9] == '=' || key[9] == sep[0]))
    857   1.92    atatat 			parse_destroy(key + 9 + (key[9] == '=' ? 1 : 0));
    858   1.84    atatat 		else if (strncmp(key + 2, "describe", 8) == 0 &&
    859   1.84    atatat 			 (key[10] == '=' || key[10] == sep[0])) {
    860   1.84    atatat 			key += 10 + (key[10] == '=');
    861   1.84    atatat 			if ((value = strchr(key, '=')) != NULL)
    862   1.84    atatat 				parse_describe(key);
    863   1.84    atatat 			else {
    864   1.84    atatat 				if (!dflag)
    865   1.84    atatat 					dodesc = 1;
    866   1.84    atatat 				break;
    867   1.84    atatat 			}
    868   1.84    atatat 		}
    869    1.1       cgd 		else
    870   1.92    atatat 			sysctlperror("unable to parse '%s'\n", key);
    871   1.32    simonb 		return;
    872   1.32    simonb 	}
    873   1.32    simonb 
    874  1.100    atatat 	if (stale) {
    875  1.100    atatat 		purge_tree(&my_root);
    876  1.100    atatat 		stale = 0;
    877  1.100    atatat 	}
    878   1.75    atatat 	node = &my_root;
    879   1.75    atatat 	namelen = CTL_MAXNAME;
    880   1.75    atatat 	sz = sizeof(gsname);
    881   1.75    atatat 
    882   1.83    atatat 	if (sysctlgetmibinfo(key, &name[0], &namelen, gsname, &sz, &node,
    883   1.83    atatat 			     SYSCTL_VERSION) == -1) {
    884  1.129  christos 		if (optional)
    885  1.129  christos 			return;
    886   1.92    atatat 		sysctlparseerror(namelen, l);
    887   1.92    atatat 		EXIT(1);
    888   1.75    atatat 	}
    889   1.75    atatat 
    890   1.75    atatat 	type = SYSCTL_TYPE(node->sysctl_flags);
    891   1.75    atatat 
    892   1.75    atatat 	if (value == NULL) {
    893   1.84    atatat 		if (dodesc)
    894   1.84    atatat 			dflag = 1;
    895  1.134  christos 		print_tree(&name[0], namelen, node, type, 0, re, lastcompiled);
    896   1.84    atatat 		if (dodesc)
    897   1.84    atatat 			dflag = 0;
    898   1.75    atatat 		gsname[0] = '\0';
    899   1.69       dsl 		return;
    900   1.69       dsl 	}
    901   1.69       dsl 
    902   1.92    atatat 	if (fn)
    903   1.92    atatat 		trim_whitespace(value, 1);
    904   1.92    atatat 
    905   1.82    atatat 	if (!wflag) {
    906   1.92    atatat 		sysctlperror("Must specify -w to set variables\n");
    907   1.82    atatat 		exit(1);
    908   1.82    atatat 	}
    909   1.82    atatat 
    910   1.98    atatat 	canonicalize(gsname, canonname);
    911  1.141  christos 	if (type != CTLTYPE_NODE && (w = findhandler(canonname, re,
    912  1.134  christos 	    lastcompiled)) != NULL) {
    913  1.141  christos 		if (w->ps_w == NULL) {
    914  1.141  christos 			sysctlperror("Cannot write `%s': %s\n", gsname,
    915  1.141  christos 			    strerror(EOPNOTSUPP));
    916  1.141  christos 			exit(1);
    917  1.141  christos 		}
    918   1.75    atatat 		(*w->ps_w)(gsname, gdname, value, name, namelen, node, type,
    919  1.104  christos 			   __UNCONST(w->ps_d));
    920   1.75    atatat 		gsname[0] = '\0';
    921   1.26      fvdl 		return;
    922   1.26      fvdl 	}
    923   1.58  sommerfe 
    924    1.1       cgd 	switch (type) {
    925   1.75    atatat 	case CTLTYPE_NODE:
    926   1.75    atatat 		/*
    927   1.75    atatat 		 * XXX old behavior is to print.  should we error instead?
    928   1.75    atatat 		 */
    929  1.134  christos 		print_tree(&name[0], namelen, node, CTLTYPE_NODE, 1, re,
    930  1.134  christos 		    lastcompiled);
    931   1.75    atatat 		break;
    932    1.1       cgd 	case CTLTYPE_INT:
    933  1.131       mrg 	case CTLTYPE_BOOL:
    934  1.131       mrg 	case CTLTYPE_QUAD:
    935   1.75    atatat 		write_number(&name[0], namelen, node, value);
    936   1.75    atatat 		break;
    937    1.1       cgd 	case CTLTYPE_STRING:
    938   1.75    atatat 		write_string(&name[0], namelen, node, value);
    939   1.75    atatat 		break;
    940   1.75    atatat 	case CTLTYPE_STRUCT:
    941   1.75    atatat 		/*
    942   1.75    atatat 		 * XXX old behavior is to print.  should we error instead?
    943   1.75    atatat 		 */
    944   1.75    atatat 		/* fprintf(warnfp, "you can't write to %s\n", gsname); */
    945  1.134  christos 		print_tree(&name[0], namelen, node, type, 0, re, lastcompiled);
    946   1.75    atatat 		break;
    947   1.75    atatat 	}
    948   1.75    atatat }
    949   1.75    atatat 
    950   1.75    atatat /*
    951   1.75    atatat 
    952   1.75    atatat   //create=foo.bar.whatever...,
    953   1.75    atatat   [type=(int|quad|string|struct|node),]
    954   1.75    atatat   [size=###,]
    955   1.75    atatat   [n=###,]
    956   1.82    atatat   [flags=(iohxparw12),]
    957   1.75    atatat   [addr=0x####,|symbol=...|value=...]
    958   1.75    atatat 
    959   1.75    atatat   size is optional for some types.  type must be set before anything
    960  1.130      elad   else.  nodes can have [rwhp], but nothing else applies.  if no
    961   1.75    atatat   size or type is given, node is asserted.  writeable is the default,
    962  1.130      elad   with [rw] being read-only and unconditionally writeable
    963   1.75    atatat   respectively.  if you specify addr, it is assumed to be the name of
    964   1.83    atatat   a kernel symbol, if value, CTLFLAG_OWNDATA will be asserted for
    965   1.83    atatat   strings, CTLFLAG_IMMEDIATE for ints and u_quad_ts.  you cannot
    966   1.75    atatat   specify both value and addr.
    967   1.75    atatat 
    968   1.75    atatat */
    969   1.75    atatat 
    970   1.75    atatat static void
    971   1.82    atatat parse_create(char *l)
    972   1.75    atatat {
    973   1.75    atatat 	struct sysctlnode node;
    974   1.75    atatat 	size_t sz;
    975   1.75    atatat 	char *nname, *key, *value, *data, *addr, *c, *t;
    976   1.75    atatat 	int name[CTL_MAXNAME], i, rc, method, flags, rw;
    977   1.75    atatat 	u_int namelen, type;
    978   1.92    atatat 	u_quad_t uq;
    979   1.92    atatat 	quad_t q;
    980  1.131       mrg 	bool b;
    981   1.75    atatat 
    982   1.82    atatat 	if (!wflag) {
    983   1.92    atatat 		sysctlperror("Must specify -w to create nodes\n");
    984   1.82    atatat 		exit(1);
    985   1.82    atatat 	}
    986   1.82    atatat 
    987   1.75    atatat 	/*
    988   1.75    atatat 	 * these are the pieces that make up the description of a new
    989   1.75    atatat 	 * node
    990   1.75    atatat 	 */
    991   1.75    atatat 	memset(&node, 0, sizeof(node));
    992   1.75    atatat 	node.sysctl_num = CTL_CREATE;  /* any number is fine */
    993   1.75    atatat 	flags = 0;
    994   1.75    atatat 	rw = -1;
    995   1.75    atatat 	type = 0;
    996   1.75    atatat 	sz = 0;
    997   1.75    atatat 	data = addr = NULL;
    998   1.75    atatat 	memset(name, 0, sizeof(name));
    999   1.75    atatat 	namelen = 0;
   1000   1.75    atatat 	method = 0;
   1001   1.75    atatat 
   1002   1.75    atatat 	/*
   1003   1.75    atatat 	 * misc stuff used when constructing
   1004   1.75    atatat 	 */
   1005   1.75    atatat 	i = 0;
   1006  1.131       mrg 	b = false;
   1007   1.92    atatat 	uq = 0;
   1008   1.75    atatat 	key = NULL;
   1009   1.75    atatat 	value = NULL;
   1010   1.75    atatat 
   1011   1.75    atatat 	/*
   1012   1.75    atatat 	 * the name of the thing we're trying to create is first, so
   1013   1.75    atatat 	 * pick it off.
   1014   1.75    atatat 	 */
   1015   1.75    atatat 	nname = l;
   1016   1.75    atatat 	if ((c = strchr(nname, ',')) != NULL)
   1017   1.75    atatat 		*c++ = '\0';
   1018   1.75    atatat 
   1019   1.75    atatat 	while (c != NULL) {
   1020   1.75    atatat 
   1021   1.75    atatat 		/*
   1022   1.75    atatat 		 * pull off the next "key=value" pair
   1023   1.75    atatat 		 */
   1024   1.75    atatat 		key = c;
   1025   1.75    atatat 		if ((t = strchr(key, '=')) != NULL) {
   1026   1.75    atatat 			*t++ = '\0';
   1027   1.75    atatat 			value = t;
   1028   1.75    atatat 		}
   1029   1.75    atatat 		else
   1030   1.75    atatat 			value = NULL;
   1031   1.75    atatat 
   1032   1.75    atatat 		/*
   1033   1.75    atatat 		 * if the "key" is "value", then that eats the rest of
   1034   1.75    atatat 		 * the string, so we're done, otherwise bite it off at
   1035   1.75    atatat 		 * the next comma.
   1036   1.75    atatat 		 */
   1037   1.75    atatat 		if (strcmp(key, "value") == 0) {
   1038   1.75    atatat 			c = NULL;
   1039   1.75    atatat 			data = value;
   1040   1.75    atatat 			break;
   1041   1.75    atatat 		}
   1042  1.112  christos 		else if (value) {
   1043   1.75    atatat 			if ((c = strchr(value, ',')) != NULL)
   1044   1.75    atatat 				*c++ = '\0';
   1045   1.75    atatat 		}
   1046   1.75    atatat 
   1047   1.75    atatat 		/*
   1048  1.133     pooka 		 * note that we (mostly) let the invoker of prog_sysctl(8)
   1049   1.75    atatat 		 * play rampant here and depend on the kernel to tell
   1050   1.75    atatat 		 * them that they were wrong.  well...within reason.
   1051   1.75    atatat 		 * we later check the various parameters against each
   1052   1.75    atatat 		 * other to make sure it makes some sort of sense.
   1053   1.75    atatat 		 */
   1054   1.75    atatat 		if (strcmp(key, "addr") == 0) {
   1055   1.75    atatat 			/*
   1056   1.75    atatat 			 * we can't check these two.  only the kernel
   1057   1.75    atatat 			 * can tell us when it fails to find the name
   1058   1.75    atatat 			 * (or if the address is invalid).
   1059   1.75    atatat 			 */
   1060   1.75    atatat 			if (method != 0) {
   1061   1.92    atatat 				sysctlperror(
   1062   1.92    atatat 				    "%s: already have %s for new node\n",
   1063   1.92    atatat 				    nname,
   1064   1.75    atatat 				    method == CTL_CREATE ? "addr" : "symbol");
   1065   1.92    atatat 				EXIT(1);
   1066   1.75    atatat 			}
   1067  1.113  christos 			if (value == NULL) {
   1068  1.113  christos 				sysctlperror("%s: missing value\n", nname);
   1069  1.113  christos 				EXIT(1);
   1070  1.113  christos 			}
   1071  1.114  christos 			errno = 0;
   1072   1.75    atatat 			addr = (void*)strtoul(value, &t, 0);
   1073   1.94    atatat 			if (t == value || *t != '\0' || errno != 0) {
   1074   1.92    atatat 				sysctlperror(
   1075   1.92    atatat 				    "%s: '%s' is not a valid address\n",
   1076   1.92    atatat 				    nname, value);
   1077   1.92    atatat 				EXIT(1);
   1078   1.75    atatat 			}
   1079   1.75    atatat 			method = CTL_CREATE;
   1080   1.75    atatat 		}
   1081   1.75    atatat 		else if (strcmp(key, "symbol") == 0) {
   1082   1.75    atatat 			if (method != 0) {
   1083   1.92    atatat 				sysctlperror(
   1084   1.92    atatat 				    "%s: already have %s for new node\n",
   1085   1.92    atatat 				    nname,
   1086   1.75    atatat 				    method == CTL_CREATE ? "addr" : "symbol");
   1087   1.92    atatat 				EXIT(1);
   1088   1.75    atatat 			}
   1089   1.75    atatat 			addr = value;
   1090   1.75    atatat 			method = CTL_CREATESYM;
   1091   1.75    atatat 		}
   1092   1.75    atatat 		else if (strcmp(key, "type") == 0) {
   1093  1.114  christos 			if (value == NULL) {
   1094  1.114  christos 				sysctlperror("%s: missing value\n", nname);
   1095  1.114  christos 				EXIT(1);
   1096  1.114  christos 			}
   1097   1.75    atatat 			if (strcmp(value, "node") == 0)
   1098   1.75    atatat 				type = CTLTYPE_NODE;
   1099   1.75    atatat 			else if (strcmp(value, "int") == 0) {
   1100   1.75    atatat 				sz = sizeof(int);
   1101   1.75    atatat 				type = CTLTYPE_INT;
   1102   1.75    atatat 			}
   1103  1.131       mrg 			else if (strcmp(value, "bool") == 0) {
   1104  1.131       mrg 				sz = sizeof(bool);
   1105  1.131       mrg 				type = CTLTYPE_BOOL;
   1106  1.131       mrg 			}
   1107   1.75    atatat 			else if (strcmp(value, "string") == 0)
   1108   1.75    atatat 				type = CTLTYPE_STRING;
   1109   1.75    atatat 			else if (strcmp(value, "quad") == 0) {
   1110   1.75    atatat 				sz = sizeof(u_quad_t);
   1111   1.75    atatat 				type = CTLTYPE_QUAD;
   1112   1.75    atatat 			}
   1113   1.75    atatat 			else if (strcmp(value, "struct") == 0)
   1114   1.75    atatat 				type = CTLTYPE_STRUCT;
   1115   1.75    atatat 			else {
   1116   1.92    atatat 				sysctlperror(
   1117   1.92    atatat 					"%s: '%s' is not a valid type\n",
   1118   1.92    atatat 					nname, value);
   1119   1.92    atatat 				EXIT(1);
   1120   1.75    atatat 			}
   1121   1.75    atatat 		}
   1122   1.75    atatat 		else if (strcmp(key, "size") == 0) {
   1123  1.115   jnemeth 			if (value == NULL) {
   1124  1.115   jnemeth 				sysctlperror("%s: missing value\n", nname);
   1125  1.115   jnemeth 				EXIT(1);
   1126  1.115   jnemeth 			}
   1127   1.75    atatat 			errno = 0;
   1128   1.75    atatat 			/*
   1129   1.75    atatat 			 * yes, i know size_t is not an unsigned long,
   1130   1.75    atatat 			 * but we can all agree that it ought to be,
   1131   1.75    atatat 			 * right?
   1132   1.75    atatat 			 */
   1133   1.75    atatat 			sz = strtoul(value, &t, 0);
   1134   1.94    atatat 			if (t == value || *t != '\0' || errno != 0) {
   1135   1.92    atatat 				sysctlperror(
   1136   1.92    atatat 					"%s: '%s' is not a valid size\n",
   1137   1.92    atatat 					nname, value);
   1138   1.92    atatat 				EXIT(1);
   1139   1.75    atatat 			}
   1140   1.75    atatat 		}
   1141   1.75    atatat 		else if (strcmp(key, "n") == 0) {
   1142  1.114  christos 			if (value == NULL) {
   1143  1.114  christos 				sysctlperror("%s: missing value\n", nname);
   1144  1.114  christos 				EXIT(1);
   1145  1.114  christos 			}
   1146   1.75    atatat 			errno = 0;
   1147  1.110  christos 			q = strtoll(value, &t, 0);
   1148   1.94    atatat 			if (t == value || *t != '\0' || errno != 0 ||
   1149   1.92    atatat 			    q < INT_MIN || q > UINT_MAX) {
   1150   1.92    atatat 				sysctlperror(
   1151   1.92    atatat 				    "%s: '%s' is not a valid mib number\n",
   1152   1.92    atatat 				    nname, value);
   1153   1.92    atatat 				EXIT(1);
   1154   1.75    atatat 			}
   1155   1.92    atatat 			node.sysctl_num = (int)q;
   1156   1.75    atatat 		}
   1157   1.75    atatat 		else if (strcmp(key, "flags") == 0) {
   1158  1.114  christos 			if (value == NULL) {
   1159  1.114  christos 				sysctlperror("%s: missing value\n", nname);
   1160  1.114  christos 				EXIT(1);
   1161  1.114  christos 			}
   1162   1.75    atatat 			t = value;
   1163   1.75    atatat 			while (*t != '\0') {
   1164   1.75    atatat 				switch (*t) {
   1165   1.75    atatat 				case 'a':
   1166   1.83    atatat 					flags |= CTLFLAG_ANYWRITE;
   1167   1.75    atatat 					break;
   1168   1.75    atatat 				case 'h':
   1169   1.83    atatat 					flags |= CTLFLAG_HIDDEN;
   1170   1.75    atatat 					break;
   1171   1.75    atatat 				case 'i':
   1172   1.83    atatat 					flags |= CTLFLAG_IMMEDIATE;
   1173   1.75    atatat 					break;
   1174   1.75    atatat 				case 'o':
   1175   1.83    atatat 					flags |= CTLFLAG_OWNDATA;
   1176   1.75    atatat 					break;
   1177   1.75    atatat 				case 'p':
   1178   1.83    atatat 					flags |= CTLFLAG_PRIVATE;
   1179   1.75    atatat 					break;
   1180   1.75    atatat 				case 'x':
   1181   1.83    atatat 					flags |= CTLFLAG_HEX;
   1182   1.75    atatat 					break;
   1183   1.75    atatat 
   1184   1.75    atatat 				case 'r':
   1185   1.83    atatat 					rw = CTLFLAG_READONLY;
   1186   1.75    atatat 					break;
   1187   1.75    atatat 				case 'w':
   1188   1.83    atatat 					rw = CTLFLAG_READWRITE;
   1189   1.75    atatat 					break;
   1190   1.75    atatat 				default:
   1191   1.92    atatat 					sysctlperror(
   1192   1.92    atatat 					   "%s: '%c' is not a valid flag\n",
   1193   1.92    atatat 					    nname, *t);
   1194   1.92    atatat 					EXIT(1);
   1195   1.75    atatat 				}
   1196   1.75    atatat 				t++;
   1197   1.75    atatat 			}
   1198   1.75    atatat 		}
   1199   1.75    atatat 		else {
   1200   1.92    atatat 			sysctlperror("%s: unrecognized keyword '%s'\n",
   1201   1.92    atatat 				     nname, key);
   1202   1.92    atatat 			EXIT(1);
   1203   1.75    atatat 		}
   1204   1.75    atatat 	}
   1205   1.75    atatat 
   1206   1.75    atatat 	/*
   1207   1.75    atatat 	 * now that we've finished parsing the given string, fill in
   1208   1.75    atatat 	 * anything they didn't specify
   1209   1.75    atatat 	 */
   1210   1.75    atatat 	if (type == 0)
   1211   1.75    atatat 		type = CTLTYPE_NODE;
   1212   1.75    atatat 
   1213   1.75    atatat 	/*
   1214   1.75    atatat 	 * the "data" can be interpreted various ways depending on the
   1215   1.75    atatat 	 * type of node we're creating, as can the size
   1216   1.75    atatat 	 */
   1217   1.75    atatat 	if (data != NULL) {
   1218   1.75    atatat 		if (addr != NULL) {
   1219   1.92    atatat 			sysctlperror(
   1220   1.92    atatat 				"%s: cannot specify both value and "
   1221   1.92    atatat 				"address\n", nname);
   1222   1.92    atatat 			EXIT(1);
   1223   1.75    atatat 		}
   1224   1.75    atatat 
   1225   1.75    atatat 		switch (type) {
   1226   1.75    atatat 		case CTLTYPE_INT:
   1227   1.75    atatat 			errno = 0;
   1228  1.110  christos 			q = strtoll(data, &t, 0);
   1229   1.94    atatat 			if (t == data || *t != '\0' || errno != 0 ||
   1230   1.92    atatat 				q < INT_MIN || q > UINT_MAX) {
   1231   1.92    atatat 				sysctlperror(
   1232   1.92    atatat 				    "%s: '%s' is not a valid integer\n",
   1233   1.92    atatat 				    nname, value);
   1234   1.92    atatat 				EXIT(1);
   1235   1.75    atatat 			}
   1236   1.92    atatat 			i = (int)q;
   1237   1.83    atatat 			if (!(flags & CTLFLAG_OWNDATA)) {
   1238   1.83    atatat 				flags |= CTLFLAG_IMMEDIATE;
   1239   1.75    atatat 				node.sysctl_idata = i;
   1240   1.75    atatat 			}
   1241   1.75    atatat 			else
   1242   1.75    atatat 				node.sysctl_data = &i;
   1243   1.75    atatat 			if (sz == 0)
   1244   1.75    atatat 				sz = sizeof(int);
   1245   1.75    atatat 			break;
   1246  1.131       mrg 		case CTLTYPE_BOOL:
   1247  1.131       mrg 			errno = 0;
   1248  1.131       mrg 			q = strtoll(data, &t, 0);
   1249  1.131       mrg 			if (t == data || *t != '\0' || errno != 0 ||
   1250  1.131       mrg 				(q != 0 && q != 1)) {
   1251  1.131       mrg 				sysctlperror(
   1252  1.131       mrg 				    "%s: '%s' is not a valid bool\n",
   1253  1.131       mrg 				    nname, value);
   1254  1.131       mrg 				EXIT(1);
   1255  1.131       mrg 			}
   1256  1.131       mrg 			b = q == 1;
   1257  1.131       mrg 			if (!(flags & CTLFLAG_OWNDATA)) {
   1258  1.131       mrg 				flags |= CTLFLAG_IMMEDIATE;
   1259  1.131       mrg 				node.sysctl_idata = b;
   1260  1.131       mrg 			}
   1261  1.131       mrg 			else
   1262  1.131       mrg 				node.sysctl_data = &b;
   1263  1.131       mrg 			if (sz == 0)
   1264  1.131       mrg 				sz = sizeof(bool);
   1265  1.131       mrg 			break;
   1266   1.75    atatat 		case CTLTYPE_STRING:
   1267   1.83    atatat 			flags |= CTLFLAG_OWNDATA;
   1268   1.75    atatat 			node.sysctl_data = data;
   1269   1.75    atatat 			if (sz == 0)
   1270   1.75    atatat 				sz = strlen(data) + 1;
   1271   1.75    atatat 			else if (sz < strlen(data) + 1) {
   1272   1.92    atatat 				sysctlperror("%s: ignoring size=%zu for "
   1273   1.75    atatat 					"string node, too small for given "
   1274   1.92    atatat 					"value\n", nname, sz);
   1275   1.75    atatat 				sz = strlen(data) + 1;
   1276   1.75    atatat 			}
   1277   1.75    atatat 			break;
   1278   1.75    atatat 		case CTLTYPE_QUAD:
   1279   1.75    atatat 			errno = 0;
   1280   1.92    atatat 			uq = strtouq(data, &t, 0);
   1281   1.94    atatat 			if (t == data || *t != '\0' || errno != 0) {
   1282   1.92    atatat 				sysctlperror(
   1283   1.92    atatat 					"%s: '%s' is not a valid quad\n",
   1284   1.92    atatat 					nname, value);
   1285   1.92    atatat 				EXIT(1);
   1286   1.75    atatat 			}
   1287   1.83    atatat 			if (!(flags & CTLFLAG_OWNDATA)) {
   1288   1.83    atatat 				flags |= CTLFLAG_IMMEDIATE;
   1289   1.92    atatat 				node.sysctl_qdata = uq;
   1290   1.75    atatat 			}
   1291   1.75    atatat 			else
   1292   1.92    atatat 				node.sysctl_data = &uq;
   1293   1.75    atatat 			if (sz == 0)
   1294   1.75    atatat 				sz = sizeof(u_quad_t);
   1295   1.75    atatat 			break;
   1296   1.75    atatat 		case CTLTYPE_STRUCT:
   1297   1.92    atatat 			sysctlperror("%s: struct not initializable\n",
   1298   1.92    atatat 				     nname);
   1299   1.92    atatat 			EXIT(1);
   1300   1.75    atatat 		}
   1301   1.75    atatat 
   1302   1.75    atatat 		/*
   1303   1.75    atatat 		 * these methods have all provided local starting
   1304   1.75    atatat 		 * values that the kernel must copy in
   1305   1.75    atatat 		 */
   1306   1.75    atatat 	}
   1307   1.75    atatat 
   1308   1.75    atatat 	/*
   1309   1.75    atatat 	 * hmm...no data, but we have an address of data.  that's
   1310   1.75    atatat 	 * fine.
   1311   1.75    atatat 	 */
   1312   1.75    atatat 	else if (addr != 0)
   1313   1.75    atatat 		node.sysctl_data = (void*)addr;
   1314   1.75    atatat 
   1315   1.75    atatat 	/*
   1316   1.75    atatat 	 * no data and no address?  well...okay.  we might be able to
   1317   1.75    atatat 	 * manage that.
   1318   1.75    atatat 	 */
   1319   1.75    atatat 	else if (type != CTLTYPE_NODE) {
   1320   1.75    atatat 		if (sz == 0) {
   1321   1.92    atatat 			sysctlperror(
   1322   1.92    atatat 			    "%s: need a size or a starting value\n",
   1323   1.92    atatat 			    nname);
   1324   1.92    atatat                         EXIT(1);
   1325   1.75    atatat                 }
   1326   1.83    atatat 		if (!(flags & CTLFLAG_IMMEDIATE))
   1327   1.83    atatat 			flags |= CTLFLAG_OWNDATA;
   1328   1.75    atatat 	}
   1329   1.75    atatat 
   1330   1.75    atatat 	/*
   1331   1.75    atatat 	 * now we do a few sanity checks on the description we've
   1332   1.75    atatat 	 * assembled
   1333   1.75    atatat 	 */
   1334   1.83    atatat 	if ((flags & CTLFLAG_IMMEDIATE) &&
   1335   1.75    atatat 	    (type == CTLTYPE_STRING || type == CTLTYPE_STRUCT)) {
   1336   1.92    atatat 		sysctlperror("%s: cannot make an immediate %s\n",
   1337   1.92    atatat 			     nname,
   1338   1.92    atatat 			     (type == CTLTYPE_STRING) ? "string" : "struct");
   1339   1.92    atatat 		EXIT(1);
   1340   1.75    atatat 	}
   1341   1.75    atatat 	if (type == CTLTYPE_NODE && node.sysctl_data != NULL) {
   1342   1.92    atatat 		sysctlperror("%s: nodes do not have data\n", nname);
   1343   1.92    atatat 		EXIT(1);
   1344   1.75    atatat 	}
   1345   1.75    atatat 
   1346   1.75    atatat 	/*
   1347   1.75    atatat 	 * some types must have a particular size
   1348   1.75    atatat 	 */
   1349   1.75    atatat 	if (sz != 0) {
   1350   1.75    atatat 		if ((type == CTLTYPE_INT && sz != sizeof(int)) ||
   1351  1.131       mrg 		    (type == CTLTYPE_BOOL && sz != sizeof(bool)) ||
   1352   1.75    atatat 		    (type == CTLTYPE_QUAD && sz != sizeof(u_quad_t)) ||
   1353   1.75    atatat 		    (type == CTLTYPE_NODE && sz != 0)) {
   1354   1.92    atatat 			sysctlperror("%s: wrong size for type\n", nname);
   1355   1.92    atatat 			EXIT(1);
   1356   1.75    atatat 		}
   1357   1.75    atatat 	}
   1358   1.75    atatat 	else if (type == CTLTYPE_STRUCT) {
   1359   1.92    atatat 		sysctlperror("%s: struct must have size\n", nname);
   1360   1.92    atatat 		EXIT(1);
   1361   1.75    atatat 	}
   1362   1.75    atatat 
   1363   1.75    atatat 	/*
   1364   1.75    atatat 	 * now...if no one said anything yet, we default nodes or
   1365   1.75    atatat 	 * any type that owns data being writeable, and everything
   1366   1.75    atatat 	 * else being readonly.
   1367   1.75    atatat 	 */
   1368   1.75    atatat 	if (rw == -1) {
   1369   1.75    atatat 		if (type == CTLTYPE_NODE ||
   1370   1.83    atatat 		    (flags & (CTLFLAG_OWNDATA|CTLFLAG_IMMEDIATE)))
   1371   1.83    atatat 			rw = CTLFLAG_READWRITE;
   1372   1.75    atatat 		else
   1373   1.83    atatat 			rw = CTLFLAG_READONLY;
   1374   1.75    atatat 	}
   1375   1.75    atatat 
   1376   1.75    atatat 	/*
   1377   1.75    atatat 	 * if a kernel address was specified, that can't be made
   1378   1.75    atatat 	 * writeable by us.
   1379   1.83    atatat 	if (rw != CTLFLAG_READONLY && addr) {
   1380   1.92    atatat 		sysctlperror("%s: kernel data can only be readable\n", nname);
   1381   1.92    atatat 		EXIT(1);
   1382   1.75    atatat 	}
   1383   1.75    atatat 	 */
   1384   1.75    atatat 
   1385   1.75    atatat 	/*
   1386   1.75    atatat 	 * what separator were they using in the full name of the new
   1387   1.75    atatat 	 * node?
   1388   1.75    atatat 	 */
   1389   1.75    atatat 	if ((t = strpbrk(nname, "./")) == NULL)
   1390   1.75    atatat 		sep[0] = '.';
   1391   1.75    atatat 	else
   1392   1.75    atatat 		sep[0] = t[0];
   1393   1.75    atatat 	sep[1] = '\0';
   1394   1.75    atatat 
   1395   1.75    atatat 	/*
   1396   1.75    atatat 	 * put it all together, now.  t'ain't much, is it?
   1397   1.75    atatat 	 */
   1398   1.83    atatat 	node.sysctl_flags = SYSCTL_VERSION|flags|rw|type;
   1399   1.75    atatat 	node.sysctl_size = sz;
   1400   1.75    atatat 	t = strrchr(nname, sep[0]);
   1401   1.75    atatat 	if (t != NULL)
   1402   1.75    atatat 		strlcpy(node.sysctl_name, t + 1, sizeof(node.sysctl_name));
   1403   1.75    atatat 	else
   1404   1.75    atatat 		strlcpy(node.sysctl_name, nname, sizeof(node.sysctl_name));
   1405   1.82    atatat 	if (t == nname)
   1406   1.82    atatat 		t = NULL;
   1407   1.75    atatat 
   1408   1.75    atatat 	/*
   1409   1.75    atatat 	 * if this is a new top-level node, then we don't need to find
   1410   1.75    atatat 	 * the mib for its parent
   1411   1.75    atatat 	 */
   1412   1.75    atatat 	if (t == NULL) {
   1413   1.75    atatat 		namelen = 0;
   1414   1.75    atatat 		gsname[0] = '\0';
   1415   1.75    atatat 	}
   1416   1.75    atatat 
   1417   1.75    atatat 	/*
   1418   1.75    atatat 	 * on the other hand, if it's not a top-level node...
   1419   1.75    atatat 	 */
   1420   1.75    atatat 	else {
   1421   1.75    atatat 		namelen = sizeof(name) / sizeof(name[0]);
   1422   1.75    atatat 		sz = sizeof(gsname);
   1423   1.75    atatat 		*t = '\0';
   1424   1.78    atatat 		rc = sysctlgetmibinfo(nname, &name[0], &namelen,
   1425   1.83    atatat 				      gsname, &sz, NULL, SYSCTL_VERSION);
   1426   1.75    atatat 		*t = sep[0];
   1427   1.75    atatat 		if (rc == -1) {
   1428   1.92    atatat 			sysctlparseerror(namelen, nname);
   1429   1.92    atatat 			EXIT(1);
   1430    1.1       cgd 		}
   1431   1.75    atatat 	}
   1432   1.75    atatat 
   1433   1.75    atatat 	/*
   1434   1.75    atatat 	 * yes, a new node is being created
   1435   1.75    atatat 	 */
   1436   1.75    atatat 	if (method != 0)
   1437   1.75    atatat 		name[namelen++] = method;
   1438   1.75    atatat 	else
   1439   1.75    atatat 		name[namelen++] = CTL_CREATE;
   1440   1.75    atatat 
   1441   1.75    atatat 	sz = sizeof(node);
   1442  1.133     pooka 	rc = prog_sysctl(&name[0], namelen, &node, &sz, &node, sizeof(node));
   1443   1.75    atatat 
   1444   1.75    atatat 	if (rc == -1) {
   1445   1.92    atatat 		sysctlperror("%s: CTL_CREATE failed: %s\n",
   1446   1.92    atatat 			     nname, strerror(errno));
   1447   1.92    atatat 		EXIT(1);
   1448   1.75    atatat 	}
   1449  1.100    atatat 	else {
   1450  1.100    atatat 		if (!qflag && !nflag)
   1451  1.100    atatat 			printf("%s(%s): (created)\n", nname, st(type));
   1452  1.100    atatat 		stale = 1;
   1453  1.100    atatat 	}
   1454   1.75    atatat }
   1455   1.75    atatat 
   1456   1.75    atatat static void
   1457   1.82    atatat parse_destroy(char *l)
   1458   1.75    atatat {
   1459   1.75    atatat 	struct sysctlnode node;
   1460   1.75    atatat 	size_t sz;
   1461   1.75    atatat 	int name[CTL_MAXNAME], rc;
   1462   1.75    atatat 	u_int namelen;
   1463   1.75    atatat 
   1464   1.82    atatat 	if (!wflag) {
   1465   1.92    atatat 		sysctlperror("Must specify -w to destroy nodes\n");
   1466   1.82    atatat 		exit(1);
   1467   1.82    atatat 	}
   1468   1.82    atatat 
   1469   1.75    atatat 	memset(name, 0, sizeof(name));
   1470   1.75    atatat 	namelen = sizeof(name) / sizeof(name[0]);
   1471   1.75    atatat 	sz = sizeof(gsname);
   1472   1.83    atatat 	rc = sysctlgetmibinfo(l, &name[0], &namelen, gsname, &sz, NULL,
   1473   1.83    atatat 			      SYSCTL_VERSION);
   1474   1.75    atatat 	if (rc == -1) {
   1475   1.92    atatat 		sysctlparseerror(namelen, l);
   1476   1.92    atatat 		EXIT(1);
   1477   1.75    atatat 	}
   1478   1.75    atatat 
   1479   1.75    atatat 	memset(&node, 0, sizeof(node));
   1480   1.83    atatat 	node.sysctl_flags = SYSCTL_VERSION;
   1481   1.75    atatat 	node.sysctl_num = name[namelen - 1];
   1482   1.75    atatat 	name[namelen - 1] = CTL_DESTROY;
   1483   1.75    atatat 
   1484   1.75    atatat 	sz = sizeof(node);
   1485  1.133     pooka 	rc = prog_sysctl(&name[0], namelen, &node, &sz, &node, sizeof(node));
   1486   1.75    atatat 
   1487   1.75    atatat 	if (rc == -1) {
   1488   1.92    atatat 		sysctlperror("%s: CTL_DESTROY failed: %s\n",
   1489   1.92    atatat 			     l, strerror(errno));
   1490   1.92    atatat 		EXIT(1);
   1491   1.75    atatat 	}
   1492  1.100    atatat 	else {
   1493  1.100    atatat 		if (!qflag && !nflag)
   1494  1.100    atatat 			printf("%s(%s): (destroyed)\n", gsname,
   1495  1.100    atatat 			       st(SYSCTL_TYPE(node.sysctl_flags)));
   1496  1.100    atatat 		stale = 1;
   1497  1.100    atatat 	}
   1498   1.75    atatat }
   1499   1.75    atatat 
   1500   1.84    atatat static void
   1501   1.84    atatat parse_describe(char *l)
   1502   1.84    atatat {
   1503   1.84    atatat 	struct sysctlnode newdesc;
   1504   1.84    atatat 	char buf[1024], *value;
   1505   1.84    atatat 	struct sysctldesc *d = (void*)&buf[0];
   1506   1.84    atatat 	int name[CTL_MAXNAME], rc;
   1507   1.84    atatat 	u_int namelen;
   1508   1.84    atatat 	size_t sz;
   1509   1.84    atatat 
   1510   1.84    atatat 	if (!wflag) {
   1511   1.92    atatat 		sysctlperror("Must specify -w to set descriptions\n");
   1512   1.84    atatat 		exit(1);
   1513   1.84    atatat 	}
   1514   1.84    atatat 
   1515   1.84    atatat 	value = strchr(l, '=');
   1516   1.84    atatat 	*value++ = '\0';
   1517   1.84    atatat 
   1518   1.84    atatat 	memset(name, 0, sizeof(name));
   1519   1.84    atatat 	namelen = sizeof(name) / sizeof(name[0]);
   1520   1.84    atatat 	sz = sizeof(gsname);
   1521   1.84    atatat 	rc = sysctlgetmibinfo(l, &name[0], &namelen, gsname, &sz, NULL,
   1522   1.84    atatat 			      SYSCTL_VERSION);
   1523   1.84    atatat 	if (rc == -1) {
   1524   1.92    atatat 		sysctlparseerror(namelen, l);
   1525   1.92    atatat 		EXIT(1);
   1526   1.84    atatat 	}
   1527   1.84    atatat 
   1528   1.84    atatat 	sz = sizeof(buf);
   1529   1.84    atatat 	memset(&newdesc, 0, sizeof(newdesc));
   1530   1.84    atatat 	newdesc.sysctl_flags = SYSCTL_VERSION|CTLFLAG_OWNDESC;
   1531   1.84    atatat 	newdesc.sysctl_num = name[namelen - 1];
   1532   1.84    atatat 	newdesc.sysctl_desc = value;
   1533   1.84    atatat 	name[namelen - 1] = CTL_DESCRIBE;
   1534  1.133     pooka 	rc = prog_sysctl(name, namelen, d, &sz, &newdesc, sizeof(newdesc));
   1535   1.84    atatat 	if (rc == -1)
   1536   1.92    atatat 		sysctlperror("%s: CTL_DESCRIBE failed: %s\n",
   1537   1.92    atatat 			     gsname, strerror(errno));
   1538   1.84    atatat 	else if (d->descr_len == 1)
   1539   1.92    atatat 		sysctlperror("%s: description not set\n", gsname);
   1540   1.84    atatat 	else if (!qflag && !nflag)
   1541   1.84    atatat 		printf("%s: %s\n", gsname, d->descr_str);
   1542   1.84    atatat }
   1543   1.84    atatat 
   1544   1.75    atatat /*
   1545   1.75    atatat  * ********************************************************************
   1546   1.75    atatat  * when things go wrong...
   1547   1.75    atatat  * ********************************************************************
   1548   1.75    atatat  */
   1549   1.75    atatat static void
   1550   1.75    atatat usage(void)
   1551   1.75    atatat {
   1552   1.75    atatat 	const char *progname = getprogname();
   1553    1.1       cgd 
   1554   1.75    atatat 	(void)fprintf(stderr,
   1555   1.77      jmmv 		      "usage:\t%s %s\n"
   1556   1.75    atatat 		      "\t%s %s\n"
   1557   1.75    atatat 		      "\t%s %s\n"
   1558   1.75    atatat 		      "\t%s %s\n"
   1559   1.75    atatat 		      "\t%s %s\n"
   1560   1.75    atatat 		      "\t%s %s\n",
   1561  1.135  christos 		      progname, "[-dneq] [-x[x]|-r] variable ...",
   1562   1.75    atatat 		      progname, "[-ne] [-q] -w variable=value ...",
   1563   1.87    atatat 		      progname, "[-dne] -a",
   1564   1.87    atatat 		      progname, "[-dne] -A",
   1565   1.75    atatat 		      progname, "[-ne] -M",
   1566   1.87    atatat 		      progname, "[-dne] [-q] -f file");
   1567   1.75    atatat 	exit(1);
   1568   1.22    bouyer }
   1569   1.22    bouyer 
   1570   1.84    atatat static void
   1571   1.84    atatat getdesc1(int *name, u_int namelen, struct sysctlnode *pnode)
   1572   1.84    atatat {
   1573   1.84    atatat 	struct sysctlnode node;
   1574   1.84    atatat 	char buf[1024], *desc;
   1575   1.84    atatat 	struct sysctldesc *d = (void*)buf;
   1576   1.84    atatat 	size_t sz = sizeof(buf);
   1577   1.84    atatat 	int rc;
   1578   1.84    atatat 
   1579   1.84    atatat 	memset(&node, 0, sizeof(node));
   1580   1.84    atatat 	node.sysctl_flags = SYSCTL_VERSION;
   1581   1.84    atatat 	node.sysctl_num = name[namelen - 1];
   1582   1.84    atatat 	name[namelen - 1] = CTL_DESCRIBE;
   1583  1.133     pooka 	rc = prog_sysctl(name, namelen, d, &sz, &node, sizeof(node));
   1584   1.84    atatat 
   1585   1.84    atatat 	if (rc == -1 ||
   1586   1.84    atatat 	    d->descr_len == 1 ||
   1587   1.84    atatat 	    d->descr_num != pnode->sysctl_num ||
   1588   1.84    atatat 	    d->descr_ver != pnode->sysctl_ver)
   1589   1.84    atatat 		desc = (char *)-1;
   1590   1.84    atatat 	else
   1591   1.84    atatat 		desc = malloc(d->descr_len);
   1592   1.84    atatat 
   1593   1.84    atatat 	if (desc == NULL)
   1594   1.84    atatat 		desc = (char *)-1;
   1595   1.84    atatat 	if (desc != (char *)-1)
   1596   1.89    atatat 		memcpy(desc, &d->descr_str[0], d->descr_len);
   1597   1.84    atatat 	name[namelen - 1] = node.sysctl_num;
   1598   1.84    atatat 	if (pnode->sysctl_desc != NULL &&
   1599   1.84    atatat 	    pnode->sysctl_desc != (const char *)-1)
   1600  1.104  christos 		free(__UNCONST(pnode->sysctl_desc));
   1601   1.84    atatat 	pnode->sysctl_desc = desc;
   1602   1.84    atatat }
   1603   1.84    atatat 
   1604   1.84    atatat static void
   1605   1.84    atatat getdesc(int *name, u_int namelen, struct sysctlnode *pnode)
   1606   1.84    atatat {
   1607   1.84    atatat 	struct sysctlnode *node = pnode->sysctl_child;
   1608   1.92    atatat 	struct sysctldesc *d, *p, *plim;
   1609   1.84    atatat 	char *desc;
   1610  1.128     lukem 	size_t i, sz;
   1611  1.128     lukem 	int rc;
   1612   1.84    atatat 
   1613   1.84    atatat 	sz = 128 * pnode->sysctl_clen;
   1614   1.84    atatat 	name[namelen] = CTL_DESCRIBE;
   1615   1.84    atatat 
   1616   1.84    atatat 	/*
   1617   1.84    atatat 	 * attempt *twice* to get the description chunk.  if two tries
   1618   1.84    atatat 	 * doesn't work, give up.
   1619   1.84    atatat 	 */
   1620   1.84    atatat 	i = 0;
   1621   1.84    atatat 	do {
   1622   1.93    atatat 		d = malloc(sz);
   1623   1.84    atatat 		if (d == NULL)
   1624   1.84    atatat 			return;
   1625  1.133     pooka 		rc = prog_sysctl(name, namelen + 1, d, &sz, NULL, 0);
   1626   1.84    atatat 		if (rc == -1) {
   1627   1.84    atatat 			free(d);
   1628   1.84    atatat 			d = NULL;
   1629   1.84    atatat 			if (i == 0 && errno == ENOMEM)
   1630   1.84    atatat 				i = 1;
   1631   1.84    atatat 			else
   1632   1.84    atatat 				return;
   1633   1.84    atatat 		}
   1634   1.84    atatat 	} while (d == NULL);
   1635   1.84    atatat 
   1636   1.84    atatat 	/*
   1637   1.84    atatat 	 * hokey nested loop here, giving O(n**2) behavior, but should
   1638   1.84    atatat 	 * suffice for now
   1639   1.84    atatat 	 */
   1640   1.92    atatat 	plim = /*LINTED ptr cast*/(struct sysctldesc *)((char*)d + sz);
   1641   1.84    atatat 	for (i = 0; i < pnode->sysctl_clen; i++) {
   1642   1.84    atatat 		node = &pnode->sysctl_child[i];
   1643   1.92    atatat 		for (p = d; p < plim; p = NEXT_DESCR(p))
   1644   1.84    atatat 			if (node->sysctl_num == p->descr_num)
   1645   1.84    atatat 				break;
   1646   1.99    atatat 		if (p < plim && node->sysctl_ver == p->descr_ver) {
   1647   1.84    atatat 			/*
   1648   1.84    atatat 			 * match found, attempt to attach description
   1649   1.84    atatat 			 */
   1650   1.84    atatat 			if (p->descr_len == 1)
   1651   1.84    atatat 				desc = NULL;
   1652   1.84    atatat 			else
   1653   1.84    atatat 				desc = malloc(p->descr_len);
   1654   1.84    atatat 			if (desc == NULL)
   1655   1.84    atatat 				desc = (char *)-1;
   1656   1.84    atatat 			else
   1657   1.90    atatat 				memcpy(desc, &p->descr_str[0], p->descr_len);
   1658   1.84    atatat 			node->sysctl_desc = desc;
   1659   1.84    atatat 		}
   1660   1.84    atatat 	}
   1661   1.84    atatat 
   1662   1.84    atatat 	free(d);
   1663   1.84    atatat }
   1664   1.84    atatat 
   1665   1.92    atatat static void
   1666   1.92    atatat trim_whitespace(char *s, int dir)
   1667   1.92    atatat {
   1668   1.92    atatat 	char *i, *o;
   1669   1.92    atatat 
   1670   1.92    atatat 	i = o = s;
   1671   1.92    atatat 	if (dir & 1)
   1672   1.92    atatat 		while (isspace((unsigned char)*i))
   1673   1.92    atatat 			i++;
   1674   1.92    atatat 	while ((*o++ = *i++) != '\0');
   1675   1.92    atatat 	o -= 2; /* already past nul, skip back to before it */
   1676   1.92    atatat 	if (dir & 2)
   1677   1.92    atatat 		while (o > s && isspace((unsigned char)*o))
   1678   1.92    atatat 			*o-- = '\0';
   1679   1.92    atatat }
   1680   1.92    atatat 
   1681   1.75    atatat void
   1682   1.75    atatat sysctlerror(int soft)
   1683   1.75    atatat {
   1684   1.75    atatat 	if (soft) {
   1685   1.75    atatat 		switch (errno) {
   1686   1.75    atatat 		case ENOENT:
   1687   1.75    atatat 		case ENOPROTOOPT:
   1688   1.75    atatat 		case ENOTDIR:
   1689   1.97    atatat 		case EINVAL:
   1690   1.75    atatat 		case EOPNOTSUPP:
   1691   1.75    atatat 		case EPROTONOSUPPORT:
   1692   1.75    atatat 			if (Aflag || req)
   1693   1.92    atatat 				sysctlperror("%s: the value is not available\n",
   1694   1.92    atatat 					     gsname);
   1695   1.75    atatat 			return;
   1696   1.22    bouyer 		}
   1697   1.75    atatat 	}
   1698   1.75    atatat 
   1699  1.140  christos 	if (Aflag || req)
   1700  1.140  christos 		sysctlperror("%s: %s\n", gsname, strerror(errno));
   1701   1.75    atatat 	if (!soft)
   1702   1.92    atatat 		EXIT(1);
   1703   1.92    atatat }
   1704   1.92    atatat 
   1705   1.92    atatat void
   1706   1.92    atatat sysctlparseerror(u_int namelen, const char *pname)
   1707   1.92    atatat {
   1708   1.92    atatat 
   1709  1.135  christos 	if (qflag) {
   1710  1.135  christos 		errs++;
   1711  1.135  christos 		return;
   1712  1.135  christos 	}
   1713   1.92    atatat 	sysctlperror("%s level name '%s' in '%s' is invalid\n",
   1714   1.92    atatat 		     lname[namelen], gsname, pname);
   1715   1.92    atatat }
   1716   1.92    atatat 
   1717   1.92    atatat static void
   1718   1.92    atatat sysctlperror(const char *fmt, ...)
   1719   1.92    atatat {
   1720   1.92    atatat 	va_list ap;
   1721   1.92    atatat 
   1722   1.92    atatat 	(void)fprintf(warnfp, "%s: ", getprogname());
   1723   1.92    atatat 	if (fn)
   1724   1.92    atatat 		(void)fprintf(warnfp, "%s#%zu: ", fn, nr);
   1725   1.92    atatat 	va_start(ap, fmt);
   1726   1.92    atatat 	(void)vfprintf(warnfp, fmt, ap);
   1727   1.92    atatat 	va_end(ap);
   1728  1.121  christos 	errs++;
   1729   1.75    atatat }
   1730   1.75    atatat 
   1731   1.92    atatat 
   1732   1.75    atatat /*
   1733   1.75    atatat  * ********************************************************************
   1734   1.75    atatat  * how to write to a "simple" node
   1735   1.75    atatat  * ********************************************************************
   1736   1.75    atatat  */
   1737   1.75    atatat static void
   1738   1.75    atatat write_number(int *name, u_int namelen, struct sysctlnode *node, char *value)
   1739   1.75    atatat {
   1740  1.110  christos 	u_int ii, io;
   1741   1.75    atatat 	u_quad_t qi, qo;
   1742   1.75    atatat 	size_t si, so;
   1743  1.131       mrg 	bool bi, bo;
   1744   1.75    atatat 	int rc;
   1745   1.75    atatat 	void *i, *o;
   1746   1.75    atatat 	char *t;
   1747   1.75    atatat 
   1748   1.92    atatat 	if (fn)
   1749   1.92    atatat 		trim_whitespace(value, 3);
   1750   1.92    atatat 
   1751   1.75    atatat 	si = so = 0;
   1752   1.75    atatat 	i = o = NULL;
   1753  1.131       mrg 	bi = bo = false;
   1754   1.75    atatat 	errno = 0;
   1755   1.75    atatat 	qi = strtouq(value, &t, 0);
   1756  1.110  christos 	if (qi == UQUAD_MAX && errno == ERANGE) {
   1757  1.110  christos 		sysctlperror("%s: %s\n", value, strerror(errno));
   1758   1.92    atatat 		EXIT(1);
   1759   1.75    atatat 	}
   1760   1.94    atatat 	if (t == value || *t != '\0') {
   1761   1.92    atatat 		sysctlperror("%s: not a number\n", value);
   1762   1.92    atatat 		EXIT(1);
   1763   1.75    atatat 	}
   1764   1.75    atatat 
   1765   1.75    atatat 	switch (SYSCTL_TYPE(node->sysctl_flags)) {
   1766  1.110  christos 	case CTLTYPE_INT:
   1767  1.110  christos 		ii = (u_int)qi;
   1768  1.111  christos 		io = (u_int)(qi >> 32);
   1769  1.111  christos 		if (io != (u_int)-1 && io != 0) {
   1770  1.110  christos 			sysctlperror("%s: %s\n", value, strerror(ERANGE));
   1771   1.92    atatat 			EXIT(1);
   1772   1.75    atatat 		}
   1773   1.75    atatat 		o = &io;
   1774   1.75    atatat 		so = sizeof(io);
   1775   1.75    atatat 		i = &ii;
   1776   1.75    atatat 		si = sizeof(ii);
   1777   1.75    atatat 		break;
   1778  1.131       mrg 	case CTLTYPE_BOOL:
   1779  1.131       mrg 		bi = (bool)qi;
   1780  1.131       mrg 		o = &bo;
   1781  1.131       mrg 		so = sizeof(bo);
   1782  1.131       mrg 		i = &bi;
   1783  1.131       mrg 		si = sizeof(bi);
   1784  1.131       mrg 		break;
   1785   1.75    atatat 	case CTLTYPE_QUAD:
   1786   1.75    atatat 		o = &qo;
   1787   1.75    atatat 		so = sizeof(qo);
   1788   1.75    atatat 		i = &qi;
   1789   1.75    atatat 		si = sizeof(qi);
   1790   1.75    atatat 		break;
   1791   1.75    atatat 	}
   1792   1.75    atatat 
   1793  1.133     pooka 	rc = prog_sysctl(name, namelen, o, &so, i, si);
   1794   1.92    atatat 	if (rc == -1) {
   1795   1.75    atatat 		sysctlerror(0);
   1796   1.92    atatat 		return;
   1797   1.92    atatat 	}
   1798   1.75    atatat 
   1799   1.75    atatat 	switch (SYSCTL_TYPE(node->sysctl_flags)) {
   1800   1.75    atatat 	case CTLTYPE_INT:
   1801   1.75    atatat 		display_number(node, gsname, &io, sizeof(io), DISPLAY_OLD);
   1802   1.75    atatat 		display_number(node, gsname, &ii, sizeof(ii), DISPLAY_NEW);
   1803   1.75    atatat 		break;
   1804  1.131       mrg 	case CTLTYPE_BOOL:
   1805  1.131       mrg 		display_number(node, gsname, &bo, sizeof(bo), DISPLAY_OLD);
   1806  1.131       mrg 		display_number(node, gsname, &bi, sizeof(bi), DISPLAY_NEW);
   1807  1.131       mrg 		break;
   1808   1.75    atatat 	case CTLTYPE_QUAD:
   1809   1.75    atatat 		display_number(node, gsname, &qo, sizeof(qo), DISPLAY_OLD);
   1810   1.75    atatat 		display_number(node, gsname, &qi, sizeof(qi), DISPLAY_NEW);
   1811   1.75    atatat 		break;
   1812   1.75    atatat 	}
   1813   1.75    atatat }
   1814   1.75    atatat 
   1815   1.75    atatat static void
   1816   1.75    atatat write_string(int *name, u_int namelen, struct sysctlnode *node, char *value)
   1817   1.75    atatat {
   1818   1.75    atatat 	char *i, *o;
   1819   1.75    atatat 	size_t si, so;
   1820   1.75    atatat 	int rc;
   1821   1.75    atatat 
   1822   1.75    atatat 	i = value;
   1823   1.75    atatat 	si = strlen(i) + 1;
   1824   1.75    atatat 	so = node->sysctl_size;
   1825   1.75    atatat 	if (si > so && so != 0) {
   1826   1.92    atatat 		sysctlperror("%s: string too long\n", value);
   1827   1.92    atatat 		EXIT(1);
   1828   1.75    atatat 	}
   1829   1.75    atatat 	o = malloc(so);
   1830   1.75    atatat 	if (o == NULL) {
   1831   1.92    atatat 		sysctlperror("%s: !malloc failed!\n", gsname);
   1832   1.75    atatat 		exit(1);
   1833   1.75    atatat 	}
   1834   1.75    atatat 
   1835  1.133     pooka 	rc = prog_sysctl(name, namelen, o, &so, i, si);
   1836   1.92    atatat 	if (rc == -1) {
   1837   1.75    atatat 		sysctlerror(0);
   1838   1.92    atatat 		return;
   1839   1.92    atatat 	}
   1840   1.75    atatat 
   1841   1.75    atatat 	display_string(node, gsname, o, so, DISPLAY_OLD);
   1842   1.75    atatat 	display_string(node, gsname, i, si, DISPLAY_NEW);
   1843   1.75    atatat 	free(o);
   1844   1.75    atatat }
   1845   1.75    atatat 
   1846   1.75    atatat /*
   1847   1.75    atatat  * ********************************************************************
   1848   1.75    atatat  * simple ways to print stuff consistently
   1849   1.75    atatat  * ********************************************************************
   1850   1.75    atatat  */
   1851   1.75    atatat static void
   1852   1.75    atatat display_number(const struct sysctlnode *node, const char *name,
   1853   1.75    atatat 	       const void *data, size_t sz, int n)
   1854   1.75    atatat {
   1855   1.75    atatat 	u_quad_t q;
   1856  1.131       mrg 	bool b;
   1857   1.75    atatat 	int i;
   1858   1.75    atatat 
   1859   1.75    atatat 	if (qflag)
   1860   1.75    atatat 		return;
   1861   1.75    atatat 	if ((nflag || rflag) && (n == DISPLAY_OLD))
   1862   1.75    atatat 		return;
   1863   1.75    atatat 
   1864   1.75    atatat 	if (rflag && n != DISPLAY_OLD) {
   1865   1.75    atatat 		fwrite(data, sz, 1, stdout);
   1866   1.75    atatat 		return;
   1867   1.75    atatat 	}
   1868   1.75    atatat 
   1869   1.75    atatat 	if (!nflag) {
   1870   1.75    atatat 		if (n == DISPLAY_VALUE)
   1871   1.75    atatat 			printf("%s%s", name, eq);
   1872   1.75    atatat 		else if (n == DISPLAY_OLD)
   1873   1.75    atatat 			printf("%s: ", name);
   1874   1.75    atatat 	}
   1875   1.75    atatat 
   1876   1.75    atatat 	if (xflag > 1) {
   1877   1.79    atatat 		if (n != DISPLAY_NEW)
   1878   1.79    atatat 			printf("\n");
   1879   1.75    atatat 		hex_dump(data, sz);
   1880   1.22    bouyer 		return;
   1881   1.75    atatat 	}
   1882   1.22    bouyer 
   1883   1.75    atatat 	switch (SYSCTL_TYPE(node->sysctl_flags)) {
   1884   1.75    atatat 	case CTLTYPE_INT:
   1885   1.75    atatat 		memcpy(&i, data, sz);
   1886   1.75    atatat 		if (xflag)
   1887   1.75    atatat 			printf("0x%0*x", (int)sz * 2, i);
   1888   1.83    atatat 		else if (node->sysctl_flags & CTLFLAG_HEX)
   1889   1.75    atatat 			printf("%#x", i);
   1890   1.75    atatat 		else
   1891   1.75    atatat 			printf("%d", i);
   1892   1.75    atatat 		break;
   1893  1.131       mrg 	case CTLTYPE_BOOL:
   1894  1.131       mrg 		memcpy(&b, data, sz);
   1895  1.131       mrg 		if (xflag)
   1896  1.131       mrg 			printf("0x%0*x", (int)sz * 2, b);
   1897  1.131       mrg 		else if (node->sysctl_flags & CTLFLAG_HEX)
   1898  1.131       mrg 			printf("%#x", b);
   1899  1.131       mrg 		else
   1900  1.131       mrg 			printf("%d", b);
   1901  1.131       mrg 		break;
   1902    1.1       cgd 	case CTLTYPE_QUAD:
   1903   1.75    atatat 		memcpy(&q, data, sz);
   1904   1.75    atatat 		if (xflag)
   1905   1.75    atatat 			printf("0x%0*" PRIx64, (int)sz * 2, q);
   1906   1.83    atatat 		else if (node->sysctl_flags & CTLFLAG_HEX)
   1907   1.75    atatat 			printf("%#" PRIx64, q);
   1908   1.75    atatat 		else
   1909   1.75    atatat 			printf("%" PRIu64, q);
   1910   1.75    atatat 		break;
   1911   1.75    atatat 	}
   1912   1.75    atatat 
   1913   1.75    atatat 	if (n == DISPLAY_OLD)
   1914   1.75    atatat 		printf(" -> ");
   1915   1.75    atatat 	else
   1916   1.75    atatat 		printf("\n");
   1917   1.75    atatat }
   1918   1.75    atatat 
   1919   1.75    atatat static void
   1920   1.75    atatat display_string(const struct sysctlnode *node, const char *name,
   1921   1.75    atatat 	       const void *data, size_t sz, int n)
   1922   1.75    atatat {
   1923   1.75    atatat 	const unsigned char *buf = data;
   1924   1.75    atatat 	int ni;
   1925   1.75    atatat 
   1926   1.75    atatat 	if (qflag)
   1927   1.75    atatat 		return;
   1928   1.75    atatat 	if ((nflag || rflag) && (n == DISPLAY_OLD))
   1929   1.75    atatat 		return;
   1930   1.75    atatat 
   1931   1.75    atatat 	if (rflag && n != DISPLAY_OLD) {
   1932   1.75    atatat 		fwrite(data, sz, 1, stdout);
   1933   1.75    atatat 		return;
   1934   1.75    atatat 	}
   1935   1.75    atatat 
   1936   1.75    atatat 	if (!nflag) {
   1937   1.75    atatat 		if (n == DISPLAY_VALUE)
   1938   1.75    atatat 			printf("%s%s", name, eq);
   1939   1.75    atatat 		else if (n == DISPLAY_OLD)
   1940   1.75    atatat 			printf("%s: ", name);
   1941   1.75    atatat 	}
   1942   1.75    atatat 
   1943   1.75    atatat 	if (xflag > 1) {
   1944   1.79    atatat 		if (n != DISPLAY_NEW)
   1945   1.79    atatat 			printf("\n");
   1946   1.75    atatat 		hex_dump(data, sz);
   1947   1.75    atatat 		return;
   1948   1.75    atatat 	}
   1949   1.75    atatat 
   1950   1.83    atatat 	if (xflag || node->sysctl_flags & CTLFLAG_HEX) {
   1951   1.75    atatat 		for (ni = 0; ni < (int)sz; ni++) {
   1952   1.75    atatat 			if (xflag)
   1953   1.75    atatat 				printf("%02x", buf[ni]);
   1954   1.75    atatat 			if (buf[ni] == '\0')
   1955   1.75    atatat 				break;
   1956   1.75    atatat 			if (!xflag)
   1957   1.75    atatat 				printf("\\x%2.2x", buf[ni]);
   1958    1.1       cgd 		}
   1959   1.75    atatat 	}
   1960   1.75    atatat 	else
   1961   1.75    atatat 		printf("%.*s", (int)sz, buf);
   1962   1.75    atatat 
   1963   1.75    atatat 	if (n == DISPLAY_OLD)
   1964   1.75    atatat 		printf(" -> ");
   1965   1.75    atatat 	else
   1966   1.75    atatat 		printf("\n");
   1967   1.75    atatat }
   1968   1.75    atatat 
   1969   1.75    atatat /*ARGSUSED*/
   1970   1.75    atatat static void
   1971   1.75    atatat display_struct(const struct sysctlnode *node, const char *name,
   1972   1.75    atatat 	       const void *data, size_t sz, int n)
   1973   1.75    atatat {
   1974   1.75    atatat 	const unsigned char *buf = data;
   1975   1.75    atatat 	int ni;
   1976   1.75    atatat 	size_t more;
   1977   1.75    atatat 
   1978   1.75    atatat 	if (qflag)
   1979   1.75    atatat 		return;
   1980   1.75    atatat 	if (!(xflag || rflag)) {
   1981   1.75    atatat 		if (Aflag || req)
   1982   1.92    atatat 			sysctlperror(
   1983   1.92    atatat 			    "%s: this type is unknown to this program\n",
   1984   1.92    atatat 			    gsname);
   1985   1.75    atatat 		return;
   1986   1.75    atatat 	}
   1987   1.75    atatat 	if ((nflag || rflag) && (n == DISPLAY_OLD))
   1988    1.1       cgd 		return;
   1989    1.1       cgd 
   1990   1.75    atatat 	if (rflag && n != DISPLAY_OLD) {
   1991   1.75    atatat 		fwrite(data, sz, 1, stdout);
   1992    1.1       cgd 		return;
   1993   1.75    atatat 	}
   1994    1.1       cgd 
   1995   1.75    atatat         if (!nflag) {
   1996   1.75    atatat                 if (n == DISPLAY_VALUE)
   1997   1.75    atatat                         printf("%s%s", name, eq);
   1998   1.75    atatat                 else if (n == DISPLAY_OLD)
   1999   1.75    atatat                         printf("%s: ", name);
   2000   1.75    atatat         }
   2001   1.75    atatat 
   2002   1.75    atatat 	if (xflag > 1) {
   2003   1.79    atatat 		if (n != DISPLAY_NEW)
   2004   1.79    atatat 			printf("\n");
   2005   1.75    atatat 		hex_dump(data, sz);
   2006    1.1       cgd 		return;
   2007    1.1       cgd 	}
   2008   1.75    atatat 
   2009   1.75    atatat 	if (sz > 16) {
   2010   1.75    atatat 		more = sz - 16;
   2011   1.75    atatat 		sz = 16;
   2012   1.75    atatat 	}
   2013   1.75    atatat 	else
   2014   1.75    atatat 		more = 0;
   2015   1.75    atatat 	for (ni = 0; ni < (int)sz; ni++)
   2016   1.75    atatat 		printf("%02x", buf[ni]);
   2017   1.75    atatat 	if (more)
   2018   1.75    atatat 		printf("...(%zu more bytes)", more);
   2019   1.75    atatat 	printf("\n");
   2020   1.75    atatat }
   2021   1.75    atatat 
   2022   1.75    atatat static void
   2023   1.75    atatat hex_dump(const unsigned char *buf, size_t len)
   2024   1.75    atatat {
   2025  1.128     lukem 	unsigned int i;
   2026  1.128     lukem 	int j;
   2027   1.75    atatat 	char line[80], tmp[12];
   2028   1.75    atatat 
   2029   1.75    atatat 	memset(line, ' ', sizeof(line));
   2030   1.75    atatat 	for (i = 0, j = 15; i < len; i++) {
   2031   1.75    atatat 		j = i % 16;
   2032   1.75    atatat 		/* reset line */
   2033   1.75    atatat 		if (j == 0) {
   2034   1.75    atatat 			line[58] = '|';
   2035   1.75    atatat 			line[77] = '|';
   2036   1.75    atatat 			line[78] = 0;
   2037  1.127  pgoyette 			snprintf(tmp, sizeof(tmp), "%07x", i);
   2038   1.75    atatat 			memcpy(&line[0], tmp, 7);
   2039   1.75    atatat 		}
   2040   1.75    atatat 		/* copy out hex version of byte */
   2041   1.75    atatat 		snprintf(tmp, sizeof(tmp), "%02x", buf[i]);
   2042   1.75    atatat 		memcpy(&line[9 + j * 3], tmp, 2);
   2043   1.75    atatat 		/* copy out plain version of byte */
   2044   1.75    atatat 		line[60 + j] = (isprint(buf[i])) ? buf[i] : '.';
   2045   1.75    atatat 		/* print a full line and erase it */
   2046   1.75    atatat 		if (j == 15) {
   2047   1.75    atatat 			printf("%s\n", line);
   2048   1.75    atatat 			memset(line, ' ', sizeof(line));
   2049   1.75    atatat 		}
   2050   1.75    atatat 	}
   2051   1.75    atatat 	if (line[0] != ' ')
   2052   1.75    atatat 		printf("%s\n", line);
   2053   1.75    atatat 	printf("%07zu bytes\n", len);
   2054    1.1       cgd }
   2055    1.1       cgd 
   2056    1.1       cgd /*
   2057   1.75    atatat  * ********************************************************************
   2058   1.75    atatat  * functions that handle particular nodes
   2059   1.75    atatat  * ********************************************************************
   2060    1.1       cgd  */
   2061   1.75    atatat /*ARGSUSED*/
   2062   1.14  christos static void
   2063   1.75    atatat printother(HANDLER_ARGS)
   2064    1.1       cgd {
   2065   1.75    atatat 	int rc;
   2066   1.75    atatat 	void *p;
   2067   1.75    atatat 	size_t sz1, sz2;
   2068    1.1       cgd 
   2069   1.75    atatat 	if (!(Aflag || req) || Mflag)
   2070    1.1       cgd 		return;
   2071   1.75    atatat 
   2072   1.75    atatat 	/*
   2073   1.75    atatat 	 * okay...you asked for it, so let's give it a go
   2074   1.75    atatat 	 */
   2075   1.75    atatat 	while (type != CTLTYPE_NODE && (xflag || rflag)) {
   2076  1.133     pooka 		rc = prog_sysctl(name, namelen, NULL, &sz1, NULL, 0);
   2077   1.75    atatat 		if (rc == -1 || sz1 == 0)
   2078   1.75    atatat 			break;
   2079   1.75    atatat 		p = malloc(sz1);
   2080   1.75    atatat 		if (p == NULL)
   2081   1.75    atatat 			break;
   2082   1.75    atatat 		sz2 = sz1;
   2083  1.133     pooka 		rc = prog_sysctl(name, namelen, p, &sz2, NULL, 0);
   2084   1.75    atatat 		if (rc == -1 || sz1 != sz2) {
   2085   1.75    atatat 			free(p);
   2086   1.75    atatat 			break;
   2087   1.75    atatat 		}
   2088   1.75    atatat 		display_struct(pnode, gsname, p, sz1, DISPLAY_VALUE);
   2089   1.75    atatat 		free(p);
   2090   1.75    atatat 		return;
   2091   1.75    atatat 	}
   2092   1.75    atatat 
   2093   1.75    atatat 	/*
   2094   1.75    atatat 	 * that didn't work...do we have a specific message for this
   2095   1.75    atatat 	 * thing?
   2096   1.75    atatat 	 */
   2097   1.75    atatat 	if (v != NULL) {
   2098   1.92    atatat 		sysctlperror("%s: use '%s' to view this information\n",
   2099   1.92    atatat 			     gsname, (const char *)v);
   2100   1.75    atatat 		return;
   2101   1.75    atatat 	}
   2102   1.75    atatat 
   2103   1.75    atatat 	/*
   2104   1.75    atatat 	 * hmm...i wonder if we have any generic hints?
   2105   1.75    atatat 	 */
   2106   1.75    atatat 	switch (name[0]) {
   2107   1.75    atatat 	case CTL_NET:
   2108   1.92    atatat 		sysctlperror("%s: use 'netstat' to view this information\n",
   2109   1.92    atatat 			     sname);
   2110   1.75    atatat 		break;
   2111   1.75    atatat 	case CTL_DEBUG:
   2112   1.92    atatat 		sysctlperror("%s: missing 'options DEBUG' from kernel?\n",
   2113   1.92    atatat 			     sname);
   2114   1.75    atatat 		break;
   2115   1.75    atatat 	case CTL_DDB:
   2116   1.92    atatat 		sysctlperror("%s: missing 'options DDB' from kernel?\n",
   2117   1.92    atatat 			     sname);
   2118   1.75    atatat 		break;
   2119   1.98    atatat 	case CTL_VENDOR:
   2120   1.98    atatat 		sysctlperror("%s: no vendor extensions installed\n",
   2121   1.98    atatat 			     sname);
   2122   1.98    atatat 		break;
   2123    1.1       cgd 	}
   2124    1.1       cgd }
   2125    1.1       cgd 
   2126   1.75    atatat /*ARGSUSED*/
   2127   1.75    atatat static void
   2128   1.75    atatat kern_clockrate(HANDLER_ARGS)
   2129   1.75    atatat {
   2130   1.75    atatat 	struct clockinfo clkinfo;
   2131   1.75    atatat 	size_t sz;
   2132   1.75    atatat 	int rc;
   2133   1.75    atatat 
   2134   1.75    atatat 	sz = sizeof(clkinfo);
   2135  1.133     pooka 	rc = prog_sysctl(name, namelen, &clkinfo, &sz, NULL, 0);
   2136   1.75    atatat 	if (rc == -1) {
   2137   1.75    atatat 		sysctlerror(1);
   2138   1.75    atatat 		return;
   2139   1.75    atatat 	}
   2140   1.75    atatat 	if (sz != sizeof(clkinfo))
   2141   1.75    atatat 		errx(1, "%s: !returned size wrong!", sname);
   2142   1.74  jonathan 
   2143   1.79    atatat 	if (xflag || rflag) {
   2144   1.75    atatat 		display_struct(pnode, sname, &clkinfo, sz,
   2145   1.75    atatat 			       DISPLAY_VALUE);
   2146   1.79    atatat 		return;
   2147   1.79    atatat 	}
   2148   1.75    atatat 	else if (!nflag)
   2149   1.75    atatat 		printf("%s: ", sname);
   2150   1.75    atatat 	printf("tick = %d, tickadj = %d, hz = %d, profhz = %d, stathz = %d\n",
   2151   1.75    atatat 	       clkinfo.tick, clkinfo.tickadj,
   2152   1.75    atatat 	       clkinfo.hz, clkinfo.profhz, clkinfo.stathz);
   2153   1.75    atatat }
   2154    1.1       cgd 
   2155   1.75    atatat /*ARGSUSED*/
   2156   1.75    atatat static void
   2157   1.75    atatat kern_boottime(HANDLER_ARGS)
   2158    1.1       cgd {
   2159   1.75    atatat 	struct timeval timeval;
   2160   1.75    atatat 	time_t boottime;
   2161   1.75    atatat 	size_t sz;
   2162   1.75    atatat 	int rc;
   2163   1.75    atatat 
   2164   1.75    atatat 	sz = sizeof(timeval);
   2165  1.133     pooka 	rc = prog_sysctl(name, namelen, &timeval, &sz, NULL, 0);
   2166   1.75    atatat 	if (rc == -1) {
   2167   1.75    atatat 		sysctlerror(1);
   2168   1.75    atatat 		return;
   2169   1.75    atatat 	}
   2170   1.75    atatat 	if (sz != sizeof(timeval))
   2171   1.75    atatat 		errx(1, "%s: !returned size wrong!", sname);
   2172    1.1       cgd 
   2173   1.75    atatat 	boottime = timeval.tv_sec;
   2174   1.75    atatat 	if (xflag || rflag)
   2175   1.75    atatat 		display_struct(pnode, sname, &timeval, sz,
   2176   1.75    atatat 			       DISPLAY_VALUE);
   2177   1.75    atatat 	else if (!nflag)
   2178   1.75    atatat 		/* ctime() provides the \n */
   2179   1.75    atatat 		printf("%s%s%s", sname, eq, ctime(&boottime));
   2180   1.75    atatat 	else if (nflag == 1)
   2181   1.75    atatat 		printf("%ld\n", (long)boottime);
   2182   1.75    atatat 	else
   2183   1.75    atatat 		printf("%ld.%06ld\n", (long)timeval.tv_sec,
   2184   1.75    atatat 		       (long)timeval.tv_usec);
   2185   1.75    atatat }
   2186   1.20    itojun 
   2187   1.75    atatat /*ARGSUSED*/
   2188   1.75    atatat static void
   2189   1.75    atatat kern_consdev(HANDLER_ARGS)
   2190   1.20    itojun {
   2191   1.75    atatat 	dev_t cons;
   2192   1.75    atatat 	size_t sz;
   2193   1.75    atatat 	int rc;
   2194   1.75    atatat 
   2195   1.75    atatat 	sz = sizeof(cons);
   2196  1.133     pooka 	rc = prog_sysctl(name, namelen, &cons, &sz, NULL, 0);
   2197   1.75    atatat 	if (rc == -1) {
   2198   1.75    atatat 		sysctlerror(1);
   2199   1.75    atatat 		return;
   2200   1.75    atatat 	}
   2201   1.75    atatat 	if (sz != sizeof(cons))
   2202   1.75    atatat 		errx(1, "%s: !returned size wrong!", sname);
   2203   1.20    itojun 
   2204   1.75    atatat 	if (xflag || rflag)
   2205   1.75    atatat 		display_struct(pnode, sname, &cons, sz,
   2206   1.75    atatat 			       DISPLAY_VALUE);
   2207  1.101  christos 	else {
   2208  1.101  christos 		if (!nflag)
   2209  1.101  christos 			printf("%s%s", sname, eq);
   2210  1.102  christos 		if (nflag < 2 && (sname = devname(cons, S_IFCHR)) != NULL)
   2211  1.102  christos 			printf("%s\n", sname);
   2212  1.101  christos 		else
   2213  1.125  christos 			printf("0x%llx\n", (unsigned long long)cons);
   2214  1.101  christos 	}
   2215   1.75    atatat }
   2216   1.17   thorpej 
   2217   1.75    atatat /*ARGSUSED*/
   2218   1.75    atatat static void
   2219   1.75    atatat kern_cp_time(HANDLER_ARGS)
   2220   1.17   thorpej {
   2221   1.80    atatat 	u_int64_t *cp_time;
   2222   1.80    atatat 	size_t sz, osz;
   2223   1.80    atatat 	int rc, i, n;
   2224   1.80    atatat 	char s[sizeof("kern.cp_time.nnnnnn")];
   2225   1.80    atatat 	const char *tname;
   2226   1.80    atatat 
   2227   1.80    atatat 	/*
   2228   1.80    atatat 	 * three things to do here.
   2229   1.80    atatat 	 * case 1: get sum (no Aflag and namelen == 2)
   2230   1.80    atatat 	 * case 2: get specific processor (namelen == 3)
   2231   1.80    atatat 	 * case 3: get all processors (Aflag and namelen == 2)
   2232   1.80    atatat 	 */
   2233   1.80    atatat 
   2234   1.80    atatat 	if (namelen == 2 && Aflag) {
   2235   1.80    atatat 		sz = sizeof(n);
   2236   1.80    atatat 		rc = sysctlbyname("hw.ncpu", &n, &sz, NULL, 0);
   2237   1.80    atatat 		if (rc != 0)
   2238   1.80    atatat 			return; /* XXX print an error, eh? */
   2239   1.81    atatat 		n++; /* Add on space for the sum. */
   2240   1.80    atatat 		sz = n * sizeof(u_int64_t) * CPUSTATES;
   2241   1.80    atatat 	}
   2242   1.80    atatat 	else {
   2243   1.81    atatat 		n = -1; /* Just print one data set. */
   2244   1.80    atatat 		sz = sizeof(u_int64_t) * CPUSTATES;
   2245   1.80    atatat 	}
   2246   1.80    atatat 
   2247   1.80    atatat 	cp_time = malloc(sz);
   2248   1.80    atatat 	if (cp_time == NULL) {
   2249   1.80    atatat 		sysctlerror(1);
   2250   1.80    atatat 		return;
   2251   1.80    atatat 	}
   2252   1.81    atatat 
   2253   1.80    atatat 	osz = sz;
   2254  1.133     pooka 	rc = prog_sysctl(name, namelen, cp_time + (n != -1) * CPUSTATES, &osz,
   2255   1.81    atatat 		    NULL, 0);
   2256   1.75    atatat 
   2257   1.75    atatat 	if (rc == -1) {
   2258   1.75    atatat 		sysctlerror(1);
   2259   1.80    atatat 		free(cp_time);
   2260   1.75    atatat 		return;
   2261   1.75    atatat 	}
   2262   1.81    atatat 
   2263   1.81    atatat 	/*
   2264   1.81    atatat 	 * Check, but account for space we'll occupy with the sum.
   2265   1.81    atatat 	 */
   2266   1.81    atatat 	if (osz != sz - (n != -1) * CPUSTATES * sizeof(u_int64_t))
   2267   1.75    atatat 		errx(1, "%s: !returned size wrong!", sname);
   2268   1.17   thorpej 
   2269   1.81    atatat 	/*
   2270   1.81    atatat 	 * Compute the actual sum.  Two calls would be easier (we
   2271   1.81    atatat 	 * could just call ourselves recursively above), but the
   2272   1.81    atatat 	 * numbers wouldn't add up.
   2273   1.81    atatat 	 */
   2274   1.81    atatat 	if (n != -1) {
   2275   1.81    atatat 		memset(cp_time, 0, sizeof(u_int64_t) * CPUSTATES);
   2276   1.81    atatat 		for (i = 1; i < n; i++) {
   2277   1.81    atatat 			cp_time[CP_USER] += cp_time[i * CPUSTATES + CP_USER];
   2278   1.81    atatat                         cp_time[CP_NICE] += cp_time[i * CPUSTATES + CP_NICE];
   2279   1.81    atatat                         cp_time[CP_SYS] += cp_time[i * CPUSTATES + CP_SYS];
   2280   1.81    atatat                         cp_time[CP_INTR] += cp_time[i * CPUSTATES + CP_INTR];
   2281   1.81    atatat                         cp_time[CP_IDLE] += cp_time[i * CPUSTATES + CP_IDLE];
   2282   1.81    atatat 		}
   2283   1.81    atatat 	}
   2284   1.81    atatat 
   2285   1.80    atatat 	tname = sname;
   2286   1.80    atatat 	for (i = 0; n == -1 || i < n; i++) {
   2287   1.81    atatat 		if (i > 0) {
   2288   1.81    atatat 			(void)snprintf(s, sizeof(s), "%s%s%d", sname, sep,
   2289   1.81    atatat 				       i - 1);
   2290   1.80    atatat 			tname = s;
   2291   1.80    atatat 		}
   2292   1.80    atatat 		if (xflag || rflag)
   2293   1.80    atatat 			display_struct(pnode, tname, cp_time + (i * CPUSTATES),
   2294   1.80    atatat 				       sizeof(u_int64_t) * CPUSTATES,
   2295   1.80    atatat 				       DISPLAY_VALUE);
   2296   1.80    atatat 		else {
   2297   1.80    atatat 			if (!nflag)
   2298   1.80    atatat 				printf("%s: ", tname);
   2299   1.80    atatat 			printf("user = %" PRIu64
   2300   1.80    atatat 			       ", nice = %" PRIu64
   2301   1.80    atatat 			       ", sys = %" PRIu64
   2302   1.80    atatat 			       ", intr = %" PRIu64
   2303   1.80    atatat 			       ", idle = %" PRIu64
   2304   1.80    atatat 			       "\n",
   2305   1.80    atatat 			       cp_time[i * CPUSTATES + CP_USER],
   2306   1.80    atatat 			       cp_time[i * CPUSTATES + CP_NICE],
   2307   1.80    atatat 			       cp_time[i * CPUSTATES + CP_SYS],
   2308   1.80    atatat 			       cp_time[i * CPUSTATES + CP_INTR],
   2309   1.80    atatat 			       cp_time[i * CPUSTATES + CP_IDLE]);
   2310   1.80    atatat 		}
   2311   1.81    atatat 		/*
   2312   1.81    atatat 		 * Just printing the one node.
   2313   1.81    atatat 		 */
   2314   1.80    atatat 		if (n == -1)
   2315   1.80    atatat 			break;
   2316   1.79    atatat 	}
   2317   1.80    atatat 
   2318   1.80    atatat 	free(cp_time);
   2319   1.17   thorpej }
   2320   1.17   thorpej 
   2321   1.75    atatat /*ARGSUSED*/
   2322   1.75    atatat static void
   2323  1.118  christos kern_drivers(HANDLER_ARGS)
   2324  1.118  christos {
   2325  1.118  christos 	struct kinfo_drivers *kd;
   2326  1.118  christos 	size_t sz, i;
   2327  1.118  christos 	int rc;
   2328  1.118  christos 	const char *comma;
   2329  1.118  christos 
   2330  1.133     pooka 	rc = prog_sysctl(name, namelen, NULL, &sz, NULL, 0);
   2331  1.118  christos 	if (rc == -1) {
   2332  1.118  christos 		sysctlerror(1);
   2333  1.118  christos 		return;
   2334  1.118  christos 	}
   2335  1.118  christos 
   2336  1.118  christos 	if (sz % sizeof(*kd))
   2337  1.118  christos 		err(1, "bad size %zu for kern.drivers", sz);
   2338  1.118  christos 
   2339  1.118  christos 	kd = malloc(sz);
   2340  1.118  christos 	if (kd == NULL) {
   2341  1.118  christos 		sysctlerror(1);
   2342  1.118  christos 		return;
   2343  1.118  christos 	}
   2344  1.118  christos 
   2345  1.133     pooka 	rc = prog_sysctl(name, namelen, kd, &sz, NULL, 0);
   2346  1.118  christos 	if (rc == -1) {
   2347  1.118  christos 		sysctlerror(1);
   2348  1.118  christos 		return;
   2349  1.118  christos 	}
   2350  1.118  christos 
   2351  1.118  christos 	comma = "";
   2352  1.119  christos 	if (!nflag)
   2353  1.119  christos 		printf("%s%s", sname, eq);
   2354  1.118  christos 	for (i = 0, sz /= sizeof(*kd); i < sz; i++) {
   2355  1.118  christos 		(void)printf("%s[%d %d %s]", comma, kd[i].d_cmajor,
   2356  1.118  christos 		    kd[i].d_bmajor, kd[i].d_name);
   2357  1.118  christos 		comma = ", ";
   2358  1.118  christos 	}
   2359  1.118  christos 	(void)printf("\n");
   2360  1.118  christos 	free(kd);
   2361  1.118  christos }
   2362  1.118  christos 
   2363  1.118  christos /*ARGSUSED*/
   2364  1.118  christos static void
   2365  1.103  christos kern_cp_id(HANDLER_ARGS)
   2366  1.103  christos {
   2367  1.103  christos 	u_int64_t *cp_id;
   2368  1.103  christos 	size_t sz, osz;
   2369  1.103  christos 	int rc, i, n;
   2370  1.103  christos 	char s[sizeof("kern.cp_id.nnnnnn")];
   2371  1.103  christos 	const char *tname;
   2372  1.103  christos 	struct sysctlnode node = *pnode;
   2373  1.103  christos 
   2374  1.103  christos 	/*
   2375  1.103  christos 	 * three things to do here.
   2376  1.103  christos 	 * case 1: print a specific cpu id (namelen == 3)
   2377  1.103  christos 	 * case 2: print all cpu ids separately (Aflag set)
   2378  1.103  christos 	 * case 3: print all cpu ids on one line
   2379  1.103  christos 	 */
   2380  1.103  christos 
   2381  1.103  christos 	if (namelen == 2) {
   2382  1.103  christos 		sz = sizeof(n);
   2383  1.103  christos 		rc = sysctlbyname("hw.ncpu", &n, &sz, NULL, 0);
   2384  1.103  christos 		if (rc != 0)
   2385  1.103  christos 			return; /* XXX print an error, eh? */
   2386  1.103  christos 		sz = n * sizeof(u_int64_t);
   2387  1.103  christos 	}
   2388  1.103  christos 	else {
   2389  1.103  christos 		n = -1; /* Just print one cpu id. */
   2390  1.103  christos 		sz = sizeof(u_int64_t);
   2391  1.103  christos 	}
   2392  1.103  christos 
   2393  1.103  christos 	cp_id = malloc(sz);
   2394  1.103  christos 	if (cp_id == NULL) {
   2395  1.103  christos 		sysctlerror(1);
   2396  1.103  christos 		return;
   2397  1.103  christos 	}
   2398  1.103  christos 
   2399  1.103  christos 	osz = sz;
   2400  1.133     pooka 	rc = prog_sysctl(name, namelen, cp_id, &osz, NULL, 0);
   2401  1.103  christos 	if (rc == -1) {
   2402  1.103  christos 		sysctlerror(1);
   2403  1.103  christos 		free(cp_id);
   2404  1.103  christos 		return;
   2405  1.103  christos 	}
   2406  1.103  christos 
   2407  1.103  christos 	/*
   2408  1.103  christos 	 * Check that we got back what we asked for.
   2409  1.103  christos 	 */
   2410  1.103  christos 	if (osz != sz)
   2411  1.103  christos 		errx(1, "%s: !returned size wrong!", sname);
   2412  1.103  christos 
   2413  1.103  christos 	/* pretend for output purposes */
   2414  1.103  christos 	node.sysctl_flags = SYSCTL_FLAGS(pnode->sysctl_flags) |
   2415  1.103  christos 		SYSCTL_TYPE(CTLTYPE_QUAD);
   2416  1.103  christos 
   2417  1.103  christos 	tname = sname;
   2418  1.103  christos 	if (namelen == 3)
   2419  1.103  christos 		display_number(&node, tname, cp_id,
   2420  1.103  christos 			       sizeof(u_int64_t),
   2421  1.103  christos 			       DISPLAY_VALUE);
   2422  1.103  christos 	else if (Aflag) {
   2423  1.103  christos 		for (i = 0; i < n; i++)
   2424  1.103  christos 			(void)snprintf(s, sizeof(s), "%s%s%d", sname, sep, i);
   2425  1.103  christos 			tname = s;
   2426  1.103  christos 			display_number(&node, tname, &cp_id[i],
   2427  1.103  christos 				       sizeof(u_int64_t),
   2428  1.103  christos 				       DISPLAY_VALUE);
   2429  1.103  christos 	}
   2430  1.103  christos 	else {
   2431  1.103  christos 		if (xflag || rflag)
   2432  1.103  christos 			display_struct(pnode, tname, cp_id, sz, DISPLAY_VALUE);
   2433  1.103  christos 		else {
   2434  1.103  christos 			if (!nflag)
   2435  1.103  christos 				printf("%s: ", tname);
   2436  1.103  christos 			for (i = 0; i < n; i++) {
   2437  1.103  christos 				if (i)
   2438  1.103  christos 					printf(", ");
   2439  1.103  christos 				printf("%d = %" PRIu64, i, cp_id[i]);
   2440  1.103  christos 			}
   2441  1.103  christos 			printf("\n");
   2442  1.103  christos 		}
   2443  1.103  christos 	}
   2444  1.103  christos 
   2445  1.103  christos 	free(cp_id);
   2446  1.103  christos }
   2447  1.103  christos 
   2448  1.103  christos /*ARGSUSED*/
   2449  1.103  christos static void
   2450   1.75    atatat vm_loadavg(HANDLER_ARGS)
   2451   1.22    bouyer {
   2452   1.75    atatat 	struct loadavg loadavg;
   2453   1.75    atatat 	size_t sz;
   2454   1.75    atatat 	int rc;
   2455   1.75    atatat 
   2456   1.75    atatat 	sz = sizeof(loadavg);
   2457  1.133     pooka 	rc = prog_sysctl(name, namelen, &loadavg, &sz, NULL, 0);
   2458   1.75    atatat 	if (rc == -1) {
   2459   1.75    atatat 		sysctlerror(1);
   2460   1.75    atatat 		return;
   2461   1.75    atatat 	}
   2462   1.75    atatat 	if (sz != sizeof(loadavg))
   2463   1.75    atatat 		errx(1, "%s: !returned size wrong!", sname);
   2464   1.75    atatat 
   2465   1.79    atatat 	if (xflag || rflag) {
   2466   1.75    atatat 		display_struct(pnode, sname, &loadavg, sz,
   2467   1.75    atatat 			       DISPLAY_VALUE);
   2468   1.79    atatat 		return;
   2469   1.79    atatat 	}
   2470   1.79    atatat 	if (!nflag)
   2471   1.75    atatat 		printf("%s: ", sname);
   2472   1.75    atatat 	printf("%.2f %.2f %.2f\n",
   2473   1.75    atatat 	       (double) loadavg.ldavg[0] / loadavg.fscale,
   2474   1.75    atatat 	       (double) loadavg.ldavg[1] / loadavg.fscale,
   2475   1.75    atatat 	       (double) loadavg.ldavg[2] / loadavg.fscale);
   2476    1.1       cgd }
   2477    1.1       cgd 
   2478   1.75    atatat /*ARGSUSED*/
   2479   1.75    atatat static void
   2480   1.75    atatat proc_limit(HANDLER_ARGS)
   2481    1.1       cgd {
   2482   1.75    atatat 	u_quad_t olim, *newp, nlim;
   2483   1.75    atatat 	size_t osz, nsz;
   2484   1.75    atatat 	char *t;
   2485   1.75    atatat 	int rc;
   2486   1.75    atatat 
   2487   1.92    atatat 	if (fn)
   2488   1.92    atatat 		trim_whitespace(value, 3);
   2489   1.92    atatat 
   2490   1.75    atatat 	osz = sizeof(olim);
   2491   1.75    atatat 	if (value != NULL) {
   2492   1.75    atatat 		nsz = sizeof(nlim);
   2493   1.75    atatat 		newp = &nlim;
   2494   1.75    atatat 		if (strcmp(value, "unlimited") == 0)
   2495   1.75    atatat 			nlim = RLIM_INFINITY;
   2496   1.75    atatat 		else {
   2497   1.75    atatat 			errno = 0;
   2498   1.75    atatat 			nlim = strtouq(value, &t, 0);
   2499   1.94    atatat 			if (t == value || *t != '\0' || errno != 0) {
   2500   1.92    atatat 				sysctlperror("%s: '%s' is not a valid limit\n",
   2501   1.92    atatat 					     sname, value);
   2502   1.92    atatat 				EXIT(1);
   2503   1.75    atatat 			}
   2504   1.75    atatat 		}
   2505   1.75    atatat 	}
   2506   1.75    atatat 	else {
   2507   1.75    atatat 		nsz = 0;
   2508   1.75    atatat 		newp = NULL;
   2509   1.75    atatat 	}
   2510   1.75    atatat 
   2511  1.133     pooka 	rc = prog_sysctl(name, namelen, &olim, &osz, newp, nsz);
   2512   1.75    atatat 	if (rc == -1) {
   2513   1.75    atatat 		sysctlerror(newp == NULL);
   2514   1.75    atatat 		return;
   2515   1.75    atatat 	}
   2516   1.75    atatat 
   2517   1.75    atatat 	if (newp && qflag)
   2518   1.75    atatat 		return;
   2519   1.75    atatat 
   2520   1.75    atatat 	if (rflag || xflag || olim != RLIM_INFINITY)
   2521   1.75    atatat 		display_number(pnode, sname, &olim, sizeof(olim),
   2522   1.75    atatat 			       newp ? DISPLAY_OLD : DISPLAY_VALUE);
   2523   1.75    atatat 	else
   2524   1.75    atatat 		display_string(pnode, sname, "unlimited", 10,
   2525   1.75    atatat 			       newp ? DISPLAY_OLD : DISPLAY_VALUE);
   2526    1.1       cgd 
   2527   1.75    atatat 	if (newp) {
   2528   1.75    atatat 		if (rflag || xflag || nlim != RLIM_INFINITY)
   2529   1.75    atatat 			display_number(pnode, sname, &nlim, sizeof(nlim),
   2530   1.75    atatat 				       DISPLAY_NEW);
   2531   1.75    atatat 		else
   2532   1.75    atatat 			display_string(pnode, sname, "unlimited", 10,
   2533   1.75    atatat 				       DISPLAY_NEW);
   2534    1.1       cgd 	}
   2535    1.1       cgd }
   2536    1.1       cgd 
   2537   1.75    atatat #ifdef CPU_DISKINFO
   2538   1.75    atatat /*ARGSUSED*/
   2539   1.14  christos static void
   2540   1.75    atatat machdep_diskinfo(HANDLER_ARGS)
   2541    1.1       cgd {
   2542   1.75    atatat 	struct disklist *dl;
   2543   1.75    atatat 	struct biosdisk_info *bi;
   2544   1.75    atatat 	struct nativedisk_info *ni;
   2545   1.75    atatat 	int rc;
   2546   1.75    atatat 	size_t sz;
   2547   1.75    atatat 	uint i, b, lim;
   2548   1.75    atatat 
   2549  1.133     pooka 	rc = prog_sysctl(name, namelen, NULL, &sz, NULL, 0);
   2550   1.75    atatat 	if (rc == -1) {
   2551   1.75    atatat 		sysctlerror(1);
   2552   1.75    atatat 		return;
   2553   1.75    atatat 	}
   2554   1.75    atatat 	dl = malloc(sz);
   2555   1.75    atatat 	if (dl == NULL) {
   2556   1.75    atatat 		sysctlerror(1);
   2557   1.75    atatat 		return;
   2558   1.75    atatat 	}
   2559  1.133     pooka 	rc = prog_sysctl(name, namelen, dl, &sz, NULL, 0);
   2560   1.75    atatat 	if (rc == -1) {
   2561   1.75    atatat 		sysctlerror(1);
   2562   1.75    atatat 		return;
   2563   1.75    atatat 	}
   2564   1.45       cgd 
   2565   1.75    atatat 	if (!nflag)
   2566   1.75    atatat 		printf("%s: ", sname);
   2567   1.75    atatat 	lim = dl->dl_nbiosdisks;
   2568   1.75    atatat 	if (lim > MAX_BIOSDISKS)
   2569   1.75    atatat 		lim = MAX_BIOSDISKS;
   2570   1.75    atatat 	for (bi = dl->dl_biosdisks, i = 0; i < lim; bi++, i++)
   2571   1.75    atatat 		printf("%x:%" PRIu64 "(%d/%d/%d),%x ",
   2572   1.75    atatat 		       bi->bi_dev, bi->bi_lbasecs,
   2573   1.75    atatat 		       bi->bi_cyl, bi->bi_head, bi->bi_sec,
   2574   1.75    atatat 		       bi->bi_flags);
   2575   1.75    atatat 	lim = dl->dl_nnativedisks;
   2576   1.75    atatat 	ni = dl->dl_nativedisks;
   2577   1.75    atatat 	bi = dl->dl_biosdisks;
   2578   1.75    atatat 	/* LINTED -- pointer casts are tedious */
   2579   1.75    atatat 	if ((char *)&ni[lim] != (char *)dl + sz) {
   2580   1.92    atatat 		sysctlperror("%s: size mismatch\n", gsname);
   2581   1.75    atatat 		return;
   2582   1.75    atatat 	}
   2583   1.75    atatat 	for (i = 0; i < lim; ni++, i++) {
   2584   1.75    atatat 		char t = ':';
   2585   1.75    atatat 		printf(" %.*s", (int)sizeof ni->ni_devname,
   2586   1.75    atatat 		       ni->ni_devname);
   2587  1.128     lukem 		for (b = 0; b < (unsigned int)ni->ni_nmatches; t = ',', b++)
   2588   1.75    atatat 			printf("%c%x", t,
   2589   1.75    atatat 			       bi[ni->ni_biosmatches[b]].bi_dev);
   2590   1.75    atatat 	}
   2591   1.75    atatat 	printf("\n");
   2592  1.126     njoly 	free(dl);
   2593    1.1       cgd }
   2594   1.75    atatat #endif /* CPU_DISKINFO */
   2595  1.108      elad 
   2596  1.108      elad /*ARGSUSED*/
   2597  1.108      elad static void
   2598  1.108      elad mode_bits(HANDLER_ARGS)
   2599  1.108      elad {
   2600  1.122      elad 	char buf[12], outbuf[100];
   2601  1.108      elad 	int o, m, *newp, rc;
   2602  1.108      elad 	size_t osz, nsz;
   2603  1.108      elad 	mode_t om, mm;
   2604  1.108      elad 
   2605  1.108      elad 	if (fn)
   2606  1.108      elad 		trim_whitespace(value, 3);
   2607  1.108      elad 
   2608  1.108      elad 	newp = NULL;
   2609  1.108      elad 	osz = sizeof(o);
   2610  1.108      elad 	if (value != NULL) {
   2611  1.108      elad 		void *foo;
   2612  1.108      elad 		int tt;
   2613  1.108      elad 		size_t ttsz = sizeof(tt);
   2614  1.108      elad 		mode_t old_umask;
   2615  1.108      elad 
   2616  1.108      elad 		nsz = sizeof(m);
   2617  1.108      elad 		newp = &m;
   2618  1.108      elad 		errno = 0;
   2619  1.133     pooka 		rc = prog_sysctl(name, namelen, &tt, &ttsz, NULL, 0);
   2620  1.108      elad 		if (rc == -1) {
   2621  1.108      elad 			sysctlperror("%s: failed query\n", sname);
   2622  1.108      elad 			return;
   2623  1.108      elad 		}
   2624  1.108      elad 
   2625  1.108      elad 		old_umask = umask(0);
   2626  1.108      elad 		foo = setmode(value);
   2627  1.108      elad 		umask(old_umask);
   2628  1.108      elad 		if (foo == NULL) {
   2629  1.108      elad 			sysctlperror("%s: '%s' is an invalid mode\n", sname,
   2630  1.108      elad 				     value);
   2631  1.108      elad 			EXIT(1);
   2632  1.108      elad 		}
   2633  1.108      elad 		old_umask = umask(0);
   2634  1.108      elad 		m = getmode(foo, (mode_t)tt);
   2635  1.108      elad 		umask(old_umask);
   2636  1.108      elad 		if (errno) {
   2637  1.108      elad 			sysctlperror("%s: '%s' is an invalid mode\n", sname,
   2638  1.108      elad 				     value);
   2639  1.108      elad 			EXIT(1);
   2640  1.108      elad 		}
   2641  1.108      elad 	}
   2642  1.108      elad 	else {
   2643  1.108      elad 		nsz = 0;
   2644  1.108      elad 		newp = NULL;
   2645  1.108      elad 	}
   2646  1.108      elad 
   2647  1.133     pooka 	rc = prog_sysctl(name, namelen, &o, &osz, newp, nsz);
   2648  1.108      elad 	if (rc == -1) {
   2649  1.108      elad 		sysctlerror(newp == NULL);
   2650  1.108      elad 		return;
   2651  1.108      elad 	}
   2652  1.108      elad 
   2653  1.108      elad 	if (newp && qflag)
   2654  1.108      elad 		return;
   2655  1.108      elad 
   2656  1.108      elad 	om = (mode_t)o;
   2657  1.108      elad 	mm = (mode_t)m;
   2658  1.108      elad 
   2659  1.108      elad 	if (rflag || xflag)
   2660  1.108      elad 		display_number(pnode, sname, &o, sizeof(o),
   2661  1.108      elad 			       newp ? DISPLAY_OLD : DISPLAY_VALUE);
   2662  1.108      elad 	else {
   2663  1.108      elad 		memset(buf, 0, sizeof(buf));
   2664  1.108      elad 		strmode(om, buf);
   2665  1.108      elad 		rc = snprintf(outbuf, sizeof(outbuf), "%04o (%s)", om, buf + 1);
   2666  1.108      elad 		display_string(pnode, sname, outbuf, rc, newp ? DISPLAY_OLD : DISPLAY_VALUE);
   2667  1.108      elad 	}
   2668  1.108      elad 
   2669  1.108      elad 	if (newp) {
   2670  1.108      elad 		if (rflag || xflag)
   2671  1.108      elad 			display_number(pnode, sname, &m, sizeof(m),
   2672  1.108      elad 				       DISPLAY_NEW);
   2673  1.108      elad 		else {
   2674  1.108      elad 			memset(buf, 0, sizeof(buf));
   2675  1.108      elad 			strmode(mm, buf);
   2676  1.108      elad 			rc = snprintf(outbuf, sizeof(outbuf), "%04o (%s)", mm, buf + 1);
   2677  1.108      elad 			display_string(pnode, sname, outbuf, rc, DISPLAY_NEW);
   2678  1.108      elad 		}
   2679  1.108      elad 	}
   2680  1.108      elad }
   2681