* Remove Alpha support and redundant flags from the Makefile.
[dragonfly.git] / sbin / ping / ping.c
CommitLineData
984263bc
MD
1/*
2 * Copyright (c) 1989, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * Mike Muuss.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by the University of
19 * California, Berkeley and its contributors.
20 * 4. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
1de703da
MD
35 *
36 * @(#) Copyright (c) 1989, 1993 The Regents of the University of California. All rights reserved.
37 * @(#)ping.c 8.1 (Berkeley) 6/5/93
38 * $FreeBSD: src/sbin/ping/ping.c,v 1.52.2.13 2002/10/29 10:23:21 maxim Exp $
d136a254 39 * $DragonFly: src/sbin/ping/ping.c,v 1.5 2005/02/13 02:11:26 swildner Exp $
984263bc
MD
40 */
41
984263bc
MD
42/*
43 * P I N G . C
44 *
45 * Using the Internet Control Message Protocol (ICMP) "ECHO" facility,
46 * measure round-trip-delays and packet loss across network paths.
47 *
48 * Author -
49 * Mike Muuss
50 * U. S. Army Ballistic Research Laboratory
51 * December, 1983
52 *
53 * Status -
54 * Public Domain. Distribution Unlimited.
55 * Bugs -
56 * More statistics could always be gathered.
57 * This program has to run SUID to ROOT to access the ICMP socket.
58 */
59
60#include <sys/param.h> /* NB: we rely on this for <sys/types.h> */
61
62#include <ctype.h>
63#include <err.h>
64#include <errno.h>
65#include <math.h>
66#include <netdb.h>
67#include <signal.h>
68#include <stdio.h>
69#include <stdlib.h>
70#include <string.h>
71#include <sysexits.h>
72#include <termios.h>
73#include <unistd.h>
74
75#include <sys/socket.h>
76#include <sys/time.h>
77#include <sys/uio.h>
78
79#include <netinet/in.h>
80#include <netinet/in_systm.h>
81#include <netinet/ip.h>
82#include <netinet/ip_icmp.h>
83#include <netinet/ip_var.h>
84#include <arpa/inet.h>
85
86#ifdef IPSEC
87#include <netinet6/ipsec.h>
88#endif /*IPSEC*/
89
90#define INADDR_LEN ((int)sizeof(in_addr_t))
91#define PHDR_LEN ((int)sizeof(struct timeval))
92#define DEFDATALEN (64 - PHDR_LEN) /* default data length */
93#define FLOOD_BACKOFF 20000 /* usecs to back off if F_FLOOD mode */
94 /* runs out of buffer space */
95#define MAXIPLEN (sizeof(struct ip) + MAX_IPOPTLEN)
96#define MAXICMPLEN (ICMP_ADVLENMIN + MAX_IPOPTLEN)
97#define MINICMPLEN ICMP_MINLEN
98#define MAXPAYLOAD (IP_MAXPACKET - MAXIPLEN - MINICMPLEN)
99#define MAXWAIT 10 /* max seconds to wait for response */
100#define MAXALARM (60 * 60) /* max seconds for alarm timeout */
101
102#define A(bit) rcvd_tbl[(bit)>>3] /* identify byte in array */
103#define B(bit) (1 << ((bit) & 0x07)) /* identify bit in byte */
104#define SET(bit) (A(bit) |= B(bit))
105#define CLR(bit) (A(bit) &= (~B(bit)))
106#define TST(bit) (A(bit) & B(bit))
107
108/* various options */
109int options;
110#define F_FLOOD 0x0001
111#define F_INTERVAL 0x0002
112#define F_NUMERIC 0x0004
113#define F_PINGFILLED 0x0008
114#define F_QUIET 0x0010
115#define F_RROUTE 0x0020
116#define F_SO_DEBUG 0x0040
117#define F_SO_DONTROUTE 0x0080
118#define F_VERBOSE 0x0100
119#define F_QUIET2 0x0200
120#define F_NOLOOP 0x0400
121#define F_MTTL 0x0800
122#define F_MIF 0x1000
123#define F_AUDIBLE 0x2000
124#ifdef IPSEC
125#ifdef IPSEC_POLICY_IPSEC
126#define F_POLICY 0x4000
127#endif /*IPSEC_POLICY_IPSEC*/
128#endif /*IPSEC*/
129#define F_TTL 0x8000
130#define F_MISSED 0x10000
131
132/*
133 * MAX_DUP_CHK is the number of bits in received table, i.e. the maximum
134 * number of received sequence numbers we can keep track of. Change 128
135 * to 8192 for complete accuracy...
136 */
137#define MAX_DUP_CHK (8 * 128)
138int mx_dup_ck = MAX_DUP_CHK;
139char rcvd_tbl[MAX_DUP_CHK / 8];
140
141struct sockaddr_in whereto; /* who to ping */
142int datalen = DEFDATALEN;
143int s; /* socket file descriptor */
144u_char outpack[MINICMPLEN + MAXPAYLOAD];
145char BSPACE = '\b'; /* characters written for flood */
146char BBELL = '\a'; /* characters written for MISSED and AUDIBLE */
147char DOT = '.';
148char *hostname;
149char *shostname;
150int ident; /* process id to identify our packets */
151int uid; /* cached uid for micro-optimization */
152
153/* counters */
154long npackets; /* max packets to transmit */
155long nreceived; /* # of packets we got back */
156long nrepeats; /* number of duplicates */
157long ntransmitted; /* sequence # for outbound packets = #sent */
158long nmissedmax; /* max value of ntransmitted - nreceived - 1 */
159int interval = 1000; /* interval between packets, ms */
160
161/* timing */
162int timing; /* flag to do timing */
163double tmin = 999999999.0; /* minimum round trip time */
164double tmax = 0.0; /* maximum round trip time */
165double tsum = 0.0; /* sum of all times, for doing average */
166double tsumsq = 0.0; /* sum of all times squared, for std. dev. */
167
168volatile sig_atomic_t finish_up; /* nonzero if we've been told to finish up */
169int reset_kerninfo;
170volatile sig_atomic_t siginfo_p;
171
172static void fill(char *, char *);
173static u_short in_cksum(u_short *, int);
174static void check_status(void);
175static void finish(void) __dead2;
176static void pinger(void);
177static char *pr_addr(struct in_addr);
178static void pr_icmph(struct icmp *);
179static void pr_iph(struct ip *);
180static void pr_pack(char *, int, struct sockaddr_in *, struct timeval *);
181static void pr_retip(struct ip *);
182static void status(int);
183static void stopit(int);
184static void tvsub(struct timeval *, struct timeval *);
185static void usage(void) __dead2;
186
187int
b5744197 188main(int argc, char **argv)
984263bc
MD
189{
190 struct in_addr ifaddr;
191 struct iovec iov;
192 struct msghdr msg;
193 struct sigaction si_sa;
d136a254 194 struct sockaddr_in from, src_in;
984263bc
MD
195 struct termios ts;
196 struct timeval last, intvl;
197 struct hostent *hp;
198 struct sockaddr_in *to;
199 double t;
200 u_char *datap, packet[IP_MAXPACKET];
201 char *ep, *source, *target;
202#ifdef IPSEC_POLICY_IPSEC
203 char *policy_in, *policy_out;
204#endif
205 u_long alarmtimeout, ultmp;
206 int ch, hold, i, packlen, preload, sockerrno, almost_done = 0, ttl;
207 char ctrl[CMSG_SPACE(sizeof(struct timeval))];
208 char hnamebuf[MAXHOSTNAMELEN], snamebuf[MAXHOSTNAMELEN];
209#ifdef IP_OPTIONS
210 char rspace[MAX_IPOPTLEN]; /* record route space */
211#endif
212 unsigned char mttl, loop;
213
214 source = NULL;
215#ifdef IPSEC_POLICY_IPSEC
216 policy_in = policy_out = NULL;
217#endif
218
219 /*
220 * Do the stuff that we need root priv's for *first*, and
221 * then drop our setuid bit. Save error reporting for
222 * after arg parsing.
223 */
224 s = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
225 sockerrno = errno;
226
227 setuid(getuid());
228 uid = getuid();
229
230 alarmtimeout = preload = 0;
231
232 datap = &outpack[MINICMPLEN + PHDR_LEN];
233 while ((ch = getopt(argc, argv,
234 "AI:LQRS:T:c:adfi:l:m:np:qrs:t:v"
235#ifdef IPSEC
236#ifdef IPSEC_POLICY_IPSEC
237 "P:"
238#endif /*IPSEC_POLICY_IPSEC*/
239#endif /*IPSEC*/
240 )) != -1)
241 {
242 switch(ch) {
243 case 'A':
244 options |= F_MISSED;
245 break;
246 case 'a':
247 options |= F_AUDIBLE;
248 break;
249 case 'c':
250 ultmp = strtoul(optarg, &ep, 0);
251 if (*ep || ep == optarg || ultmp > LONG_MAX || !ultmp)
252 errx(EX_USAGE,
253 "invalid count of packets to transmit: `%s'",
254 optarg);
255 npackets = ultmp;
256 break;
257 case 'd':
258 options |= F_SO_DEBUG;
259 break;
260 case 'f':
261 if (uid) {
262 errno = EPERM;
263 err(EX_NOPERM, "-f flag");
264 }
265 options |= F_FLOOD;
266 setbuf(stdout, (char *)NULL);
267 break;
268 case 'i': /* wait between sending packets */
269 t = strtod(optarg, &ep) * 1000.0;
270 if (*ep || ep == optarg || t > (double)INT_MAX)
271 errx(EX_USAGE, "invalid timing interval: `%s'",
272 optarg);
273 options |= F_INTERVAL;
274 interval = (int)t;
275 if (uid && interval < 1000) {
276 errno = EPERM;
277 err(EX_NOPERM, "-i interval too short");
278 }
279 break;
280 case 'I': /* multicast interface */
281 if (inet_aton(optarg, &ifaddr) == 0)
282 errx(EX_USAGE,
283 "invalid multicast interface: `%s'",
284 optarg);
285 options |= F_MIF;
286 break;
287 case 'l':
288 ultmp = strtoul(optarg, &ep, 0);
289 if (*ep || ep == optarg || ultmp > INT_MAX)
290 errx(EX_USAGE,
291 "invalid preload value: `%s'", optarg);
292 if (uid) {
293 errno = EPERM;
294 err(EX_NOPERM, "-l flag");
295 }
296 preload = ultmp;
297 break;
298 case 'L':
299 options |= F_NOLOOP;
300 loop = 0;
301 break;
302 case 'm': /* TTL */
303 ultmp = strtoul(optarg, &ep, 0);
304 if (*ep || ep == optarg || ultmp > 255)
305 errx(EX_USAGE, "invalid TTL: `%s'", optarg);
306 ttl = ultmp;
307 options |= F_TTL;
308 break;
309 case 'n':
310 options |= F_NUMERIC;
311 break;
312 case 'p': /* fill buffer with user pattern */
313 options |= F_PINGFILLED;
314 fill((char *)datap, optarg);
315 break;
316 case 'Q':
317 options |= F_QUIET2;
318 break;
319 case 'q':
320 options |= F_QUIET;
321 break;
322 case 'R':
323 options |= F_RROUTE;
324 break;
325 case 'r':
326 options |= F_SO_DONTROUTE;
327 break;
328 case 's': /* size of packet to send */
329 if (uid) {
330 errno = EPERM;
331 err(EX_NOPERM, "-s flag");
332 }
333 ultmp = strtoul(optarg, &ep, 0);
334 if (ultmp > MAXPAYLOAD)
335 errx(EX_USAGE,
336 "packet size too large: %lu > %u",
337 ultmp, MAXPAYLOAD);
338 if (*ep || ep == optarg)
339 errx(EX_USAGE, "invalid packet size: `%s'",
340 optarg);
341 datalen = ultmp;
342 break;
343 case 'S':
344 source = optarg;
345 break;
346 case 't':
347 alarmtimeout = strtoul(optarg, &ep, 0);
348 if ((alarmtimeout < 1) || (alarmtimeout == ULONG_MAX))
349 errx(EX_USAGE, "invalid timeout: `%s'",
350 optarg);
351 if (alarmtimeout > MAXALARM)
352 errx(EX_USAGE, "invalid timeout: `%s' > %d",
353 optarg, MAXALARM);
354 alarm((int)alarmtimeout);
355 break;
356 case 'T': /* multicast TTL */
357 ultmp = strtoul(optarg, &ep, 0);
358 if (*ep || ep == optarg || ultmp > 255)
359 errx(EX_USAGE, "invalid multicast TTL: `%s'",
360 optarg);
361 mttl = ultmp;
362 options |= F_MTTL;
363 break;
364 case 'v':
365 options |= F_VERBOSE;
366 break;
367#ifdef IPSEC
368#ifdef IPSEC_POLICY_IPSEC
369 case 'P':
370 options |= F_POLICY;
371 if (!strncmp("in", optarg, 2))
372 policy_in = strdup(optarg);
373 else if (!strncmp("out", optarg, 3))
374 policy_out = strdup(optarg);
375 else
376 errx(1, "invalid security policy");
377 break;
378#endif /*IPSEC_POLICY_IPSEC*/
379#endif /*IPSEC*/
380 default:
381 usage();
382 }
383 }
384
385 if (argc - optind != 1)
386 usage();
387 target = argv[optind];
388
389 if (source) {
d136a254
SW
390 bzero((char *)&src_in, sizeof(src_in));
391 src_in.sin_family = AF_INET;
392 if (inet_aton(source, &src_in.sin_addr) != 0) {
984263bc
MD
393 shostname = source;
394 } else {
395 hp = gethostbyname2(source, AF_INET);
396 if (!hp)
397 errx(EX_NOHOST, "cannot resolve %s: %s",
398 source, hstrerror(h_errno));
399
d136a254
SW
400 src_in.sin_len = sizeof src_in;
401 if (hp->h_length > (int)sizeof(src_in.sin_addr) ||
984263bc
MD
402 hp->h_length < 0)
403 errx(1, "gethostbyname2: illegal address");
d136a254
SW
404 memcpy(&src_in.sin_addr, hp->h_addr_list[0],
405 sizeof(src_in.sin_addr));
7cee7052 406 strncpy(snamebuf, hp->h_name,
984263bc
MD
407 sizeof(snamebuf) - 1);
408 snamebuf[sizeof(snamebuf) - 1] = '\0';
409 shostname = snamebuf;
410 }
d136a254 411 if (bind(s, (struct sockaddr *)&src_in, sizeof src_in) == -1)
984263bc
MD
412 err(1, "bind");
413 }
414
415 bzero(&whereto, sizeof(whereto));
416 to = &whereto;
417 to->sin_family = AF_INET;
418 to->sin_len = sizeof *to;
419 if (inet_aton(target, &to->sin_addr) != 0) {
420 hostname = target;
421 } else {
422 hp = gethostbyname2(target, AF_INET);
423 if (!hp)
424 errx(EX_NOHOST, "cannot resolve %s: %s",
425 target, hstrerror(h_errno));
426
d136a254 427 if (hp->h_length > (int)sizeof(to->sin_addr))
984263bc
MD
428 errx(1, "gethostbyname2 returned an illegal address");
429 memcpy(&to->sin_addr, hp->h_addr_list[0], sizeof to->sin_addr);
7cee7052 430 strncpy(hnamebuf, hp->h_name, sizeof(hnamebuf) - 1);
984263bc
MD
431 hnamebuf[sizeof(hnamebuf) - 1] = '\0';
432 hostname = hnamebuf;
433 }
434
435 if (options & F_FLOOD && options & F_INTERVAL)
436 errx(EX_USAGE, "-f and -i: incompatible options");
437
438 if (options & F_FLOOD && IN_MULTICAST(ntohl(to->sin_addr.s_addr)))
439 errx(EX_USAGE,
440 "-f flag cannot be used with multicast destination");
441 if (options & (F_MIF | F_NOLOOP | F_MTTL)
442 && !IN_MULTICAST(ntohl(to->sin_addr.s_addr)))
443 errx(EX_USAGE,
444 "-I, -L, -T flags cannot be used with unicast destination");
445
446 if (datalen >= PHDR_LEN) /* can we time transfer */
447 timing = 1;
448 packlen = MAXIPLEN + MAXICMPLEN + datalen;
449 packlen = packlen > IP_MAXPACKET ? IP_MAXPACKET : packlen;
450
451 if (!(options & F_PINGFILLED))
452 for (i = PHDR_LEN; i < datalen; ++i)
453 *datap++ = i;
454
455 ident = getpid() & 0xFFFF;
456
457 if (s < 0) {
458 errno = sockerrno;
459 err(EX_OSERR, "socket");
460 }
461 hold = 1;
462 if (options & F_SO_DEBUG)
7cee7052 463 setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&hold,
984263bc
MD
464 sizeof(hold));
465 if (options & F_SO_DONTROUTE)
7cee7052 466 setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)&hold,
984263bc
MD
467 sizeof(hold));
468#ifdef IPSEC
469#ifdef IPSEC_POLICY_IPSEC
470 if (options & F_POLICY) {
471 char *buf;
472 if (policy_in != NULL) {
473 buf = ipsec_set_policy(policy_in, strlen(policy_in));
474 if (buf == NULL)
475 errx(EX_CONFIG, "%s", ipsec_strerror());
476 if (setsockopt(s, IPPROTO_IP, IP_IPSEC_POLICY,
477 buf, ipsec_get_policylen(buf)) < 0)
478 err(EX_CONFIG,
479 "ipsec policy cannot be configured");
480 free(buf);
481 }
482
483 if (policy_out != NULL) {
484 buf = ipsec_set_policy(policy_out, strlen(policy_out));
485 if (buf == NULL)
486 errx(EX_CONFIG, "%s", ipsec_strerror());
487 if (setsockopt(s, IPPROTO_IP, IP_IPSEC_POLICY,
488 buf, ipsec_get_policylen(buf)) < 0)
489 err(EX_CONFIG,
490 "ipsec policy cannot be configured");
491 free(buf);
492 }
493 }
494#endif /*IPSEC_POLICY_IPSEC*/
495#endif /*IPSEC*/
496
497 /* record route option */
498 if (options & F_RROUTE) {
499#ifdef IP_OPTIONS
500 bzero(rspace, sizeof(rspace));
501 rspace[IPOPT_OPTVAL] = IPOPT_RR;
502 rspace[IPOPT_OLEN] = sizeof(rspace) - 1;
503 rspace[IPOPT_OFFSET] = IPOPT_MINOFF;
504 rspace[sizeof(rspace) - 1] = IPOPT_EOL;
505 if (setsockopt(s, IPPROTO_IP, IP_OPTIONS, rspace,
506 sizeof(rspace)) < 0)
507 err(EX_OSERR, "setsockopt IP_OPTIONS");
508#else
509 errx(EX_UNAVAILABLE,
510 "record route not available in this implementation");
511#endif /* IP_OPTIONS */
512 }
513
514 if (options & F_TTL) {
515 if (setsockopt(s, IPPROTO_IP, IP_TTL, &ttl,
516 sizeof(ttl)) < 0) {
517 err(EX_OSERR, "setsockopt IP_TTL");
518 }
519 }
520 if (options & F_NOLOOP) {
521 if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_LOOP, &loop,
522 sizeof(loop)) < 0) {
523 err(EX_OSERR, "setsockopt IP_MULTICAST_LOOP");
524 }
525 }
526 if (options & F_MTTL) {
527 if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, &mttl,
528 sizeof(mttl)) < 0) {
529 err(EX_OSERR, "setsockopt IP_MULTICAST_TTL");
530 }
531 }
532 if (options & F_MIF) {
533 if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_IF, &ifaddr,
534 sizeof(ifaddr)) < 0) {
535 err(EX_OSERR, "setsockopt IP_MULTICAST_IF");
536 }
537 }
538#ifdef SO_TIMESTAMP
539 { int on = 1;
540 if (setsockopt(s, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on)) < 0)
541 err(EX_OSERR, "setsockopt SO_TIMESTAMP");
542 }
543#endif
544
545 /*
546 * When pinging the broadcast address, you can get a lot of answers.
547 * Doing something so evil is useful if you are trying to stress the
548 * ethernet, or just want to fill the arp cache to get some stuff for
549 * /etc/ethers. But beware: RFC 1122 allows hosts to ignore broadcast
550 * or multicast pings if they wish.
551 */
552
553 /*
554 * XXX receive buffer needs undetermined space for mbuf overhead
555 * as well.
556 */
557 hold = IP_MAXPACKET + 128;
7cee7052 558 setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&hold, sizeof(hold));
984263bc
MD
559
560 if (!uid) {
7cee7052 561 setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&hold,
984263bc
MD
562 sizeof(hold));
563 }
564
565 if (to->sin_family == AF_INET) {
7cee7052 566 printf("PING %s (%s)", hostname, inet_ntoa(to->sin_addr));
984263bc 567 if (source)
7cee7052
SW
568 printf(" from %s", shostname);
569 printf(": %d data bytes\n", datalen);
984263bc 570 } else
7cee7052 571 printf("PING %s: %d data bytes\n", hostname, datalen);
984263bc
MD
572
573 /*
574 * Use sigaction() instead of signal() to get unambiguous semantics,
575 * in particular with SA_RESTART not set.
576 */
577
578 sigemptyset(&si_sa.sa_mask);
579 si_sa.sa_flags = 0;
580
581 si_sa.sa_handler = stopit;
582 if (sigaction(SIGINT, &si_sa, 0) == -1) {
583 err(EX_OSERR, "sigaction SIGINT");
584 }
585
586 si_sa.sa_handler = status;
587 if (sigaction(SIGINFO, &si_sa, 0) == -1) {
588 err(EX_OSERR, "sigaction");
589 }
590
591 if (alarmtimeout > 0) {
592 si_sa.sa_handler = stopit;
593 if (sigaction(SIGALRM, &si_sa, 0) == -1)
594 err(EX_OSERR, "sigaction SIGALRM");
595 }
596
597 bzero(&msg, sizeof(msg));
598 msg.msg_name = (caddr_t)&from;
599 msg.msg_iov = &iov;
600 msg.msg_iovlen = 1;
601#ifdef SO_TIMESTAMP
602 msg.msg_control = (caddr_t)ctrl;
603#endif
604 iov.iov_base = packet;
605 iov.iov_len = packlen;
606
607 if (tcgetattr(STDOUT_FILENO, &ts) != -1) {
608 reset_kerninfo = !(ts.c_lflag & NOKERNINFO);
609 ts.c_lflag |= NOKERNINFO;
610 tcsetattr(STDOUT_FILENO, TCSANOW, &ts);
611 }
612
613 if (preload == 0)
614 pinger(); /* send the first ping */
615 else {
616 if (npackets != 0 && preload > npackets)
617 preload = npackets;
618 while (preload--) /* fire off them quickies */
619 pinger();
620 }
7cee7052 621 gettimeofday(&last, NULL);
984263bc
MD
622
623 if (options & F_FLOOD) {
624 intvl.tv_sec = 0;
625 intvl.tv_usec = 10000;
626 } else {
627 intvl.tv_sec = interval / 1000;
628 intvl.tv_usec = interval % 1000 * 1000;
629 }
630
631 while (!finish_up) {
632 int cc;
633 int n;
634 struct timeval timeout, now;
635 fd_set rfds;
636
637 check_status();
638 if (s >= FD_SETSIZE)
639 errx(EX_OSERR, "descriptor too large");
640 FD_ZERO(&rfds);
641 FD_SET(s, &rfds);
7cee7052 642 gettimeofday(&now, NULL);
984263bc
MD
643 timeout.tv_sec = last.tv_sec + intvl.tv_sec - now.tv_sec;
644 timeout.tv_usec = last.tv_usec + intvl.tv_usec - now.tv_usec;
645 while (timeout.tv_usec < 0) {
646 timeout.tv_usec += 1000000;
647 timeout.tv_sec--;
648 }
649 while (timeout.tv_usec >= 1000000) {
650 timeout.tv_usec -= 1000000;
651 timeout.tv_sec++;
652 }
653 if (timeout.tv_sec < 0)
654 timeout.tv_sec = timeout.tv_usec = 0;
655 n = select(s + 1, &rfds, NULL, NULL, &timeout);
656 if (n < 0)
657 continue; /* Must be EINTR. */
658 if (n == 1) {
d136a254 659 struct timeval *tv = 0;
984263bc
MD
660#ifdef SO_TIMESTAMP
661 struct cmsghdr *cmsg = (struct cmsghdr *)&ctrl;
662
663 msg.msg_controllen = sizeof(ctrl);
664#endif
665 msg.msg_namelen = sizeof(from);
666 if ((cc = recvmsg(s, &msg, 0)) < 0) {
667 if (errno == EINTR)
668 continue;
669 warn("recvmsg");
670 continue;
671 }
672#ifdef SO_TIMESTAMP
673 if (cmsg->cmsg_level == SOL_SOCKET &&
674 cmsg->cmsg_type == SCM_TIMESTAMP &&
d136a254 675 cmsg->cmsg_len == CMSG_LEN(sizeof *tv)) {
984263bc
MD
676 /* Copy to avoid alignment problems: */
677 memcpy(&now,CMSG_DATA(cmsg),sizeof(now));
d136a254 678 tv = &now;
984263bc
MD
679 }
680#endif
d136a254 681 if (tv == 0) {
7cee7052 682 gettimeofday(&now, NULL);
d136a254 683 tv = &now;
984263bc 684 }
d136a254 685 pr_pack((char *)packet, cc, &from, tv);
984263bc
MD
686 if (npackets && nreceived >= npackets)
687 break;
688 }
689 if (n == 0 || options & F_FLOOD) {
690 if (!npackets || ntransmitted < npackets)
691 pinger();
692 else {
693 if (almost_done)
694 break;
695 almost_done = 1;
696 intvl.tv_usec = 0;
697 if (nreceived) {
698 intvl.tv_sec = 2 * tmax / 1000;
699 if (!intvl.tv_sec)
700 intvl.tv_sec = 1;
701 } else
702 intvl.tv_sec = MAXWAIT;
703 }
7cee7052 704 gettimeofday(&last, NULL);
984263bc
MD
705
706 if (ntransmitted - nreceived - 1 > nmissedmax) {
707 nmissedmax = ntransmitted - nreceived - 1;
708 if (options & F_MISSED)
7cee7052 709 write(STDOUT_FILENO, &BBELL, 1);
984263bc
MD
710 }
711 }
712 }
713 finish();
714 /* NOTREACHED */
715 exit(0); /* Make the compiler happy */
716}
717
718/*
719 * stopit --
720 * Set the global bit that causes the main loop to quit.
721 * Do NOT call finish() from here, since finish() does far too much
722 * to be called from a signal handler.
723 */
724void
b5744197 725stopit(int sig __unused)
984263bc
MD
726{
727
728 finish_up = 1;
729}
730
731/*
732 * pinger --
733 * Compose and transmit an ICMP ECHO REQUEST packet. The IP packet
734 * will be added on by the kernel. The ID field is our UNIX process ID,
735 * and the sequence number is an ascending integer. The first PHDR_LEN
736 * bytes of the data portion are used to hold a UNIX "timeval" struct in
737 * host byte-order, to compute the round-trip time.
738 */
739static void
740pinger(void)
741{
742 struct icmp *icp;
743 int cc, i;
744
745 icp = (struct icmp *)outpack;
746 icp->icmp_type = ICMP_ECHO;
747 icp->icmp_code = 0;
748 icp->icmp_cksum = 0;
749 icp->icmp_seq = ntransmitted;
750 icp->icmp_id = ident; /* ID */
751
752 CLR(icp->icmp_seq % mx_dup_ck);
753
754 if (timing)
7cee7052 755 gettimeofday((struct timeval *)&outpack[MINICMPLEN],
984263bc
MD
756 (struct timezone *)NULL);
757
758 cc = MINICMPLEN + datalen;
759
760 /* compute ICMP checksum here */
761 icp->icmp_cksum = in_cksum((u_short *)icp, cc);
762
763 i = sendto(s, (char *)outpack, cc, 0, (struct sockaddr *)&whereto,
764 sizeof(whereto));
765
766 if (i < 0 || i != cc) {
767 if (i < 0) {
768 if (options & F_FLOOD && errno == ENOBUFS) {
769 usleep(FLOOD_BACKOFF);
770 return;
771 }
772 warn("sendto");
773 } else {
774 warn("%s: partial write: %d of %d bytes",
775 hostname, i, cc);
776 }
777 }
778 ntransmitted++;
779 if (!(options & F_QUIET) && options & F_FLOOD)
7cee7052 780 write(STDOUT_FILENO, &DOT, 1);
984263bc
MD
781}
782
783/*
784 * pr_pack --
785 * Print out the packet, if it came from us. This logic is necessary
786 * because ALL readers of the ICMP socket get a copy of ALL ICMP packets
787 * which arrive ('tis only fair). This permits multiple copies of this
788 * program to be run without having intermingled output (or statistics!).
789 */
790static void
b5744197 791pr_pack(char *buf, int cc, struct sockaddr_in *from, struct timeval *tv)
984263bc
MD
792{
793 struct icmp *icp;
794 struct ip *ip;
795 struct in_addr ina;
796 struct timeval *tp;
797 u_char *cp, *dp;
798 double triptime;
799 int dupflag, hlen, i, j;
800 static int old_rrlen;
801 static char old_rr[MAX_IPOPTLEN];
802
803 /* Check the IP header */
804 ip = (struct ip *)buf;
805 hlen = ip->ip_hl << 2;
806 if (cc < hlen + ICMP_MINLEN) {
807 if (options & F_VERBOSE)
808 warn("packet too short (%d bytes) from %s", cc,
809 inet_ntoa(from->sin_addr));
810 return;
811 }
812
813 /* Now the ICMP part */
814 cc -= hlen;
815 icp = (struct icmp *)(buf + hlen);
816 if (icp->icmp_type == ICMP_ECHOREPLY) {
817 if (icp->icmp_id != ident)
818 return; /* 'Twas not our ECHO */
819 ++nreceived;
820 triptime = 0.0;
821 if (timing) {
822 struct timeval tv1;
823#ifndef icmp_data
824 tp = (struct timeval *)&icp->icmp_ip;
825#else
826 tp = (struct timeval *)icp->icmp_data;
827#endif
828 /* Avoid unaligned data: */
829 memcpy(&tv1,tp,sizeof(tv1));
830 tvsub(tv, &tv1);
831 triptime = ((double)tv->tv_sec) * 1000.0 +
832 ((double)tv->tv_usec) / 1000.0;
833 tsum += triptime;
834 tsumsq += triptime * triptime;
835 if (triptime < tmin)
836 tmin = triptime;
837 if (triptime > tmax)
838 tmax = triptime;
839 }
840
841 if (TST(icp->icmp_seq % mx_dup_ck)) {
842 ++nrepeats;
843 --nreceived;
844 dupflag = 1;
845 } else {
846 SET(icp->icmp_seq % mx_dup_ck);
847 dupflag = 0;
848 }
849
850 if (options & F_QUIET)
851 return;
852
853 if (options & F_FLOOD)
7cee7052 854 write(STDOUT_FILENO, &BSPACE, 1);
984263bc 855 else {
7cee7052 856 printf("%d bytes from %s: icmp_seq=%u", cc,
984263bc
MD
857 inet_ntoa(*(struct in_addr *)&from->sin_addr.s_addr),
858 icp->icmp_seq);
7cee7052 859 printf(" ttl=%d", ip->ip_ttl);
984263bc 860 if (timing)
7cee7052 861 printf(" time=%.3f ms", triptime);
984263bc 862 if (dupflag)
7cee7052 863 printf(" (DUP!)");
984263bc 864 if (options & F_AUDIBLE)
7cee7052 865 write(STDOUT_FILENO, &BBELL, 1);
984263bc
MD
866 /* check the data */
867 cp = (u_char*)&icp->icmp_data[PHDR_LEN];
868 dp = &outpack[MINICMPLEN + PHDR_LEN];
869 for (i = PHDR_LEN; i < datalen; ++i, ++cp, ++dp) {
870 if (*cp != *dp) {
7cee7052 871 printf("\nwrong data byte #%d should be 0x%x but was 0x%x",
984263bc 872 i, *dp, *cp);
7cee7052 873 printf("\ncp:");
984263bc
MD
874 cp = (u_char*)&icp->icmp_data[0];
875 for (i = 0; i < datalen; ++i, ++cp) {
876 if ((i % 32) == 8)
7cee7052
SW
877 printf("\n\t");
878 printf("%x ", *cp);
984263bc 879 }
7cee7052 880 printf("\ndp:");
984263bc
MD
881 cp = &outpack[MINICMPLEN];
882 for (i = 0; i < datalen; ++i, ++cp) {
883 if ((i % 32) == 8)
7cee7052
SW
884 printf("\n\t");
885 printf("%x ", *cp);
984263bc
MD
886 }
887 break;
888 }
889 }
890 }
891 } else {
892 /*
893 * We've got something other than an ECHOREPLY.
894 * See if it's a reply to something that we sent.
895 * We can compare IP destination, protocol,
896 * and ICMP type and ID.
897 *
898 * Only print all the error messages if we are running
899 * as root to avoid leaking information not normally
900 * available to those not running as root.
901 */
902#ifndef icmp_data
903 struct ip *oip = &icp->icmp_ip;
904#else
905 struct ip *oip = (struct ip *)icp->icmp_data;
906#endif
907 struct icmp *oicmp = (struct icmp *)(oip + 1);
908
909 if (((options & F_VERBOSE) && uid == 0) ||
910 (!(options & F_QUIET2) &&
911 (oip->ip_dst.s_addr == whereto.sin_addr.s_addr) &&
912 (oip->ip_p == IPPROTO_ICMP) &&
913 (oicmp->icmp_type == ICMP_ECHO) &&
914 (oicmp->icmp_id == ident))) {
7cee7052 915 printf("%d bytes from %s: ", cc,
984263bc
MD
916 pr_addr(from->sin_addr));
917 pr_icmph(icp);
918 } else
919 return;
920 }
921
922 /* Display any IP options */
923 cp = (u_char *)buf + sizeof(struct ip);
924
925 for (; hlen > (int)sizeof(struct ip); --hlen, ++cp)
926 switch (*cp) {
927 case IPOPT_EOL:
928 hlen = 0;
929 break;
930 case IPOPT_LSRR:
7cee7052 931 printf("\nLSRR: ");
984263bc
MD
932 j = cp[IPOPT_OLEN] - IPOPT_MINOFF + 1;
933 hlen -= 2;
934 cp += 2;
935 if (j >= INADDR_LEN &&
936 j <= hlen - (int)sizeof(struct ip)) {
937 for (;;) {
938 bcopy(++cp, &ina.s_addr, INADDR_LEN);
939 if (ina.s_addr == 0)
7cee7052 940 printf("\t0.0.0.0");
984263bc 941 else
7cee7052 942 printf("\t%s", pr_addr(ina));
984263bc
MD
943 hlen -= INADDR_LEN;
944 cp += INADDR_LEN - 1;
945 j -= INADDR_LEN;
946 if (j < INADDR_LEN)
947 break;
7cee7052 948 putchar('\n');
984263bc
MD
949 }
950 } else
7cee7052 951 printf("\t(truncated route)\n");
984263bc
MD
952 break;
953 case IPOPT_RR:
954 j = cp[IPOPT_OLEN]; /* get length */
955 i = cp[IPOPT_OFFSET]; /* and pointer */
956 hlen -= 2;
957 cp += 2;
958 if (i > j)
959 i = j;
960 i = i - IPOPT_MINOFF + 1;
961 if (i < 0 || i > (hlen - (int)sizeof(struct ip))) {
962 old_rrlen = 0;
963 continue;
964 }
965 if (i == old_rrlen
966 && !bcmp((char *)cp, old_rr, i)
967 && !(options & F_FLOOD)) {
7cee7052 968 printf("\t(same route)");
984263bc
MD
969 hlen -= i;
970 cp += i;
971 break;
972 }
973 old_rrlen = i;
974 bcopy((char *)cp, old_rr, i);
975
7cee7052 976 printf("\nRR: ");
984263bc
MD
977
978 if (i >= INADDR_LEN &&
979 i <= hlen - (int)sizeof(struct ip)) {
980 for (;;) {
981 bcopy(++cp, &ina.s_addr, INADDR_LEN);
982 if (ina.s_addr == 0)
7cee7052 983 printf("\t0.0.0.0");
984263bc 984 else
7cee7052 985 printf("\t%s", pr_addr(ina));
984263bc
MD
986 hlen -= INADDR_LEN;
987 cp += INADDR_LEN - 1;
988 i -= INADDR_LEN;
989 if (i < INADDR_LEN)
990 break;
7cee7052 991 putchar('\n');
984263bc
MD
992 }
993 } else
7cee7052 994 printf("\t(truncated route)");
984263bc
MD
995 break;
996 case IPOPT_NOP:
7cee7052 997 printf("\nNOP");
984263bc
MD
998 break;
999 default:
7cee7052 1000 printf("\nunknown option %x", *cp);
984263bc
MD
1001 break;
1002 }
1003 if (!(options & F_FLOOD)) {
7cee7052
SW
1004 putchar('\n');
1005 fflush(stdout);
984263bc
MD
1006 }
1007}
1008
1009/*
1010 * in_cksum --
1011 * Checksum routine for Internet Protocol family headers (C Version)
1012 */
1013u_short
b5744197 1014in_cksum(u_short *addr, int len)
984263bc
MD
1015{
1016 int nleft, sum;
1017 u_short *w;
1018 union {
1019 u_short us;
1020 u_char uc[2];
1021 } last;
1022 u_short answer;
1023
1024 nleft = len;
1025 sum = 0;
1026 w = addr;
1027
1028 /*
1029 * Our algorithm is simple, using a 32 bit accumulator (sum), we add
1030 * sequential 16 bit words to it, and at the end, fold back all the
1031 * carry bits from the top 16 bits into the lower 16 bits.
1032 */
1033 while (nleft > 1) {
1034 sum += *w++;
1035 nleft -= 2;
1036 }
1037
1038 /* mop up an odd byte, if necessary */
1039 if (nleft == 1) {
1040 last.uc[0] = *(u_char *)w;
1041 last.uc[1] = 0;
1042 sum += last.us;
1043 }
1044
1045 /* add back carry outs from top 16 bits to low 16 bits */
1046 sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
1047 sum += (sum >> 16); /* add carry */
1048 answer = ~sum; /* truncate to 16 bits */
1049 return(answer);
1050}
1051
1052/*
1053 * tvsub --
1054 * Subtract 2 timeval structs: out = out - in. Out is assumed to
1055 * be >= in.
1056 */
1057static void
b5744197 1058tvsub(struct timeval *out, struct timeval *in)
984263bc
MD
1059{
1060
1061 if ((out->tv_usec -= in->tv_usec) < 0) {
1062 --out->tv_sec;
1063 out->tv_usec += 1000000;
1064 }
1065 out->tv_sec -= in->tv_sec;
1066}
1067
1068/*
1069 * status --
1070 * Print out statistics when SIGINFO is received.
1071 */
1072
1073static void
b5744197 1074status(int sig __unused)
984263bc
MD
1075{
1076
1077 siginfo_p = 1;
1078}
1079
1080static void
b5744197 1081check_status(void)
984263bc
MD
1082{
1083
1084 if (siginfo_p) {
1085 siginfo_p = 0;
7cee7052 1086 fprintf(stderr,
984263bc
MD
1087 "\r%ld/%ld packets received (%.0f%%) %.3f min / %.3f avg / %.3f max\n",
1088 nreceived, ntransmitted,
1089 ntransmitted ? nreceived * 100.0 / ntransmitted : 0.0,
1090 nreceived ? tmin : 0.0,
1091 nreceived + nrepeats ? tsum / (nreceived + nrepeats) : tsum,
1092 tmax);
1093 }
1094}
1095
1096/*
1097 * finish --
1098 * Print out statistics, and give up.
1099 */
1100static void
b5744197 1101finish(void)
984263bc
MD
1102{
1103
1104 struct termios ts;
1105
7cee7052
SW
1106 signal(SIGINT, SIG_IGN);
1107 signal(SIGALRM, SIG_IGN);
1108 putchar('\n');
1109 fflush(stdout);
1110 printf("--- %s ping statistics ---\n", hostname);
1111 printf("%ld packets transmitted, ", ntransmitted);
1112 printf("%ld packets received, ", nreceived);
984263bc 1113 if (nrepeats)
7cee7052 1114 printf("+%ld duplicates, ", nrepeats);
984263bc
MD
1115 if (ntransmitted) {
1116 if (nreceived > ntransmitted)
7cee7052 1117 printf("-- somebody's printing up packets!");
984263bc 1118 else
7cee7052 1119 printf("%d%% packet loss",
984263bc
MD
1120 (int)(((ntransmitted - nreceived) * 100) /
1121 ntransmitted));
1122 }
7cee7052 1123 putchar('\n');
984263bc
MD
1124 if (nreceived && timing) {
1125 double n = nreceived + nrepeats;
1126 double avg = tsum / n;
1127 double vari = tsumsq / n - avg * avg;
7cee7052 1128 printf(
984263bc
MD
1129 "round-trip min/avg/max/stddev = %.3f/%.3f/%.3f/%.3f ms\n",
1130 tmin, avg, tmax, sqrt(vari));
1131 }
1132 if (reset_kerninfo && tcgetattr(STDOUT_FILENO, &ts) != -1) {
1133 ts.c_lflag &= ~NOKERNINFO;
1134 tcsetattr(STDOUT_FILENO, TCSANOW, &ts);
1135 }
1136
1137 if (nreceived)
1138 exit(0);
1139 else
1140 exit(2);
1141}
1142
1143#ifdef notdef
1144static char *ttab[] = {
1145 "Echo Reply", /* ip + seq + udata */
1146 "Dest Unreachable", /* net, host, proto, port, frag, sr + IP */
1147 "Source Quench", /* IP */
1148 "Redirect", /* redirect type, gateway, + IP */
1149 "Echo",
1150 "Time Exceeded", /* transit, frag reassem + IP */
1151 "Parameter Problem", /* pointer + IP */
1152 "Timestamp", /* id + seq + three timestamps */
1153 "Timestamp Reply", /* " */
1154 "Info Request", /* id + sq */
1155 "Info Reply" /* " */
1156};
1157#endif
1158
1159/*
1160 * pr_icmph --
1161 * Print a descriptive string about an ICMP header.
1162 */
1163static void
b5744197 1164pr_icmph(struct icmp *icp)
984263bc
MD
1165{
1166
1167 switch(icp->icmp_type) {
1168 case ICMP_ECHOREPLY:
7cee7052 1169 printf("Echo Reply\n");
984263bc
MD
1170 /* XXX ID + Seq + Data */
1171 break;
1172 case ICMP_UNREACH:
1173 switch(icp->icmp_code) {
1174 case ICMP_UNREACH_NET:
7cee7052 1175 printf("Destination Net Unreachable\n");
984263bc
MD
1176 break;
1177 case ICMP_UNREACH_HOST:
7cee7052 1178 printf("Destination Host Unreachable\n");
984263bc
MD
1179 break;
1180 case ICMP_UNREACH_PROTOCOL:
7cee7052 1181 printf("Destination Protocol Unreachable\n");
984263bc
MD
1182 break;
1183 case ICMP_UNREACH_PORT:
7cee7052 1184 printf("Destination Port Unreachable\n");
984263bc
MD
1185 break;
1186 case ICMP_UNREACH_NEEDFRAG:
7cee7052 1187 printf("frag needed and DF set (MTU %d)\n",
984263bc
MD
1188 ntohs(icp->icmp_nextmtu));
1189 break;
1190 case ICMP_UNREACH_SRCFAIL:
7cee7052 1191 printf("Source Route Failed\n");
984263bc
MD
1192 break;
1193 case ICMP_UNREACH_FILTER_PROHIB:
7cee7052 1194 printf("Communication prohibited by filter\n");
984263bc
MD
1195 break;
1196 default:
7cee7052 1197 printf("Dest Unreachable, Bad Code: %d\n",
984263bc
MD
1198 icp->icmp_code);
1199 break;
1200 }
1201 /* Print returned IP header information */
1202#ifndef icmp_data
1203 pr_retip(&icp->icmp_ip);
1204#else
1205 pr_retip((struct ip *)icp->icmp_data);
1206#endif
1207 break;
1208 case ICMP_SOURCEQUENCH:
7cee7052 1209 printf("Source Quench\n");
984263bc
MD
1210#ifndef icmp_data
1211 pr_retip(&icp->icmp_ip);
1212#else
1213 pr_retip((struct ip *)icp->icmp_data);
1214#endif
1215 break;
1216 case ICMP_REDIRECT:
1217 switch(icp->icmp_code) {
1218 case ICMP_REDIRECT_NET:
7cee7052 1219 printf("Redirect Network");
984263bc
MD
1220 break;
1221 case ICMP_REDIRECT_HOST:
7cee7052 1222 printf("Redirect Host");
984263bc
MD
1223 break;
1224 case ICMP_REDIRECT_TOSNET:
7cee7052 1225 printf("Redirect Type of Service and Network");
984263bc
MD
1226 break;
1227 case ICMP_REDIRECT_TOSHOST:
7cee7052 1228 printf("Redirect Type of Service and Host");
984263bc
MD
1229 break;
1230 default:
7cee7052 1231 printf("Redirect, Bad Code: %d", icp->icmp_code);
984263bc
MD
1232 break;
1233 }
7cee7052 1234 printf("(New addr: %s)\n", inet_ntoa(icp->icmp_gwaddr));
984263bc
MD
1235#ifndef icmp_data
1236 pr_retip(&icp->icmp_ip);
1237#else
1238 pr_retip((struct ip *)icp->icmp_data);
1239#endif
1240 break;
1241 case ICMP_ECHO:
7cee7052 1242 printf("Echo Request\n");
984263bc
MD
1243 /* XXX ID + Seq + Data */
1244 break;
1245 case ICMP_TIMXCEED:
1246 switch(icp->icmp_code) {
1247 case ICMP_TIMXCEED_INTRANS:
7cee7052 1248 printf("Time to live exceeded\n");
984263bc
MD
1249 break;
1250 case ICMP_TIMXCEED_REASS:
7cee7052 1251 printf("Frag reassembly time exceeded\n");
984263bc
MD
1252 break;
1253 default:
7cee7052 1254 printf("Time exceeded, Bad Code: %d\n",
984263bc
MD
1255 icp->icmp_code);
1256 break;
1257 }
1258#ifndef icmp_data
1259 pr_retip(&icp->icmp_ip);
1260#else
1261 pr_retip((struct ip *)icp->icmp_data);
1262#endif
1263 break;
1264 case ICMP_PARAMPROB:
7cee7052 1265 printf("Parameter problem: pointer = 0x%02x\n",
984263bc
MD
1266 icp->icmp_hun.ih_pptr);
1267#ifndef icmp_data
1268 pr_retip(&icp->icmp_ip);
1269#else
1270 pr_retip((struct ip *)icp->icmp_data);
1271#endif
1272 break;
1273 case ICMP_TSTAMP:
7cee7052 1274 printf("Timestamp\n");
984263bc
MD
1275 /* XXX ID + Seq + 3 timestamps */
1276 break;
1277 case ICMP_TSTAMPREPLY:
7cee7052 1278 printf("Timestamp Reply\n");
984263bc
MD
1279 /* XXX ID + Seq + 3 timestamps */
1280 break;
1281 case ICMP_IREQ:
7cee7052 1282 printf("Information Request\n");
984263bc
MD
1283 /* XXX ID + Seq */
1284 break;
1285 case ICMP_IREQREPLY:
7cee7052 1286 printf("Information Reply\n");
984263bc
MD
1287 /* XXX ID + Seq */
1288 break;
1289 case ICMP_MASKREQ:
7cee7052 1290 printf("Address Mask Request\n");
984263bc
MD
1291 break;
1292 case ICMP_MASKREPLY:
7cee7052 1293 printf("Address Mask Reply\n");
984263bc
MD
1294 break;
1295 case ICMP_ROUTERADVERT:
7cee7052 1296 printf("Router Advertisement\n");
984263bc
MD
1297 break;
1298 case ICMP_ROUTERSOLICIT:
7cee7052 1299 printf("Router Solicitation\n");
984263bc
MD
1300 break;
1301 default:
7cee7052 1302 printf("Bad ICMP type: %d\n", icp->icmp_type);
984263bc
MD
1303 }
1304}
1305
1306/*
1307 * pr_iph --
1308 * Print an IP header with options.
1309 */
1310static void
b5744197 1311pr_iph(struct ip *ip)
984263bc
MD
1312{
1313 u_char *cp;
1314 int hlen;
1315
1316 hlen = ip->ip_hl << 2;
1317 cp = (u_char *)ip + 20; /* point to options */
1318
7cee7052
SW
1319 printf("Vr HL TOS Len ID Flg off TTL Pro cks Src Dst\n");
1320 printf(" %1x %1x %02x %04x %04x",
984263bc
MD
1321 ip->ip_v, ip->ip_hl, ip->ip_tos, ntohs(ip->ip_len),
1322 ntohs(ip->ip_id));
7cee7052 1323 printf(" %1lx %04lx",
984263bc
MD
1324 (u_long) (ntohl(ip->ip_off) & 0xe000) >> 13,
1325 (u_long) ntohl(ip->ip_off) & 0x1fff);
7cee7052
SW
1326 printf(" %02x %02x %04x", ip->ip_ttl, ip->ip_p, ntohs(ip->ip_sum));
1327 printf(" %s ", inet_ntoa(*(struct in_addr *)&ip->ip_src.s_addr));
1328 printf(" %s ", inet_ntoa(*(struct in_addr *)&ip->ip_dst.s_addr));
984263bc
MD
1329 /* dump any option bytes */
1330 while (hlen-- > 20) {
7cee7052 1331 printf("%02x", *cp++);
984263bc 1332 }
7cee7052 1333 putchar('\n');
984263bc
MD
1334}
1335
1336/*
1337 * pr_addr --
1338 * Return an ascii host address as a dotted quad and optionally with
1339 * a hostname.
1340 */
1341static char *
b5744197 1342pr_addr(struct in_addr ina)
984263bc
MD
1343{
1344 struct hostent *hp;
1345 static char buf[16 + 3 + MAXHOSTNAMELEN];
1346
1347 if ((options & F_NUMERIC) ||
1348 !(hp = gethostbyaddr((char *)&ina, 4, AF_INET)))
1349 return inet_ntoa(ina);
1350 else
7cee7052 1351 snprintf(buf, sizeof(buf), "%s (%s)", hp->h_name,
984263bc
MD
1352 inet_ntoa(ina));
1353 return(buf);
1354}
1355
1356/*
1357 * pr_retip --
1358 * Dump some info on a returned (via ICMP) IP packet.
1359 */
1360static void
b5744197 1361pr_retip(struct ip *ip)
984263bc
MD
1362{
1363 u_char *cp;
1364 int hlen;
1365
1366 pr_iph(ip);
1367 hlen = ip->ip_hl << 2;
1368 cp = (u_char *)ip + hlen;
1369
1370 if (ip->ip_p == 6)
7cee7052 1371 printf("TCP: from port %u, to port %u (decimal)\n",
984263bc
MD
1372 (*cp * 256 + *(cp + 1)), (*(cp + 2) * 256 + *(cp + 3)));
1373 else if (ip->ip_p == 17)
7cee7052 1374 printf("UDP: from port %u, to port %u (decimal)\n",
984263bc
MD
1375 (*cp * 256 + *(cp + 1)), (*(cp + 2) * 256 + *(cp + 3)));
1376}
1377
1378static void
b5744197 1379fill(char *bp, char *patp)
984263bc
MD
1380{
1381 char *cp;
1382 int pat[16];
1383 u_int ii, jj, kk;
1384
1385 for (cp = patp; *cp; cp++) {
1386 if (!isxdigit(*cp))
1387 errx(EX_USAGE,
1388 "patterns must be specified as hex digits");
1389
1390 }
1391 ii = sscanf(patp,
1392 "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
1393 &pat[0], &pat[1], &pat[2], &pat[3], &pat[4], &pat[5], &pat[6],
1394 &pat[7], &pat[8], &pat[9], &pat[10], &pat[11], &pat[12],
1395 &pat[13], &pat[14], &pat[15]);
1396
1397 if (ii > 0)
1398 for (kk = 0; kk <= MAXPAYLOAD - (PHDR_LEN + ii); kk += ii)
1399 for (jj = 0; jj < ii; ++jj)
1400 bp[jj + kk] = pat[jj];
1401 if (!(options & F_QUIET)) {
7cee7052 1402 printf("PATTERN: 0x");
984263bc 1403 for (jj = 0; jj < ii; ++jj)
7cee7052
SW
1404 printf("%02x", bp[jj] & 0xFF);
1405 printf("\n");
984263bc
MD
1406 }
1407}
1408
1409static void
b5744197 1410usage(void)
984263bc 1411{
7cee7052 1412 fprintf(stderr, "%s\n%s\n%s\n",
984263bc
MD
1413"usage: ping [-AQRadfnqrv] [-c count] [-i wait] [-l preload] [-m ttl]",
1414" [-p pattern] "
1415#ifdef IPSEC
1416#ifdef IPSEC_POLICY_IPSEC
1417"[-P policy] "
1418#endif
1419#endif
1420"[-s packetsize] [-S src_addr] [-t timeout]",
1421" [host | [-L] [-I iface] [-T ttl] mcast-group]");
1422 exit(EX_USAGE);
1423}