[unix-history] / usr.sbin / rwhod / rwhod.c

/*
 * Copyright (c) 1983 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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. 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.
 */

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

#ifndef lint
static char sccsid[] = "@(#)rwhod.c	5.20 (Berkeley) 3/2/91";
#endif /* not lint */

#include <sys/param.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/signal.h>
#include <sys/ioctl.h>
#include <sys/file.h>

#include <net/if.h>
#include <netinet/in.h>

#include <nlist.h>
#include <errno.h>
#include <utmp.h>
#include <ctype.h>
#include <netdb.h>
#include <syslog.h>
#include <protocols/rwhod.h>
#include <stdio.h>
#include <paths.h>

/*
 * Alarm interval. Don't forget to change the down time check in ruptime
 * if this is changed.
 */
#define AL_INTERVAL (3 * 60)

struct	sockaddr_in s_in;

char	myname[MAXHOSTNAMELEN];

struct	nlist nl[] = {
#define	NL_BOOTTIME	0
	{ "_boottime" },
	0
};

/*
 * We communicate with each neighbor in
 * a list constructed at the time we're
 * started up.  Neighbors are currently
 * directly connected via a hardware interface.
 */
struct	neighbor {
	struct	neighbor *n_next;
	char	*n_name;		/* interface name */
	char	*n_addr;		/* who to send to */
	int	n_addrlen;		/* size of address */
	int	n_flags;		/* should forward?, interface flags */
};

struct	neighbor *neighbors;
struct	whod mywd;
struct	servent *sp;
int	s, utmpf, kmemf = -1;

#define	WHDRSIZE	(sizeof (mywd) - sizeof (mywd.wd_we))

extern int errno;
char	*strcpy(), *malloc();
long	lseek();
void	getkmem(), onalrm();
struct	in_addr inet_makeaddr();

main()
{
	struct sockaddr_in from;
	struct stat st;
	char path[64];
	int on = 1;
	char *cp, *index(), *strerror();

	if (getuid()) {
		fprintf(stderr, "rwhod: not super user\n");
		exit(1);
	}
	sp = getservbyname("who", "udp");
	if (sp == 0) {
		fprintf(stderr, "rwhod: udp/who: unknown service\n");
		exit(1);
	}
#ifndef DEBUG
	daemon(1, 0);
#endif
	if (chdir(_PATH_RWHODIR) < 0) {
		(void)fprintf(stderr, "rwhod: %s: %s\n",
		    _PATH_RWHODIR, strerror(errno));
		exit(1);
	}
	(void) signal(SIGHUP, getkmem);
	openlog("rwhod", LOG_PID, LOG_DAEMON);
	/*
	 * Establish host name as returned by system.
	 */
	if (gethostname(myname, sizeof (myname) - 1) < 0) {
		syslog(LOG_ERR, "gethostname: %m");
		exit(1);
	}
	if ((cp = index(myname, '.')) != NULL)
		*cp = '\0';
	strncpy(mywd.wd_hostname, myname, sizeof (myname) - 1);
	utmpf = open(_PATH_UTMP, O_RDONLY|O_CREAT, 0644);
	if (utmpf < 0) {
		syslog(LOG_ERR, "%s: %m", _PATH_UTMP);
		exit(1);
	}
	getkmem();
	if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		syslog(LOG_ERR, "socket: %m");
		exit(1);
	}
	if (setsockopt(s, SOL_SOCKET, SO_BROADCAST, &on, sizeof (on)) < 0) {
		syslog(LOG_ERR, "setsockopt SO_BROADCAST: %m");
		exit(1);
	}
	s_in.sin_family = AF_INET;
	s_in.sin_port = sp->s_port;
	if (bind(s, (struct sockaddr *)&s_in, sizeof (s_in)) < 0) {
		syslog(LOG_ERR, "bind: %m");
		exit(1);
	}
	if (!configure(s))
		exit(1);
	signal(SIGALRM, onalrm);
	onalrm();
	for (;;) {
		struct whod wd;
		int cc, whod, len = sizeof (from);

		cc = recvfrom(s, (char *)&wd, sizeof (struct whod), 0,
			(struct sockaddr *)&from, &len);
		if (cc <= 0) {
			if (cc < 0 && errno != EINTR)
				syslog(LOG_WARNING, "recv: %m");
			continue;
		}
		if (from.sin_port != sp->s_port) {
			syslog(LOG_WARNING, "%d: bad from port",
				ntohs(from.sin_port));
			continue;
		}
		if (wd.wd_vers != WHODVERSION)
			continue;
		if (wd.wd_type != WHODTYPE_STATUS)
			continue;
		if (!verify(wd.wd_hostname)) {
			syslog(LOG_WARNING, "malformed host name from %x",
				from.sin_addr);
			continue;
		}
		(void) sprintf(path, "whod.%s", wd.wd_hostname);
		/*
		 * Rather than truncating and growing the file each time,
		 * use ftruncate if size is less than previous size.
		 */
		whod = open(path, O_WRONLY | O_CREAT, 0644);
		if (whod < 0) {
			syslog(LOG_WARNING, "%s: %m", path);
			continue;
		}
#if ENDIAN != BIG_ENDIAN
		{
			int i, n = (cc - WHDRSIZE)/sizeof(struct whoent);
			struct whoent *we;

			/* undo header byte swapping before writing to file */
			wd.wd_sendtime = ntohl(wd.wd_sendtime);
			for (i = 0; i < 3; i++)
				wd.wd_loadav[i] = ntohl(wd.wd_loadav[i]);
			wd.wd_boottime = ntohl(wd.wd_boottime);
			we = wd.wd_we;
			for (i = 0; i < n; i++) {
				we->we_idle = ntohl(we->we_idle);
				we->we_utmp.out_time =
				    ntohl(we->we_utmp.out_time);
				we++;
			}
		}
#endif
		(void) time((time_t *)&wd.wd_recvtime);
		(void) write(whod, (char *)&wd, cc);
		if (fstat(whod, &st) < 0 || st.st_size > cc)
			ftruncate(whod, cc);
		(void) close(whod);
	}
}

