[unix-history] / usr / src / usr.sbin / sysctl / sysctl.c

/*
 * Copyright (c) 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * %sccs.include.redist.c%
 */

#ifndef lint
static char copyright[] =
"@(#) Copyright (c) 1993\n\
	The Regents of the University of California.  All rights reserved.\n";
#endif /* not lint */

#ifndef lint
static char sccsid[] = "@(#)sysctl.c	8.1 (Berkeley) %G%";
#endif /* not lint */

#include <sys/param.h>
#include <sys/gmon.h>
#include <sys/stat.h>
#include <sys/sysctl.h>
#include <sys/socket.h>
#include <vm/vm_param.h>
#include <machine/cpu.h>

#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include <netinet/icmp_var.h>
#include <netinet/ip_var.h>
#include <netinet/udp.h>
#include <netinet/udp_var.h>

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct ctlname topname[] = CTL_NAMES;
struct ctlname kernname[] = CTL_KERN_NAMES;
struct ctlname vmname[] = CTL_VM_NAMES;
struct ctlname netname[] = CTL_NET_NAMES;
struct ctlname hwname[] = CTL_HW_NAMES;
struct ctlname username[] = CTL_USER_NAMES;
struct ctlname debugname[CTL_DEBUG_MAXID];
#ifdef CTL_MACHDEP_NAMES
struct ctlname machdepname[] = CTL_MACHDEP_NAMES;
#endif
char names[BUFSIZ];

struct list {
	struct	ctlname *list;
	int	size;
};
struct list toplist = { topname, CTL_MAXID };
struct list secondlevel[] = {
	{ 0, 0 },			/* CTL_UNSPEC */
	{ kernname, KERN_MAXID },	/* CTL_KERN */
	{ vmname, VM_MAXID },		/* CTL_VM */
	{ 0, 0 },			/* CTL_FS */
	{ netname, NET_MAXID },		/* CTL_NET */
	{ 0, CTL_DEBUG_MAXID },		/* CTL_DEBUG */
	{ hwname, HW_MAXID },		/* CTL_HW */
#ifdef CTL_MACHDEP_NAMES
	{ machdepname, CPU_MAXID },	/* CTL_MACHDEP */
#else
	{ 0, 0 },			/* CTL_MACHDEP */
#endif
	{ username, USER_MAXID },	/* CTL_USER_NAMES */
};

int	Aflag, aflag, nflag, wflag;

/*
 * Variables requiring special processing.
 */
#define	CLOCK		0x00000001
#define	BOOTTIME	0x00000002
#define	CONSDEV		0x00000004

int
main(argc, argv)
	int argc;
	char *argv[];
{
	extern char *optarg;
	extern int optind;
	int ch, lvl1;

	while ((ch = getopt(argc, argv, "Aanw")) != EOF) {
		switch (ch) {

		case 'A':
			Aflag = 1;
			break;

		case 'a':
			aflag = 1;
			break;

		case 'n':
			nflag = 1;
			break;

		case 'w':
			wflag = 1;
			break;

		default:
			usage();
		}
	}
	argc -= optind;
	argv += optind;

	if (Aflag || aflag) {
		debuginit();
		for (lvl1 = 1; lvl1 < CTL_MAXID; lvl1++)
			listall(topname[lvl1].ctl_name, &secondlevel[lvl1]);
		exit(0);
	}
	if (argc == 0)
		usage();
	while (argc-- > 0)
		parse(*argv, 1);
	exit(0);
}

/*
 * List all variables known to the system.
 */
listall(prefix, lp)
	char *prefix;
	struct list *lp;
{
	int lvl2;
	char *cp, name[BUFSIZ];

	if (lp->list == 0)
		return;
	strcpy(name, prefix);
	cp = &name[strlen(name)];
	*cp++ = '.';
	for (lvl2 = 0; lvl2 < lp->size; lvl2++) {
		if (lp->list[lvl2].ctl_name == 0)
			continue;
		strcpy(cp, lp->list[lvl2].ctl_name);
		parse(name, Aflag);
	}
}

/*
 * Parse a name into a MIB entry.
 * Lookup and print out the MIB entry if it exists.
 * Set a new value if requested.
 */
