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