/*
 * Check out host name for unprintables
 * and other funnies before allowing a file
 * to be created.  Sorry, but blanks aren't allowed.
 */
verify(name)
	register char *name;
{
	register int size = 0;

	while (*name) {
		if (!isascii(*name) || !(isalnum(*name) || ispunct(*name)))
			return (0);
		name++, size++;
	}
	return (size > 0);
}

int	utmptime;
int	utmpent;
int	utmpsize = 0;
struct	utmp *utmp;
int	alarmcount;

void
onalrm()
{
	register struct neighbor *np;
	register struct whoent *we = mywd.wd_we, *wlast;
	register int i;
	struct stat stb;
	int cc;
	double avenrun[3];
	time_t now = time((time_t *)NULL);
	char *strerror();

	if (alarmcount % 10 == 0)
		getkmem();
	alarmcount++;
	(void) fstat(utmpf, &stb);
	if ((stb.st_mtime != utmptime) || (stb.st_size > utmpsize)) {
		utmptime = stb.st_mtime;
		if (stb.st_size > utmpsize) {
			utmpsize = stb.st_size + 10 * sizeof(struct utmp);
			if (utmp)
				utmp = (struct utmp *)realloc(utmp, utmpsize);
			else
				utmp = (struct utmp *)malloc(utmpsize);
			if (! utmp) {
				fprintf(stderr, "rwhod: malloc failed\n");
				utmpsize = 0;
				goto done;
			}
		}
		(void) lseek(utmpf, (long)0, L_SET);
		cc = read(utmpf, (char *)utmp, stb.st_size);
		if (cc < 0) {
			fprintf(stderr, "rwhod: %s: %s\n",
			    _PATH_UTMP, strerror(errno));
			goto done;
		}
		wlast = &mywd.wd_we[1024 / sizeof (struct whoent) - 1];
		utmpent = cc / sizeof (struct utmp);
		for (i = 0; i < utmpent; i++)
			if (utmp[i].ut_name[0]) {
				bcopy(utmp[i].ut_line, we->we_utmp.out_line,
				   sizeof (utmp[i].ut_line));
				bcopy(utmp[i].ut_name, we->we_utmp.out_name,
				   sizeof (utmp[i].ut_name));
				we->we_utmp.out_time = htonl(utmp[i].ut_time);
				if (we >= wlast)
					break;
				we++;
			}
		utmpent = we - mywd.wd_we;
	}

	/*
	 * The test on utmpent looks silly---after all, if no one is
	 * logged on, why worry about efficiency?---but is useful on
	 * (e.g.) compute servers.
	 */
	if (utmpent && chdir(_PATH_DEV)) {
		syslog(LOG_ERR, "chdir(%s): %m", _PATH_DEV);
		exit(1);
	}
	we = mywd.wd_we;
	for (i = 0; i < utmpent; i++) {
		if (stat(we->we_utmp.out_line, &stb) >= 0)
			we->we_idle = htonl(now - stb.st_atime);
		we++;
	}
	(void) getloadavg(avenrun, sizeof(avenrun)/sizeof(avenrun[0]));
	for (i = 0; i < 3; i++)
		mywd.wd_loadav[i] = htonl((u_long)(avenrun[i] * 100));
	cc = (char *)we - (char *)&mywd;
	mywd.wd_sendtime = htonl(time(0));
	mywd.wd_vers = WHODVERSION;
	mywd.wd_type = WHODTYPE_STATUS;
	for (np = neighbors; np != NULL; np = np->n_next)
		(void) sendto(s, (char *)&mywd, cc, 0,
			(struct sockaddr *)np->n_addr, np->n_addrlen);
	if (utmpent && chdir(_PATH_RWHODIR)) {
		syslog(LOG_ERR, "chdir(%s): %m", _PATH_RWHODIR);
		exit(1);
	}
done:
	(void) alarm(AL_INTERVAL);
}

