from Cliff Frost
[unix-history] / usr / src / sbin / ping / ping.c
index 827c6e7..c6e3c2b 100644 (file)
@@ -1,30 +1,3 @@
-/*
- * Copyright (c) 1987, 1988 Regents of the University of California.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms are permitted
- * provided that the above copyright notice and this paragraph are
- * duplicated in all such forms and that any documentation,
- * advertising materials, and other materials related to such
- * distribution and use acknowledge that the software was developed
- * by the University of California, Berkeley.  The name of the
- * University may not be used to endorse or promote products derived
- * from this software without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
- * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
- */
-
-#ifndef lint
-char copyright[] =
-"@(#) Copyright (c) 1987, 1988 Regents of the University of California.\n\
- All rights reserved.\n";
-#endif /* not lint */
-
-#ifndef lint
-static char sccsid[] = "@(#)ping.c     4.12 (Berkeley) %G%";
-#endif /* not lint */
-
 /*
  *                     P I N G . C
  *
 /*
  *                     P I N G . C
  *
@@ -36,6 +9,10 @@ static char sccsid[] = "@(#)ping.c    4.12 (Berkeley) %G%";
  *     U. S. Army Ballistic Research Laboratory
  *     December, 1983
  * Modified at Uc Berkeley
  *     U. S. Army Ballistic Research Laboratory
  *     December, 1983
  * Modified at Uc Berkeley
+ * Record Route and verbose headers - Phil Dykstra, BRL, March 1988.
+ * ttl, duplicate detection - Cliff Frost, UCB, April 1989
+ * Pad pattern - Cliff Frost (from Tom Ferrin, UCSF), April 1989
+ * Wait for dribbles, option decoding, pkt compare - vjs@sgi.com, May 1989
  *
  * Status -
  *     Public Domain.  Distribution Unlimited.
  *
  * Status -
  *     Public Domain.  Distribution Unlimited.
@@ -48,6 +25,7 @@ static char sccsid[] = "@(#)ping.c    4.12 (Berkeley) %G%";
 #include <stdio.h>
 #include <errno.h>
 #include <sys/time.h>
 #include <stdio.h>
 #include <errno.h>
 #include <sys/time.h>
+#include <sys/signal.h>
 
 #include <sys/param.h>
 #include <sys/socket.h>
 
 #include <sys/param.h>
 #include <sys/socket.h>
@@ -57,36 +35,67 @@ static char sccsid[] = "@(#)ping.c  4.12 (Berkeley) %G%";
 #include <netinet/in.h>
 #include <netinet/ip.h>
 #include <netinet/ip_icmp.h>
 #include <netinet/in.h>
 #include <netinet/ip.h>
 #include <netinet/ip_icmp.h>
+#include <netinet/ip_var.h>
+#include <ctype.h>
 #include <netdb.h>
 
 #define        MAXWAIT         10      /* max time to wait for response, sec. */
 #include <netdb.h>
 
 #define        MAXWAIT         10      /* max time to wait for response, sec. */
-#define        MAXPACKET       4096    /* max packet size */
+#define        MAXPACKET       (65536-60-8)    /* max packet size */
+#define VERBOSE                1       /* verbose flag */
+#define QUIET          2       /* quiet flag */
+#define FLOOD          4       /* floodping flag */
+#define        RROUTE          8       /* record route flag */
+#define PING_FILLED     16      /* is buffer filled? */
+#define        NUMERIC         32      /* don't do gethostbyaddr() calls */
+#define        INTERVAL        64      /* did user specify interval? */
+#define        NROUTES         9       /* number of record route slots */
 #ifndef MAXHOSTNAMELEN
 #define MAXHOSTNAMELEN 64
 #endif
 
 #ifndef MAXHOSTNAMELEN
 #define MAXHOSTNAMELEN 64
 #endif
 
-int    verbose;
-u_char packet[MAXPACKET];
-int    options;
+/* MAX_DUP_CHK is the number of bits in received table, ie the */
+/*      maximum number of received sequence numbers we can keep track of. */
+/*      Change 128 to 8192 for complete accuracy... */
+
+#define MAX_DUP_CHK     8 * 128
+int     mx_dup_ck = MAX_DUP_CHK;
+char    rcvd_tbl[ MAX_DUP_CHK / 8 ];
+int     nrepeats = 0;
+
+#define A(bit)          rcvd_tbl[ (bit>>3) ]    /* identify byte in array */
+#define B(bit)          ( 1 << (bit & 0x07) )   /* identify bit in byte */
+#define SET(bit)        A(bit) |= B(bit)
+#define CLR(bit)        A(bit) &= (~B(bit))
+#define TST(bit)        (A(bit) & B(bit))
+
+
+char   *malloc();
+
+u_char *packet;
+int    packlen;
+int    i, pingflags = 0, options;
 extern int errno;
 
 int s;                 /* Socket file descriptor */
 struct hostent *hp;    /* Pointer to host info */
 struct timezone tz;    /* leftover */
 
 extern int errno;
 
 int s;                 /* Socket file descriptor */
 struct hostent *hp;    /* Pointer to host info */
 struct timezone tz;    /* leftover */
 
