/* $NetBSD: sysctl.c,v 1.156 2015/08/17 06:42:46 knakahara Exp $ */

/*-

* Copyright (c) 2003 The NetBSD Foundation, Inc.

* All rights reserved.

*

* This code is derived from software contributed to The NetBSD Foundation

* by Andrew Brown.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

*

* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS

* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED

* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS

* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

* POSSIBILITY OF SUCH DAMAGE.

*/

/*

* Copyright (c) 1993

* The Regents of the University of California. All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

* 3. Neither the name of the University nor the names of its contributors

* may be used to endorse or promote products derived from this software

* without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*/

#include <sys/cdefs.h>

#ifndef lint

__COPYRIGHT("@(#) Copyright (c) 1993\

The Regents of the University of California. All rights reserved.");

#endif /* not lint */

#ifndef lint

#if 0

static char sccsid[] = "@(#)sysctl.c 8.1 (Berkeley) 6/6/93";

#else

__RCSID("$NetBSD: sysctl.c,v 1.156 2015/08/17 06:42:46 knakahara Exp $");

#endif

#endif /* not lint */

#include <sys/types.h>

#include <sys/param.h>

#include <sys/sysctl.h>

#include <sys/mount.h>

#include <sys/resource.h>

#include <sys/stat.h>

#include <sys/sched.h>

#include <sys/socket.h>

#include <sys/bitops.h>

#include <netinet/in.h>

#include <netinet/ip_var.h>

#include <netinet/tcp.h>

#ifndef __minix

#include <netinet/tcp_timer.h>

#include <netinet/tcp_var.h>

#include <netinet/icmp6.h>

#include <nfs/rpcv2.h>

#include <nfs/nfsproto.h>

#include <nfs/nfs.h>

#endif /* !__minix */

#include <machine/cpu.h>

#include <assert.h>

#include <ctype.h>

#include <err.h>

#include <errno.h>

#include <inttypes.h>

#include <regex.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <unistd.h>

#include "prog_ops.h"

/*

* this needs to be able to do the printing and the setting

*/

#define HANDLER_PROTO const char *, const char *, char *, \

int *, u_int, const struct sysctlnode *, \

u_int, void *

#define HANDLER_ARGS const char *sname, const char *dname, char *value, \

int *name, u_int namelen, const struct sysctlnode *pnode, \

u_int type, void *v

#define DISPLAY_VALUE 0

#define DISPLAY_OLD 1

#define DISPLAY_NEW 2

/*

* generic routines

*/

static const struct handlespec *findhandler(const char *, regex_t *, size_t *);

static void canonicalize(const char *, char *);

static void purge_tree(struct sysctlnode *);

static void print_tree(int *, u_int, struct sysctlnode *, u_int, int, regex_t *,

size_t *);

static void write_number(int *, u_int, struct sysctlnode *, char *);

static void write_string(int *, u_int, struct sysctlnode *, char *);

static void display_number(const struct sysctlnode *, const char *,

const void *, size_t, int);

static void display_string(const struct sysctlnode *, const char *,

const void *, size_t, int);

static void display_struct(const struct sysctlnode *, const char *,

const void *, size_t, int);

static void hex_dump(const unsigned char *, size_t);

__dead static void usage(void);

static void parse(char *, regex_t *, size_t *);

static void parse_create(char *);

static void parse_destroy(char *);

static void parse_describe(char *);

static void getdesc1(int *, u_int, struct sysctlnode *);

static void getdesc(int *, u_int, struct sysctlnode *);

static void trim_whitespace(char *, int);

static void sysctlerror(int);

static void sysctlparseerror(u_int, const char *);

static void sysctlperror(const char *, ...) __printflike(1, 2);

#define EXIT(n) do { \

if (fn == NULL) exit(n); else return; } while (/*CONSTCOND*/0)

/*

* "borrowed" from libc:sysctlgetmibinfo.c

*/

int __learn_tree(int *, u_int, struct sysctlnode *);

/*

* "handlers"

*/

static void printother(HANDLER_PROTO);

static void kern_clockrate(HANDLER_PROTO);

static void kern_boottime(HANDLER_PROTO);

static void kern_consdev(HANDLER_PROTO);

