version 1.143.2.2, 2014/08/20 00:02:28 |
version 1.144, 2012/11/29 02:06:17 |
Line 72 __RCSID("$NetBSD$"); |
|
Line 72 __RCSID("$NetBSD$"); |
|
#endif |
#endif |
#endif /* not lint */ |
#endif /* not lint */ |
|
|
|
#define FD_SETSIZE 0x10000 |
|
#include <sys/fd_set.h> |
#include <sys/types.h> |
#include <sys/types.h> |
#include <sys/param.h> |
#include <sys/param.h> |
#include <sys/sysctl.h> |
#include <sys/sysctl.h> |
Line 80 __RCSID("$NetBSD$"); |
|
Line 82 __RCSID("$NetBSD$"); |
|
#include <sys/stat.h> |
#include <sys/stat.h> |
#include <sys/sched.h> |
#include <sys/sched.h> |
#include <sys/socket.h> |
#include <sys/socket.h> |
#include <sys/bitops.h> |
|
#include <netinet/in.h> |
#include <netinet/in.h> |
#include <netinet/ip_var.h> |
#include <netinet/ip_var.h> |
#include <netinet/tcp.h> |
#include <netinet/tcp.h> |
Line 212 static const struct handlespec { |
|
Line 213 static const struct handlespec { |
|
{ "/net/(inet|inet6)/[^/]+/stats", printother, NULL, "netstat"}, |
{ "/net/(inet|inet6)/[^/]+/stats", printother, NULL, "netstat"}, |
{ "/net/bpf/(stats|peers)", 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/inet.*/ip.*/anonportalgo/reserve", reserve, reserve, NULL }, |
|
|
{ "/net/ns/spp/deb.*", printother, NULL, "trsp" }, |
{ "/net/ns/spp/deb.*", printother, NULL, "trsp" }, |
Line 242 static const struct handlespec { |
|
Line 241 static const struct handlespec { |
|
|
|
struct sysctlnode my_root = { |
struct sysctlnode my_root = { |
.sysctl_flags = SYSCTL_VERSION|CTLFLAG_ROOT|CTLTYPE_NODE, |
.sysctl_flags = SYSCTL_VERSION|CTLFLAG_ROOT|CTLTYPE_NODE, |
.sysctl_size = sizeof(struct sysctlnode), |
sysc_init_field(_sysctl_size, sizeof(struct sysctlnode)), |
.sysctl_num = 0, |
.sysctl_num = 0, |
.sysctl_name = "(prog_root)", |
.sysctl_name = "(prog_root)", |
}; |
}; |
|
|
int req, stale, errs; |
int req, stale, errs; |
FILE *warnfp = stderr; |
FILE *warnfp = stderr; |
|
|
#define MAXPORTS 0x10000 |
|
|
|
/* |
/* |
* vah-riables n stuff |
* vah-riables n stuff |
*/ |
*/ |
Line 337 main(int argc, char *argv[]) |
|
Line 334 main(int argc, char *argv[]) |
|
aflag = 1; |
aflag = 1; |
|
|
if (prog_init && prog_init() == -1) |
if (prog_init && prog_init() == -1) |
err(EXIT_FAILURE, "prog init failed"); |
err(1, "prog init failed"); |
|
|
if (Aflag) |
if (Aflag) |
warnfp = stdout; |
warnfp = stdout; |
stale = req = 0; |
stale = req = 0; |
|
|
if ((re = malloc(sizeof(*re) * __arraycount(handlers))) == NULL) |
if ((re = malloc(sizeof(*re) * __arraycount(handlers))) == NULL) |
err(EXIT_FAILURE, "malloc regex"); |
err(1, "malloc regex"); |
|
|
if (aflag) { |
if (aflag) { |
print_tree(&name[0], 0, NULL, CTLTYPE_NODE, 1, |
print_tree(&name[0], 0, NULL, CTLTYPE_NODE, 1, |
Line 359 main(int argc, char *argv[]) |
|
Line 356 main(int argc, char *argv[]) |
|
|
|
fp = fopen(fn, "r"); |
fp = fopen(fn, "r"); |
if (fp == NULL) { |
if (fp == NULL) { |
err(EXIT_FAILURE, "%s", fn); |
err(1, "%s", fn); |
} else { |
} else { |
nr = 0; |
nr = 0; |
while ((l = fparseln(fp, NULL, &nr, NULL, 0)) != NULL) |
while ((l = fparseln(fp, NULL, &nr, NULL, 0)) != NULL) |
Line 380 main(int argc, char *argv[]) |
|
Line 377 main(int argc, char *argv[]) |
|
while (argc-- > 0) |
while (argc-- > 0) |
parse(*argv++, re, &lastcompiled); |
parse(*argv++, re, &lastcompiled); |
|
|
return errs ? EXIT_FAILURE : EXIT_SUCCESS; |
return errs ? 1 : 0; |
} |
} |
|
|
/* |
/* |
Line 405 findhandler(const char *s, regex_t *re, |
|
Line 402 findhandler(const char *s, regex_t *re, |
|
j = regcomp(&re[i], p[i].ps_re, REG_EXTENDED); |
j = regcomp(&re[i], p[i].ps_re, REG_EXTENDED); |
if (j != 0) { |
if (j != 0) { |
regerror(j, &re[i], eb, sizeof(eb)); |
regerror(j, &re[i], eb, sizeof(eb)); |
errx(EXIT_FAILURE, "regcomp: %s: %s", p[i].ps_re, eb); |
errx(1, "regcomp: %s: %s", p[i].ps_re, eb); |
} |
} |
*lastcompiled = i + 1; |
*lastcompiled = i + 1; |
} |
} |
Line 416 findhandler(const char *s, regex_t *re, |
|
Line 413 findhandler(const char *s, regex_t *re, |
|
} |
} |
else if (j != REG_NOMATCH) { |
else if (j != REG_NOMATCH) { |
regerror(j, &re[i], eb, sizeof(eb)); |
regerror(j, &re[i], eb, sizeof(eb)); |
errx(EXIT_FAILURE, "regexec: %s: %s", p[i].ps_re, eb); |
errx(1, "regexec: %s: %s", p[i].ps_re, eb); |
} |
} |
} |
} |
|
|
Line 679 print_tree(int *name, u_int namelen, str |
|
Line 676 print_tree(int *name, u_int namelen, str |
|
if (p->ps_p == NULL) { |
if (p->ps_p == NULL) { |
sysctlperror("Cannot print `%s': %s\n", gsname, |
sysctlperror("Cannot print `%s': %s\n", gsname, |
strerror(EOPNOTSUPP)); |
strerror(EOPNOTSUPP)); |
exit(EXIT_FAILURE); |
exit(1); |
} |
} |
(*p->ps_p)(gsname, gdname, NULL, name, namelen, pnode, type, |
(*p->ps_p)(gsname, gdname, NULL, name, namelen, pnode, type, |
__UNCONST(p->ps_d)); |
__UNCONST(p->ps_d)); |
Line 890 parse(char *l, regex_t *re, size_t *last |
|
Line 887 parse(char *l, regex_t *re, size_t *last |
|
if (optional) |
if (optional) |
return; |
return; |
sysctlparseerror(namelen, l); |
sysctlparseerror(namelen, l); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
|
|
type = SYSCTL_TYPE(node->sysctl_flags); |
type = SYSCTL_TYPE(node->sysctl_flags); |
Line 910 parse(char *l, regex_t *re, size_t *last |
|
Line 907 parse(char *l, regex_t *re, size_t *last |
|
|
|
if (!wflag) { |
if (!wflag) { |
sysctlperror("Must specify -w to set variables\n"); |
sysctlperror("Must specify -w to set variables\n"); |
exit(EXIT_FAILURE); |
exit(1); |
} |
} |
|
|
canonicalize(gsname, canonname); |
canonicalize(gsname, canonname); |
Line 919 parse(char *l, regex_t *re, size_t *last |
|
Line 916 parse(char *l, regex_t *re, size_t *last |
|
if (w->ps_w == NULL) { |
if (w->ps_w == NULL) { |
sysctlperror("Cannot write `%s': %s\n", gsname, |
sysctlperror("Cannot write `%s': %s\n", gsname, |
strerror(EOPNOTSUPP)); |
strerror(EOPNOTSUPP)); |
exit(EXIT_FAILURE); |
exit(1); |
} |
} |
(*w->ps_w)(gsname, gdname, value, name, namelen, node, type, |
(*w->ps_w)(gsname, gdname, value, name, namelen, node, type, |
__UNCONST(w->ps_d)); |
__UNCONST(w->ps_d)); |
Line 987 parse_create(char *l) |
|
Line 984 parse_create(char *l) |
|
|
|
if (!wflag) { |
if (!wflag) { |
sysctlperror("Must specify -w to create nodes\n"); |
sysctlperror("Must specify -w to create nodes\n"); |
exit(EXIT_FAILURE); |
exit(1); |
} |
} |
|
|
/* |
/* |
Line 1068 parse_create(char *l) |
|
Line 1065 parse_create(char *l) |
|
"%s: already have %s for new node\n", |
"%s: already have %s for new node\n", |
nname, |
nname, |
method == CTL_CREATE ? "addr" : "symbol"); |
method == CTL_CREATE ? "addr" : "symbol"); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
if (value == NULL) { |
if (value == NULL) { |
sysctlperror("%s: missing value\n", nname); |
sysctlperror("%s: missing value\n", nname); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
errno = 0; |
errno = 0; |
addr = (void*)strtoul(value, &t, 0); |
addr = (void*)strtoul(value, &t, 0); |
Line 1080 parse_create(char *l) |
|
Line 1077 parse_create(char *l) |
|
sysctlperror( |
sysctlperror( |
"%s: '%s' is not a valid address\n", |
"%s: '%s' is not a valid address\n", |
nname, value); |
nname, value); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
method = CTL_CREATE; |
method = CTL_CREATE; |
} |
} |
Line 1090 parse_create(char *l) |
|
Line 1087 parse_create(char *l) |
|
"%s: already have %s for new node\n", |
"%s: already have %s for new node\n", |
nname, |
nname, |
method == CTL_CREATE ? "addr" : "symbol"); |
method == CTL_CREATE ? "addr" : "symbol"); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
addr = value; |
addr = value; |
method = CTL_CREATESYM; |
method = CTL_CREATESYM; |
Line 1098 parse_create(char *l) |
|
Line 1095 parse_create(char *l) |
|
else if (strcmp(key, "type") == 0) { |
else if (strcmp(key, "type") == 0) { |
if (value == NULL) { |
if (value == NULL) { |
sysctlperror("%s: missing value\n", nname); |
sysctlperror("%s: missing value\n", nname); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
if (strcmp(value, "node") == 0) |
if (strcmp(value, "node") == 0) |
type = CTLTYPE_NODE; |
type = CTLTYPE_NODE; |
Line 1122 parse_create(char *l) |
|
Line 1119 parse_create(char *l) |
|
sysctlperror( |
sysctlperror( |
"%s: '%s' is not a valid type\n", |
"%s: '%s' is not a valid type\n", |
nname, value); |
nname, value); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
} |
} |
else if (strcmp(key, "size") == 0) { |
else if (strcmp(key, "size") == 0) { |
if (value == NULL) { |
if (value == NULL) { |
sysctlperror("%s: missing value\n", nname); |
sysctlperror("%s: missing value\n", nname); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
errno = 0; |
errno = 0; |
/* |
/* |
Line 1141 parse_create(char *l) |
|
Line 1138 parse_create(char *l) |
|
sysctlperror( |
sysctlperror( |
"%s: '%s' is not a valid size\n", |
"%s: '%s' is not a valid size\n", |
nname, value); |
nname, value); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
} |
} |
else if (strcmp(key, "n") == 0) { |
else if (strcmp(key, "n") == 0) { |
if (value == NULL) { |
if (value == NULL) { |
sysctlperror("%s: missing value\n", nname); |
sysctlperror("%s: missing value\n", nname); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
errno = 0; |
errno = 0; |
q = strtoll(value, &t, 0); |
q = strtoll(value, &t, 0); |
Line 1156 parse_create(char *l) |
|
Line 1153 parse_create(char *l) |
|
sysctlperror( |
sysctlperror( |
"%s: '%s' is not a valid mib number\n", |
"%s: '%s' is not a valid mib number\n", |
nname, value); |
nname, value); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
node.sysctl_num = (int)q; |
node.sysctl_num = (int)q; |
} |
} |
else if (strcmp(key, "flags") == 0) { |
else if (strcmp(key, "flags") == 0) { |
if (value == NULL) { |
if (value == NULL) { |
sysctlperror("%s: missing value\n", nname); |
sysctlperror("%s: missing value\n", nname); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
t = value; |
t = value; |
while (*t != '\0') { |
while (*t != '\0') { |
Line 1200 parse_create(char *l) |
|
Line 1197 parse_create(char *l) |
|
sysctlperror( |
sysctlperror( |
"%s: '%c' is not a valid flag\n", |
"%s: '%c' is not a valid flag\n", |
nname, *t); |
nname, *t); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
t++; |
t++; |
} |
} |
Line 1208 parse_create(char *l) |
|
Line 1205 parse_create(char *l) |
|
else { |
else { |
sysctlperror("%s: unrecognized keyword '%s'\n", |
sysctlperror("%s: unrecognized keyword '%s'\n", |
nname, key); |
nname, key); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
} |
} |
|
|
Line 1228 parse_create(char *l) |
|
Line 1225 parse_create(char *l) |
|
sysctlperror( |
sysctlperror( |
"%s: cannot specify both value and " |
"%s: cannot specify both value and " |
"address\n", nname); |
"address\n", nname); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
|
|
switch (type) { |
switch (type) { |
Line 1240 parse_create(char *l) |
|
Line 1237 parse_create(char *l) |
|
sysctlperror( |
sysctlperror( |
"%s: '%s' is not a valid integer\n", |
"%s: '%s' is not a valid integer\n", |
nname, value); |
nname, value); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
i = (int)q; |
i = (int)q; |
if (!(flags & CTLFLAG_OWNDATA)) { |
if (!(flags & CTLFLAG_OWNDATA)) { |
Line 1260 parse_create(char *l) |
|
Line 1257 parse_create(char *l) |
|
sysctlperror( |
sysctlperror( |
"%s: '%s' is not a valid bool\n", |
"%s: '%s' is not a valid bool\n", |
nname, value); |
nname, value); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
b = q == 1; |
b = q == 1; |
if (!(flags & CTLFLAG_OWNDATA)) { |
if (!(flags & CTLFLAG_OWNDATA)) { |
Line 1291 parse_create(char *l) |
|
Line 1288 parse_create(char *l) |
|
sysctlperror( |
sysctlperror( |
"%s: '%s' is not a valid quad\n", |
"%s: '%s' is not a valid quad\n", |
nname, value); |
nname, value); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
if (!(flags & CTLFLAG_OWNDATA)) { |
if (!(flags & CTLFLAG_OWNDATA)) { |
flags |= CTLFLAG_IMMEDIATE; |
flags |= CTLFLAG_IMMEDIATE; |
Line 1305 parse_create(char *l) |
|
Line 1302 parse_create(char *l) |
|
case CTLTYPE_STRUCT: |
case CTLTYPE_STRUCT: |
sysctlperror("%s: struct not initializable\n", |
sysctlperror("%s: struct not initializable\n", |
nname); |
nname); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
|
|
/* |
/* |
Line 1330 parse_create(char *l) |
|
Line 1327 parse_create(char *l) |
|
sysctlperror( |
sysctlperror( |
"%s: need a size or a starting value\n", |
"%s: need a size or a starting value\n", |
nname); |
nname); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
if (!(flags & CTLFLAG_IMMEDIATE)) |
if (!(flags & CTLFLAG_IMMEDIATE)) |
flags |= CTLFLAG_OWNDATA; |
flags |= CTLFLAG_OWNDATA; |
Line 1345 parse_create(char *l) |
|
Line 1342 parse_create(char *l) |
|
sysctlperror("%s: cannot make an immediate %s\n", |
sysctlperror("%s: cannot make an immediate %s\n", |
nname, |
nname, |
(type == CTLTYPE_STRING) ? "string" : "struct"); |
(type == CTLTYPE_STRING) ? "string" : "struct"); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
if (type == CTLTYPE_NODE && node.sysctl_data != NULL) { |
if (type == CTLTYPE_NODE && node.sysctl_data != NULL) { |
sysctlperror("%s: nodes do not have data\n", nname); |
sysctlperror("%s: nodes do not have data\n", nname); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
|
|
/* |
/* |
Line 1361 parse_create(char *l) |
|
Line 1358 parse_create(char *l) |
|
(type == CTLTYPE_QUAD && sz != sizeof(u_quad_t)) || |
(type == CTLTYPE_QUAD && sz != sizeof(u_quad_t)) || |
(type == CTLTYPE_NODE && sz != 0)) { |
(type == CTLTYPE_NODE && sz != 0)) { |
sysctlperror("%s: wrong size for type\n", nname); |
sysctlperror("%s: wrong size for type\n", nname); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
} |
} |
else if (type == CTLTYPE_STRUCT) { |
else if (type == CTLTYPE_STRUCT) { |
sysctlperror("%s: struct must have size\n", nname); |
sysctlperror("%s: struct must have size\n", nname); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
|
|
/* |
/* |
Line 1387 parse_create(char *l) |
|
Line 1384 parse_create(char *l) |
|
* writeable by us. |
* writeable by us. |
if (rw != CTLFLAG_READONLY && addr) { |
if (rw != CTLFLAG_READONLY && addr) { |
sysctlperror("%s: kernel data can only be readable\n", nname); |
sysctlperror("%s: kernel data can only be readable\n", nname); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
*/ |
*/ |
|
|
Line 1435 parse_create(char *l) |
|
Line 1432 parse_create(char *l) |
|
*t = sep[0]; |
*t = sep[0]; |
if (rc == -1) { |
if (rc == -1) { |
sysctlparseerror(namelen, nname); |
sysctlparseerror(namelen, nname); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
} |
} |
|
|
Line 1453 parse_create(char *l) |
|
Line 1450 parse_create(char *l) |
|
if (rc == -1) { |
if (rc == -1) { |
sysctlperror("%s: CTL_CREATE failed: %s\n", |
sysctlperror("%s: CTL_CREATE failed: %s\n", |
nname, strerror(errno)); |
nname, strerror(errno)); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
else { |
else { |
if (!qflag && !nflag) |
if (!qflag && !nflag) |
Line 1472 parse_destroy(char *l) |
|
Line 1469 parse_destroy(char *l) |
|
|
|
if (!wflag) { |
if (!wflag) { |
sysctlperror("Must specify -w to destroy nodes\n"); |
sysctlperror("Must specify -w to destroy nodes\n"); |
exit(EXIT_FAILURE); |
exit(1); |
} |
} |
|
|
memset(name, 0, sizeof(name)); |
memset(name, 0, sizeof(name)); |
Line 1482 parse_destroy(char *l) |
|
Line 1479 parse_destroy(char *l) |
|
SYSCTL_VERSION); |
SYSCTL_VERSION); |
if (rc == -1) { |
if (rc == -1) { |
sysctlparseerror(namelen, l); |
sysctlparseerror(namelen, l); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
|
|
memset(&node, 0, sizeof(node)); |
memset(&node, 0, sizeof(node)); |
Line 1496 parse_destroy(char *l) |
|
Line 1493 parse_destroy(char *l) |
|
if (rc == -1) { |
if (rc == -1) { |
sysctlperror("%s: CTL_DESTROY failed: %s\n", |
sysctlperror("%s: CTL_DESTROY failed: %s\n", |
l, strerror(errno)); |
l, strerror(errno)); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
else { |
else { |
if (!qflag && !nflag) |
if (!qflag && !nflag) |
Line 1518 parse_describe(char *l) |
|
Line 1515 parse_describe(char *l) |
|
|
|
if (!wflag) { |
if (!wflag) { |
sysctlperror("Must specify -w to set descriptions\n"); |
sysctlperror("Must specify -w to set descriptions\n"); |
exit(EXIT_FAILURE); |
exit(1); |
} |
} |
|
|
value = strchr(l, '='); |
value = strchr(l, '='); |
Line 1531 parse_describe(char *l) |
|
Line 1528 parse_describe(char *l) |
|
SYSCTL_VERSION); |
SYSCTL_VERSION); |
if (rc == -1) { |
if (rc == -1) { |
sysctlparseerror(namelen, l); |
sysctlparseerror(namelen, l); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
|
|
sz = sizeof(buf); |
sz = sizeof(buf); |
|
|
progname, "[-dne] -A", |
progname, "[-dne] -A", |
progname, "[-ne] -M", |
progname, "[-ne] -M", |
progname, "[-dne] [-q] -f file"); |
progname, "[-dne] [-q] -f file"); |
exit(EXIT_FAILURE); |
exit(1); |
} |
} |
|
|
static void |
static void |
Line 1616 getdesc(int *name, u_int namelen, struct |
|
Line 1613 getdesc(int *name, u_int namelen, struct |
|
struct sysctlnode *node = pnode->sysctl_child; |
struct sysctlnode *node = pnode->sysctl_child; |
struct sysctldesc *d, *p, *plim; |
struct sysctldesc *d, *p, *plim; |
char *desc; |
char *desc; |
size_t i, sz, child_cnt; |
size_t i, sz; |
int rc; |
int rc; |
|
|
sz = 128 * pnode->sysctl_clen; |
sz = 128 * pnode->sysctl_clen; |
Line 1647 getdesc(int *name, u_int namelen, struct |
|
Line 1644 getdesc(int *name, u_int namelen, struct |
|
* suffice for now |
* suffice for now |
*/ |
*/ |
plim = /*LINTED ptr cast*/(struct sysctldesc *)((char*)d + sz); |
plim = /*LINTED ptr cast*/(struct sysctldesc *)((char*)d + sz); |
child_cnt = (pnode->sysctl_flags & CTLTYPE_NODE) ? pnode->sysctl_clen |
for (i = 0; i < pnode->sysctl_clen; i++) { |
: 0; |
|
for (i = 0; i < child_cnt; i++) { |
|
node = &pnode->sysctl_child[i]; |
node = &pnode->sysctl_child[i]; |
for (p = d; p < plim; p = NEXT_DESCR(p)) |
for (p = d; p < plim; p = NEXT_DESCR(p)) |
if (node->sysctl_num == p->descr_num) |
if (node->sysctl_num == p->descr_num) |
Line 1710 sysctlerror(int soft) |
|
Line 1705 sysctlerror(int soft) |
|
if (Aflag || req) |
if (Aflag || req) |
sysctlperror("%s: %s\n", gsname, strerror(errno)); |
sysctlperror("%s: %s\n", gsname, strerror(errno)); |
if (!soft) |
if (!soft) |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
|
|
void |
void |
Line 1766 write_number(int *name, u_int namelen, s |
|
Line 1761 write_number(int *name, u_int namelen, s |
|
qi = strtouq(value, &t, 0); |
qi = strtouq(value, &t, 0); |
if (qi == UQUAD_MAX && errno == ERANGE) { |
if (qi == UQUAD_MAX && errno == ERANGE) { |
sysctlperror("%s: %s\n", value, strerror(errno)); |
sysctlperror("%s: %s\n", value, strerror(errno)); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
if (t == value || *t != '\0') { |
if (t == value || *t != '\0') { |
sysctlperror("%s: not a number\n", value); |
sysctlperror("%s: not a number\n", value); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
|
|
switch (SYSCTL_TYPE(node->sysctl_flags)) { |
switch (SYSCTL_TYPE(node->sysctl_flags)) { |
Line 1779 write_number(int *name, u_int namelen, s |
|
Line 1774 write_number(int *name, u_int namelen, s |
|
io = (u_int)(qi >> 32); |
io = (u_int)(qi >> 32); |
if (io != (u_int)-1 && io != 0) { |
if (io != (u_int)-1 && io != 0) { |
sysctlperror("%s: %s\n", value, strerror(ERANGE)); |
sysctlperror("%s: %s\n", value, strerror(ERANGE)); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
o = &io; |
o = &io; |
so = sizeof(io); |
so = sizeof(io); |
Line 1835 write_string(int *name, u_int namelen, s |
|
Line 1830 write_string(int *name, u_int namelen, s |
|
so = node->sysctl_size; |
so = node->sysctl_size; |
if (si > so && so != 0) { |
if (si > so && so != 0) { |
sysctlperror("%s: string too long\n", value); |
sysctlperror("%s: string too long\n", value); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
o = malloc(so); |
o = malloc(so); |
if (o == NULL) { |
if (o == NULL) { |
sysctlperror("%s: !malloc failed!\n", gsname); |
sysctlperror("%s: !malloc failed!\n", gsname); |
exit(EXIT_FAILURE); |
exit(1); |
} |
} |
|
|
rc = prog_sysctl(name, namelen, o, &so, i, si); |
rc = prog_sysctl(name, namelen, o, &so, i, si); |
Line 2153 kern_clockrate(HANDLER_ARGS) |
|
Line 2148 kern_clockrate(HANDLER_ARGS) |
|
return; |
return; |
} |
} |
if (sz != sizeof(clkinfo)) |
if (sz != sizeof(clkinfo)) |
errx(EXIT_FAILURE, "%s: !returned size wrong!", sname); |
errx(1, "%s: !returned size wrong!", sname); |
|
|
if (xflag || rflag) { |
if (xflag || rflag) { |
display_struct(pnode, sname, &clkinfo, sz, |
display_struct(pnode, sname, &clkinfo, sz, |
Line 2183 kern_boottime(HANDLER_ARGS) |
|
Line 2178 kern_boottime(HANDLER_ARGS) |
|
return; |
return; |
} |
} |
if (sz != sizeof(timeval)) |
if (sz != sizeof(timeval)) |
errx(EXIT_FAILURE, "%s: !returned size wrong!", sname); |
errx(1, "%s: !returned size wrong!", sname); |
|
|
boottime = timeval.tv_sec; |
boottime = timeval.tv_sec; |
if (xflag || rflag) |
if (xflag || rflag) |
Line 2214 kern_consdev(HANDLER_ARGS) |
|
Line 2209 kern_consdev(HANDLER_ARGS) |
|
return; |
return; |
} |
} |
if (sz != sizeof(cons)) |
if (sz != sizeof(cons)) |
errx(EXIT_FAILURE, "%s: !returned size wrong!", sname); |
errx(1, "%s: !returned size wrong!", sname); |
|
|
if (xflag || rflag) |
if (xflag || rflag) |
display_struct(pnode, sname, &cons, sz, |
display_struct(pnode, sname, &cons, sz, |
Line 2279 kern_cp_time(HANDLER_ARGS) |
|
Line 2274 kern_cp_time(HANDLER_ARGS) |
|
* Check, but account for space we'll occupy with the sum. |
* Check, but account for space we'll occupy with the sum. |
*/ |
*/ |
if (osz != sz - (n != -1) * CPUSTATES * sizeof(u_int64_t)) |
if (osz != sz - (n != -1) * CPUSTATES * sizeof(u_int64_t)) |
errx(EXIT_FAILURE, "%s: !returned size wrong!", sname); |
errx(1, "%s: !returned size wrong!", sname); |
|
|
/* |
/* |
* Compute the actual sum. Two calls would be easier (we |
* Compute the actual sum. Two calls would be easier (we |
Line 2349 kern_drivers(HANDLER_ARGS) |
|
Line 2344 kern_drivers(HANDLER_ARGS) |
|
} |
} |
|
|
if (sz % sizeof(*kd)) |
if (sz % sizeof(*kd)) |
err(EXIT_FAILURE, "bad size %zu for kern.drivers", sz); |
err(1, "bad size %zu for kern.drivers", sz); |
|
|
kd = malloc(sz); |
kd = malloc(sz); |
if (kd == NULL) { |
if (kd == NULL) { |
Line 2360 kern_drivers(HANDLER_ARGS) |
|
Line 2355 kern_drivers(HANDLER_ARGS) |
|
rc = prog_sysctl(name, namelen, kd, &sz, NULL, 0); |
rc = prog_sysctl(name, namelen, kd, &sz, NULL, 0); |
if (rc == -1) { |
if (rc == -1) { |
sysctlerror(1); |
sysctlerror(1); |
free(kd); |
|
return; |
return; |
} |
} |
|
|
Line 2424 kern_cp_id(HANDLER_ARGS) |
|
Line 2418 kern_cp_id(HANDLER_ARGS) |
|
* Check that we got back what we asked for. |
* Check that we got back what we asked for. |
*/ |
*/ |
if (osz != sz) |
if (osz != sz) |
errx(EXIT_FAILURE, "%s: !returned size wrong!", sname); |
errx(1, "%s: !returned size wrong!", sname); |
|
|
/* pretend for output purposes */ |
/* pretend for output purposes */ |
node.sysctl_flags = SYSCTL_FLAGS(pnode->sysctl_flags) | |
node.sysctl_flags = SYSCTL_FLAGS(pnode->sysctl_flags) | |
Line 2476 vm_loadavg(HANDLER_ARGS) |
|
Line 2470 vm_loadavg(HANDLER_ARGS) |
|
return; |
return; |
} |
} |
if (sz != sizeof(loadavg)) |
if (sz != sizeof(loadavg)) |
errx(EXIT_FAILURE, "%s: !returned size wrong!", sname); |
errx(1, "%s: !returned size wrong!", sname); |
|
|
if (xflag || rflag) { |
if (xflag || rflag) { |
display_struct(pnode, sname, &loadavg, sz, |
display_struct(pnode, sname, &loadavg, sz, |
Line 2515 proc_limit(HANDLER_ARGS) |
|
Line 2509 proc_limit(HANDLER_ARGS) |
|
if (t == value || *t != '\0' || errno != 0) { |
if (t == value || *t != '\0' || errno != 0) { |
sysctlperror("%s: '%s' is not a valid limit\n", |
sysctlperror("%s: '%s' is not a valid limit\n", |
sname, value); |
sname, value); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
} |
} |
} |
} |
Line 2644 mode_bits(HANDLER_ARGS) |
|
Line 2638 mode_bits(HANDLER_ARGS) |
|
if (foo == NULL) { |
if (foo == NULL) { |
sysctlperror("%s: '%s' is an invalid mode\n", sname, |
sysctlperror("%s: '%s' is an invalid mode\n", sname, |
value); |
value); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
old_umask = umask(0); |
old_umask = umask(0); |
m = getmode(foo, (mode_t)tt); |
m = getmode(foo, (mode_t)tt); |
Line 2652 mode_bits(HANDLER_ARGS) |
|
Line 2646 mode_bits(HANDLER_ARGS) |
|
if (errno) { |
if (errno) { |
sysctlperror("%s: '%s' is an invalid mode\n", sname, |
sysctlperror("%s: '%s' is an invalid mode\n", sname, |
value); |
value); |
EXIT(EXIT_FAILURE); |
EXIT(1); |
} |
} |
} |
} |
else { |
else { |
Line 2695 mode_bits(HANDLER_ARGS) |
|
Line 2689 mode_bits(HANDLER_ARGS) |
|
} |
} |
} |
} |
|
|
typedef __BITMAP_TYPE(, uint32_t, 0x10000) bitmap; |
|
|
|
static char * |
static char * |
bitmask_print(const bitmap *o) |
bitmask_print(const fd_set *o) |
{ |
{ |
char *s, *os; |
char *s, *os; |
|
|
s = os = NULL; |
s = os = NULL; |
for (size_t i = 0; i < MAXPORTS; i++) |
for (size_t i = 0; i < FD_SETSIZE; i++) |
if (__BITMAP_ISSET(i, o)) { |
if (FD_ISSET(i, o)) { |
int rv; |
int rv; |
|
|
if (os) |
if (os) |
Line 2712 bitmask_print(const bitmap *o) |
|
Line 2704 bitmask_print(const bitmap *o) |
|
else |
else |
rv = asprintf(&s, "%zu", i); |
rv = asprintf(&s, "%zu", i); |
if (rv == -1) |
if (rv == -1) |
err(EXIT_FAILURE, "%s 1", __func__); |
err(1, ""); |
free(os); |
free(os); |
os = s; |
os = s; |
} |
} |
if (s == NULL && (s = strdup("")) == NULL) |
if (s == NULL && (s = strdup("")) == NULL) |
err(EXIT_FAILURE, "%s 2", __func__); |
err(1, ""); |
return s; |
return s; |
} |
} |
|
|
static void |
static void |
bitmask_scan(const void *v, bitmap *o) |
bitmask_scan(const void *v, fd_set *o) |
{ |
{ |
char *s = strdup(v); |
char *s = strdup(v); |
if (s == NULL) |
if (s == NULL) |
err(EXIT_FAILURE, "%s", __func__); |
err(1, ""); |
|
FD_ZERO(o); |
__BITMAP_ZERO(o); |
|
for (s = strtok(s, ","); s; s = strtok(NULL, ",")) { |
for (s = strtok(s, ","); s; s = strtok(NULL, ",")) { |
char *e; |
char *e; |
errno = 0; |
errno = 0; |
unsigned long l = strtoul(s, &e, 0); |
unsigned long l = strtoul(s, &e, 0); |
if ((l == ULONG_MAX && errno == ERANGE) || s == e || *e) |
if ((l == ULONG_MAX && errno == ERANGE) || s == e || *e) |
errx(EXIT_FAILURE, "Invalid port: %s", s); |
errx(1, "Invalid port: %s", s); |
if (l >= MAXPORTS) |
if (l >= FD_SETSIZE) |
errx(EXIT_FAILURE, "Port out of range: %s", s); |
errx(1, "Port out of range: %s", s); |
__BITMAP_SET(l, o); |
FD_SET(l, o); |
} |
} |
} |
} |
|
|
Line 2747 reserve(HANDLER_ARGS) |
|
Line 2738 reserve(HANDLER_ARGS) |
|
{ |
{ |
int rc; |
int rc; |
size_t osz, nsz; |
size_t osz, nsz; |
bitmap o, n; |
fd_set o, n; |
|
|
if (fn) |
if (fn) |
trim_whitespace(value, 3); |
trim_whitespace(value, 3); |