void
getkmem()
{
	static ino_t vmunixino;
	static time_t vmunixctime;
	struct stat sb;

	if (stat(_PATH_UNIX, &sb) < 0) {
		if (vmunixctime)
			return;
	} else {
		if (sb.st_ctime == vmunixctime && sb.st_ino == vmunixino)
			return;
		vmunixctime = sb.st_ctime;
		vmunixino= sb.st_ino;
	}
	if (kmemf >= 0)
		(void) close(kmemf);
loop:
	if (nlist(_PATH_UNIX, nl)) {
		syslog(LOG_WARNING, "%s: namelist botch", _PATH_UNIX);
		sleep(300);
		goto loop;
	}
	kmemf = open(_PATH_KMEM, O_RDONLY, 0);
	if (kmemf < 0) {
		syslog(LOG_ERR, "%s: %m", _PATH_KMEM);
		exit(1);
	}
	(void) lseek(kmemf, (long)nl[NL_BOOTTIME].n_value, L_SET);
	(void) read(kmemf, (char *)&mywd.wd_boottime,
	    sizeof (mywd.wd_boottime));
	mywd.wd_boottime = htonl(mywd.wd_boottime);
}

/*
 * Figure out device configuration and select
 * networks which deserve status information.
 */
configure(s)
	int s;
{
	char buf[BUFSIZ], *cp, *cplim;
	struct ifconf ifc;
	struct ifreq ifreq, *ifr;
	struct sockaddr_in *s_in;
	register struct neighbor *np;

	ifc.ifc_len = sizeof (buf);
	ifc.ifc_buf = buf;
	if (ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0) {
		syslog(LOG_ERR, "ioctl (get interface configuration)");
		return (0);
	}
	ifr = ifc.ifc_req;
#ifdef AF_LINK
#define max(a, b) (a > b ? a : b)
#define size(p)	max((p).sa_len, sizeof(p))
#else
#define size(p) (sizeof (p))
#endif
	cplim = buf + ifc.ifc_len; /*skip over if's with big ifr_addr's */
	for (cp = buf; cp < cplim;
			cp += sizeof (ifr->ifr_name) + size(ifr->ifr_addr)) {
		ifr = (struct ifreq *)cp;
		for (np = neighbors; np != NULL; np = np->n_next)
			if (np->n_name &&
			    strcmp(ifr->ifr_name, np->n_name) == 0)
				break;
		if (np != NULL)
			continue;
		ifreq = *ifr;
		np = (struct neighbor *)malloc(sizeof (*np));
		if (np == NULL)
			continue;
		np->n_name = malloc(strlen(ifr->ifr_name) + 1);
		if (np->n_name == NULL) {
			free((char *)np);
			continue;
		}
		strcpy(np->n_name, ifr->ifr_name);
		np->n_addrlen = sizeof (ifr->ifr_addr);
		np->n_addr = malloc(np->n_addrlen);
		if (np->n_addr == NULL) {
			free(np->n_name);
			free((char *)np);
			continue;
		}
		bcopy((char *)&ifr->ifr_addr, np->n_addr, np->n_addrlen);
		if (ioctl(s, SIOCGIFFLAGS, (char *)&ifreq) < 0) {
			syslog(LOG_ERR, "ioctl (get interface flags)");
			free((char *)np);
			continue;
		}
		if ((ifreq.ifr_flags & IFF_UP) == 0 ||
		    (ifreq.ifr_flags & (IFF_BROADCAST|IFF_POINTOPOINT)) == 0) {
			free((char *)np);
			continue;
		}
		np->n_flags = ifreq.ifr_flags;
		if (np->n_flags & IFF_POINTOPOINT) {
			if (ioctl(s, SIOCGIFDSTADDR, (char *)&ifreq) < 0) {
				syslog(LOG_ERR, "ioctl (get dstaddr)");
				free((char *)np);
				continue;
			}
			/* we assume addresses are all the same size */
			bcopy((char *)&ifreq.ifr_dstaddr,
			  np->n_addr, np->n_addrlen);
		}
		if (np->n_flags & IFF_BROADCAST) {
			if (ioctl(s, SIOCGIFBRDADDR, (char *)&ifreq) < 0) {
				syslog(LOG_ERR, "ioctl (get broadaddr)");
				free((char *)np);
				continue;
			}
			/* we assume addresses are all the same size */
			bcopy((char *)&ifreq.ifr_broadaddr,
			  np->n_addr, np->n_addrlen);
		}
		/* gag, wish we could get rid of Internet dependencies */
		s_in = (struct sockaddr_in *)np->n_addr;
		s_in->sin_port = sp->s_port;
		np->n_next = neighbors;
		neighbors = np;
	}
	return (1);
}