parse(string, flags)
	char *string;
	int flags;
{
	int indx, type, state, size, len;
	int special = 0;
	void *newval = 0;
	int intval, newsize = 0;
	quad_t quadval;
	struct list *lp;
	int mib[CTL_MAXNAME];
	char *cp, *bufp, buf[BUFSIZ], strval[BUFSIZ];

	bufp = buf;
	snprintf(buf, BUFSIZ, "%s", string);
	if ((cp = strchr(string, '=')) != NULL) {
		if (!wflag) {
			fprintf(stderr, "Must specify -w to set variables\n");
			exit(2);
		}
		*strchr(buf, '=') = '\0';
		*cp++ = '\0';
		while (isspace(*cp))
			cp++;
		newval = cp;
		newsize = strlen(cp);
	}
	if ((indx = findname(string, "top", &bufp, &toplist)) == -1)
		return;
	mib[0] = indx;
	if (indx == CTL_DEBUG)
		debuginit();
	lp = &secondlevel[indx];
	if (lp->list == 0) {
		fprintf(stderr, "%s: class is not implemented\n",
		    topname[indx]);
		return;
	}
	if (bufp == NULL) {
		listall(topname[indx].ctl_name, lp);
		return;
	}
	if ((indx = findname(string, "second", &bufp, lp)) == -1)
		return;
	mib[1] = indx;
	type = lp->list[indx].ctl_type;
	len = 2;
	switch (mib[0]) {

	case CTL_KERN:
		switch (mib[1]) {
		case KERN_PROF:
			mib[2] = GPROF_STATE;
			size = sizeof state;
			if (sysctl(mib, 3, &state, &size, NULL, 0) < 0) {
				if (flags == 0)
					return;
				if (!nflag)
					fprintf(stdout, "%s: ", string);
				fprintf(stderr,
				    "kernel is not compiled for profiling\n");
				return;
			}
			if (!nflag)
				fprintf(stdout, "%s: %s\n", string,
				    state == GMON_PROF_OFF ? "off" : "running");
			return;
		case KERN_VNODE:
		case KERN_FILE:
			if (flags == 0)
				return;
			fprintf(stderr,
			    "Use pstat to view %s information\n", string);
			return;
		case KERN_PROC:
			if (flags == 0)
				return;
			fprintf(stderr,
			    "Use ps to view %s information\n", string);
			return;
		case KERN_CLOCKRATE:
			special |= CLOCK;
			break;
		case KERN_BOOTTIME:
			special |= BOOTTIME;
			break;
		}
		break;

	case CTL_HW:
		break;

	case CTL_VM:
		if (mib[1] == VM_LOADAVG) {
			double loads[3];

			getloadavg(loads, 3);
			if (!nflag)
				fprintf(stdout, "%s: ", string);
			fprintf(stdout, "%.2f %.2f %.2f\n", 
			    loads[0], loads[1], loads[2]);
			return;
		}
		if (flags == 0)
			return;
		fprintf(stderr,
		    "Use vmstat or systat to view %s information\n", string);
		return;

	case CTL_NET:
		if (mib[1] == PF_INET) {
			len = sysctl_inet(string, &bufp, mib, flags, &type);
			if (len >= 0)
				break;
			return;
		}
		if (flags == 0)
			return;
		fprintf(stderr, "Use netstat to view %s information\n", string);
		return;

	case CTL_DEBUG:
		mib[2] = CTL_DEBUG_VALUE;
		len = 3;
		break;

	case CTL_MACHDEP:
#ifdef CPU_CONSDEV
		if (mib[1] == CPU_CONSDEV)
			special |= CONSDEV;
#endif
		break;

	case CTL_FS:
	case CTL_USER:
		break;

	default:
		fprintf(stderr, "Illegal top level value: %d\n", mib[0]);
		return;
	
	}
	if (bufp) {
		fprintf(stderr, "name %s in %s is unknown\n", *bufp, string);
		return;
	}
	if (newsize > 0) {
		switch (type) {
		case CTLTYPE_INT:
			intval = atoi(newval);
			newval = &intval;
			newsize = sizeof intval;
			break;

		case CTLTYPE_QUAD:
			sscanf(newval, "%qd", &quadval);
			newval = &quadval;
			newsize = sizeof quadval;
			break;
		}
	}
	size = BUFSIZ;
	if (sysctl(mib, len, buf, &size, newsize ? newval : 0, newsize) == -1) {
		if (flags == 0)
			return;
		switch (errno) {
		case EOPNOTSUPP:
			fprintf(stderr, "%s: value is not available\n", string);
			return;
		case ENOTDIR:
			fprintf(stderr, "%s: specification is incomplete\n",
			    string);
			return;
		case ENOMEM:
			fprintf(stderr, "%s: type is unknown to this program\n",
			    string);
			return;
		default:
			perror(string);
			return;
		}
	}
	if (special & CLOCK) {
		struct clockinfo *clkp = (struct clockinfo *)buf;

		if (!nflag)
			fprintf(stdout, "%s: ", string);
		fprintf(stdout,
		    "hz = %d, tick = %d, profhz = %d, stathz = %d\n",
		    clkp->hz, clkp->tick, clkp->profhz, clkp->stathz);
		return;
	}
	if (special & BOOTTIME) {
		struct timeval *btp = (struct timeval *)buf;

		if (!nflag)
			fprintf(stdout, "%s = %s\n", string,
			    ctime(&btp->tv_sec));
		else
			fprintf(stdout, "%d\n", btp->tv_sec);
		return;
	}
	if (special & CONSDEV) {
		dev_t dev = *(dev_t *)buf;

		if (!nflag)
			fprintf(stdout, "%s = %s\n", string,
			    devname(dev, S_IFCHR));
		else
			fprintf(stdout, "0x%x\n", dev);
		return;
	}
	switch (type) {
	case CTLTYPE_INT:
		if (newsize == 0) {
			if (!nflag)
				fprintf(stdout, "%s = ", string);
			fprintf(stdout, "%d\n", *(int *)buf);
		} else {
			if (!nflag)
				fprintf(stdout, "%s: %d -> ", string,
				    *(int *)buf);
			fprintf(stdout, "%d\n", *(int *)newval);
		}
		return;

	case CTLTYPE_STRING:
		if (newsize == 0) {
			if (!nflag)
				fprintf(stdout, "%s = ", string);
			fprintf(stdout, "%s\n", buf);
		} else {
			if (!nflag)
				fprintf(stdout, "%s: %s -> ", string, buf);
			fprintf(stdout, "%s\n", newval);
		}
		return;

	case CTLTYPE_QUAD:
		if (newsize == 0) {
			if (!nflag)
				fprintf(stdout, "%s = ", string);
			fprintf(stdout, "%qd\n", *(quad_t *)buf);
		} else {
			if (!nflag)
				fprintf(stdout, "%s: %qd -> ", string,
				    *(quad_t *)buf);
			fprintf(stdout, "%qd\n", *(quad_t *)newval);
		}
		return;

	case CTLTYPE_STRUCT:
		fprintf(stderr, "%s: unknown structure returned\n",
		    string);
		return;

	default:
	case CTLTYPE_NODE:
		fprintf(stderr, "%s: unknown type returned\n",
		    string);
		return;
	}
}