-struct sockaddr whereto;/* Who to ping */
-int datalen;           /* How much data */
+struct sockaddr whereto;       /* Who to ping */
+int datalen = 64-8;            /* How much data */
 
 
-char usage[] = "Usage:  ping [-drv] host [data size] [npackets]\n";
+char usage[] =
+"Usage:  ping [-dfnqrvR][-c count][-i wait][-l preload][-p pattern][-s packetsize][-h] host \n";
 
 char *hostname;
 char hnamebuf[MAXHOSTNAMELEN];
 
 char *hostname;
 char hnamebuf[MAXHOSTNAMELEN];
-char *inet_ntoa();
 
 
-int npackets;
-int burst = 1;
+static u_char outpack[MAXPACKET];
+
+int npackets=0;
+int preload = 0;               /* number of packets to "preload" */
 int ntransmitted = 0;          /* sequence # for outbound packets = #sent */
 int ident;
 int ntransmitted = 0;          /* sequence # for outbound packets = #sent */
 int ident;
+unsigned interval=1;           /* interval between packets */
 
 int nreceived = 0;             /* # of packets we got back */
 int timing = 0;
 
 int nreceived = 0;             /* # of packets we got back */
 int timing = 0;
@@ -94,6 +103,12 @@ int tmin = 999999999;
 int tmax = 0;
 int tsum = 0;                  /* sum of all times, for doing average */
 int finish(), catcher();
 int tmax = 0;
 int tsum = 0;                  /* sum of all times, for doing average */
 int finish(), catcher();
+int bufspace = 48*1024;
+int prefinish();
+char *inet_ntoa(),*strcpy(),*strncpy(),*sprintf();
+char *pr_addr();
+u_long inet_addr();
+char rspace[3+4*NROUTES+1];    /* record route space */
 
 /*
  *                     M A I N
 
 /*
  *                     M A I N
@@ -102,63 +117,110 @@ main(argc, argv)
 char *argv[];
 {
        struct sockaddr_in from;
 char *argv[];
 {
        struct sockaddr_in from;
-       char **av = argv;
-       char *toaddr = NULL;
+/*     char **av = argv; */
        struct sockaddr_in *to = (struct sockaddr_in *) &whereto;
        struct sockaddr_in *to = (struct sockaddr_in *) &whereto;
-       int on = 1;
+       int c, k, on = 1, hostind = 0;
        struct protoent *proto;
        struct protoent *proto;
-
-       argc--, av++;
-       while (argc > 0 && *av[0] == '-') {
-               while (*++av[0]) switch (*av[0]) {
+       static u_char *datap = &outpack[8+sizeof(struct timeval)];
+       extern int optind;
+       extern char *optarg;
+
+       while ((c = getopt(argc, argv, "c:dfh:i:l:np:qrs:vR")) != EOF)
+               switch(c) {
+                       case 'c':
+                               npackets = atoi(optarg);
+                               break;
                        case 'd':
                                options |= SO_DEBUG;
                                break;
                        case 'd':
                                options |= SO_DEBUG;
                                break;
+                       case 'f':
+                               pingflags |= FLOOD;
+                               break;
+                       case 'h':
+                               hostind = optind-1;
+                               break;
+                        case 'i':       /* wait between sending packets */
+                               interval = atoi(optarg);
+                               if (interval == 0) 
+                                       interval = 1;
+                               pingflags |= INTERVAL;
+                                break;
+                       case 'l':
+                               preload = atoi(optarg);
+                               break;
+                       case 'n':
+                               pingflags |= NUMERIC;
+                               break;
+                        case 'p':       /* fill buffer with user pattern */
+                                pingflags |= PING_FILLED;
+                               fill((char *)datap, optarg);
+                                break;
+                       case 'q':
+                               pingflags |= QUIET;
+                               break;
                        case 'r':
                                options |= SO_DONTROUTE;
                                break;
                        case 'r':
                                options |= SO_DONTROUTE;
                                break;
+                        case 's':       /* size of packet to send */
+                               datalen = atoi(optarg);
+                                break;
                        case 'v':
                        case 'v':
-                               verbose++;
+                               pingflags |= VERBOSE;
+                               break;
+                       case 'R':
+                               pingflags |= RROUTE;
                                break;
                                break;
+                       default:
+                               printf(usage);
+                               exit(1);
                }
                }
-               argc--, av++;
-       }
-       if( argc < 1)  {
-               printf(usage);
-               exit(1);
+
+       if (hostind == 0) {
+               if (optind != argc-1) {
+                       fprintf(stderr, usage);
+                       exit(1);
+               } else hostind = optind;
        }
 
        }
 
-       bzero( (char *)&whereto, sizeof(struct sockaddr) );
+       bzero((char *)&whereto, sizeof(struct sockaddr) );
        to->sin_family = AF_INET;
        to->sin_family = AF_INET;