#ifdef DEBUG
sendto(s, buf, cc, flags, to, tolen)
	int s;
	char *buf;
	int cc, flags;
	char *to;
	int tolen;
{
	register struct whod *w = (struct whod *)buf;
	register struct whoent *we;
	struct sockaddr_in *s_in = (struct sockaddr_in *)to;
	char *interval();

	printf("sendto %x.%d\n", ntohl(s_in->sin_addr), ntohs(s_in->sin_port));
	printf("hostname %s %s\n", w->wd_hostname,
	   interval(ntohl(w->wd_sendtime) - ntohl(w->wd_boottime), "  up"));
	printf("load %4.2f, %4.2f, %4.2f\n",
	    ntohl(w->wd_loadav[0]) / 100.0, ntohl(w->wd_loadav[1]) / 100.0,
	    ntohl(w->wd_loadav[2]) / 100.0);
	cc -= WHDRSIZE;
	for (we = w->wd_we, cc /= sizeof (struct whoent); cc > 0; cc--, we++) {
		time_t t = ntohl(we->we_utmp.out_time);
		printf("%-8.8s %s:%s %.12s",
			we->we_utmp.out_name,
			w->wd_hostname, we->we_utmp.out_line,
			ctime(&t)+4);
		we->we_idle = ntohl(we->we_idle) / 60;
		if (we->we_idle) {
			if (we->we_idle >= 100*60)
				we->we_idle = 100*60 - 1;
			if (we->we_idle >= 60)
				printf(" %2d", we->we_idle / 60);
			else
				printf("   ");
			printf(":%02d", we->we_idle % 60);
		}
		printf("\n");
	}
}