/*
 * Initialize the set of debugging names
 */
debuginit()
{
	int mib[3], size, loc, i;

	if (secondlevel[CTL_DEBUG].list != 0)
		return;
	secondlevel[CTL_DEBUG].list = debugname;
	mib[0] = CTL_DEBUG;
	mib[2] = CTL_DEBUG_NAME;
	for (loc = 0, i = 0; i < CTL_DEBUG_MAXID; i++) {
		mib[1] = i;
		size = BUFSIZ - loc;
		if (sysctl(mib, 3, &names[loc], &size, NULL, 0) == -1)
			continue;
		debugname[i].ctl_name = &names[loc];
		debugname[i].ctl_type = CTLTYPE_INT;
		loc += size;
	}
}

struct ctlname inetname[] = CTL_IPPROTO_NAMES;
struct ctlname ipname[] = IPCTL_NAMES;
struct ctlname icmpname[] = ICMPCTL_NAMES;
struct ctlname udpname[] = UDPCTL_NAMES;
struct list inetlist = { inetname, IPPROTO_MAXID };
struct list inetvars[] = {
	{ ipname, IPCTL_MAXID },	/* ip */
	{ icmpname, ICMPCTL_MAXID },	/* icmp */
	{ 0, 0 },			/* igmp */
	{ 0, 0 },			/* ggmp */
	{ 0, 0 },
	{ 0, 0 },
	{ 0, 0 },			/* tcp */
	{ 0, 0 },
	{ 0, 0 },			/* egp */
	{ 0, 0 },
	{ 0, 0 },
	{ 0, 0 },
	{ 0, 0 },			/* pup */
	{ 0, 0 },
	{ 0, 0 },
	{ 0, 0 },
	{ 0, 0 },
	{ udpname, UDPCTL_MAXID },	/* udp */
};

/*
 * handle internet requests
 */