static void kern_cp_time(HANDLER_PROTO);

static void kern_cp_id(HANDLER_PROTO);

static void kern_drivers(HANDLER_PROTO);

static void vm_loadavg(HANDLER_PROTO);

static void proc_limit(HANDLER_PROTO);

#ifdef CPU_DISKINFO

static void machdep_diskinfo(HANDLER_PROTO);

#endif /* CPU_DISKINFO */

static void mode_bits(HANDLER_PROTO);

static void reserve(HANDLER_PROTO);

static const struct handlespec {

const char *ps_re;

void (*ps_p)(HANDLER_PROTO);

void (*ps_w)(HANDLER_PROTO);

const void *ps_d;

} handlers[] = {

{ "/kern/clockrate", kern_clockrate, NULL, NULL },

{ "/kern/evcnt", printother, NULL, "vmstat -e" },

{ "/kern/vnode", printother, NULL, "pstat" },

{ "/kern/proc(2|_args)?", printother, NULL, "ps" },

{ "/kern/file2?", printother, NULL, "pstat" },

{ "/kern/ntptime", printother, NULL,

"ntpdc -c kerninfo" },

{ "/kern/msgbuf", printother, NULL, "dmesg" },

{ "/kern/boottime", kern_boottime, NULL, NULL },

{ "/kern/consdev", kern_consdev, NULL, NULL },

{ "/kern/cp_time(/[0-9]+)?", kern_cp_time, NULL, NULL },

{ "/kern/sysvipc_info", printother, NULL, "ipcs" },

{ "/kern/cp_id(/[0-9]+)?", kern_cp_id, NULL, NULL },

{ "/kern/coredump/setid/mode", mode_bits, mode_bits, NULL },

{ "/kern/drivers", kern_drivers, NULL, NULL },

{ "/kern/intr/list", printother, NULL, "intrctl" },

{ "/kern/intr/affinity", printother, NULL, "intrctl" },

{ "/kern/intr/intr", printother, NULL, "intrctl" },

{ "/kern/intr/nointr", printother, NULL, "intrctl" },

{ "/vm/vmmeter", printother, NULL,

"vmstat' or 'systat" },

{ "/vm/loadavg", vm_loadavg, NULL, NULL },

{ "/vm/uvmexp2?", printother, NULL,

"vmstat' or 'systat" },

{ "/vfs/nfs/nfsstats", printother, NULL, "nfsstat" },

{ "/net/inet6?/tcp6?/ident", printother, NULL, "identd" },

{ "/net/inet6/icmp6/nd6_[dp]rlist", printother, NULL, "ndp" },

{ "/net/key/dumps[ap]", printother, NULL, "setkey" },

{ "/net/[^/]+/[^/]+/pcblist", printother, NULL,

"netstat' or 'sockstat" },

{ "/net/(inet|inet6)/[^/]+/stats", printother, NULL, "netstat"},

{ "/net/bpf/(stats|peers)", printother, NULL, "netstat"},

{ "/net/inet.*/tcp.*/deb.*", printother, NULL, "trpt" },

{ "/net/inet.*/ip.*/anonportalgo/reserve", reserve, reserve, NULL },

{ "/net/ns/spp/deb.*", printother, NULL, "trsp" },

{ "/hw/diskstats", printother, NULL, "iostat" },

#ifdef CPU_CONSDEV

{ "/machdep/consdev", kern_consdev, NULL, NULL },

#endif /* CPU_CONSDEV */

#ifdef CPU_DISKINFO

{ "/machdep/diskinfo", machdep_diskinfo, NULL, NULL },

#endif /* CPU_CONSDEV */

{ "/proc/[^/]+/rlimit/[^/]+/[^/]+", proc_limit, proc_limit, NULL },

/*

* these will only be called when the given node has no children

*/

{ "/net/[^/]+", printother, NULL, NULL },

{ "/debug", printother, NULL, NULL },

{ "/ddb", printother, NULL, NULL },

{ "/vendor", printother, NULL, NULL },

{ NULL, NULL, NULL, NULL },

};

