icmptime.c

TCP／IP详解

/*
 * Fetch the current time from another host using the ICMP timestamp
 * request/reply.
 *
 * You must be superuser to run this program (or it must be suid to root)
 * since it requires a raw socket.
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/file.h>
#include <sys/time.h>
#include <sys/signal.h>

#include <netinet/in_systm.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include <netinet/ip_var.h>
#include <netdb.h>
#include <unistd.h>
#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <string.h>

#define	DEFDATALEN	(12)	/* default data length */
#define	MAXIPLEN	60
#define	MAXICMPLEN	76
#define	MAXPACKET	(65536 - 60 - 8)/* max packet size */

struct sockaddr	whereto;	/* who to ping */
int		datalen = DEFDATALEN;
int		s;
u_char		outpack[MAXPACKET];
char		*hostname;

struct timeval	tvorig, tvrecv;	/* originate & receive timeval structs */
long		tsorig, tsrecv;	/* originate & receive timestamps */
			/* timestamp = #millisec since midnight UTC */
			/* both host byte ordered */
long		tsdiff;		/* adjustment must also be signed */

u_long		inet_addr();
char		*inet_ntoa();
void		sig_alrm(int);

main(argc, argv)
int	argc;
char	**argv;
{
	int			i, ch, fdmask, hold, packlen, preload;
	extern int		errno;
	struct hostent		*hp;
	struct sockaddr_in	*to;
	struct protoent		*proto;
	u_char			*packet;
	char			*target, hnamebuf[MAXHOSTNAMELEN], *malloc();

	if (argc != 2)
		exit(1);

	target = argv[1];

	bzero((char *)&whereto, sizeof(struct sockaddr));
	to = (struct sockaddr_in *)&whereto;
	to->sin_family = AF_INET;

		/* try to convert as dotted decimal address,
		   else if that fails assume it's a hostname */
	to->sin_addr.s_addr = inet_addr(target);
	if (to->sin_addr.s_addr != (u_int)-1)
		hostname = target;
	else {
		hp = gethostbyname(target);
		if (!hp) {
			fprintf(stderr, "unknown host %s\n", target);
			exit(1);
		}
		to->sin_family = hp->h_addrtype;
		bcopy(hp->h_addr, (caddr_t)&to->sin_addr, hp->h_length);
		strncpy(hnamebuf, hp->h_name, sizeof(hnamebuf) - 1);
		hostname = hnamebuf;
	}

	packlen = datalen + MAXIPLEN + MAXICMPLEN;
	if ( (packet = (u_char *)malloc((u_int)packlen)) == NULL) {
		fprintf(stderr, "malloc error\n");
		exit(1);
	}

	if ( (proto = getprotobyname("icmp")) == NULL) {
		fprintf(stderr, "unknown protocol icmp\n");
		exit(1);
	}

	if ( (s = socket(AF_INET, SOCK_RAW, proto->p_proto)) < 0) {
		perror("socket");
		exit(1);
	}

	/*
	 * We send one request and wait up to 30 seconds for a reply.
	 */

	signal(SIGALRM, sig_alrm);
	alarm(30);	/* 30 second time limit */

	sender();	/* send the request */

	for (;;) {
		struct sockaddr_in from;
		register int cc;
		int fromlen;

		fromlen = sizeof(from);
		if ( (cc = recvfrom(s, (char *)packet, packlen, 0,
		    (struct sockaddr *)&from, &fromlen)) < 0) {
			if (errno == EINTR)
				continue;
			perror("recvfrom error");
			continue;
		}

			/* process received ICMP message */
		if (procpack((char *)packet, cc, &from) == 0)
			exit(0);	/* terminate if reply received */
	}
}

/*
 * Send the request.
 */

sender()
{
	int		i, cc;
	struct icmp	*icp;

	icp = (struct icmp *)outpack;
	icp->icmp_type = ICMP_TSTAMP;
	icp->icmp_code = 0;
	icp->icmp_cksum = 0;	/* compute checksum below */
	icp->icmp_seq = 12345;	/* seq and id must be reflected */
	icp->icmp_id = getpid();

		/* fill in originate timestamp: have to convert tv_sec
		   from seconds since the Epoch to milliseconds since
		   midnight, then add in microseconds */

	gettimeofday(&tvorig, (struct timezone *)NULL);
	tsorig = (tvorig.tv_sec % (24*60*60)) * 1000 + tvorig.tv_usec / 1000;
	icp->icmp_otime = htonl(tsorig);
	icp->icmp_rtime = 0;		/* filled in by receiver */
	icp->icmp_ttime = 0;		/* filled in by receiver */

	cc = datalen + 8;	/* 8 bytes of header, 12 bytes of data */

					/* compute ICMP checksum */
	icp->icmp_cksum = in_cksum((u_short *)icp, cc);

	i = sendto(s, (char *)outpack, cc, 0, &whereto,
	    				sizeof(struct sockaddr));
	if (i < 0 || i != cc)  {
		if (i < 0)
			perror("sendto error");
		printf("wrote %s %d chars, ret=%d\n", hostname, cc, i);
	}
}