sysctl_inet(string, bufpp, mib, flags, typep)
	char *string;
	char **bufpp;
	int mib[];
	int flags;
	int *typep;
{
	struct list *lp;
	int indx;

	if (*bufpp == NULL) {
		listall(string, &inetlist);
		return (-1);
	}
	if ((indx = findname(string, "third", bufpp, &inetlist)) == -1)
		return (-1);
	mib[2] = indx;
	if (indx <= IPPROTO_UDP && inetvars[indx].list != NULL)
		lp = &inetvars[indx];
	else if (!flags)
		return (-1);
	else {
		fprintf(stderr, "%s: no variables defined for this protocol\n",
		    string);
		return (-1);
	}
	if (*bufpp == NULL) {
		listall(string, lp);
		return (-1);
	}
	if ((indx = findname(string, "fourth", bufpp, lp)) == -1)
		return (-1);
	mib[3] = indx;
	*typep = lp->list[indx].ctl_type;
	return (4);
}

/*
 * Scan a list of names searching for a particular name.
 */
findname(string, level, bufp, namelist)
	char *string;
	char *level;
	char **bufp;
	struct list *namelist;
{
	char *name;
	int i;

	if (namelist->list == 0 || (name = strsep(bufp, ".")) == NULL) {
		fprintf(stderr, "%s: incomplete specification\n", string);
		return (-1);
	}
	for (i = 0; i < namelist->size; i++)
		if (namelist->list[i].ctl_name != NULL &&
		    strcmp(name, namelist->list[i].ctl_name) == 0)
			break;
	if (i == namelist->size) {
		fprintf(stderr, "%s level name %s in %s is invalid\n",
		    level, name, string);
		return (-1);
	}
	return (i);
}

usage()
{

	(void)fprintf(stderr, "usage:\t%s\n\t%s\n\t%s\n\t%s\n",
	    "sysctl [-n] variable ...", "sysctl [-n] -w variable=value ...",
	    "sysctl [-n] -a", "sysctl [-n] -A");
	exit(1);
}
Commit	Line	Data
33a39b1e	1	/*
a42b3e1b KB	2	* Copyright (c) 1993
a42b3e1b KB	3	* The Regents of the University of California. All rights reserved.
33a39b1e KM	4	*
	5	* %sccs.include.redist.c%
	6	*/
	7
	8	#ifndef lint
a42b3e1b KB	9	static char copyright[] =
	10	"@(#) Copyright (c) 1993\n\
	11	The Regents of the University of California. All rights reserved.\n";
33a39b1e KM	12	#endif /* not lint */
	13
	14	#ifndef lint
a42b3e1b	15	static char sccsid[] = "@(#)sysctl.c 8.1 (Berkeley) %G%";
33a39b1e KM	16	#endif /* not lint */
33a39b1e KM	17
3a9dd945	18	#include <sys/param.h>
629efb73	19	#include <sys/gmon.h>
33a39b1e KM	20	#include <sys/stat.h>
	21	#include <sys/sysctl.h>
	22	#include <sys/socket.h>
	23	#include <vm/vm_param.h>
b04cc8ac	24	#include <machine/cpu.h>
3a9dd945	25
129fa670 KM	26	#include <netinet/in.h>
	27	#include <netinet/in_systm.h>
	28	#include <netinet/ip.h>
	29	#include <netinet/ip_icmp.h>
	30	#include <netinet/icmp_var.h>
5082da2b KM	31	#include <netinet/ip_var.h>
	32	#include <netinet/udp.h>
	33	#include <netinet/udp_var.h>
3a9dd945	34
33a39b1e	35	#include <errno.h>
3a9dd945	36	#include <stdio.h>
33a39b1e KM	37	#include <stdlib.h>
33a39b1e KM	38	#include <string.h>
33a39b1e	39
129fa670 KM	40	struct ctlname topname[] = CTL_NAMES;
	41	struct ctlname kernname[] = CTL_KERN_NAMES;
	42	struct ctlname vmname[] = CTL_VM_NAMES;
	43	struct ctlname netname[] = CTL_NET_NAMES;
	44	struct ctlname hwname[] = CTL_HW_NAMES;
759ce31c	45	struct ctlname username[] = CTL_USER_NAMES;
1fdacbde	46	struct ctlname debugname[CTL_DEBUG_MAXID];
b04cc8ac KM	47	#ifdef CTL_MACHDEP_NAMES
	48	struct ctlname machdepname[] = CTL_MACHDEP_NAMES;
	49	#endif