struct sysctlnode my_root = {

.sysctl_flags = SYSCTL_VERSION|CTLFLAG_ROOT|CTLTYPE_NODE,

.sysctl_size = sizeof(struct sysctlnode),

.sysctl_num = 0,

.sysctl_name = "(prog_root)",

};

int Aflag, aflag, dflag, Mflag, nflag, qflag, rflag, wflag, xflag;

size_t nr;

char *fn;

int req, stale, errs;

FILE *warnfp = stderr;

#define MAXPORTS 0x10000

/*

* vah-riables n stuff

*/

char gsname[SYSCTL_NAMELEN * CTL_MAXNAME + CTL_MAXNAME],

canonname[SYSCTL_NAMELEN * CTL_MAXNAME + CTL_MAXNAME],

gdname[10 * CTL_MAXNAME + CTL_MAXNAME];

char sep[] = ".";

const char *eq = " = ";

const char *lname[] = {

"top", "second", "third", "fourth", "fifth", "sixth",

"seventh", "eighth", "ninth", "tenth", "eleventh", "twelfth"

};

/*

* you've heard of main, haven't you?

*/

int

main(int argc, char *argv[])

{

int name[CTL_MAXNAME];

int ch;

size_t lastcompiled = 0;

regex_t *re;

setprogname(argv[0]);

while ((ch = getopt(argc, argv, "Aabdef:Mnqrwx")) != -1) {

switch (ch) {

case 'A':

Aflag++;

break;

case 'a':

aflag++;

break;

case 'd':

dflag++;

break;

case 'e':

eq = "=";

break;

case 'f':

fn = optarg;

wflag++;

break;

case 'M':

Mflag++;

break;

case 'n':

nflag++;

break;

case 'q':

qflag++;

break;

case 'b': /* FreeBSD compat */

case 'r':

rflag++;

break;

case 'w':

wflag++;

break;

case 'x':

xflag++;

break;

default:

usage();

}

}

argc -= optind;

argv += optind;

if (xflag && rflag)

usage();

/* if ((xflag || rflag) && wflag)

usage(); */

/* if (aflag && (Mflag || qflag))

usage(); */

if ((aflag || Aflag) && qflag)

usage();

if ((Aflag || Mflag || dflag) && argc == 0 && fn == NULL)

aflag = 1;

if (prog_init && prog_init() == -1)

err(EXIT_FAILURE, "prog init failed");

if (Aflag)

warnfp = stdout;

stale = req = 0;

if ((re = malloc(sizeof(*re) * __arraycount(handlers))) == NULL)

err(EXIT_FAILURE, "malloc regex");

if (aflag) {

print_tree(&name[0], 0, NULL, CTLTYPE_NODE, 1,

re, &lastcompiled);

/* if (argc == 0) */

return (0);

}

if (fn) {

FILE *fp;

char *l;

fp = fopen(fn, "r");

if (fp == NULL) {

err(EXIT_FAILURE, "%s", fn);

} else {

nr = 0;

while ((l = fparseln(fp, NULL, &nr, NULL, 0)) != NULL)

{

if (*l) {

parse(l, re, &lastcompiled);

free(l);

}

}

fclose(fp);

}

return errs ? 1 : 0;

}

if (argc == 0)

usage();

while (argc-- > 0)

parse(*argv++, re, &lastcompiled);

return errs ? EXIT_FAILURE : EXIT_SUCCESS;

}

/*

* ********************************************************************

* how to find someone special to handle the reading (or maybe even

* writing) of a particular node

* ********************************************************************

*/

static const struct handlespec *

findhandler(const char *s, regex_t *re, size_t *lastcompiled)

{

const struct handlespec *p;

size_t i, l;

int j;

char eb[64];

regmatch_t match;

p = &handlers[0];

l = strlen(s);

for (i = 0; p[i].ps_re != NULL; i++) {

if (i >= *lastcompiled) {

j = regcomp(&re[i], p[i].ps_re, REG_EXTENDED);

if (j != 0) {

regerror(j, &re[i], eb, sizeof(eb));

errx(EXIT_FAILURE, "regcomp: %s: %s", p[i].ps_re, eb);

}

*lastcompiled = i + 1;

}

j = regexec(&re[i], s, 1, &match, 0);

if (j == 0) {

if (match.rm_so == 0 && match.rm_eo == (int)l)

return &p[i];

}

else if (j != REG_NOMATCH) {

regerror(j, &re[i], eb, sizeof(eb));

errx(EXIT_FAILURE, "regexec: %s: %s", p[i].ps_re, eb);

}

}

return NULL;

}