-       to->sin_addr.s_addr = inet_addr(av[0]);
-       if (to->sin_addr.s_addr != -1) {
-               strcpy(hnamebuf, av[0]);
+       to->sin_addr.s_addr = inet_addr(argv[hostind]);
+       if(to->sin_addr.s_addr != (unsigned)-1) {
+               strcpy(hnamebuf, argv[hostind]);
                hostname = hnamebuf;
        } else {
                hostname = hnamebuf;
        } else {
-               hp = gethostbyname(av[0]);
-               if (!hp) {
-                       fprintf(stderr, "ping: %s: ", av[0]);
-                       herror((char *)NULL);
+               hp = gethostbyname(argv[hostind]);
+               if (hp) {
+                       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;
+               } else {
+                       printf("%s: unknown host %s\n", argv[0], argv[hostind]);
                        exit(1);
                }
                        exit(1);
                }
-               to->sin_family = hp->h_addrtype;
-               bcopy(hp->h_addr, (caddr_t)&to->sin_addr, hp->h_length);
-               hostname = hp->h_name;
-               toaddr = inet_ntoa(to->sin_addr.s_addr);
        }
 
        }
 
-       if( argc >= 2 )
-               datalen = atoi( av[1] );
-       else
-               datalen = 64-8;
+       if ( (pingflags & FLOOD) && (pingflags & INTERVAL) ) {
+               fprintf(stderr, "ping: -f and -i incompatible options\n");
+               exit(1);
+       }
+
        if (datalen > MAXPACKET) {
                fprintf(stderr, "ping: packet size too large\n");
                exit(1);
        }
        if (datalen > MAXPACKET) {
                fprintf(stderr, "ping: packet size too large\n");
                exit(1);
        }
-       if (datalen >= sizeof(struct timeval))
+       if (datalen >= sizeof(struct timeval))  /* can we time 'em? */
                timing = 1;
                timing = 1;
-       if (argc > 2)
-               npackets = atoi(av[2]);
+       packlen = datalen + 60 + 76;    /* MAXIP + MAXICMP */
+       if( (packet = (u_char *)malloc((unsigned)packlen)) == NULL ) {
+               fprintf( stderr, "ping: malloc failed\n" );
+               exit(1);
+       }
+
+       if (!(pingflags & PING_FILLED)) {
+                for( k=8; k<datalen; k++) *datap++ = k;
+        }
 
        ident = getpid() & 0xFFFF;
 
 
        ident = getpid() & 0xFFFF;
 
@@ -170,37 +232,73 @@ char *argv[];
                perror("ping: socket");
                exit(5);
        }
                perror("ping: socket");
                exit(5);
        }
-       if (options & SO_DEBUG)
-               setsockopt(s, SOL_SOCKET, SO_DEBUG, &on, sizeof(on));
-       if (options & SO_DONTROUTE)
-               setsockopt(s, SOL_SOCKET, SO_DONTROUTE, &on, sizeof(on));
-
-       printf("PING %s", hostname);
-       if (toaddr)
-               printf(" (%s)", toaddr);
-       printf(": %d data bytes\n", datalen);
-                               
+       if (options & SO_DEBUG) {
+               (void)setsockopt(s, SOL_SOCKET, SO_DEBUG, &on, sizeof(on));
+       }
+       if (options & SO_DONTROUTE) {
+               (void)setsockopt(s, SOL_SOCKET, SO_DONTROUTE, &on, sizeof(on));
+       }
+       /* Record Route option */
+       if( pingflags & RROUTE ) {
+#ifdef IP_OPTIONS
+               rspace[IPOPT_OPTVAL] = IPOPT_RR;
+               rspace[IPOPT_OLEN] = sizeof(rspace)-1;
+               rspace[IPOPT_OFFSET] = IPOPT_MINOFF;
+               if( setsockopt(s, IPPROTO_IP, IP_OPTIONS, rspace, sizeof(rspace)) < 0 ) {
+                       perror( "Record route" );
+                       exit( 42 );
+               }
+#else
+               fprintf( stderr, "ping: record route not available on this machine.\n" );
+               exit( 42 );
+#endif IP_OPTIONS
+       }
 
 
-       setlinebuf( stdout );
+       if(to->sin_family == AF_INET) {
+               printf("PING %s (%s): %d data bytes\n", hostname,
+                 inet_ntoa(*(struct in_addr *)&to->sin_addr.s_addr), datalen);
+       } else {
+               printf("PING %s: %d data bytes\n", hostname, datalen );
+       }
+       /* When pinging the broadcast address, you can get a lot
+        * of answers.  Doing something so evil is useful if you
+        * are trying to stress the ethernet, or just want to
+        * fill the arp cache to get some stuff for /etc/ethers.
+        */
+       (void)setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char*)&bufspace,
+                        sizeof(bufspace));
 
 
-       signal( SIGINT, finish );
+       signal( SIGINT, prefinish );
        signal(SIGALRM, catcher);
 
        signal(SIGALRM, catcher);
 