1fdacbde	50	char names[BUFSIZ];
33a39b1e KM	51
33a39b1e KM	52	struct list {
129fa670	53	struct ctlname *list;
33a39b1e	54	int size;
129fa670 KM	55	};
	56	struct list toplist = { topname, CTL_MAXID };
	57	struct list secondlevel[] = {
33a39b1e KM	58	{ 0, 0 }, /* CTL_UNSPEC */
	59	{ kernname, KERN_MAXID }, /* CTL_KERN */
	60	{ vmname, VM_MAXID }, /* CTL_VM */
	61	{ 0, 0 }, /* CTL_FS */
	62	{ netname, NET_MAXID }, /* CTL_NET */
1fdacbde	63	{ 0, CTL_DEBUG_MAXID }, /* CTL_DEBUG */
33a39b1e	64	{ hwname, HW_MAXID }, /* CTL_HW */
b04cc8ac KM	65	#ifdef CTL_MACHDEP_NAMES
	66	{ machdepname, CPU_MAXID }, /* CTL_MACHDEP */
	67	#else
33a39b1e	68	{ 0, 0 }, /* CTL_MACHDEP */
b04cc8ac	69	#endif
759ce31c	70	{ username, USER_MAXID }, /* CTL_USER_NAMES */
33a39b1e KM	71	};
33a39b1e KM	72
18ca9a3c	73	int Aflag, aflag, nflag, wflag;
33a39b1e	74
b04cc8ac KM	75	/*
	76	* Variables requiring special processing.
	77	*/
	78	#define CLOCK 0x00000001
	79	#define BOOTTIME 0x00000002
	80	#define CONSDEV 0x00000004
	81
33a39b1e KM	82	int
	83	main(argc, argv)
	84	int argc;
	85	char *argv[];
	86	{
	87	extern char *optarg;
	88	extern int optind;
18ca9a3c	89	int ch, lvl1;
33a39b1e	90
18ca9a3c	91	while ((ch = getopt(argc, argv, "Aanw")) != EOF) {
33a39b1e KM	92	switch (ch) {
	93
	94	case 'A':
	95	Aflag = 1;
	96	break;
	97
	98	case 'a':
	99	aflag = 1;
	100	break;
	101
18ca9a3c KM	102	case 'n':
	103	nflag = 1;
	104	break;
	105
33a39b1e KM	106	case 'w':
	107	wflag = 1;
	108	break;
	109
	110	default:
	111	usage();
	112	}
	113	}
	114	argc -= optind;
	115	argv += optind;
	116
	117	if (Aflag \|\| aflag) {
1fdacbde	118	debuginit();
18ca9a3c	119	for (lvl1 = 1; lvl1 < CTL_MAXID; lvl1++)
129fa670	120	listall(topname[lvl1].ctl_name, &secondlevel[lvl1]);
33a39b1e KM	121	exit(0);
	122	}
	123	if (argc == 0)
	124	usage();
	125	while (argc-- > 0)
	126	parse(*argv, 1);
	127	exit(0);
	128	}
	129
	130	/*
	131	* List all variables known to the system.
	132	*/