/*
 * Process a received ICMP message.  Since we receive *all* ICMP messages
 * that the kernel receives, we may receive other than the timestamp
 * reply we're waiting for.
 */

int
procpack(buf, cc, from)
char			*buf;
int			cc;
struct sockaddr_in	*from;
{
	int		i, hlen;
	struct icmp	*icp;
	struct ip	*ip;
	struct timeval	tvdelta;

	/* We could call gettimeofday() again to measure the RTT and use
	 * that in computing the offset, but some (most?) systems only
	 * have 100 Hz resoultion for this function and the RTT on a
	 * LAN is usually less than this (i.e., it wouldn't buy us
	 * anything). */

#ifdef	notdef
	gettimeofday(&tvrecv, (struct timezone *)NULL);
#endif

		/* Check the IP header */
	ip = (struct ip *)buf;
	hlen = ip->ip_hl << 2;
	if (cc < hlen + ICMP_MINLEN) {
		fprintf(stderr, "packet too short (%d bytes) from %s\n", cc,
			  inet_ntoa(*(struct in_addr *)&from->sin_addr.s_addr));
		return;
	}

		/* Now the ICMP part */
	cc -= hlen;
	icp = (struct icmp *)(buf + hlen);

		/* With a raw ICMP socket we get all ICMP packets that
		   come into the kernel. */

	if (icp->icmp_type == ICMP_TSTAMPREPLY) {
		if (ntohl(icp->icmp_otime) != tsorig)
			printf("originate timestamp not echoed: sent $lu, received %lu\n",
						tsorig, ntohl(icp->icmp_otime));
		if (cc != 20)
			printf("cc = %d, expected cc = 20\n", cc);
		if (icp->icmp_seq != 12345)
			printf("received sequence # %d\n", icp->icmp_seq);
		if (icp->icmp_id != getpid())
			printf("received id %d\n", icp->icmp_id);

		/* tsorig and tsrecv are both signed longs.  The icmp_[ort]time
		 * members in the structure are unsigned, but the max value
		 * for the #millisec since midnight is (24*60*60*1000 - 1)
		 * or 85,399,999, which easily fits into a signed long.
		 * We want them signed to compute a signed difference. */

		tsrecv = ntohl(icp->icmp_rtime);
		tsdiff = tsrecv - tsorig;	/* difference in millisec */

		printf("orig = %ld, recv = %ld\n",
				ntohl(icp->icmp_otime), ntohl(icp->icmp_rtime));
		printf("adjustment = %ld ms\n", tsdiff);
		tvdelta.tv_sec  = tsdiff / 1000;	/* normally 0 */
		tvdelta.tv_usec = (tsdiff % 1000) * 1000;
		printf("correction = %ld sec, %ld usec\n",
				tvdelta.tv_sec, tvdelta.tv_usec);
		if (adjtime(&tvdelta, (struct timeval *) 0) < 0) {
			perror("adjtime error");
			exit(1);
		}
		return(0);	/* done */
	} else
		return(-1);	/* some other type of ICMP message */
}

/*
 * in_cksum --
 *	Checksum routine for Internet Protocol family headers (C Version)
 */
in_cksum(addr, len)
	u_short *addr;
	int len;
{
	register int nleft = len;
	register u_short *w = addr;
	register int sum = 0;
	u_short answer = 0;

	/*
	 * Our algorithm is simple, using a 32 bit accumulator (sum), we add
	 * sequential 16 bit words to it, and at the end, fold back all the
	 * carry bits from the top 16 bits into the lower 16 bits.
	 */
	while (nleft > 1)  {
		sum += *w++;
		nleft -= 2;
	}

	/* mop up an odd byte, if necessary */
	if (nleft == 1) {
		*(u_char *)(&answer) = *(u_char *)w ;
		sum += answer;
	}

	/* add back carry outs from top 16 bits to low 16 bits */
	sum = (sum >> 16) + (sum & 0xffff);	/* add hi 16 to low 16 */
	sum += (sum >> 16);			/* add carry */
	answer = ~sum;				/* truncate to 16 bits */
	return(answer);
}

void
sig_alrm(int signo)
{
	printf("timeout\n");
	exit(1);
}