/*

* after sysctlgetmibinfo is done with the name, we convert all

* separators to / and stuff one at the front if it was missing

*/

static void

canonicalize(const char *i, char *o)

{

const char *t;

char p[SYSCTL_NAMELEN + 1];

int l;

if (i[0] != *sep) {

o[0] = '/';

o[1] = '\0';

}

else

o[0] = '\0';

t = i;

do {

i = t;

t = strchr(i, sep[0]);

if (t == NULL)

strcat(o, i);

else {

l = t - i;

t++;

memcpy(p, i, l);

p[l] = '\0';

strcat(o, p);

strcat(o, "/");

}

} while (t != NULL);

}

/*

* ********************************************************************

* convert this special number to a special string so we can print the

* mib

* ********************************************************************

*/

static const char *

sf(u_int f)

{

static char s[256];

const char *c;

s[0] = '\0';

c = "";

#define print_flag(_f, _s, _c, _q, _x) \

if (((_f) & (__CONCAT(CTLFLAG_,_x))) == (__CONCAT(CTLFLAG_,_q))) { \

strlcat((_s), (_c), sizeof(_s)); \

strlcat((_s), __STRING(_q), sizeof(_s)); \

(_c) = ","; \

(_f) &= ~(__CONCAT(CTLFLAG_,_x)); \

}

print_flag(f, s, c, READONLY, READWRITE);

print_flag(f, s, c, READWRITE, READWRITE);

print_flag(f, s, c, ANYWRITE, ANYWRITE);

print_flag(f, s, c, PRIVATE, PRIVATE);

print_flag(f, s, c, PERMANENT, PERMANENT);

print_flag(f, s, c, OWNDATA, OWNDATA);

print_flag(f, s, c, IMMEDIATE, IMMEDIATE);

print_flag(f, s, c, HEX, HEX);

print_flag(f, s, c, ROOT, ROOT);

print_flag(f, s, c, ANYNUMBER, ANYNUMBER);

print_flag(f, s, c, HIDDEN, HIDDEN);

print_flag(f, s, c, ALIAS, ALIAS);

#undef print_flag

if (f) {

char foo[9];

snprintf(foo, sizeof(foo), "%x", f);

strlcat(s, c, sizeof(s));

strlcat(s, foo, sizeof(s));

}

return (s);

}

static const char *

st(u_int t)

{

switch (t) {

case CTLTYPE_NODE:

return "NODE";

case CTLTYPE_INT:

return "INT";

case CTLTYPE_STRING:

return "STRING";

case CTLTYPE_QUAD:

return "QUAD";

case CTLTYPE_STRUCT:

return "STRUCT";

case CTLTYPE_BOOL:

return "BOOL";

}

return "???";

}

/*

* ********************************************************************

* recursively eliminate all data belonging to the given node

* ********************************************************************

*/

static void

purge_tree(struct sysctlnode *rnode)

{

struct sysctlnode *node;

if (rnode == NULL ||

SYSCTL_TYPE(rnode->sysctl_flags) != CTLTYPE_NODE ||

rnode->sysctl_child == NULL)

return;

for (node = rnode->sysctl_child;

node < &rnode->sysctl_child[rnode->sysctl_clen];

node++)

purge_tree(node);

free(rnode->sysctl_child);

rnode->sysctl_csize = 0;

rnode->sysctl_clen = 0;

rnode->sysctl_child = NULL;

if (rnode->sysctl_desc == (const char*)-1)

rnode->sysctl_desc = NULL;

if (rnode->sysctl_desc != NULL)

free(__UNCONST(rnode->sysctl_desc));

rnode->sysctl_desc = NULL;

}

static void __attribute__((__format__(__printf__, 3, 4)))

appendprintf(char **bp, size_t *lbp, const char *fmt, ...)