129fa670 KM	133	listall(prefix, lp)
129fa670 KM	134	char *prefix;
33a39b1e	135	struct list *lp;
129fa670	136	{
18ca9a3c	137	int lvl2;
33a39b1e KM	138	char *cp, name[BUFSIZ];
33a39b1e KM	139
18ca9a3c KM	140	if (lp->list == 0)
18ca9a3c KM	141	return;
129fa670	142	strcpy(name, prefix);
18ca9a3c KM	143	cp = &name[strlen(name)];
18ca9a3c KM	144	*cp++ = '.';
129fa670 KM	145	for (lvl2 = 0; lvl2 < lp->size; lvl2++) {
	146	if (lp->list[lvl2].ctl_name == 0)
	147	continue;
	148	strcpy(cp, lp->list[lvl2].ctl_name);
18ca9a3c	149	parse(name, Aflag);
33a39b1e KM	150	}
	151	}
	152
	153	/*
	154	* Parse a name into a MIB entry.
	155	* Lookup and print out the MIB entry if it exists.
	156	* Set a new value if requested.
	157	*/
	158	parse(string, flags)
	159	char *string;
	160	int flags;
	161	{
629efb73	162	int indx, type, state, size, len;
b04cc8ac	163	int special = 0;
33a39b1e KM	164	void *newval = 0;
33a39b1e KM	165	int intval, newsize = 0;
129fa670 KM	166	quad_t quadval;
129fa670 KM	167	struct list *lp;
33a39b1e KM	168	int mib[CTL_MAXNAME];
	169	char cp, bufp, buf[BUFSIZ], strval[BUFSIZ];
	170
	171	bufp = buf;
	172	snprintf(buf, BUFSIZ, "%s", string);
	173	if ((cp = strchr(string, '=')) != NULL) {
	174	if (!wflag) {
	175	fprintf(stderr, "Must specify -w to set variables\n");
	176	exit(2);
	177	}
	178	*strchr(buf, '=') = '\0';
	179	*cp++ = '\0';
	180	while (isspace(*cp))
	181	cp++;
129fa670 KM	182	newval = cp;
129fa670 KM	183	newsize = strlen(cp);
33a39b1e	184	}
129fa670	185	if ((indx = findname(string, "top", &bufp, &toplist)) == -1)
33a39b1e KM	186	return;
33a39b1e KM	187	mib[0] = indx;
1fdacbde KM	188	if (indx == CTL_DEBUG)
1fdacbde KM	189	debuginit();
33a39b1e KM	190	lp = &secondlevel[indx];
	191	if (lp->list == 0) {
	192	fprintf(stderr, "%s: class is not implemented\n",
	193	topname[indx]);
	194	return;
	195	}
18ca9a3c	196	if (bufp == NULL) {
129fa670	197	listall(topname[indx].ctl_name, lp);
18ca9a3c KM	198	return;
18ca9a3c KM	199	}
33a39b1e KM	200	if ((indx = findname(string, "second", &bufp, lp)) == -1)
	201	return;
	202	mib[1] = indx;
129fa670 KM	203	type = lp->list[indx].ctl_type;
129fa670 KM	204	len = 2;
33a39b1e KM	205	switch (mib[0]) {
	206
	207	case CTL_KERN:
	208	switch (mib[1]) {
629efb73 KM	209	case KERN_PROF:
	210	mib[2] = GPROF_STATE;
	211	size = sizeof state;
	212	if (sysctl(mib, 3, &state, &size, NULL, 0) < 0) {
	213	if (flags == 0)
	214	return;
	215	if (!nflag)
	216	fprintf(stdout, "%s: ", string);
	217	fprintf(stderr,
	218	"kernel is not compiled for profiling\n");
	219	return;
	220	}
	221	if (!nflag)
	222	fprintf(stdout, "%s: %s\n", string,
	223	state == GMON_PROF_OFF ? "off" : "running");
	224	return;
33a39b1e KM	225	case KERN_VNODE:
	226	case KERN_FILE:
	227	if (flags == 0)
	228	return;
	229	fprintf(stderr,
	230	"Use pstat to view %s information\n", string);
	231	return;
	232	case KERN_PROC:
	233	if (flags == 0)
	234	return;
	235	fprintf(stderr,
	236	"Use ps to view %s information\n", string);
	237	return;
	238	case KERN_CLOCKRATE:
b04cc8ac	239	special \|= CLOCK;
33a39b1e	240	break;
3c56a5f8	241	case KERN_BOOTTIME:
b04cc8ac	242	special \|= BOOTTIME;
3c56a5f8	243	break;
33a39b1e KM	244	}
	245	break;
	246
	247	case CTL_HW:
	248	break;
	249
	250	case CTL_VM:
	251	if (mib[1] == VM_LOADAVG) {
	252	double loads[3];
	253
	254	getloadavg(loads, 3);
18ca9a3c KM	255	if (!nflag)
	256	fprintf(stdout, "%s: ", string);
	257	fprintf(stdout, "%.2f %.2f %.2f\n",
33a39b1e KM	258	loads[0], loads[1], loads[2]);
	259	return;
	260	}
	261	if (flags == 0)
	262	return;
	263	fprintf(stderr,
	264	"Use vmstat or systat to view %s information\n", string);
	265	return;
	266
	267	case CTL_NET:
129fa670 KM	268	if (mib[1] == PF_INET) {
	269	len = sysctl_inet(string, &bufp, mib, flags, &type);
	270	if (len >= 0)
	271	break;
	272	return;
	273	}
33a39b1e KM	274	if (flags == 0)
	275	return;
	276	fprintf(stderr, "Use netstat to view %s information\n", string);
	277	return;
	278
33a39b1e	279	case CTL_DEBUG:
1fdacbde KM	280	mib[2] = CTL_DEBUG_VALUE;
	281	len = 3;
	282	break;
	283
33a39b1e	284	case CTL_MACHDEP:
b04cc8ac KM	285	#ifdef CPU_CONSDEV
	286	if (mib[1] == CPU_CONSDEV)
	287	special \|= CONSDEV;
	288	#endif
	289	break;
	290
	291	case CTL_FS:
759ce31c	292	case CTL_USER:
33a39b1e KM	293	break;
	294
	295	default:
	296	fprintf(stderr, "Illegal top level value: %d\n", mib[0]);
	297	return;
	298
	299	}
129fa670 KM	300	if (bufp) {
	301	fprintf(stderr, "name %s in %s is unknown\n", *bufp, string);
	302	return;
	303	}
	304	if (newsize > 0) {
	305	switch (type) {
	306	case CTLTYPE_INT:
	307	intval = atoi(newval);
	308	newval = &intval;
	309	newsize = sizeof intval;
	310	break;
33a39b1e	311
129fa670 KM	312	case CTLTYPE_QUAD:
	313	sscanf(newval, "%qd", &quadval);
	314	newval = &quadval;
	315	newsize = sizeof quadval;
	316	break;
	317	}
	318	}
33a39b1e	319	size = BUFSIZ;
129fa670	320	if (sysctl(mib, len, buf, &size, newsize ? newval : 0, newsize) == -1) {
33a39b1e KM	321	if (flags == 0)
	322	return;
	323	switch (errno) {
	324	case EOPNOTSUPP:
	325	fprintf(stderr, "%s: value is not available\n", string);
	326	return;
	327	case ENOTDIR:
	328	fprintf(stderr, "%s: specification is incomplete\n",
	329	string);
	330	return;
	331	case ENOMEM:
	332	fprintf(stderr, "%s: type is unknown to this program\n",
	333	string);
	334	return;
	335	default:
	336	perror(string);
	337	return;
	338	}
	339	}
b04cc8ac	340	if (special & CLOCK) {
33a39b1e KM	341	struct clockinfo clkp = (struct clockinfo )buf;
33a39b1e KM	342
18ca9a3c KM	343	if (!nflag)
18ca9a3c KM	344	fprintf(stdout, "%s: ", string);
33a39b1e	345	fprintf(stdout,
18ca9a3c KM	346	"hz = %d, tick = %d, profhz = %d, stathz = %d\n",
18ca9a3c KM	347	clkp->hz, clkp->tick, clkp->profhz, clkp->stathz);
33a39b1e KM	348	return;
33a39b1e KM	349	}
b04cc8ac	350	if (special & BOOTTIME) {
3c56a5f8 KM	351	struct timeval btp = (struct timeval )buf;
	352
	353	if (!nflag)
	354	fprintf(stdout, "%s = %s\n", string,
	355	ctime(&btp->tv_sec));
	356	else
	357	fprintf(stdout, "%d\n", btp->tv_sec);
	358	return;
	359	}
b04cc8ac KM	360	if (special & CONSDEV) {
	361	dev_t dev = (dev_t )buf;
	362
	363	if (!nflag)
	364	fprintf(stdout, "%s = %s\n", string,
	365	devname(dev, S_IFCHR));
	366	else
	367	fprintf(stdout, "0x%x\n", dev);
	368	return;
	369	}
129fa670 KM	370	switch (type) {
129fa670 KM	371	case CTLTYPE_INT:
18ca9a3c KM	372	if (newsize == 0) {
	373	if (!nflag)
	374	fprintf(stdout, "%s = ", string);
	375	fprintf(stdout, "%d\n", (int )buf);
	376	} else {
	377	if (!nflag)
	378	fprintf(stdout, "%s: %d -> ", string,
	379	(int )buf);
	380	fprintf(stdout, "%d\n", (int )newval);
	381	}
129fa670 KM	382	return;
	383
	384	case CTLTYPE_STRING:
18ca9a3c KM	385	if (newsize == 0) {
	386	if (!nflag)
	387	fprintf(stdout, "%s = ", string);
	388	fprintf(stdout, "%s\n", buf);
	389	} else {
	390	if (!nflag)
	391	fprintf(stdout, "%s: %s -> ", string, buf);
	392	fprintf(stdout, "%s\n", newval);
	393	}
129fa670 KM	394	return;
	395
	396	case CTLTYPE_QUAD:
	397	if (newsize == 0) {
	398	if (!nflag)
	399	fprintf(stdout, "%s = ", string);
	400	fprintf(stdout, "%qd\n", (quad_t )buf);
	401	} else {
	402	if (!nflag)
	403	fprintf(stdout, "%s: %qd -> ", string,
	404	(quad_t )buf);
	405	fprintf(stdout, "%qd\n", (quad_t )newval);
	406	}
	407	return;
	408
	409	case CTLTYPE_STRUCT:
	410	fprintf(stderr, "%s: unknown structure returned\n",
	411	string);
	412	return;
	413
	414	default:
	415	case CTLTYPE_NODE:
	416	fprintf(stderr, "%s: unknown type returned\n",
	417	string);
	418	return;
	419	}
	420	}
	421
