BSD 4.4 Lite usr.sbin Sources

1 files changed, 526 insertions, 0 deletions

diff --git a/usr.sbin/timed/timedc/cmds.c b/usr.sbin/timed/timedc/cmds.c
new file mode 100644
index 0000000..557f721
--- /dev/null
+++ b/usr.sbin/timed/timedc/cmds.c
@@ -0,0 +1,526 @@
+/*-
+ * Copyright (c) 1985, 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. 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
+static char sccsid[] = "@(#)cmds.c	8.1 (Berkeley) 6/6/93";
+#endif /* not lint */
+
+#ifdef sgi
+#ident "$Revision: 1.10 $"
+#endif
+
+#include "timedc.h"
+#include <sys/file.h>
+
+#include <netinet/in_systm.h>
+#include <netinet/ip.h>
+#include <netinet/ip_icmp.h>
+
+#include <stdlib.h>
+#include <strings.h>
+#include <unistd.h>
+
+#define TSPTYPES
+#include <protocols/timed.h>
+
+#ifdef sgi
+#include <bstring.h>
+#include <sys/clock.h>
+#else
+#define	SECHR	(60*60)
+#define	SECDAY	(24*SECHR)
+#endif /* sgi */
+
+# define DATE_PROTO "udp"
+# define DATE_PORT "time"
+
+
+int sock;
+int sock_raw;
+char myname[MAXHOSTNAMELEN];
+struct hostent *hp;
+struct sockaddr_in server;
+struct sockaddr_in dayaddr;
+extern int measure_delta;
+
+void bytenetorder(struct tsp *);
+void bytehostorder(struct tsp *);
+
+
+#define BU ((unsigned long)2208988800)	/* seconds before UNIX epoch */
+
+
+/* compute the difference between our date and another machine
+ */
+static int				/* difference in days from our time */
+daydiff(hostname)
+	char *hostname;
+{
+	int i;
+	int trials;
+	struct timeval tout, now;
+	fd_set ready;
+	struct sockaddr from;
+	int fromlen;
+	unsigned long sec;
+
+
+	/* wait 2 seconds between 10 tries */
+	tout.tv_sec = 2;
+	tout.tv_usec = 0;
+	for (trials = 0; trials < 10; trials++) {
+		/* ask for the time */
+		sec = 0;
+		if (sendto(sock, &sec, sizeof(sec), 0,
+			   (struct sockaddr*)&dayaddr, sizeof(dayaddr)) < 0) {
+			perror("sendto(sock)");
+			return 0;
+		}
+
+		for (;;) {
+			FD_ZERO(&ready);
+			FD_SET(sock, &ready);
+			i = select(sock+1, &ready, (fd_set *)0,
+				   (fd_set *)0, &tout);
+			if (i < 0) {
+				if (errno = EINTR)
+					continue;
+				perror("select(date read)");
+				return 0;
+			}
+			if (0 == i)
+				break;
+
+			fromlen = sizeof(from);
+			if (recvfrom(sock,&sec,sizeof(sec),0,
+				     &from,&fromlen) < 0) {
+				perror("recvfrom(date read)");
+				return 0;
+			}
+
+			sec = ntohl(sec);
+			if (sec < BU) {
+				fprintf(stderr,
+					"%s says it is before 1970: %lu",
+					hostname, sec);
+				return 0;
+			}
+			sec -= BU;
+
+			(void)gettimeofday(&now, (struct timezone*)0);
+			return (sec - now.tv_sec);
+		}
+	}
+
+	/* if we get here, we tried too many times */
+	fprintf(stderr,"%s will not tell us the date\n", hostname);
+	return 0;
+}
+
+
+/*
+ * Clockdiff computes the difference between the time of the machine on
+ * which it is called and the time of the machines given as argument.
+ * The time differences measured by clockdiff are obtained using a sequence
+ * of ICMP TSTAMP messages which are returned to the sender by the IP module
+ * in the remote machine.
+ * In order to compare clocks of machines in different time zones, the time
+ * is transmitted (as a 32-bit value) in milliseconds since midnight UT.
+ * If a hosts uses a different time format, it should set the high order
+ * bit of the 32-bit quantity it transmits.
+ * However, VMS apparently transmits the time in milliseconds since midnight
+ * local time (rather than GMT) without setting the high order bit.
+ * Furthermore, it does not understand daylight-saving time.  This makes
+ * clockdiff behaving inconsistently with hosts running VMS.
+ *
+ * In order to reduce the sensitivity to the variance of message transmission
+ * time, clockdiff sends a sequence of messages.  Yet, measures between
+ * two `distant' hosts can be affected by a small error. The error can,
+ * however, be reduced by increasing the number of messages sent in each
+ * measurement.
+ */
+void
+clockdiff(argc, argv)
+	int argc;
+	char *argv[];
+{
+	int measure_status;
+	extern int measure(u_long, u_long, char *, struct sockaddr_in*, int);
+	register int avg_cnt;
+	register long avg;
+	struct servent *sp;
+
+	if (argc < 2)  {
+		printf("Usage: clockdiff host ... \n");
+		return;
+	}
+
+	(void)gethostname(myname,sizeof(myname));
+
+	/* get the address for the date ready */
+	sp = getservbyname(DATE_PORT, DATE_PROTO);
+	if (!sp) {
+		(void)fprintf(stderr, "%s/%s is an unknown service\n",
+			      DATE_PORT, DATE_PROTO);
+		dayaddr.sin_port = 0;
+	} else {
+		dayaddr.sin_port = sp->s_port;
+	}
+
+	while (argc > 1) {
+		argc--; argv++;
+		hp = gethostbyname(*argv);
+		if (hp == NULL) {
+			fprintf(stderr, "timedc: %s: ", *argv);
+			herror(0);
+			continue;
+		}
+
+		server.sin_family = hp->h_addrtype;
+		bcopy(hp->h_addr, &server.sin_addr.s_addr, hp->h_length);
+		for (avg_cnt = 0, avg = 0; avg_cnt < 16; avg_cnt++) {
+			measure_status = measure(10000,100, *argv, &server, 1);
+			if (measure_status != GOOD)
+				break;
+			avg += measure_delta;
+		}
+		if (measure_status == GOOD)
+			measure_delta = avg/avg_cnt;
+
+		switch (measure_status) {
+		case HOSTDOWN:
+			printf("%s is down\n", hp->h_name);
+			continue;
+		case NONSTDTIME:
+			printf("%s transmitts a non-standard time format\n",
+			       hp->h_name);
+			continue;
+		case UNREACHABLE:
+			printf("%s is unreachable\n", hp->h_name);
+			continue;
+		}
+
+		/*
+		 * Try to get the date only after using ICMP timestamps to
+		 * get the time.  This is because the date protocol
+		 * is optional.
+		 */
+		if (dayaddr.sin_port != 0) {
+			dayaddr.sin_family = hp->h_addrtype;
+			bcopy(hp->h_addr, &dayaddr.sin_addr.s_addr,
+			      hp->h_length);
+			avg = daydiff(*argv);
+			if (avg > SECDAY) {
+				printf("time on %s is %ld days ahead %s\n",
+				       hp->h_name, avg/SECDAY, myname);
+				continue;
+			} else if (avg < -SECDAY) {
+				printf("time on %s is %ld days behind %s\n",
+				       hp->h_name, -avg/SECDAY, myname);
+				continue;
+			}
+		}
+
+		if (measure_delta > 0) {
+			printf("time on %s is %d ms. ahead of time on %s\n",
+			       hp->h_name, measure_delta, myname);
+		} else if (measure_delta == 0) {
+			printf("%s and %s have the same time\n",
+			       hp->h_name, myname);
+		} else {
+			printf("time on %s is %d ms. behind time on %s\n",
+			       hp->h_name, -measure_delta, myname);
+		}
+	}
+	return;
+}
+
+
+/*
+ * finds location of master timedaemon
+ */
+void
+msite(argc, argv)
+	int argc;
+	char *argv[];
+{
+	int cc;
+	fd_set ready;
+	struct sockaddr_in dest;
+	int i, length;
+	struct sockaddr from;
+	struct timeval tout;
+	struct tsp msg;
+	struct servent *srvp;
+	char *tgtname;
+
+	if (argc < 1) {
+		printf("Usage: msite [hostname]\n");
+		return;
+	}
+
+	srvp = getservbyname("timed", "udp");
+	if (srvp == 0) {
+		fprintf(stderr, "udp/timed: unknown service\n");
+		return;
+	}
+	dest.sin_port = srvp->s_port;
+	dest.sin_family = AF_INET;
+
+	(void)gethostname(myname, sizeof(myname));
+	i = 1;
+	do {
+		tgtname = (i >= argc) ? myname : argv[i];
+		hp = gethostbyname(tgtname);
+		if (hp == 0) {
+			fprintf(stderr, "timedc: %s: ", tgtname);
+			herror(0);
+			continue;
+		}
+		bcopy(hp->h_addr, &dest.sin_addr.s_addr, hp->h_length);
+
+		(void)strcpy(msg.tsp_name, myname);
+		msg.tsp_type = TSP_MSITE;
+		msg.tsp_vers = TSPVERSION;
+		bytenetorder(&msg);
+		if (sendto(sock, &msg, sizeof(struct tsp), 0,
+			   (struct sockaddr*)&dest,
+			   sizeof(struct sockaddr)) < 0) {
+			perror("sendto");
+			continue;
+		}
+
+		tout.tv_sec = 15;
+		tout.tv_usec = 0;
+		FD_ZERO(&ready);
+		FD_SET(sock, &ready);
+		if (select(FD_SETSIZE, &ready, (fd_set *)0, (fd_set *)0,
+			   &tout)) {
+			length = sizeof(struct sockaddr);
+			cc = recvfrom(sock, &msg, sizeof(struct tsp), 0,
+				      &from, &length);
+			if (cc < 0) {
+				perror("recvfrom");
+				continue;
+			}
+			bytehostorder(&msg);
+			if (msg.tsp_type == TSP_ACK) {
+				printf("master timedaemon at %s is %s\n",
+				       tgtname, msg.tsp_name);
+			} else {
+				printf("received wrong ack: %s\n",
+				       tsptype[msg.tsp_type]);
+			}
+		} else {
+			printf("communication error with %s\n", tgtname);
+		}
+	} while (++i < argc);
+}
+
+/*
+ * quits timedc
+ */
+void
+quit()
+{
+	exit(0);
+}
+
+
+/*
+ * Causes the election timer to expire on the selected hosts
+ * It sends just one udp message per machine, relying on
+ * reliability of communication channel.
+ */
+void
+testing(argc, argv)
+	int argc;
+	char *argv[];
+{
+	struct servent *srvp;
+	struct sockaddr_in sin;
+	struct tsp msg;
+
+	if (argc < 2)  {
+		printf("Usage: election host1 [host2 ...]\n");
+		return;
+	}
+
+	srvp = getservbyname("timed", "udp");
+	if (srvp == 0) {
+		fprintf(stderr, "udp/timed: unknown service\n");
+		return;
+	}
+
+	while (argc > 1) {
+		argc--; argv++;
+		hp = gethostbyname(*argv);
+		if (hp == NULL) {
+			fprintf(stderr, "timedc: %s: ", *argv);
+			herror(0);
+			argc--; argv++;
+			continue;
+		}
+		sin.sin_port = srvp->s_port;
+		sin.sin_family = hp->h_addrtype;
+		bcopy(hp->h_addr, &sin.sin_addr.s_addr, hp->h_length);
+
+		msg.tsp_type = TSP_TEST;
+		msg.tsp_vers = TSPVERSION;
+		(void)gethostname(myname, sizeof(myname));
+		(void)strncpy(msg.tsp_name, myname, sizeof(msg.tsp_name));
+		bytenetorder(&msg);
+		if (sendto(sock, &msg, sizeof(struct tsp), 0,
+			   (struct sockaddr*)&sin,
+			   sizeof(struct sockaddr)) < 0) {
+			perror("sendto");
+		}
+	}
+}
+
+
+/*
+ * Enables or disables tracing on local timedaemon
+ */
+void
+tracing(argc, argv)
+	int argc;
+	char *argv[];
+{
+	int onflag;
+	int length;
+	int cc;
+	fd_set ready;
+	struct sockaddr_in dest;
+	struct sockaddr from;
+	struct timeval tout;
+	struct tsp msg;
+	struct servent *srvp;
+
+	if (argc != 2) {
+		printf("Usage: tracing { on | off }\n");
+		return;
+	}
+
+	srvp = getservbyname("timed", "udp");
+	if (srvp == 0) {
+		fprintf(stderr, "udp/timed: unknown service\n");
+		return;
+	}
+	dest.sin_port = srvp->s_port;
+	dest.sin_family = AF_INET;
+
+	(void)gethostname(myname,sizeof(myname));
+	hp = gethostbyname(myname);
+	bcopy(hp->h_addr, &dest.sin_addr.s_addr, hp->h_length);
+
+	if (strcmp(argv[1], "on") == 0) {
+		msg.tsp_type = TSP_TRACEON;
+		onflag = ON;
+	} else {
+		msg.tsp_type = TSP_TRACEOFF;
+		onflag = OFF;
+	}
+
+	(void)strcpy(msg.tsp_name, myname);
+	msg.tsp_vers = TSPVERSION;
+	bytenetorder(&msg);
+	if (sendto(sock, &msg, sizeof(struct tsp), 0,
+		   (struct sockaddr*)&dest, sizeof(struct sockaddr)) < 0) {
+		perror("sendto");
+		return;
+	}
+
+	tout.tv_sec = 5;
+	tout.tv_usec = 0;
+	FD_ZERO(&ready);
+	FD_SET(sock, &ready);
+	if (select(FD_SETSIZE, &ready, (fd_set *)0, (fd_set *)0, &tout)) {
+		length = sizeof(struct sockaddr);
+		cc = recvfrom(sock, &msg, sizeof(struct tsp), 0,
+			      &from, &length);
+		if (cc < 0) {
+			perror("recvfrom");
+			return;
+		}
+		bytehostorder(&msg);
+		if (msg.tsp_type == TSP_ACK)
+			if (onflag)
+				printf("timed tracing enabled\n");
+			else
+				printf("timed tracing disabled\n");
+		else
+			printf("wrong ack received: %s\n",
+						tsptype[msg.tsp_type]);
+	} else
+		printf("communication error\n");
+}
+
+int
+priv_resources()
+{
+	int port;
+	struct sockaddr_in sin;
+
+	sock = socket(AF_INET, SOCK_DGRAM, 0);
+	if (sock < 0) {
+		perror("opening socket");
+		return(-1);
+	}
+
+	sin.sin_family = AF_INET;
+	sin.sin_addr.s_addr = 0;
+	for (port = IPPORT_RESERVED - 1; port > IPPORT_RESERVED / 2; port--) {
+		sin.sin_port = htons((u_short)port);
+		if (bind(sock, (struct sockaddr*)&sin, sizeof (sin)) >= 0)
+			break;
+		if (errno != EADDRINUSE && errno != EADDRNOTAVAIL) {
+			perror("bind");
+			(void) close(sock);
+			return(-1);
+		}
+	}
+	if (port == IPPORT_RESERVED / 2) {
+		fprintf(stderr, "all reserved ports in use\n");
+		(void) close(sock);
+		return(-1);
+	}
+
+	sock_raw = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
+	if (sock_raw < 0)  {
+		perror("opening raw socket");
+		(void) close(sock);
+		return(-1);
+	}
+	return(1);
+}