{

int r;

va_list ap;

va_start(ap, fmt);

r = vsnprintf(*bp, *lbp, fmt, ap);

va_end(ap);

if (r < 0 || (size_t)r > *lbp)

r = *lbp;

*bp += r;

*lbp -= r;

}

/*

* ********************************************************************

* print this node and any others underneath it

* ********************************************************************

*/

static void

print_tree(int *name, u_int namelen, struct sysctlnode *pnode, u_int type,

int add, regex_t *re, size_t *lastcompiled)

{

struct sysctlnode *node;

int rc;

size_t ni, sz, ldp, lsp;

char *sp, *dp, *tsp, *tdp;

const struct handlespec *p;

sp = tsp = &gsname[strlen(gsname)];

dp = tdp = &gdname[strlen(gdname)];

ldp = sizeof(gdname) - (dp - gdname);

lsp = sizeof(gsname) - (sp - gsname);

if (sp != &gsname[0] && dp == &gdname[0]) {

/*

* aw...shucks. now we must play catch up

*/

for (ni = 0; ni < namelen; ni++)

appendprintf(&tdp, &ldp, "%s%d", ni > 0 ? "." : "",

name[ni]);

}

if (pnode == NULL)

pnode = &my_root;

else if (add) {

appendprintf(&tsp, &lsp, "%s%s", namelen > 1 ? sep : "",

pnode->sysctl_name);

appendprintf(&tdp, &ldp, "%s%d", namelen > 1 ? "." : "",

pnode->sysctl_num);

}

if (Mflag && pnode != &my_root) {

if (nflag)

printf("%s: ", gdname);

else

printf("%s (%s): ", gsname, gdname);

printf("CTLTYPE_%s", st(type));

if (type == CTLTYPE_NODE) {

if (SYSCTL_FLAGS(pnode->sysctl_flags) & CTLFLAG_ALIAS)

printf(", alias %d",

pnode->sysctl_alias);

else

printf(", children %d/%d",

pnode->sysctl_clen,

pnode->sysctl_csize);

}

printf(", size %zu", pnode->sysctl_size);

printf(", flags 0x%x<%s>",

SYSCTL_FLAGS(pnode->sysctl_flags),

sf(SYSCTL_FLAGS(pnode->sysctl_flags)));

if (pnode->sysctl_func)

printf(", func=%p", pnode->sysctl_func);

printf(", ver=%d", pnode->sysctl_ver);

printf("\n");

if (type != CTLTYPE_NODE) {

*sp = *dp = '\0';

return;

}

}

if (dflag && pnode != &my_root) {

if (Aflag || type != CTLTYPE_NODE) {

if (pnode->sysctl_desc == NULL)

getdesc1(name, namelen, pnode);

if (Aflag || !add ||

(pnode->sysctl_desc != NULL &&

pnode->sysctl_desc != (const char*)-1)) {

if (!nflag)

printf("%s: ", gsname);

if (pnode->sysctl_desc == NULL ||

pnode->sysctl_desc == (const char*)-1)

printf("(no description)\n");

else

printf("%s\n", pnode->sysctl_desc);

}

}

if (type != CTLTYPE_NODE) {

*sp = *dp = '\0';

return;

}

}

/*

* if this is an alias and we added our name, that means we

* got here by recursing down into the tree, so skip it. The

* only way to print an aliased node is with either -M or by

* name specifically.

*/

if (SYSCTL_FLAGS(pnode->sysctl_flags) & CTLFLAG_ALIAS && add) {

*sp = *dp = '\0';

return;

}

canonicalize(gsname, canonname);

p = findhandler(canonname, re, lastcompiled);

if (type != CTLTYPE_NODE && p != NULL) {

if (p->ps_p == NULL) {

sysctlperror("Cannot print `%s': %s\n", gsname,

strerror(EOPNOTSUPP));

exit(EXIT_FAILURE);

}

(*p->ps_p)(gsname, gdname, NULL, name, namelen, pnode, type,

__UNCONST(p->ps_d));

*sp = *dp = '\0';

return;

}

if (type != CTLTYPE_NODE && pnode->sysctl_size == 0) {

rc = prog_sysctl(&name[0], namelen, NULL, &sz, NULL, 0);

if (rc == -1) {

sysctlerror(1);

*sp = *dp = '\0';

return;

}

if (sz == 0) {

if ((Aflag || req) && !Mflag)

printf("%s: node contains no data\n", gsname);

*sp = *dp = '\0';

return;

}

}

else

sz = pnode->sysctl_size;

switch (type) {

case CTLTYPE_NODE: {

__learn_tree(name, namelen, pnode);

node = pnode->sysctl_child;

if (node == NULL) {

if (dflag)

/* do nothing */;

else if (p != NULL)

(*p->ps_p)(gsname, gdname, NULL, name, namelen,

pnode, type, __UNCONST(p->ps_d));

else if ((Aflag || req) && !Mflag)

printf("%s: no children\n", gsname);

}

else {

if (dflag)

/*

* get all descriptions for next level

* in one chunk

*/

getdesc(name, namelen, pnode);

req = 0;

for (ni = 0; ni < pnode->sysctl_clen; ni++) {

name[namelen] = node[ni].sysctl_num;

if ((node[ni].sysctl_flags & CTLFLAG_HIDDEN) &&

!(Aflag || req))

continue;

print_tree(name, namelen + 1, &node[ni],

SYSCTL_TYPE(node[ni].sysctl_flags),

1, re, lastcompiled);

}

}

break;

}

case CTLTYPE_INT: {

int i;

rc = prog_sysctl(name, namelen, &i, &sz, NULL, 0);

if (rc == -1) {

sysctlerror(1);

break;

}

display_number(pnode, gsname, &i, sizeof(i), DISPLAY_VALUE);

break;

}

case CTLTYPE_BOOL: {

bool b;

rc = prog_sysctl(name, namelen, &b, &sz, NULL, 0);

if (rc == -1) {

sysctlerror(1);

break;

}

display_number(pnode, gsname, &b, sizeof(b), DISPLAY_VALUE);

break;

}

case CTLTYPE_STRING: {

unsigned char buf[1024], *tbuf;

tbuf = buf;

sz = sizeof(buf);

rc = prog_sysctl(&name[0], namelen, tbuf, &sz, NULL, 0);

if (rc == -1 && errno == ENOMEM) {

tbuf = malloc(sz);

if (tbuf == NULL) {

sysctlerror(1);

break;

}

rc = prog_sysctl(&name[0], namelen, tbuf, &sz, NULL, 0);

}

if (rc == -1)

sysctlerror(1);

else

display_string(pnode, gsname, tbuf, sz, DISPLAY_VALUE);

if (tbuf != buf)

free(tbuf);

break;

}

case CTLTYPE_QUAD: {

u_quad_t q;

sz = sizeof(q);

rc = prog_sysctl(&name[0], namelen, &q, &sz, NULL, 0);

if (rc == -1) {

sysctlerror(1);

break;

}

display_number(pnode, gsname, &q, sizeof(q), DISPLAY_VALUE);

break;

}

case CTLTYPE_STRUCT: {

/*

* we shouldn't actually get here, but if we

* do, would it be nice to have *something* to

* do other than completely ignore the

* request.

*/

unsigned char *d;

if ((d = malloc(sz)) == NULL) {

fprintf(warnfp, "%s: !malloc failed!\n", gsname);

break;

}

rc = prog_sysctl(&name[0], namelen, d, &sz, NULL, 0);

if (rc == -1) {

sysctlerror(1);

break;

}

display_struct(pnode, gsname, d, sz, DISPLAY_VALUE);

free(d);

break;

}

default:

/* should i print an error here? */

break;

}

*sp = *dp = '\0';

}