char *
interval(time, updown)
	int time;
	char *updown;
{
	static char resbuf[32];
	int days, hours, minutes;

	if (time < 0 || time > 3*30*24*60*60) {
		(void) sprintf(resbuf, "   %s ??:??", updown);
		return (resbuf);
	}
	minutes = (time + 59) / 60;		/* round to minutes */
	hours = minutes / 60; minutes %= 60;
	days = hours / 24; hours %= 24;
	if (days)
		(void) sprintf(resbuf, "%s %2d+%02d:%02d",
		    updown, days, hours, minutes);
	else
		(void) sprintf(resbuf, "%s    %2d:%02d",
		    updown, hours, minutes);
	return (resbuf);
}
#endif
Commit	Line	Data
15637ed4 RG	1	/*
	2	* Copyright (c) 1983 The Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	* 3. All advertising materials mentioning features or use of this software
	14	* must display the following acknowledgement:
	15	* This product includes software developed by the University of
	16	* California, Berkeley and its contributors.
	17	* 4. Neither the name of the University nor the names of its contributors
	18	* may be used to endorse or promote products derived from this software
	19	* without specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	22	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	24	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	25	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	26	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	27	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	29	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	30	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	31	* SUCH DAMAGE.
	32	*/
	33
	34	#ifndef lint
	35	char copyright[] =
	36	"@(#) Copyright (c) 1983 The Regents of the University of California.\n\
	37	All rights reserved.\n";
	38	#endif /* not lint */
	39
	40	#ifndef lint
	41	static char sccsid[] = "@(#)rwhod.c 5.20 (Berkeley) 3/2/91";
	42	#endif /* not lint */
	43
	44	#include <sys/param.h>
	45	#include <sys/socket.h>
	46	#include <sys/stat.h>
	47	#include <sys/signal.h>
	48	#include <sys/ioctl.h>
	49	#include <sys/file.h>
	50
	51	#include <net/if.h>
	52	#include <netinet/in.h>
	53
	54	#include <nlist.h>
	55	#include <errno.h>
	56	#include <utmp.h>
	57	#include <ctype.h>
	58	#include <netdb.h>
	59	#include <syslog.h>
	60	#include <protocols/rwhod.h>
	61	#include <stdio.h>
	62	#include <paths.h>
	63
	64	/*
65	* Alarm interval. Don't forget to change the down time check in ruptime
66	* if this is changed.
67	*/
68	#define AL_INTERVAL (3 * 60)
69
78ed81a3	70	struct sockaddr_in s_in;
15637ed4 RG	71
	72	char myname[MAXHOSTNAMELEN];
	73
	74	struct nlist nl[] = {
	75	#define NL_BOOTTIME 0
	76	{ "_boottime" },
	77	0
	78	};
	79
	80	/*
	81	* We communicate with each neighbor in
	82	* a list constructed at the time we're
	83	* started up. Neighbors are currently
	84	* directly connected via a hardware interface.
	85	*/
	86	struct neighbor {
	87	struct neighbor *n_next;
	88	char n_name; / interface name */
	89	char n_addr; / who to send to */
	90	int n_addrlen; /* size of address */
	91	int n_flags; /* should forward?, interface flags */
	92	};
	93
	94	struct neighbor *neighbors;
	95	struct whod mywd;
	96	struct servent *sp;
	97	int s, utmpf, kmemf = -1;
	98
	99	#define WHDRSIZE (sizeof (mywd) - sizeof (mywd.wd_we))
	100
	101	extern int errno;
	102	char strcpy(), malloc();
	103	long lseek();
	104	void getkmem(), onalrm();
	105	struct in_addr inet_makeaddr();
	106
	107	main()
	108	{
	109	struct sockaddr_in from;
	110	struct stat st;
	111	char path[64];
	112	int on = 1;
	113	char cp, index(), *strerror();
	114
	115	if (getuid()) {
	116	fprintf(stderr, "rwhod: not super user\n");
	117	exit(1);
	118	}
	119	sp = getservbyname("who", "udp");
	120	if (sp == 0) {
	121	fprintf(stderr, "rwhod: udp/who: unknown service\n");
	122	exit(1);
	123	}
	124	#ifndef DEBUG
	125	daemon(1, 0);
	126	#endif
	127	if (chdir(_PATH_RWHODIR) < 0) {
	128	(void)fprintf(stderr, "rwhod: %s: %s\n",
	129	_PATH_RWHODIR, strerror(errno));
	130	exit(1);
	131	}
	132	(void) signal(SIGHUP, getkmem);
	133	openlog("rwhod", LOG_PID, LOG_DAEMON);
	134	/*
135	* Establish host name as returned by system.
136	*/
137	if (gethostname(myname, sizeof (myname) - 1) < 0) {
138	syslog(LOG_ERR, "gethostname: %m");
139	exit(1);
140	}
141	if ((cp = index(myname, '.')) != NULL)
142	*cp = '\0';
143	strncpy(mywd.wd_hostname, myname, sizeof (myname) - 1);
144	utmpf = open(_PATH_UTMP, O_RDONLY\|O_CREAT, 0644);
145	if (utmpf < 0) {
146	syslog(LOG_ERR, "%s: %m", _PATH_UTMP);
147	exit(1);
148	}
149	getkmem();
150	if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
151	syslog(LOG_ERR, "socket: %m");
152	exit(1);
153	}
154	if (setsockopt(s, SOL_SOCKET, SO_BROADCAST, &on, sizeof (on)) < 0) {
155	syslog(LOG_ERR, "setsockopt SO_BROADCAST: %m");
156	exit(1);
157	}
78ed81a3	158	s_in.sin_family = AF_INET;
	159	s_in.sin_port = sp->s_port;
	160	if (bind(s, (struct sockaddr *)&s_in, sizeof (s_in)) < 0) {
15637ed4 RG	161	syslog(LOG_ERR, "bind: %m");
	162	exit(1);
	163	}
	164	if (!configure(s))
	165	exit(1);
	166	signal(SIGALRM, onalrm);
	167	onalrm();
	168	for (;;) {
	169	struct whod wd;
	170	int cc, whod, len = sizeof (from);
	171
	172	cc = recvfrom(s, (char *)&wd, sizeof (struct whod), 0,
	173	(struct sockaddr *)&from, &len);
	174	if (cc <= 0) {
	175	if (cc < 0 && errno != EINTR)
	176	syslog(LOG_WARNING, "recv: %m");
	177	continue;
	178	}
	179	if (from.sin_port != sp->s_port) {
	180	syslog(LOG_WARNING, "%d: bad from port",
	181	ntohs(from.sin_port));
	182	continue;
	183	}
	184	if (wd.wd_vers != WHODVERSION)
	185	continue;
	186	if (wd.wd_type != WHODTYPE_STATUS)
	187	continue;
	188	if (!verify(wd.wd_hostname)) {
	189	syslog(LOG_WARNING, "malformed host name from %x",
	190	from.sin_addr);
	191	continue;
	192	}
	193	(void) sprintf(path, "whod.%s", wd.wd_hostname);
	194	/*
	195	* Rather than truncating and growing the file each time,
	196	* use ftruncate if size is less than previous size.
	197	*/
	198	whod = open(path, O_WRONLY \| O_CREAT, 0644);
	199	if (whod < 0) {
	200	syslog(LOG_WARNING, "%s: %m", path);
	201	continue;
	202	}
	203	#if ENDIAN != BIG_ENDIAN
	204	{
	205	int i, n = (cc - WHDRSIZE)/sizeof(struct whoent);
	206	struct whoent *we;
	207
	208	/* undo header byte swapping before writing to file */
	209	wd.wd_sendtime = ntohl(wd.wd_sendtime);
	210	for (i = 0; i < 3; i++)
	211	wd.wd_loadav[i] = ntohl(wd.wd_loadav[i]);
	212	wd.wd_boottime = ntohl(wd.wd_boottime);
	213	we = wd.wd_we;
	214	for (i = 0; i < n; i++) {
	215	we->we_idle = ntohl(we->we_idle);
	216	we->we_utmp.out_time =
	217	ntohl(we->we_utmp.out_time);
	218	we++;
	219	}
	220	}
	221	#endif
	222	(void) time((time_t *)&wd.wd_recvtime);
	223	(void) write(whod, (char *)&wd, cc);
	224	if (fstat(whod, &st) < 0 \|\| st.st_size > cc)
225	ftruncate(whod, cc);
226	(void) close(whod);
227	}
228	}
229
230	/*
231	* Check out host name for unprintables
232	* and other funnies before allowing a file
233	* to be created. Sorry, but blanks aren't allowed.
234	*/
235	verify(name)
236	register char *name;
237	{
238	register int size = 0;
239
240	while (*name) {
241	if (!isascii(name) \|\| !(isalnum(name) \|\| ispunct(*name)))
242	return (0);
243	name++, size++;
244	}
245	return (size > 0);
246	}
247
248	int utmptime;
249	int utmpent;
250	int utmpsize = 0;
251	struct utmp *utmp;
252	int alarmcount;
253
254	void
255	onalrm()
256	{
257	register struct neighbor *np;
258	register struct whoent we = mywd.wd_we, wlast;
259	register int i;
260	struct stat stb;
261	int cc;
262	double avenrun[3];
263	time_t now = time((time_t *)NULL);
264	char *strerror();
265
266	if (alarmcount % 10 == 0)
267	getkmem();
268	alarmcount++;
269	(void) fstat(utmpf, &stb);
270	if ((stb.st_mtime != utmptime) \|\| (stb.st_size > utmpsize)) {
271	utmptime = stb.st_mtime;
272	if (stb.st_size > utmpsize) {
273	utmpsize = stb.st_size + 10 * sizeof(struct utmp);
274	if (utmp)
275	utmp = (struct utmp *)realloc(utmp, utmpsize);
276	else
277	utmp = (struct utmp *)malloc(utmpsize);
278	if (! utmp) {
279	fprintf(stderr, "rwhod: malloc failed\n");
280	utmpsize = 0;
281	goto done;
282	}
283	}
284	(void) lseek(utmpf, (long)0, L_SET);
285	cc = read(utmpf, (char *)utmp, stb.st_size);
286	if (cc < 0) {
287	fprintf(stderr, "rwhod: %s: %s\n",
288	_PATH_UTMP, strerror(errno));
289	goto done;
290	}
291	wlast = &mywd.wd_we[1024 / sizeof (struct whoent) - 1];
292	utmpent = cc / sizeof (struct utmp);
293	for (i = 0; i < utmpent; i++)
294	if (utmp[i].ut_name[0]) {
295	bcopy(utmp[i].ut_line, we->we_utmp.out_line,
296	sizeof (utmp[i].ut_line));
297	bcopy(utmp[i].ut_name, we->we_utmp.out_name,
298	sizeof (utmp[i].ut_name));
299	we->we_utmp.out_time = htonl(utmp[i].ut_time);
300	if (we >= wlast)
301	break;
302	we++;
303	}
304	utmpent = we - mywd.wd_we;
305	}
306
307	/*
308	* The test on utmpent looks silly---after all, if no one is
309	* logged on, why worry about efficiency?---but is useful on
310	* (e.g.) compute servers.
311	*/
312	if (utmpent && chdir(_PATH_DEV)) {
313	syslog(LOG_ERR, "chdir(%s): %m", _PATH_DEV);
314	exit(1);
315	}
316	we = mywd.wd_we;
317	for (i = 0; i < utmpent; i++) {
318	if (stat(we->we_utmp.out_line, &stb) >= 0)
319	we->we_idle = htonl(now - stb.st_atime);
320	we++;
321	}
322	(void) getloadavg(avenrun, sizeof(avenrun)/sizeof(avenrun[0]));
323	for (i = 0; i < 3; i++)
324	mywd.wd_loadav[i] = htonl((u_long)(avenrun[i] * 100));
325	cc = (char )we - (char )&mywd;
326	mywd.wd_sendtime = htonl(time(0));
327	mywd.wd_vers = WHODVERSION;
328	mywd.wd_type = WHODTYPE_STATUS;
329	for (np = neighbors; np != NULL; np = np->n_next)
330	(void) sendto(s, (char *)&mywd, cc, 0,
331	(struct sockaddr *)np->n_addr, np->n_addrlen);
332	if (utmpent && chdir(_PATH_RWHODIR)) {
333	syslog(LOG_ERR, "chdir(%s): %m", _PATH_RWHODIR);
334	exit(1);
335	}
336	done:
337	(void) alarm(AL_INTERVAL);
338	}
339
340	void
341	getkmem()
342	{
343	static ino_t vmunixino;
344	static time_t vmunixctime;
345	struct stat sb;
346
347	if (stat(_PATH_UNIX, &sb) < 0) {
348	if (vmunixctime)
349	return;
350	} else {
351	if (sb.st_ctime == vmunixctime && sb.st_ino == vmunixino)
352	return;
353	vmunixctime = sb.st_ctime;
354	vmunixino= sb.st_ino;
355	}
356	if (kmemf >= 0)
357	(void) close(kmemf);
358	loop:
359	if (nlist(_PATH_UNIX, nl)) {
360	syslog(LOG_WARNING, "%s: namelist botch", _PATH_UNIX);
361	sleep(300);
362	goto loop;
363	}
364	kmemf = open(_PATH_KMEM, O_RDONLY, 0);
365	if (kmemf < 0) {
366	syslog(LOG_ERR, "%s: %m", _PATH_KMEM);
367	exit(1);
368	}
369	(void) lseek(kmemf, (long)nl[NL_BOOTTIME].n_value, L_SET);
370	(void) read(kmemf, (char *)&mywd.wd_boottime,
371	sizeof (mywd.wd_boottime));
372	mywd.wd_boottime = htonl(mywd.wd_boottime);
373	}
374
375	/*
376	* Figure out device configuration and select
377	* networks which deserve status information.
378	*/
379	configure(s)
380	int s;
381	{
382	char buf[BUFSIZ], cp, cplim;
383	struct ifconf ifc;
384	struct ifreq ifreq, *ifr;
78ed81a3	385	struct sockaddr_in *s_in;
15637ed4 RG	386	register struct neighbor *np;
	387
	388	ifc.ifc_len = sizeof (buf);
	389	ifc.ifc_buf = buf;
	390	if (ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0) {
	391	syslog(LOG_ERR, "ioctl (get interface configuration)");
	392	return (0);
	393	}
	394	ifr = ifc.ifc_req;
	395	#ifdef AF_LINK
	396	#define max(a, b) (a > b ? a : b)
	397	#define size(p) max((p).sa_len, sizeof(p))
	398	#else
	399	#define size(p) (sizeof (p))
	400	#endif
	401	cplim = buf + ifc.ifc_len; /skip over if's with big ifr_addr's /
	402	for (cp = buf; cp < cplim;
	403	cp += sizeof (ifr->ifr_name) + size(ifr->ifr_addr)) {
	404	ifr = (struct ifreq *)cp;
	405	for (np = neighbors; np != NULL; np = np->n_next)
	406	if (np->n_name &&
	407	strcmp(ifr->ifr_name, np->n_name) == 0)
	408	break;
	409	if (np != NULL)
	410	continue;
	411	ifreq = *ifr;
	412	np = (struct neighbor )malloc(sizeof (np));
	413	if (np == NULL)
	414	continue;
	415	np->n_name = malloc(strlen(ifr->ifr_name) + 1);
	416	if (np->n_name == NULL) {
	417	free((char *)np);
	418	continue;
	419	}
	420	strcpy(np->n_name, ifr->ifr_name);
	421	np->n_addrlen = sizeof (ifr->ifr_addr);
	422	np->n_addr = malloc(np->n_addrlen);
	423	if (np->n_addr == NULL) {
	424	free(np->n_name);
	425	free((char *)np);
	426	continue;
	427	}
	428	bcopy((char *)&ifr->ifr_addr, np->n_addr, np->n_addrlen);
	429	if (ioctl(s, SIOCGIFFLAGS, (char *)&ifreq) < 0) {
	430	syslog(LOG_ERR, "ioctl (get interface flags)");
	431	free((char *)np);
	432	continue;
	433	}
	434	if ((ifreq.ifr_flags & IFF_UP) == 0 \|\|
	435	(ifreq.ifr_flags & (IFF_BROADCAST\|IFF_POINTOPOINT)) == 0) {
	436	free((char *)np);
	437	continue;
	438	}
	439	np->n_flags = ifreq.ifr_flags;
	440	if (np->n_flags & IFF_POINTOPOINT) {
	441	if (ioctl(s, SIOCGIFDSTADDR, (char *)&ifreq) < 0) {
	442	syslog(LOG_ERR, "ioctl (get dstaddr)");
	443	free((char *)np);
	444	continue;
	445	}
	446	/* we assume addresses are all the same size */
	447	bcopy((char *)&ifreq.ifr_dstaddr,
	448	np->n_addr, np->n_addrlen);
	449	}
450	if (np->n_flags & IFF_BROADCAST) {
451	if (ioctl(s, SIOCGIFBRDADDR, (char *)&ifreq) < 0) {
452	syslog(LOG_ERR, "ioctl (get broadaddr)");
453	free((char *)np);
454	continue;
455	}
456	/* we assume addresses are all the same size */
457	bcopy((char *)&ifreq.ifr_broadaddr,
458	np->n_addr, np->n_addrlen);
459	}
460	/* gag, wish we could get rid of Internet dependencies */
78ed81a3	461	s_in = (struct sockaddr_in *)np->n_addr;
78ed81a3	462	s_in->sin_port = sp->s_port;
15637ed4 RG	463	np->n_next = neighbors;
	464	neighbors = np;
	465	}
	466	return (1);
	467	}
	468
	469	#ifdef DEBUG
	470	sendto(s, buf, cc, flags, to, tolen)
	471	int s;
	472	char *buf;
	473	int cc, flags;
	474	char *to;
	475	int tolen;
	476	{
	477	register struct whod w = (struct whod )buf;
	478	register struct whoent *we;
78ed81a3	479	struct sockaddr_in s_in = (struct sockaddr_in )to;
15637ed4 RG	480	char *interval();
15637ed4 RG	481
78ed81a3	482	printf("sendto %x.%d\n", ntohl(s_in->sin_addr), ntohs(s_in->sin_port));
15637ed4 RG	483	printf("hostname %s %s\n", w->wd_hostname,
	484	interval(ntohl(w->wd_sendtime) - ntohl(w->wd_boottime), " up"));
	485	printf("load %4.2f, %4.2f, %4.2f\n",
	486	ntohl(w->wd_loadav[0]) / 100.0, ntohl(w->wd_loadav[1]) / 100.0,
	487	ntohl(w->wd_loadav[2]) / 100.0);
	488	cc -= WHDRSIZE;
	489	for (we = w->wd_we, cc /= sizeof (struct whoent); cc > 0; cc--, we++) {
	490	time_t t = ntohl(we->we_utmp.out_time);
	491	printf("%-8.8s %s:%s %.12s",
	492	we->we_utmp.out_name,
	493	w->wd_hostname, we->we_utmp.out_line,
	494	ctime(&t)+4);
	495	we->we_idle = ntohl(we->we_idle) / 60;
	496	if (we->we_idle) {
	497	if (we->we_idle >= 100*60)
	498	we->we_idle = 100*60 - 1;
	499	if (we->we_idle >= 60)
	500	printf(" %2d", we->we_idle / 60);
	501	else
	502	printf(" ");
	503	printf(":%02d", we->we_idle % 60);
	504	}
	505	printf("\n");
	506	}
	507	}
	508
	509	char *
	510	interval(time, updown)
	511	int time;
	512	char *updown;
	513	{
	514	static char resbuf[32];
	515	int days, hours, minutes;
	516
	517	if (time < 0 \|\| time > 330246060) {
	518	(void) sprintf(resbuf, " %s ??:??", updown);
	519	return (resbuf);
	520	}
	521	minutes = (time + 59) / 60; /* round to minutes */
	522	hours = minutes / 60; minutes %= 60;
	523	days = hours / 24; hours %= 24;
	524	if (days)
	525	(void) sprintf(resbuf, "%s %2d+%02d:%02d",
	526	updown, days, hours, minutes);
	527	else
	528	(void) sprintf(resbuf, "%s %2d:%02d",
	529	updown, hours, minutes);
	530	return (resbuf);
	531	}
	532	#endif