ae1fecd92f
2) Must be root to run preload (OpenBSD ping.c 1.8) 3) Don't print all replies unless verbose and root (from idea in OpenBSD ping.c 1.10 and 1.11) to avoid leaking information available only to root. 4) Remove unused h: from option string to getopt. 5) Make the compiler happy with exit(0) (Lite-2?) Reviewed by: Dan Cross <tenser@spitfire.ecsel.psu.edu> Good candidate for 2.2 and 2.1 (as are many of the 1.17 changes).
1179 lines
29 KiB
C
1179 lines
29 KiB
C
/*
|
|
* Copyright (c) 1989, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to Berkeley by
|
|
* Mike Muuss.
|
|
*
|
|
* 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 const char copyright[] =
|
|
"@(#) Copyright (c) 1989, 1993\n\
|
|
The Regents of the University of California. All rights reserved.\n";
|
|
#endif /* not lint */
|
|
|
|
#ifndef lint
|
|
/*
|
|
static char sccsid[] = "@(#)ping.c 8.1 (Berkeley) 6/5/93";
|
|
*/
|
|
static const char rcsid[] =
|
|
"$Id: ping.c,v 1.17 1997/03/01 20:19:18 wollman Exp $";
|
|
#endif /* not lint */
|
|
|
|
/*
|
|
* P I N G . C
|
|
*
|
|
* Using the InterNet Control Message Protocol (ICMP) "ECHO" facility,
|
|
* measure round-trip-delays and packet loss across network paths.
|
|
*
|
|
* Author -
|
|
* Mike Muuss
|
|
* U. S. Army Ballistic Research Laboratory
|
|
* December, 1983
|
|
*
|
|
* Status -
|
|
* Public Domain. Distribution Unlimited.
|
|
* Bugs -
|
|
* More statistics could always be gathered.
|
|
* This program has to run SUID to ROOT to access the ICMP socket.
|
|
*/
|
|
|
|
#include <sys/param.h> /* NB: we rely on this for <sys/types.h> */
|
|
|
|
#include <ctype.h>
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <netdb.h>
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sysexits.h>
|
|
#include <termios.h>
|
|
#include <unistd.h>
|
|
|
|
#include <sys/socket.h>
|
|
#include <sys/file.h>
|
|
#include <sys/time.h>
|
|
|
|
#include <netinet/in.h>
|
|
#include <netinet/in_systm.h>
|
|
#include <netinet/ip.h>
|
|
#include <netinet/ip_icmp.h>
|
|
#include <netinet/ip_var.h>
|
|
#include <arpa/inet.h>
|
|
|
|
#define DEFDATALEN (64 - 8) /* default data length */
|
|
#define MAXIPLEN 60
|
|
#define MAXICMPLEN 76
|
|
#define MAXPACKET (65536 - 60 - 8)/* max packet size */
|
|
#define MAXWAIT 10 /* max seconds to wait for response */
|
|
#define NROUTES 9 /* number of record route slots */
|
|
|
|
#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))
|
|
|
|
/* various options */
|
|
int options;
|
|
#define F_FLOOD 0x0001
|
|
#define F_INTERVAL 0x0002
|
|
#define F_NUMERIC 0x0004
|
|
#define F_PINGFILLED 0x0008
|
|
#define F_QUIET 0x0010
|
|
#define F_RROUTE 0x0020
|
|
#define F_SO_DEBUG 0x0040
|
|
#define F_SO_DONTROUTE 0x0080
|
|
#define F_VERBOSE 0x0100
|
|
#define F_QUIET2 0x0200
|
|
#define F_NOLOOP 0x0400
|
|
#define F_MTTL 0x0800
|
|
#define F_MIF 0x1000
|
|
#define F_AUDIBLE 0x2000
|
|
|
|
/*
|
|
* MAX_DUP_CHK is the number of bits in received table, i.e. 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];
|
|
|
|
struct sockaddr whereto; /* who to ping */
|
|
int datalen = DEFDATALEN;
|
|
int s; /* socket file descriptor */
|
|
u_char outpack[MAXPACKET];
|
|
char BSPACE = '\b'; /* characters written for flood */
|
|
char DOT = '.';
|
|
char *hostname;
|
|
int ident; /* process id to identify our packets */
|
|
|
|
/* counters */
|
|
long npackets; /* max packets to transmit */
|
|
long nreceived; /* # of packets we got back */
|
|
long nrepeats; /* number of duplicates */
|
|
long ntransmitted; /* sequence # for outbound packets = #sent */
|
|
int interval = 1; /* interval between packets */
|
|
|
|
/* timing */
|
|
int timing; /* flag to do timing */
|
|
double tmin = 999999999.0; /* minimum round trip time */
|
|
double tmax = 0.0; /* maximum round trip time */
|
|
double tsum = 0.0; /* sum of all times, for doing average */
|
|
|
|
int reset_kerninfo;
|
|
sig_atomic_t siginfo_p;
|
|
|
|
static void fill(char *, char *);
|
|
static u_short in_cksum(u_short *, int);
|
|
static void catcher(int sig);
|
|
static void check_status(void);
|
|
static void finish(int) __dead2;
|
|
static void pinger(void);
|
|
static char *pr_addr(struct in_addr);
|
|
static void pr_icmph(struct icmp *);
|
|
static void pr_iph(struct ip *);
|
|
static void pr_pack(char *, int, struct sockaddr_in *);
|
|
static void pr_retip(struct ip *);
|
|
static void status(int);
|
|
static void tvsub(struct timeval *, struct timeval *);
|
|
static void usage(const char *) __dead2;
|
|
|
|
int
|
|
main(argc, argv)
|
|
int argc;
|
|
char *const *argv;
|
|
{
|
|
struct timeval timeout;
|
|
struct hostent *hp;
|
|
struct sockaddr_in *to;
|
|
struct termios ts;
|
|
register int i;
|
|
int ch, fdmask, hold, packlen, preload, sockerrno;
|
|
struct in_addr ifaddr;
|
|
unsigned char ttl, loop;
|
|
u_char *datap, *packet;
|
|
char *target, hnamebuf[MAXHOSTNAMELEN];
|
|
char *ep;
|
|
u_long ultmp;
|
|
#ifdef IP_OPTIONS
|
|
char rspace[3 + 4 * NROUTES + 1]; /* record route space */
|
|
#endif
|
|
struct sigaction si_sa;
|
|
|
|
/*
|
|
* Do the stuff that we need root priv's for *first*, and
|
|
* then drop our setuid bit. Save error reporting for
|
|
* after arg parsing.
|
|
*/
|
|
s = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
|
|
sockerrno = errno;
|
|
|
|
setuid(getuid());
|
|
|
|
preload = 0;
|
|
|
|
datap = &outpack[8 + sizeof(struct timeval)];
|
|
while ((ch = getopt(argc, argv, "I:LQRT:c:adfi:l:np:qrs:v")) != -1) {
|
|
switch(ch) {
|
|
case 'a':
|
|
options |= F_AUDIBLE;
|
|
break;
|
|
case 'c':
|
|
ultmp = strtoul(optarg, &ep, 0);
|
|
if (*ep || ep == optarg || ultmp > LONG_MAX || !ultmp)
|
|
errx(EX_USAGE,
|
|
"invalid count of packets to transmit: `%s'",
|
|
optarg);
|
|
npackets = ultmp;
|
|
break;
|
|
case 'd':
|
|
options |= F_SO_DEBUG;
|
|
break;
|
|
case 'f':
|
|
if (getuid()) {
|
|
errno = EPERM;
|
|
err(EX_NOPERM, "-f flag");
|
|
}
|
|
options |= F_FLOOD;
|
|
setbuf(stdout, (char *)NULL);
|
|
break;
|
|
case 'i': /* wait between sending packets */
|
|
ultmp = strtoul(optarg, &ep, 0);
|
|
if (*ep || ep == optarg || ultmp > INT_MAX)
|
|
errx(EX_USAGE,
|
|
"invalid timing interval: `%s'", optarg);
|
|
options |= F_INTERVAL;
|
|
interval = ultmp;
|
|
break;
|
|
case 'I': /* multicast interface */
|
|
if (inet_aton(optarg, &ifaddr) == 0)
|
|
errx(EX_USAGE,
|
|
"invalid multicast interface: `%s'",
|
|
optarg);
|
|
options |= F_MIF;
|
|
break;
|
|
case 'l':
|
|
ultmp = strtoul(optarg, &ep, 0);
|
|
if (*ep || ep == optarg || ultmp > INT_MAX)
|
|
errx(EX_USAGE,
|
|
"invalid preload value: `%s'", optarg);
|
|
if (getuid()) {
|
|
errno = EPERM;
|
|
err(EX_NOPERM, "-l flag");
|
|
}
|
|
options |= F_FLOOD;
|
|
preload = ultmp;
|
|
break;
|
|
case 'L':
|
|
options |= F_NOLOOP;
|
|
loop = 0;
|
|
break;
|
|
case 'n':
|
|
options |= F_NUMERIC;
|
|
break;
|
|
case 'p': /* fill buffer with user pattern */
|
|
options |= F_PINGFILLED;
|
|
fill((char *)datap, optarg);
|
|
break;
|
|
case 'Q':
|
|
options |= F_QUIET2;
|
|
break;
|
|
case 'q':
|
|
options |= F_QUIET;
|
|
break;
|
|
case 'R':
|
|
options |= F_RROUTE;
|
|
break;
|
|
case 'r':
|
|
options |= F_SO_DONTROUTE;
|
|
break;
|
|
case 's': /* size of packet to send */
|
|
ultmp = strtoul(optarg, &ep, 0);
|
|
if (ultmp > MAXPACKET)
|
|
errx(EX_USAGE, "packet size too large: %lu",
|
|
ultmp);
|
|
if (*ep || ep == optarg || !ultmp)
|
|
errx(EX_USAGE, "invalid packet size: `%s'",
|
|
optarg);
|
|
datalen = ultmp;
|
|
break;
|
|
case 'T': /* multicast TTL */
|
|
ultmp = strtoul(optarg, &ep, 0);
|
|
if (*ep || ep == optarg || ultmp > 255)
|
|
errx(EX_USAGE, "invalid multicast TTL: `%s'",
|
|
optarg);
|
|
ttl = ultmp;
|
|
options |= F_MTTL;
|
|
break;
|
|
case 'v':
|
|
options |= F_VERBOSE;
|
|
break;
|
|
default:
|
|
|
|
usage(argv[0]);
|
|
}
|
|
}
|
|
|
|
if (argc - optind != 1)
|
|
usage(argv[0]);
|
|
target = argv[optind];
|
|
|
|
bzero((char *)&whereto, sizeof(struct sockaddr));
|
|
to = (struct sockaddr_in *)&whereto;
|
|
to->sin_family = AF_INET;
|
|
if (inet_aton(target, &to->sin_addr) != 0) {
|
|
hostname = target;
|
|
} else {
|
|
hp = gethostbyname2(target, AF_INET);
|
|
if (!hp)
|
|
errx(EX_NOHOST, "cannot resolve %s: %s",
|
|
target, hstrerror(h_errno));
|
|
|
|
to->sin_len = sizeof *to;
|
|
memcpy(&to->sin_addr, hp->h_addr_list[0], sizeof to->sin_addr);
|
|
(void)strncpy(hnamebuf, hp->h_name, sizeof(hnamebuf) - 1);
|
|
hnamebuf[(sizeof hnamebuf) - 1] = '\0';
|
|
hostname = hnamebuf;
|
|
}
|
|
|
|
if (options & F_FLOOD && options & F_INTERVAL)
|
|
errx(EX_USAGE, "-f and -i: incompatible options");
|
|
|
|
if (options & F_FLOOD && IN_MULTICAST(ntohl(to->sin_addr.s_addr)))
|
|
errx(EX_USAGE,
|
|
"-f flag cannot be used with multicast destination");
|
|
if (options & (F_MIF | F_NOLOOP | F_MTTL)
|
|
&& !IN_MULTICAST(ntohl(to->sin_addr.s_addr)))
|
|
errx(EX_USAGE,
|
|
"-I, -L, -T flags cannot be used with unicast destination");
|
|
|
|
if (datalen >= sizeof(struct timeval)) /* can we time transfer */
|
|
timing = 1;
|
|
packlen = datalen + MAXIPLEN + MAXICMPLEN;
|
|
if (!(packet = (u_char *)malloc((size_t)packlen)))
|
|
err(EX_UNAVAILABLE, "malloc");
|
|
|
|
if (!(options & F_PINGFILLED))
|
|
for (i = 8; i < datalen; ++i)
|
|
*datap++ = i;
|
|
|
|
ident = getpid() & 0xFFFF;
|
|
|
|
if (s < 0) {
|
|
errno = sockerrno;
|
|
err(EX_OSERR, "socket");
|
|
}
|
|
hold = 1;
|
|
if (options & F_SO_DEBUG)
|
|
(void)setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&hold,
|
|
sizeof(hold));
|
|
if (options & F_SO_DONTROUTE)
|
|
(void)setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)&hold,
|
|
sizeof(hold));
|
|
|
|
/* record route option */
|
|
if (options & F_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)
|
|
err(EX_OSERR, "setsockopt IP_OPTIONS");
|
|
#else
|
|
errx(EX_UNAVAILABLE,
|
|
"record route not available in this implementation");
|
|
#endif /* IP_OPTIONS */
|
|
}
|
|
|
|
if (options & F_NOLOOP) {
|
|
if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_LOOP, &loop,
|
|
sizeof(loop)) < 0) {
|
|
err(EX_OSERR, "setsockopt IP_MULTICAST_LOOP");
|
|
}
|
|
}
|
|
if (options & F_MTTL) {
|
|
if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, &ttl,
|
|
sizeof(ttl)) < 0) {
|
|
err(EX_OSERR, "setsockopt IP_MULTICAST_TTL");
|
|
}
|
|
}
|
|
if (options & F_MIF) {
|
|
if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_IF, &ifaddr,
|
|
sizeof(ifaddr)) < 0) {
|
|
err(EX_OSERR, "setsockopt IP_MULTICAST_IF");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* 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. But beware: RFC 1122 allows hosts to ignore broadcast
|
|
* or multicast pings if they wish.
|
|
*/
|
|
hold = 48 * 1024;
|
|
(void)setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&hold,
|
|
sizeof(hold));
|
|
|
|
if (to->sin_family == AF_INET)
|
|
(void)printf("PING %s (%s): %d data bytes\n", hostname,
|
|
inet_ntoa(to->sin_addr),
|
|
datalen);
|
|
else
|
|
(void)printf("PING %s: %d data bytes\n", hostname, datalen);
|
|
|
|
(void)signal(SIGINT, finish);
|
|
(void)signal(SIGALRM, catcher);
|
|
|
|
/*
|
|
* Use sigaction instead of signal() to get unambiguous semantics
|
|
* for SIGINFO, in particular with SA_RESTART not set.
|
|
*/
|
|
si_sa.sa_handler = status;
|
|
sigemptyset(&si_sa.sa_mask);
|
|
si_sa.sa_flags = 0;
|
|
if (sigaction(SIGINFO, &si_sa, 0) == -1) {
|
|
err(EX_OSERR, "sigsction");
|
|
}
|
|
|
|
if (tcgetattr(STDOUT_FILENO, &ts) != -1) {
|
|
reset_kerninfo = !(ts.c_lflag & NOKERNINFO);
|
|
ts.c_lflag |= NOKERNINFO;
|
|
tcsetattr(STDOUT_FILENO, TCSANOW, &ts);
|
|
}
|
|
|
|
while (preload--) /* fire off them quickies */
|
|
pinger();
|
|
|
|
if ((options & F_FLOOD) == 0)
|
|
catcher(0); /* start things going */
|
|
|
|
for (;;) {
|
|
struct sockaddr_in from;
|
|
register int cc;
|
|
int fromlen;
|
|
|
|
check_status();
|
|
if (options & F_FLOOD) {
|
|
pinger();
|
|
timeout.tv_sec = 0;
|
|
timeout.tv_usec = 10000;
|
|
fdmask = 1 << s;
|
|
if (select(s + 1, (fd_set *)&fdmask, (fd_set *)NULL,
|
|
(fd_set *)NULL, &timeout) < 1)
|
|
continue;
|
|
}
|
|
fromlen = sizeof(from);
|
|
if ((cc = recvfrom(s, (char *)packet, packlen, 0,
|
|
(struct sockaddr *)&from, &fromlen)) < 0) {
|
|
if (errno == EINTR)
|
|
continue;
|
|
perror("ping: recvfrom");
|
|
continue;
|
|
}
|
|
pr_pack((char *)packet, cc, &from);
|
|
if (npackets && nreceived >= npackets)
|
|
break;
|
|
}
|
|
finish(0);
|
|
/* NOTREACHED */
|
|
exit(0); /* Make the compiler happy */
|
|
}
|
|
|
|
/*
|
|
* catcher --
|
|
* This routine causes another PING to be transmitted, and then
|
|
* schedules another SIGALRM for 1 second from now.
|
|
*
|
|
* bug --
|
|
* Our sense of time will slowly skew (i.e., packets will not be
|
|
* launched exactly at 1-second intervals). This does not affect the
|
|
* quality of the delay and loss statistics.
|
|
*/
|
|
static void
|
|
catcher(int sig)
|
|
{
|
|
int waittime;
|
|
|
|
pinger();
|
|
(void)signal(SIGALRM, catcher);
|
|
if (!npackets || ntransmitted < npackets)
|
|
alarm((u_int)interval);
|
|
else {
|
|
if (nreceived) {
|
|
waittime = 2 * tmax / 1000;
|
|
if (!waittime)
|
|
waittime = 1;
|
|
} else
|
|
waittime = MAXWAIT;
|
|
(void)signal(SIGALRM, finish);
|
|
(void)alarm((u_int)waittime);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* pinger --
|
|
* Compose and transmit an ICMP ECHO REQUEST packet. The IP packet
|
|
* will be added on by the kernel. The ID field is our UNIX process ID,
|
|
* and the sequence number is an ascending integer. The first 8 bytes
|
|
* of the data portion are used to hold a UNIX "timeval" struct in host
|
|
* byte-order, to compute the round-trip time.
|
|
*/
|
|
static void
|
|
pinger(void)
|
|
{
|
|
register struct icmp *icp;
|
|
register int cc;
|
|
int i;
|
|
|
|
icp = (struct icmp *)outpack;
|
|
icp->icmp_type = ICMP_ECHO;
|
|
icp->icmp_code = 0;
|
|
icp->icmp_cksum = 0;
|
|
icp->icmp_seq = ntransmitted++;
|
|
icp->icmp_id = ident; /* ID */
|
|
|
|
CLR(icp->icmp_seq % mx_dup_ck);
|
|
|
|
if (timing)
|
|
(void)gettimeofday((struct timeval *)&outpack[8],
|
|
(struct timezone *)NULL);
|
|
|
|
cc = datalen + 8; /* skips ICMP portion */
|
|
|
|
/* compute ICMP checksum here */
|
|
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) {
|
|
warn("sendto");
|
|
} else {
|
|
warn("%s: partial write: %d of %d bytes",
|
|
hostname, cc, i);
|
|
}
|
|
}
|
|
if (!(options & F_QUIET) && options & F_FLOOD)
|
|
(void)write(STDOUT_FILENO, &DOT, 1);
|
|
}
|
|
|
|
/*
|
|
* pr_pack --
|
|
* Print out the packet, if it came from us. This logic is necessary
|
|
* because ALL readers of the ICMP socket get a copy of ALL ICMP packets
|
|
* which arrive ('tis only fair). This permits multiple copies of this
|
|
* program to be run without having intermingled output (or statistics!).
|
|
*/
|
|
static void
|
|
pr_pack(buf, cc, from)
|
|
char *buf;
|
|
int cc;
|
|
struct sockaddr_in *from;
|
|
{
|
|
register struct icmp *icp;
|
|
register u_long l;
|
|
register int i, j;
|
|
register u_char *cp,*dp;
|
|
static int old_rrlen;
|
|
static char old_rr[MAX_IPOPTLEN];
|
|
struct ip *ip;
|
|
struct timeval tv, *tp;
|
|
double triptime;
|
|
int hlen, dupflag;
|
|
|
|
(void)gettimeofday(&tv, (struct timezone *)NULL);
|
|
|
|
/* Check the IP header */
|
|
ip = (struct ip *)buf;
|
|
hlen = ip->ip_hl << 2;
|
|
if (cc < hlen + ICMP_MINLEN) {
|
|
if (options & F_VERBOSE)
|
|
warn("packet too short (%d bytes) from %s", cc,
|
|
inet_ntoa(from->sin_addr));
|
|
return;
|
|
}
|
|
|
|
/* Now the ICMP part */
|
|
cc -= hlen;
|
|
icp = (struct icmp *)(buf + hlen);
|
|
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;
|
|
#endif
|
|
tvsub(&tv, tp);
|
|
triptime = ((double)tv.tv_sec) * 1000.0 +
|
|
((double)tv.tv_usec) / 1000.0;
|
|
tsum += triptime;
|
|
if (triptime < tmin)
|
|
tmin = triptime;
|
|
if (triptime > tmax)
|
|
tmax = triptime;
|
|
}
|
|
|
|
if (TST(icp->icmp_seq % mx_dup_ck)) {
|
|
++nrepeats;
|
|
--nreceived;
|
|
dupflag = 1;
|
|
} else {
|
|
SET(icp->icmp_seq % mx_dup_ck);
|
|
dupflag = 0;
|
|
}
|
|
|
|
if (options & F_QUIET)
|
|
return;
|
|
|
|
if (options & F_FLOOD)
|
|
(void)write(STDOUT_FILENO, &BSPACE, 1);
|
|
else {
|
|
(void)printf("%d bytes from %s: icmp_seq=%u", cc,
|
|
inet_ntoa(*(struct in_addr *)&from->sin_addr.s_addr),
|
|
icp->icmp_seq);
|
|
(void)printf(" ttl=%d", ip->ip_ttl);
|
|
if (timing)
|
|
(void)printf(" time=%.3f ms", triptime);
|
|
if (dupflag)
|
|
(void)printf(" (DUP!)");
|
|
if (options & F_AUDIBLE)
|
|
(void)printf("\a");
|
|
/* 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) {
|
|
(void)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)
|
|
(void)printf("\n\t");
|
|
(void)printf("%x ", *cp);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
/*
|
|
* We've got something other than an ECHOREPLY.
|
|
* See if it's a reply to something that we sent.
|
|
* We can compare IP destination, protocol,
|
|
* and ICMP type and ID.
|
|
*
|
|
* Only print all the error messages if we are running
|
|
* as root to avoid leaking information not normally
|
|
* available to those not running as root.
|
|
*/
|
|
#ifndef icmp_data
|
|
struct ip *oip = &icp->icmp_ip;
|
|
#else
|
|
struct ip *oip = (struct ip *)icp->icmp_data;
|
|
#endif
|
|
struct icmp *oicmp = (struct icmp *)(oip + 1);
|
|
|
|
if (((options & F_VERBOSE) && getuid() == 0) ||
|
|
(!(options & F_QUIET2) &&
|
|
(oip->ip_dst.s_addr ==
|
|
((struct sockaddr_in *)&whereto)->sin_addr.s_addr) &&
|
|
(oip->ip_p == IPPROTO_ICMP) &&
|
|
(oicmp->icmp_type == ICMP_ECHO) &&
|
|
(oicmp->icmp_id == ident))) {
|
|
(void)printf("%d bytes from %s: ", cc,
|
|
pr_addr(from->sin_addr));
|
|
pr_icmph(icp);
|
|
} else
|
|
return;
|
|
}
|
|
|
|
/* Display any IP options */
|
|
cp = (u_char *)buf + sizeof(struct ip);
|
|
|
|
for (; hlen > (int)sizeof(struct ip); --hlen, ++cp)
|
|
switch (*cp) {
|
|
case IPOPT_EOL:
|
|
hlen = 0;
|
|
break;
|
|
case IPOPT_LSRR:
|
|
(void)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 {
|
|
struct in_addr ina;
|
|
ina.s_addr = ntohl(l);
|
|
printf("\t%s", pr_addr(ina));
|
|
}
|
|
hlen -= 4;
|
|
j -= 4;
|
|
if (j <= IPOPT_MINOFF)
|
|
break;
|
|
(void)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)
|
|
&& !(options & F_FLOOD)) {
|
|
(void)printf("\t(same route)");
|
|
i = ((i + 3) / 4) * 4;
|
|
hlen -= i;
|
|
cp += i;
|
|
break;
|
|
}
|
|
old_rrlen = i;
|
|
bcopy((char *)cp, old_rr, i);
|
|
(void)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 {
|
|
struct in_addr ina;
|
|
ina.s_addr = ntohl(l);
|
|
printf("\t%s", pr_addr(ina));
|
|
}
|
|
hlen -= 4;
|
|
i -= 4;
|
|
if (i <= 0)
|
|
break;
|
|
(void)putchar('\n');
|
|
}
|
|
break;
|
|
case IPOPT_NOP:
|
|
(void)printf("\nNOP");
|
|
break;
|
|
default:
|
|
(void)printf("\nunknown option %x", *cp);
|
|
break;
|
|
}
|
|
if (!(options & F_FLOOD)) {
|
|
(void)putchar('\n');
|
|
(void)fflush(stdout);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* in_cksum --
|
|
* Checksum routine for Internet Protocol family headers (C Version)
|
|
*/
|
|
u_short
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* tvsub --
|
|
* Subtract 2 timeval structs: out = out - in. Out is assumed to
|
|
* be >= in.
|
|
*/
|
|
static void
|
|
tvsub(out, in)
|
|
register struct timeval *out, *in;
|
|
{
|
|
if ((out->tv_usec -= in->tv_usec) < 0) {
|
|
--out->tv_sec;
|
|
out->tv_usec += 1000000;
|
|
}
|
|
out->tv_sec -= in->tv_sec;
|
|
}
|
|
|
|
/*
|
|
* status --
|
|
* Print out statistics when SIGINFO is received.
|
|
*/
|
|
|
|
static void
|
|
status(sig)
|
|
int sig;
|
|
{
|
|
siginfo_p = 1;
|
|
}
|
|
|
|
static void
|
|
check_status()
|
|
{
|
|
if (siginfo_p) {
|
|
siginfo_p = 0;
|
|
(void)fprintf(stderr,
|
|
"\r%ld/%ld packets received (%.0f%%) %.3f min / %.3f avg / %.3f max\n",
|
|
nreceived, ntransmitted,
|
|
ntransmitted ? nreceived * 100.0 / ntransmitted : 0.0,
|
|
nreceived ? tmin : 0.0,
|
|
nreceived + nrepeats ? tsum / (nreceived + nrepeats) : tsum,
|
|
tmax);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* finish --
|
|
* Print out statistics, and give up.
|
|
*/
|
|
static void
|
|
finish(int sig)
|
|
{
|
|
struct termios ts;
|
|
|
|
(void)signal(SIGINT, SIG_IGN);
|
|
(void)putchar('\n');
|
|
(void)fflush(stdout);
|
|
(void)printf("--- %s ping statistics ---\n", hostname);
|
|
(void)printf("%ld packets transmitted, ", ntransmitted);
|
|
(void)printf("%ld packets received, ", nreceived);
|
|
if (nrepeats)
|
|
(void)printf("+%ld duplicates, ", nrepeats);
|
|
if (ntransmitted)
|
|
if (nreceived > ntransmitted)
|
|
(void)printf("-- somebody's printing up packets!");
|
|
else
|
|
(void)printf("%d%% packet loss",
|
|
(int) (((ntransmitted - nreceived) * 100) /
|
|
ntransmitted));
|
|
(void)putchar('\n');
|
|
if (nreceived && timing)
|
|
(void)printf("round-trip min/avg/max = %.3f/%.3f/%.3f ms\n",
|
|
tmin, tsum / (nreceived + nrepeats), tmax);
|
|
if (reset_kerninfo && tcgetattr(STDOUT_FILENO, &ts) != -1) {
|
|
ts.c_lflag &= ~NOKERNINFO;
|
|
tcsetattr(STDOUT_FILENO, TCSANOW, &ts);
|
|
}
|
|
|
|
if (nreceived)
|
|
exit(0);
|
|
else
|
|
exit(2);
|
|
}
|
|
|
|
#ifdef notdef
|
|
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
|
|
|
|
/*
|
|
* pr_icmph --
|
|
* Print a descriptive string about an ICMP header.
|
|
*/
|
|
static void
|
|
pr_icmph(icp)
|
|
struct icmp *icp;
|
|
{
|
|
switch(icp->icmp_type) {
|
|
case ICMP_ECHOREPLY:
|
|
(void)printf("Echo Reply\n");
|
|
/* XXX ID + Seq + Data */
|
|
break;
|
|
case ICMP_UNREACH:
|
|
switch(icp->icmp_code) {
|
|
case ICMP_UNREACH_NET:
|
|
(void)printf("Destination Net Unreachable\n");
|
|
break;
|
|
case ICMP_UNREACH_HOST:
|
|
(void)printf("Destination Host Unreachable\n");
|
|
break;
|
|
case ICMP_UNREACH_PROTOCOL:
|
|
(void)printf("Destination Protocol Unreachable\n");
|
|
break;
|
|
case ICMP_UNREACH_PORT:
|
|
(void)printf("Destination Port Unreachable\n");
|
|
break;
|
|
case ICMP_UNREACH_NEEDFRAG:
|
|
(void)printf("frag needed and DF set (MTU %d)\n",
|
|
icp->icmp_nextmtu);
|
|
break;
|
|
case ICMP_UNREACH_SRCFAIL:
|
|
(void)printf("Source Route Failed\n");
|
|
break;
|
|
case ICMP_UNREACH_FILTER_PROHIB:
|
|
(void)printf("Communication prohibited by filter\n");
|
|
break;
|
|
default:
|
|
(void)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:
|
|
(void)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:
|
|
(void)printf("Redirect Network");
|
|
break;
|
|
case ICMP_REDIRECT_HOST:
|
|
(void)printf("Redirect Host");
|
|
break;
|
|
case ICMP_REDIRECT_TOSNET:
|
|
(void)printf("Redirect Type of Service and Network");
|
|
break;
|
|
case ICMP_REDIRECT_TOSHOST:
|
|
(void)printf("Redirect Type of Service and Host");
|
|
break;
|
|
default:
|
|
(void)printf("Redirect, Bad Code: %d", icp->icmp_code);
|
|
break;
|
|
}
|
|
(void)printf("(New addr: 0x%08lx)\n", icp->icmp_gwaddr.s_addr);
|
|
#ifndef icmp_data
|
|
pr_retip(&icp->icmp_ip);
|
|
#else
|
|
pr_retip((struct ip *)icp->icmp_data);
|
|
#endif
|
|
break;
|
|
case ICMP_ECHO:
|
|
(void)printf("Echo Request\n");
|
|
/* XXX ID + Seq + Data */
|
|
break;
|
|
case ICMP_TIMXCEED:
|
|
switch(icp->icmp_code) {
|
|
case ICMP_TIMXCEED_INTRANS:
|
|
(void)printf("Time to live exceeded\n");
|
|
break;
|
|
case ICMP_TIMXCEED_REASS:
|
|
(void)printf("Frag reassembly time exceeded\n");
|
|
break;
|
|
default:
|
|
(void)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:
|
|
(void)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:
|
|
(void)printf("Timestamp\n");
|
|
/* XXX ID + Seq + 3 timestamps */
|
|
break;
|
|
case ICMP_TSTAMPREPLY:
|
|
(void)printf("Timestamp Reply\n");
|
|
/* XXX ID + Seq + 3 timestamps */
|
|
break;
|
|
case ICMP_IREQ:
|
|
(void)printf("Information Request\n");
|
|
/* XXX ID + Seq */
|
|
break;
|
|
case ICMP_IREQREPLY:
|
|
(void)printf("Information Reply\n");
|
|
/* XXX ID + Seq */
|
|
break;
|
|
case ICMP_MASKREQ:
|
|
(void)printf("Address Mask Request\n");
|
|
break;
|
|
case ICMP_MASKREPLY:
|
|
(void)printf("Address Mask Reply\n");
|
|
break;
|
|
case ICMP_ROUTERADVERT:
|
|
(void)printf("Router Advertisement\n");
|
|
break;
|
|
case ICMP_ROUTERSOLICIT:
|
|
(void)printf("Router Solicitation\n");
|
|
break;
|
|
default:
|
|
(void)printf("Bad ICMP type: %d\n", icp->icmp_type);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* pr_iph --
|
|
* Print an IP header with options.
|
|
*/
|
|
static void
|
|
pr_iph(ip)
|
|
struct ip *ip;
|
|
{
|
|
int hlen;
|
|
u_char *cp;
|
|
|
|
hlen = ip->ip_hl << 2;
|
|
cp = (u_char *)ip + 20; /* point to options */
|
|
|
|
(void)printf("Vr HL TOS Len ID Flg off TTL Pro cks Src Dst\n");
|
|
(void)printf(" %1x %1x %02x %04x %04x",
|
|
ip->ip_v, ip->ip_hl, ip->ip_tos, ntohs(ip->ip_len),
|
|
ntohs(ip->ip_id));
|
|
(void)printf(" %1lx %04lx", (ntohl(ip->ip_off) & 0xe000) >> 13,
|
|
ntohl(ip->ip_off) & 0x1fff);
|
|
(void)printf(" %02x %02x %04x", ip->ip_ttl, ip->ip_p,
|
|
ntohs(ip->ip_sum));
|
|
(void)printf(" %s ", inet_ntoa(*(struct in_addr *)&ip->ip_src.s_addr));
|
|
(void)printf(" %s ", inet_ntoa(*(struct in_addr *)&ip->ip_dst.s_addr));
|
|
/* dump any option bytes */
|
|
while (hlen-- > 20) {
|
|
(void)printf("%02x", *cp++);
|
|
}
|
|
(void)putchar('\n');
|
|
}
|
|
|
|
/*
|
|
* pr_addr --
|
|
* Return an ascii host address as a dotted quad and optionally with
|
|
* a hostname.
|
|
*/
|
|
static char *
|
|
pr_addr(ina)
|
|
struct in_addr ina;
|
|
{
|
|
struct hostent *hp;
|
|
static char buf[16 + 3 + MAXHOSTNAMELEN];
|
|
|
|
if ((options & F_NUMERIC) ||
|
|
!(hp = gethostbyaddr((char *)&ina, 4, AF_INET)))
|
|
return inet_ntoa(ina);
|
|
else
|
|
(void)snprintf(buf, sizeof(buf), "%s (%s)", hp->h_name,
|
|
inet_ntoa(ina));
|
|
return(buf);
|
|
}
|
|
|
|
/*
|
|
* pr_retip --
|
|
* Dump some info on a returned (via ICMP) IP packet.
|
|
*/
|
|
static void
|
|
pr_retip(ip)
|
|
struct ip *ip;
|
|
{
|
|
int hlen;
|
|
u_char *cp;
|
|
|
|
pr_iph(ip);
|
|
hlen = ip->ip_hl << 2;
|
|
cp = (u_char *)ip + hlen;
|
|
|
|
if (ip->ip_p == 6)
|
|
(void)printf("TCP: from port %u, to port %u (decimal)\n",
|
|
(*cp * 256 + *(cp + 1)), (*(cp + 2) * 256 + *(cp + 3)));
|
|
else if (ip->ip_p == 17)
|
|
(void)printf("UDP: from port %u, to port %u (decimal)\n",
|
|
(*cp * 256 + *(cp + 1)), (*(cp + 2) * 256 + *(cp + 3)));
|
|
}
|
|
|
|
static void
|
|
fill(bp, patp)
|
|
char *bp, *patp;
|
|
{
|
|
register int ii, jj, kk;
|
|
int pat[16];
|
|
char *cp;
|
|
|
|
for (cp = patp; *cp; cp++) {
|
|
if (!isxdigit(*cp))
|
|
errx(EX_USAGE,
|
|
"patterns must be specified as hex digits");
|
|
|
|
}
|
|
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 + sizeof(struct timeval) + ii);
|
|
kk += ii)
|
|
for (jj = 0; jj < ii; ++jj)
|
|
bp[jj + kk] = pat[jj];
|
|
if (!(options & F_QUIET)) {
|
|
(void)printf("PATTERN: 0x");
|
|
for (jj = 0; jj < ii; ++jj)
|
|
(void)printf("%02x", bp[jj] & 0xFF);
|
|
(void)printf("\n");
|
|
}
|
|
}
|
|
|
|
static void
|
|
usage(argv0)
|
|
const char *argv0;
|
|
{
|
|
if (strrchr(argv0,'/'))
|
|
argv0 = strrchr(argv0,'/') + 1;
|
|
fprintf(stderr,
|
|
"usage: %s [-QRadfnqrv] [-c count] [-i wait] [-l preload] "
|
|
"[-p pattern]\n\t\t[-s packetsize] "
|
|
"[host | [-L] [-I iface] [-T ttl] mcast-group]\n",
|
|
argv0);
|
|
exit(EX_USAGE);
|
|
}
|