-       catcher();      /* start things going */
+       /* fire off them quickies */
+       for(i=0; i < preload; i++)
+               pinger();
+
+       if(!(pingflags & FLOOD))
+               catcher();      /* start things going */
 
        for (;;) {
 
        for (;;) {
-               int len = sizeof (packet);
-               int fromlen;
+               int fromlen = sizeof (from);
                int cc;
                int cc;
+               struct timeval timeout;
+               int fdmask = 1 << s;
 
 
-               fromlen = sizeof (from);
-               if ( (cc=recvfrom(s, packet, len, 0, &from, &fromlen)) < 0) {
+               timeout.tv_sec = 0;
+               timeout.tv_usec = 10000;
+
+               if(pingflags & FLOOD) {
+                       pinger();
+                       if( select(32, (fd_set *)&fdmask, (fd_set *)0, (fd_set *)0, &timeout) == 0)
+                               continue;
+               }
+               if ( (cc=recvfrom(s, (char *)packet, packlen, 0, (struct sockaddr *)&from, &fromlen)) < 0) {
                        if( errno == EINTR )
                                continue;
                        perror("ping: recvfrom");
                        continue;
                }
                        if( errno == EINTR )
                                continue;
                        perror("ping: recvfrom");
                        continue;
                }
-               pr_pack( packet, cc, &from );
+               pr_pack( (char *)packet, cc, &from );
                if (npackets && nreceived >= npackets)
                        finish();
        }
                if (npackets && nreceived >= npackets)
                        finish();
        }
@@ -223,8 +321,9 @@ catcher()
        int waittime;
 
        pinger();
        int waittime;
 
        pinger();
+       signal(SIGALRM, catcher);
        if (npackets == 0 || ntransmitted < npackets)
        if (npackets == 0 || ntransmitted < npackets)
-               alarm(1);
+               alarm(interval);
        else {
                if (nreceived) {
                        waittime = 2 * tmax / 1000;
        else {
                if (nreceived) {
                        waittime = 2 * tmax / 1000;
@@ -233,7 +332,7 @@ catcher()
                } else
                        waittime = MAXWAIT;
                signal(SIGALRM, finish);
                } else
                        waittime = MAXWAIT;
                signal(SIGALRM, finish);
-               alarm(waittime);
+               alarm((unsigned)waittime);
        }
 }
 
        }
 }
 