/*

* ********************************************************************

* parse a request, possibly determining that it's a create or destroy

* request

* ********************************************************************

*/

static void

parse(char *l, regex_t *re, size_t *lastcompiled)

{

struct sysctlnode *node;

const struct handlespec *w;

int name[CTL_MAXNAME], dodesc = 0;

u_int namelen, type;

char *key, *value, *dot;

size_t sz;

bool optional = false;

req = 1;

key = l;

if ((value = strchr(l, '=')) != NULL) {

if (value > l && value[-1] == '?') {

value[-1] = '\0';

optional = true;

}

*value++ = '\0';

}

if ((dot = strpbrk(key, "./")) == NULL)

sep[0] = '.';

else

sep[0] = dot[0];

sep[1] = '\0';

while (key[0] == sep[0] && key[1] == sep[0]) {

if (value != NULL)

value[-1] = '=';

if (strncmp(key + 2, "create", 6) == 0 &&

(key[8] == '=' || key[8] == sep[0]))

parse_create(key + 8 + (key[8] == '=' ? 1 : 0));

else if (strncmp(key + 2, "destroy", 7) == 0 &&

(key[9] == '=' || key[9] == sep[0]))

parse_destroy(key + 9 + (key[9] == '=' ? 1 : 0));

else if (strncmp(key + 2, "describe", 8) == 0 &&

(key[10] == '=' || key[10] == sep[0])) {

key += 10 + (key[10] == '=');

if ((value = strchr(key, '=')) != NULL)

parse_describe(key);

else {

if (!dflag)

dodesc = 1;

break;

}

}

else

sysctlperror("unable to parse '%s'\n", key);

return;

}

if (stale) {

purge_tree(&my_root);

stale = 0;

}

node = &my_root;

namelen = CTL_MAXNAME;

sz = sizeof(gsname);

if (sysctlgetmibinfo(key, &name[0], &namelen, gsname, &sz, &node,

SYSCTL_VERSION) == -1) {

if (optional)

return;

sysctlparseerror(namelen, l);

EXIT(EXIT_FAILURE);

}

type = SYSCTL_TYPE(node->sysctl_flags);

if (value == NULL) {

if (dodesc)

dflag = 1;

print_tree(&name[0], namelen, node, type, 0, re, lastcompiled);

if (dodesc)

dflag = 0;

gsname[0] = '\0';

return;

}

if (fn)

trim_whitespace(value, 1);

if (!wflag) {

sysctlperror("Must specify -w to set variables\n");

exit(EXIT_FAILURE);

}

canonicalize(gsname, canonname);

if (type != CTLTYPE_NODE && (w = findhandler(canonname, re,

lastcompiled)) != NULL) {

if (w->ps_w == NULL) {

sysctlperror("Cannot write `%s': %s\n", gsname,

strerror(EOPNOTSUPP));

exit(EXIT_FAILURE);

}

(*w->ps_w)(gsname, gdname, value, name, namelen, node, type,

__UNCONST(w->ps_d));

gsname[0] = '\0';

return;

}

switch (type) {

case CTLTYPE_NODE:

/*

* XXX old behavior is to print. should we error instead?

*/

print_tree(&name[0], namelen, node, CTLTYPE_NODE, 1, re,

lastcompiled);

break;

case CTLTYPE_INT:

case CTLTYPE_BOOL:

case CTLTYPE_QUAD:

write_number(&name[0], namelen, node, value);

break;

case CTLTYPE_STRING:

write_string(&name[0], namelen, node, value);

break;

case CTLTYPE_STRUCT:

/*

* XXX old behavior is to print. should we error instead?

*/

/* fprintf(warnfp, "you can't write to %s\n", gsname); */

print_tree(&name[0], namelen, node, type, 0, re, lastcompiled);

break;

}

}

/*

//create=foo.bar.whatever...,

[type=(int|quad|string|struct|node),]

[size=###,]

[n=###,]

[flags=(iohxparw12),]

[addr=0x####,|symbol=...|value=...]

size is optional for some types. type must be set before anything

else. nodes can have [rwhp], but nothing else applies. if no

size or type is given, node is asserted. writeable is the default,

with [rw] being read-only and unconditionally writeable

respectively. if you specify addr, it is assumed to be the name of

a kernel symbol, if value, CTLFLAG_OWNDATA will be asserted for

strings, CTLFLAG_IMMEDIATE for ints and u_quad_ts. you cannot

specify both value and addr.

*/

static void

parse_create(char *l)

{

struct sysctlnode node;

size_t sz;

char *nname, *key, *value, *data, *addr, *c, *t;

int name[CTL_MAXNAME], i, rc, method, flags, rw;

u_int namelen, type;

u_quad_t uq;

quad_t q;

bool b;

if (!wflag) {

sysctlperror("Must specify -w to create nodes\n");

exit(EXIT_FAILURE);

}