1fdacbde KM	422	/*
	423	* Initialize the set of debugging names
	424	*/
	425	debuginit()
	426	{
	427	int mib[3], size, loc, i;
	428
	429	if (secondlevel[CTL_DEBUG].list != 0)
	430	return;
	431	secondlevel[CTL_DEBUG].list = debugname;
	432	mib[0] = CTL_DEBUG;
	433	mib[2] = CTL_DEBUG_NAME;
	434	for (loc = 0, i = 0; i < CTL_DEBUG_MAXID; i++) {
	435	mib[1] = i;
	436	size = BUFSIZ - loc;
	437	if (sysctl(mib, 3, &names[loc], &size, NULL, 0) == -1)
	438	continue;
	439	debugname[i].ctl_name = &names[loc];
	440	debugname[i].ctl_type = CTLTYPE_INT;
	441	loc += size;
	442	}
	443	}
	444
129fa670 KM	445	struct ctlname inetname[] = CTL_IPPROTO_NAMES;
	446	struct ctlname ipname[] = IPCTL_NAMES;
	447	struct ctlname icmpname[] = ICMPCTL_NAMES;
5082da2b	448	struct ctlname udpname[] = UDPCTL_NAMES;
129fa670 KM	449	struct list inetlist = { inetname, IPPROTO_MAXID };
129fa670 KM	450	struct list inetvars[] = {
5082da2b KM	451	{ ipname, IPCTL_MAXID }, /* ip */
	452	{ icmpname, ICMPCTL_MAXID }, /* icmp */
	453	{ 0, 0 }, /* igmp */
	454	{ 0, 0 }, /* ggmp */
	455	{ 0, 0 },
	456	{ 0, 0 },
	457	{ 0, 0 }, /* tcp */
	458	{ 0, 0 },
	459	{ 0, 0 }, /* egp */
	460	{ 0, 0 },
	461	{ 0, 0 },
	462	{ 0, 0 },
	463	{ 0, 0 }, /* pup */
	464	{ 0, 0 },
	465	{ 0, 0 },
	466	{ 0, 0 },
	467	{ 0, 0 },
	468	{ udpname, UDPCTL_MAXID }, /* udp */
129fa670 KM	469	};
	470
	471	/*
	472	* handle internet requests
	473	*/
	474	sysctl_inet(string, bufpp, mib, flags, typep)
	475	char *string;
	476	char **bufpp;
	477	int mib[];
	478	int flags;
	479	int *typep;
	480	{
	481	struct list *lp;
	482	int indx;
	483
	484	if (*bufpp == NULL) {
	485	listall(string, &inetlist);
	486	return (-1);
	487	}
	488	if ((indx = findname(string, "third", bufpp, &inetlist)) == -1)
	489	return (-1);
	490	mib[2] = indx;
5082da2b	491	if (indx <= IPPROTO_UDP && inetvars[indx].list != NULL)
129fa670 KM	492	lp = &inetvars[indx];
	493	else if (!flags)
	494	return (-1);
	495	else {
	496	fprintf(stderr, "%s: no variables defined for this protocol\n",
	497	string);
	498	return (-1);
	499	}
	500	if (*bufpp == NULL) {
	501	listall(string, lp);
	502	return (-1);
	503	}
	504	if ((indx = findname(string, "fourth", bufpp, lp)) == -1)
	505	return (-1);
	506	mib[3] = indx;
	507	*typep = lp->list[indx].ctl_type;
	508	return (4);
33a39b1e KM	509	}
	510
	511	/*
	512	* Scan a list of names searching for a particular name.
	513	*/
	514	findname(string, level, bufp, namelist)
	515	char *string;
	516	char *level;
	517	char **bufp;
	518	struct list *namelist;
	519	{
	520	char *name;
	521	int i;
	522
	523	if (namelist->list == 0 \|\| (name = strsep(bufp, ".")) == NULL) {
	524	fprintf(stderr, "%s: incomplete specification\n", string);
	525	return (-1);
	526	}
	527	for (i = 0; i < namelist->size; i++)
cdbdb4d7 CT	528	if (namelist->list[i].ctl_name != NULL &&
cdbdb4d7 CT	529	strcmp(name, namelist->list[i].ctl_name) == 0)
33a39b1e KM	530	break;
	531	if (i == namelist->size) {
	532	fprintf(stderr, "%s level name %s in %s is invalid\n",
	533	level, name, string);
	534	return (-1);
	535	}
	536	return (i);
	537	}
	538
	539	usage()
	540	{
	541
31ac5c9a KM	542	(void)fprintf(stderr, "usage:\t%s\n\t%s\n\t%s\n\t%s\n",
	543	"sysctl [-n] variable ...", "sysctl [-n] -w variable=value ...",
	544	"sysctl [-n] -a", "sysctl [-n] -A");
33a39b1e KM	545	exit(1);
33a39b1e KM	546	}