@@ -248,11 +347,9 @@ catcher()
  */
 pinger()
 {
  */
 pinger()
 {
-       static u_char outpack[MAXPACKET];
        register struct icmp *icp = (struct icmp *) outpack;
        register struct icmp *icp = (struct icmp *) outpack;
-       int i, cc, n;
+       int i, cc;
        register struct timeval *tp = (struct timeval *) &outpack[8];
        register struct timeval *tp = (struct timeval *) &outpack[8];
-       register u_char *datap = &outpack[8+sizeof(struct timeval)];
 
        icp->icmp_type = ICMP_ECHO;
        icp->icmp_code = 0;
 
        icp->icmp_type = ICMP_ECHO;
        icp->icmp_code = 0;
@@ -260,63 +357,29 @@ pinger()
        icp->icmp_seq = ntransmitted++;
        icp->icmp_id = ident;           /* ID */
 
        icp->icmp_seq = ntransmitted++;
        icp->icmp_id = ident;           /* ID */
 
+        CLR( icp->icmp_seq % mx_dup_ck );
+
        cc = datalen+8;                 /* skips ICMP portion */
 
        if (timing)
                gettimeofday( tp, &tz );
 
        cc = datalen+8;                 /* skips ICMP portion */
 
        if (timing)
                gettimeofday( tp, &tz );
 
-       for( i=8; i<datalen; i++)       /* skip 8 for time */
-               *datap++ = i;
-
        /* Compute ICMP checksum here */
        /* Compute ICMP checksum here */
-       icp->icmp_cksum = in_cksum( icp, cc );
+       icp->icmp_cksum = in_cksum( (u_short *)icp, cc );
 
        /* cc = sendto(s, msg, len, flags, to, tolen) */
 
        /* cc = sendto(s, msg, len, flags, to, tolen) */
-       for (n = 0; n < burst; n++) {
-               i = sendto(s, outpack, cc, 0, &whereto, sizeof(whereto));
+       i = sendto( s, (char *)outpack, cc, 0, &whereto, sizeof(struct sockaddr) );
 
 
-               if( i < 0 || i != cc )  {
-                       if( i<0 )  perror("sendto");
-                       printf("ping: wrote %s %d chars, ret=%d\n",
-                               hostname, cc, i );
-                       fflush(stdout);
-               }
+       if( i < 0 || i != cc )  {
+               if( i<0 )  perror("sendto");
+               printf("ping: wrote %s %d chars, ret=%d\n",
+                       hostname, cc, i );
+               fflush(stdout);
+       }
+       if( pingflags & FLOOD ) {
+               putchar('.');
+               fflush(stdout);
        }
        }
-}
-
-/*
- *                     P R _ T Y P E
- *
- * Convert an ICMP "type" field to a printable string.
- */
-char *
-pr_type( t )
-register int t;
-{
-       static char *ttab[] = {
-               "Echo Reply",
-               "ICMP 1",
-               "ICMP 2",
-               "Dest Unreachable",
-               "Source Quence",
-               "Redirect",
-               "ICMP 6",
-               "ICMP 7",
-               "Echo",
-               "ICMP 9",
-               "ICMP 10",
-               "Time Exceeded",
-               "Parameter Problem",
-               "Timestamp",
-               "Timestamp Reply",
-               "Info Request",
-               "Info Reply"
-       };
-
-       if( t < 0 || t > 16 )
-               return("OUT-OF-RANGE");
-
-       return(ttab[t]);
 }
 
 /*
 }
 
 /*
@@ -334,59 +397,181 @@ struct sockaddr_in *from;
 {
        struct ip *ip;
        register struct icmp *icp;
 {
        struct ip *ip;
        register struct icmp *icp;
-       register long *lp = (long *) packet;
-       register int i;
+       register int i, j;
+       register u_char *cp,*dp;
+       static int old_rrlen;
+       static char old_rr[MAX_IPOPTLEN];
        struct timeval tv;
        struct timeval *tp;
        struct timeval tv;
        struct timeval *tp;
-       int hlen, triptime;
+       int hlen, triptime, dupflag;
 
 
-       from->sin_addr.s_addr = ntohl( from->sin_addr.s_addr );
        gettimeofday( &tv, &tz );
 
        gettimeofday( &tv, &tz );
 
+       /* Check the IP header */
        ip = (struct ip *) buf;
        hlen = ip->ip_hl << 2;
        ip = (struct ip *) buf;
        hlen = ip->ip_hl << 2;
-       if (cc < hlen + ICMP_MINLEN) {
-               if (verbose)
+       if( cc < hlen + ICMP_MINLEN ) {
+               if( pingflags & VERBOSE )
                        printf("packet too short (%d bytes) from %s\n", cc,
                        printf("packet too short (%d bytes) from %s\n", cc,
-                               inet_ntoa(ntohl(from->sin_addr.s_addr)));
+                               inet_ntoa(*(struct in_addr *)&from->sin_addr.s_addr));
+                       fflush(stdout);
                return;
        }
                return;
        }
+
+       /* Now the ICMP part */
        cc -= hlen;
        icp = (struct icmp *)(buf + hlen);
        cc -= hlen;
        icp = (struct icmp *)(buf + hlen);
-       if( icp->icmp_type != ICMP_ECHOREPLY )  {
-               if (verbose) {
-                       printf("%d bytes from %s: ", cc,
-                               inet_ntoa(ntohl(from->sin_addr.s_addr)));
-                       printf("icmp_type=%d (%s)\n",
-                               icp->icmp_type, pr_type(icp->icmp_type) );
-                       for( i=0; i<12; i++)
-                           printf("x%2.2x: x%8.8x\n", i*sizeof(long), *lp++ );
-                       printf("icmp_code=%d\n", icp->icmp_code );
+       if( icp->icmp_type == ICMP_ECHOREPLY ) {
+               if( icp->icmp_id != ident )
+                       return;                 /* 'Twas not our ECHO */
+
+               nreceived++;
+               if (timing) {
+#ifndef icmp_data
+                       tp = (struct timeval *)&icp->icmp_ip;
+#else
+                       tp = (struct timeval *)&icp->icmp_data[0];
+#endif
+                       tvsub( &tv, tp );
+                       triptime = tv.tv_sec*1000+(tv.tv_usec/1000);
+                       tsum += triptime;
+                       if( triptime < tmin )
+                               tmin = triptime;
+                       if( triptime > tmax )
+                               tmax = triptime;
                }
                }
-               return;
+
+                if ( TST(icp->icmp_seq%mx_dup_ck) ) {
+                               nrepeats++, nreceived--;
+                       dupflag=1;
+                } else {
+                       SET(icp->icmp_seq%mx_dup_ck);
+                       dupflag=0;
+               }
+
+               if( pingflags & QUIET )
+                       return;
+
+               if( pingflags & FLOOD ) {
+                       putchar('\b');
+                       fflush(stdout);
+               } else {
+                       printf("%d bytes from %s: icmp_seq=%d", cc,
+                         inet_ntoa(*(struct in_addr *)&from->sin_addr.s_addr),
+                         icp->icmp_seq );
+                       if ( dupflag ) printf(" DUP!");
+                       printf(" ttl=%d", ip->ip_ttl);
+                       if (timing)
+                               printf(" time=%d ms", triptime );
+                       /* check the data */
+                       cp = (u_char*)&icp->icmp_data[8];
+                       dp = &outpack[8+sizeof(struct timeval)];
+                       for (i=8; i<datalen; i++, cp++, dp++) {
+                               if (*cp != *dp) {
+                   printf("\nwrong data byte #%d should be 0x%x but was 0x%x",
+                                               i, *dp, *cp);
+                                       cp = (u_char*)&icp->icmp_data[0];
+                                       for (i=8; i<datalen; i++, cp++) {
+                                               if ((i%32) == 8)
+                                                       printf("\n\t");
+                                               printf("%x ", *cp);
+                                       }
+                                       break;
+                               }
+                       }
+
+               }
+       } else {
+               /* We've got something other than an ECHOREPLY */
+               if( !(pingflags & VERBOSE) )
+                       return;
+
+               printf("%d bytes from %s: ",
+                 cc, pr_addr(from->sin_addr.s_addr) );
+               pr_icmph( icp );
+       }
+
+       /* Display any IP options */
+       cp = (u_char *)buf + sizeof(struct ip);
+       while (hlen > sizeof(struct ip) & (hlen >= 0)) { /* !ANSI C will  */
+               register unsigned long l;                /* force hlen to */
+               switch (*cp) {                           /* unsigned!     */
+               case IPOPT_EOL:
+                       hlen = 0;
+                       break;
+               case IPOPT_LSRR:
+                       printf("\nLSRR: ");
+                       hlen -= 2;
+                       j = *++cp;
+                       ++cp;
+                       if (j > IPOPT_MINOFF) for (;;) {
+                               l = *++cp;
+                               l = (l<<8) + *++cp;
+                               l = (l<<8) + *++cp;
+                               l = (l<<8) + *++cp;
+                               if (l == 0)
+                                       printf("\t0.0.0.0");
+                               else
+                                       printf("\t%s", pr_addr(ntohl(l)));
+                               hlen -= 4;
+                               j -= 4;
+                               if (j <= IPOPT_MINOFF)
+                                       break;
+                               putchar('\n');
+                       }
+                       break;
+               case IPOPT_RR:
+                       j = *++cp;      /* get length */
+                       i = *++cp;      /* and pointer */
+                       hlen -= 2;
+                       if (i > j) i = j;
+                       i -= IPOPT_MINOFF;
+                       if (i <= 0)
+                               continue;
+                       if (i == old_rrlen
+                           && cp == (u_char *)buf + sizeof(struct ip) + 2
+                           && !bcmp((char *)cp, old_rr, i)
+                           && !(pingflags & FLOOD)) {
+                               printf("\t(same route)");
+                               i = ((i+3)/4)*4;
+                               hlen -= i;
+                               cp += i;
+                               break;
+                       }
+                       old_rrlen = i;
+                       bcopy((char *)cp, old_rr, i);
+                       printf("\nRR: ");
+                       for (;;) {
+                               l = *++cp;
+                               l = (l<<8) + *++cp;
+                               l = (l<<8) + *++cp;
+                               l = (l<<8) + *++cp;
+                               if (l == 0)
+                                       printf("\t0.0.0.0");
+                               else
+                                       printf("\t%s", pr_addr(ntohl(l)));
+                               hlen -= 4;
+                               i -= 4;
+                               if (i <= 0)
+                                       break;
+                               putchar('\n');
+                       }
+                       break;
+               case IPOPT_NOP:
+                       printf("\nNOP");
+                       break;
+               default:
+                       printf("\nunknown option %x", *cp);
+                       break;
+               }
+               hlen--;
+               cp++;
        }
        }
-       if( icp->icmp_id != ident )
-               return;                 /* 'Twas not our ECHO */
-
-       tp = (struct timeval *)&icp->icmp_data[0];
-       printf("%d bytes from %s: ", cc,
-               inet_ntoa(ntohl(from->sin_addr.s_addr)));
-       printf("icmp_seq=%d. ", icp->icmp_seq );
-       if (timing) {
-               tvsub( &tv, tp );
-               triptime = tv.tv_sec*1000+(tv.tv_usec/1000);
-               printf("time=%d. ms\n", triptime );
-               tsum += triptime;
-               if( triptime < tmin )
-                       tmin = triptime;
-               if( triptime > tmax )
-                       tmax = triptime;
-       } else
+       if (!(pingflags & FLOOD))
                putchar('\n');
                putchar('\n');
-       nreceived++;
+       fflush(stdout);
 }
 
 }
 
