<![CDATA[/*
* 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);
}
]]>