-
 /*
  *                     I N _ C K S U M
  *
 /*
  *                     I N _ C K S U M
  *
@@ -399,9 +584,8 @@ int len;
 {
        register int nleft = len;
        register u_short *w = addr;
 {
        register int nleft = len;
        register u_short *w = addr;
-       register u_short answer;
        register int sum = 0;
        register int sum = 0;
-       u_short odd_byte = 0;
+       u_short answer = 0;
 
        /*
         *  Our algorithm is simple, using a 32 bit accumulator (sum),
 
        /*
         *  Our algorithm is simple, using a 32 bit accumulator (sum),
@@ -416,8 +600,8 @@ int len;
 
        /* mop up an odd byte, if necessary */
        if( nleft == 1 ) {
 
        /* mop up an odd byte, if necessary */
        if( nleft == 1 ) {
-               *(u_char *)(&odd_byte) = *(u_char *)w;
-               sum += odd_byte;
+               *(u_char *)(&answer) = *(u_char *)w ;
+               sum += answer;
        }
 
        /*
        }
 
        /*
@@ -446,6 +630,15 @@ register struct timeval *out, *in;
        out->tv_sec -= in->tv_sec;
 }
 
        out->tv_sec -= in->tv_sec;
 }
 
+/* On the first SIGINT, allow any outstanding packets to dribble in */
+prefinish()
+{
+       if (nreceived >= ntransmitted   /* quit now if caught up */
+           || nreceived == 0)          /* or if remote is dead */
+               finish();
+       signal(SIGINT, finish);         /* do this only the 1st time */
+       npackets = ntransmitted+1;      /* let the normal limit work */
+}
 /*
  *                     F I N I S H
  *
 /*
  *                     F I N I S H
  *
@@ -457,23 +650,280 @@ register struct timeval *out, *in;
  */
 finish()
 {
  */
 finish()
 {
+       putchar('\n');
+       fflush(stdout);
        printf("\n----%s PING Statistics----\n", hostname );
        printf("%d packets transmitted, ", ntransmitted );
        printf("%d packets received, ", nreceived );
        printf("\n----%s PING Statistics----\n", hostname );
        printf("%d packets transmitted, ", ntransmitted );
        printf("%d packets received, ", nreceived );
-       if (ntransmitted) {
-               if (nreceived <= ntransmitted)
-                   printf("%d%% packet loss",
-                       (int) (((ntransmitted-nreceived)*100) / ntransmitted));
+        if (nrepeats) printf("+%d duplicates, ", nrepeats );
+       if (ntransmitted)
+               if( nreceived > ntransmitted)
+                       printf("-- somebody's printing up packets!");
                else
                else
-                   printf("%.2f responses per request",
-                       (float) nreceived / (float) ntransmitted);
-       }
+                       printf("%d%% packet loss", 
+                         (int) (((ntransmitted-nreceived)*100) /
+                         ntransmitted));
        printf("\n");
        if (nreceived && timing)
            printf("round-trip (ms)  min/avg/max = %d/%d/%d\n",
                tmin,
        printf("\n");
        if (nreceived && timing)
            printf("round-trip (ms)  min/avg/max = %d/%d/%d\n",
                tmin,
-               tsum / nreceived,
+               tsum / (nreceived + nrepeats),
                tmax );
        fflush(stdout);
        exit(0);
 }
                tmax );
        fflush(stdout);
        exit(0);
 }
+
+#if 0
+static char *ttab[] = {
+       "Echo Reply",           /* ip + seq + udata */
+       "Dest Unreachable",     /* net, host, proto, port, frag, sr + IP */
+       "Source Quench",        /* IP */
+       "Redirect",             /* redirect type, gateway, + IP  */
+       "Echo",
+       "Time Exceeded",        /* transit, frag reassem + IP */
+       "Parameter Problem",    /* pointer + IP */
+       "Timestamp",            /* id + seq + three timestamps */
+       "Timestamp Reply",      /* " */
+       "Info Request",         /* id + sq */
+       "Info Reply"            /* " */
+};
+#endif /* 0 */
+
+/*
+ *  Print a descriptive string about an ICMP header.
+ */
+pr_icmph( icp )
+struct icmp *icp;
+{
+       switch( icp->icmp_type ) {
+       case ICMP_ECHOREPLY:
+               printf("Echo Reply\n");
+               /* XXX ID + Seq + Data */
+               break;
+       case ICMP_UNREACH:
+               switch( icp->icmp_code ) {
+               case ICMP_UNREACH_NET:
+                       printf("Destination Net Unreachable\n");
+                       break;
+               case ICMP_UNREACH_HOST:
+                       printf("Destination Host Unreachable\n");
+                       break;
+               case ICMP_UNREACH_PROTOCOL:
+                       printf("Destination Protocol Unreachable\n");
+                       break;
+               case ICMP_UNREACH_PORT:
+                       printf("Destination Port Unreachable\n");
+                       break;
+               case ICMP_UNREACH_NEEDFRAG:
+                       printf("frag needed and DF set\n");
+                       break;
+               case ICMP_UNREACH_SRCFAIL:
+                       printf("Source Route Failed\n");
+                       break;
+               default:
+                       printf("Dest Unreachable, Bad Code: %d\n", icp->icmp_code );
+                       break;
+               }
+               /* Print returned IP header information */
+#ifndef icmp_data
+               pr_retip( &icp->icmp_ip );
+#else
+               pr_retip( (struct ip *)icp->icmp_data );
+#endif
+               break;
+       case ICMP_SOURCEQUENCH:
+               printf("Source Quench\n");
+#ifndef icmp_data
+               pr_retip( &icp->icmp_ip );
+#else
+               pr_retip( (struct ip *)icp->icmp_data );
+#endif
+               break;
+       case ICMP_REDIRECT:
+               switch( icp->icmp_code ) {
+               case ICMP_REDIRECT_NET:
+                       printf("Redirect Network");
+                       break;
+               case ICMP_REDIRECT_HOST:
+                       printf("Redirect Host");
+                       break;
+               case ICMP_REDIRECT_TOSNET:
+                       printf("Redirect Type of Service and Network");
+                       break;
+               case ICMP_REDIRECT_TOSHOST:
+                       printf("Redirect Type of Service and Host");
+                       break;
+               default:
+                       printf("Redirect, Bad Code: %d", icp->icmp_code );
+                       break;
+               }
+               printf(" (New addr: 0x%08x)\n", icp->icmp_hun.ih_gwaddr );
+#ifndef icmp_data
+               pr_retip( &icp->icmp_ip );
+#else
+               pr_retip( (struct ip *)icp->icmp_data );
+#endif
+               break;
+       case ICMP_ECHO:
+               printf("Echo Request\n");
+               /* XXX ID + Seq + Data */
+               break;
+       case ICMP_TIMXCEED:
+               switch( icp->icmp_code ) {
+               case ICMP_TIMXCEED_INTRANS:
+                       printf("Time to live exceeded\n");
+                       break;
+               case ICMP_TIMXCEED_REASS:
+                       printf("Frag reassembly time exceeded\n");
+                       break;
+               default:
+                       printf("Time exceeded, Bad Code: %d\n", icp->icmp_code );
+                       break;
+               }
+#ifndef icmp_data
+               pr_retip( &icp->icmp_ip );
+#else
+               pr_retip( (struct ip *)icp->icmp_data );
+#endif
+               break;
+       case ICMP_PARAMPROB:
+               printf("Parameter problem: pointer = 0x%02x\n",
+                       icp->icmp_hun.ih_pptr );
+#ifndef icmp_data
+               pr_retip( &icp->icmp_ip );
+#else
+               pr_retip( (struct ip *)icp->icmp_data );
+#endif
+               break;
+       case ICMP_TSTAMP:
+               printf("Timestamp\n");
+               /* XXX ID + Seq + 3 timestamps */
+               break;
+       case ICMP_TSTAMPREPLY:
+               printf("Timestamp Reply\n");
+               /* XXX ID + Seq + 3 timestamps */
+               break;
+       case ICMP_IREQ:
+               printf("Information Request\n");
+               /* XXX ID + Seq */
+               break;
+       case ICMP_IREQREPLY:
+               printf("Information Reply\n");
+               /* XXX ID + Seq */
+               break;
+#ifdef ICMP_MASKREQ
+       case ICMP_MASKREQ:
+               printf("Address Mask Request\n");
+               break;
+#endif
+#ifdef ICMP_MASKREPLY
+       case ICMP_MASKREPLY:
+               printf("Address Mask Reply\n");
+               break;
+#endif
+       default:
+               printf("Bad ICMP type: %d\n", icp->icmp_type);
+       }
+}
+
+/*
+ *  Print an IP header with options.
+ */
+pr_iph( ip )
+struct ip *ip;
+{
+       int     hlen;
+       unsigned char *cp;
+
+       hlen = ip->ip_hl << 2;
+       cp = (unsigned char *)ip + 20;  /* point to options */
+
+       printf("Vr HL TOS  Len   ID Flg  off TTL Pro  cks      Src      Dst Data\n");
+       printf(" %1x  %1x  %02x %04x %04x",
+               ip->ip_v, ip->ip_hl, ip->ip_tos, ip->ip_len, ip->ip_id );
+       printf("   %1x %04x", ((ip->ip_off)&0xe000)>>13, (ip->ip_off)&0x1fff );
+       printf("  %02x  %02x %04x", ip->ip_ttl, ip->ip_p, ip->ip_sum );
+       printf(" %s ", inet_ntoa(*(struct in_addr *)&ip->ip_src.s_addr));
+       printf(" %s ", inet_ntoa(*(struct in_addr *)&ip->ip_dst.s_addr));
+       /* dump and option bytes */
+       while( hlen-- > 20 ) {
+               printf( "%02x", *cp++ );
+       }
+       printf("\n");
+}
+
+/*
+ *  Return an ascii host address
+ *  as a dotted quad and optionally with a hostname
+ */
+char *
+pr_addr( l )
+unsigned long l;
+{
+       struct  hostent *hp;
+       static  char    buf[80];
+
+       if( (pingflags & NUMERIC) || (hp = gethostbyaddr((char *)&l, 4, AF_INET)) == NULL )
+               sprintf( buf, "%s", inet_ntoa(*(struct in_addr *)&l) );
+       else
+               sprintf( buf, "%s (%s)", hp->h_name, inet_ntoa(*(struct in_addr *)&l) );
+
+       return( buf );
+}
+
+/*
+ *  Dump some info on a returned (via ICMP) IP packet.
+ */
+pr_retip( ip )
+struct ip *ip;
+{
+       int     hlen;
+       unsigned char   *cp;
+
+       pr_iph( ip );
+       hlen = ip->ip_hl << 2;
+       cp = (unsigned char *)ip + hlen;
+
+       if( ip->ip_p == 6 ) {
+               printf( "TCP: from port %d, to port %d (decimal)\n",
+                       (*cp*256+*(cp+1)), (*(cp+2)*256+*(cp+3)) );
+       } else if( ip->ip_p == 17 ) {
+               printf( "UDP: from port %d, to port %d (decimal)\n",
+                       (*cp*256+*(cp+1)), (*(cp+2)*256+*(cp+3)) );
+       }
+}
+
+fill(bp, patp)
+char *bp, *patp;
+{
+        register int ii,jj,kk;
+        char *cp;
+        int pat[16];
+
+        for (cp=patp; *cp; cp++)
+                if (!isxdigit(*cp)) {
+                        printf("\"-p %s\" ???: ", patp);
+                        printf("patterns must be specified as hex digits\n");
+                        exit(1);
+                }
+
+        ii = sscanf(patp,
+                "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
+                &pat[0], &pat[1], &pat[2], &pat[3],
+                &pat[4], &pat[5], &pat[6], &pat[7],
+                &pat[8], &pat[9], &pat[10], &pat[11],
+                &pat[12], &pat[13], &pat[14], &pat[15]);
+
+        if (ii > 0)
+                for (kk=0; kk<=MAXPACKET-(8+ii); kk+=ii)
+                for (jj=0; jj<ii; jj++)
+                        bp[jj+kk] = pat[jj];
+
+        if (!(pingflags & QUIET)) {
+                printf("PATTERN: 0x");
+                for (jj=0; jj<ii; jj++)
+                        printf("%02x", bp[jj]&0xFF);
+                printf("\n");
+        }
+
+}