aboutsummaryrefslogtreecommitdiff
path: root/networking/traceroute.c
diff options
context:
space:
mode:
Diffstat (limited to 'networking/traceroute.c')
-rw-r--r--networking/traceroute.c1350
1 files changed, 1350 insertions, 0 deletions
diff --git a/networking/traceroute.c b/networking/traceroute.c
new file mode 100644
index 000000000..490076543
--- /dev/null
+++ b/networking/traceroute.c
@@ -0,0 +1,1350 @@
1/* vi: set sw=4 ts=4: */
2/*
3 * Copyright (c) 1988, 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999, 2000
4 * The Regents of the University of California. All rights reserved.
5 *
6 * Busybox port by Vladimir Oleynik (C) 2005 <dzo@simtreas.ru>
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that: (1) source code distributions
10 * retain the above copyright notice and this paragraph in its entirety, (2)
11 * distributions including binary code include the above copyright notice and
12 * this paragraph in its entirety in the documentation or other materials
13 * provided with the distribution, and (3) all advertising materials mentioning
14 * features or use of this software display the following acknowledgement:
15 * ``This product includes software developed by the University of California,
16 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
17 * the University nor the names of its contributors may be used to endorse
18 * or promote products derived from this software without specific prior
19 * written permission.
20 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
21 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
22 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
23 */
24
25//#define version "1.4a12"
26
27
28/*
29 * traceroute host - trace the route ip packets follow going to "host".
30 *
31 * Attempt to trace the route an ip packet would follow to some
32 * internet host. We find out intermediate hops by launching probe
33 * packets with a small ttl (time to live) then listening for an
34 * icmp "time exceeded" reply from a gateway. We start our probes
35 * with a ttl of one and increase by one until we get an icmp "port
36 * unreachable" (which means we got to "host") or hit a max (which
37 * defaults to 30 hops & can be changed with the -m flag). Three
38 * probes (change with -q flag) are sent at each ttl setting and a
39 * line is printed showing the ttl, address of the gateway and
40 * round trip time of each probe. If the probe answers come from
41 * different gateways, the address of each responding system will
42 * be printed. If there is no response within a 5 sec. timeout
43 * interval (changed with the -w flag), a "*" is printed for that
44 * probe.
45 *
46 * Probe packets are UDP format. We don't want the destination
47 * host to process them so the destination port is set to an
48 * unlikely value (if some clod on the destination is using that
49 * value, it can be changed with the -p flag).
50 *
51 * A sample use might be:
52 *
53 * [yak 71]% traceroute nis.nsf.net.
54 * traceroute to nis.nsf.net (35.1.1.48), 30 hops max, 56 byte packet
55 * 1 helios.ee.lbl.gov (128.3.112.1) 19 ms 19 ms 0 ms
56 * 2 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 39 ms 19 ms
57 * 3 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 39 ms 19 ms
58 * 4 ccngw-ner-cc.Berkeley.EDU (128.32.136.23) 39 ms 40 ms 39 ms
59 * 5 ccn-nerif22.Berkeley.EDU (128.32.168.22) 39 ms 39 ms 39 ms
60 * 6 128.32.197.4 (128.32.197.4) 40 ms 59 ms 59 ms
61 * 7 131.119.2.5 (131.119.2.5) 59 ms 59 ms 59 ms
62 * 8 129.140.70.13 (129.140.70.13) 99 ms 99 ms 80 ms
63 * 9 129.140.71.6 (129.140.71.6) 139 ms 239 ms 319 ms
64 * 10 129.140.81.7 (129.140.81.7) 220 ms 199 ms 199 ms
65 * 11 nic.merit.edu (35.1.1.48) 239 ms 239 ms 239 ms
66 *
67 * Note that lines 2 & 3 are the same. This is due to a buggy
68 * kernel on the 2nd hop system -- lbl-csam.arpa -- that forwards
69 * packets with a zero ttl.
70 *
71 * A more interesting example is:
72 *
73 * [yak 72]% traceroute allspice.lcs.mit.edu.
74 * traceroute to allspice.lcs.mit.edu (18.26.0.115), 30 hops max
75 * 1 helios.ee.lbl.gov (128.3.112.1) 0 ms 0 ms 0 ms
76 * 2 lilac-dmc.Berkeley.EDU (128.32.216.1) 19 ms 19 ms 19 ms
77 * 3 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 19 ms 19 ms
78 * 4 ccngw-ner-cc.Berkeley.EDU (128.32.136.23) 19 ms 39 ms 39 ms
79 * 5 ccn-nerif22.Berkeley.EDU (128.32.168.22) 20 ms 39 ms 39 ms
80 * 6 128.32.197.4 (128.32.197.4) 59 ms 119 ms 39 ms
81 * 7 131.119.2.5 (131.119.2.5) 59 ms 59 ms 39 ms
82 * 8 129.140.70.13 (129.140.70.13) 80 ms 79 ms 99 ms
83 * 9 129.140.71.6 (129.140.71.6) 139 ms 139 ms 159 ms
84 * 10 129.140.81.7 (129.140.81.7) 199 ms 180 ms 300 ms
85 * 11 129.140.72.17 (129.140.72.17) 300 ms 239 ms 239 ms
86 * 12 * * *
87 * 13 128.121.54.72 (128.121.54.72) 259 ms 499 ms 279 ms
88 * 14 * * *
89 * 15 * * *
90 * 16 * * *
91 * 17 * * *
92 * 18 ALLSPICE.LCS.MIT.EDU (18.26.0.115) 339 ms 279 ms 279 ms
93 *
94 * (I start to see why I'm having so much trouble with mail to
95 * MIT.) Note that the gateways 12, 14, 15, 16 & 17 hops away
96 * either don't send ICMP "time exceeded" messages or send them
97 * with a ttl too small to reach us. 14 - 17 are running the
98 * MIT C Gateway code that doesn't send "time exceeded"s. God
99 * only knows what's going on with 12.
100 *
101 * The silent gateway 12 in the above may be the result of a bug in
102 * the 4.[23]BSD network code (and its derivatives): 4.x (x <= 3)
103 * sends an unreachable message using whatever ttl remains in the
104 * original datagram. Since, for gateways, the remaining ttl is
105 * zero, the icmp "time exceeded" is guaranteed to not make it back
106 * to us. The behavior of this bug is slightly more interesting
107 * when it appears on the destination system:
108 *
109 * 1 helios.ee.lbl.gov (128.3.112.1) 0 ms 0 ms 0 ms
110 * 2 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 19 ms 39 ms
111 * 3 lilac-dmc.Berkeley.EDU (128.32.216.1) 19 ms 39 ms 19 ms
112 * 4 ccngw-ner-cc.Berkeley.EDU (128.32.136.23) 39 ms 40 ms 19 ms
113 * 5 ccn-nerif35.Berkeley.EDU (128.32.168.35) 39 ms 39 ms 39 ms
114 * 6 csgw.Berkeley.EDU (128.32.133.254) 39 ms 59 ms 39 ms
115 * 7 * * *
116 * 8 * * *
117 * 9 * * *
118 * 10 * * *
119 * 11 * * *
120 * 12 * * *
121 * 13 rip.Berkeley.EDU (128.32.131.22) 59 ms ! 39 ms ! 39 ms !
122 *
123 * Notice that there are 12 "gateways" (13 is the final
124 * destination) and exactly the last half of them are "missing".
125 * What's really happening is that rip (a Sun-3 running Sun OS3.5)
126 * is using the ttl from our arriving datagram as the ttl in its
127 * icmp reply. So, the reply will time out on the return path
128 * (with no notice sent to anyone since icmp's aren't sent for
129 * icmp's) until we probe with a ttl that's at least twice the path
130 * length. I.e., rip is really only 7 hops away. A reply that
131 * returns with a ttl of 1 is a clue this problem exists.
132 * Traceroute prints a "!" after the time if the ttl is <= 1.
133 * Since vendors ship a lot of obsolete (DEC's Ultrix, Sun 3.x) or
134 * non-standard (HPUX) software, expect to see this problem
135 * frequently and/or take care picking the target host of your
136 * probes.
137 *
138 * Other possible annotations after the time are !H, !N, !P (got a host,
139 * network or protocol unreachable, respectively), !S or !F (source
140 * route failed or fragmentation needed -- neither of these should
141 * ever occur and the associated gateway is busted if you see one). If
142 * almost all the probes result in some kind of unreachable, traceroute
143 * will give up and exit.
144 *
145 * Notes
146 * -----
147 * This program must be run by root or be setuid. (I suggest that
148 * you *don't* make it setuid -- casual use could result in a lot
149 * of unnecessary traffic on our poor, congested nets.)
150 *
151 * This program requires a kernel mod that does not appear in any
152 * system available from Berkeley: A raw ip socket using proto
153 * IPPROTO_RAW must interpret the data sent as an ip datagram (as
154 * opposed to data to be wrapped in a ip datagram). See the README
155 * file that came with the source to this program for a description
156 * of the mods I made to /sys/netinet/raw_ip.c. Your mileage may
157 * vary. But, again, ANY 4.x (x < 4) BSD KERNEL WILL HAVE TO BE
158 * MODIFIED TO RUN THIS PROGRAM.
159 *
160 * The udp port usage may appear bizarre (well, ok, it is bizarre).
161 * The problem is that an icmp message only contains 8 bytes of
162 * data from the original datagram. 8 bytes is the size of a udp
163 * header so, if we want to associate replies with the original
164 * datagram, the necessary information must be encoded into the
165 * udp header (the ip id could be used but there's no way to
166 * interlock with the kernel's assignment of ip id's and, anyway,
167 * it would have taken a lot more kernel hacking to allow this
168 * code to set the ip id). So, to allow two or more users to
169 * use traceroute simultaneously, we use this task's pid as the
170 * source port (the high bit is set to move the port number out
171 * of the "likely" range). To keep track of which probe is being
172 * replied to (so times and/or hop counts don't get confused by a
173 * reply that was delayed in transit), we increment the destination
174 * port number before each probe.
175 *
176 * Don't use this as a coding example. I was trying to find a
177 * routing problem and this code sort-of popped out after 48 hours
178 * without sleep. I was amazed it ever compiled, much less ran.
179 *
180 * I stole the idea for this program from Steve Deering. Since
181 * the first release, I've learned that had I attended the right
182 * IETF working group meetings, I also could have stolen it from Guy
183 * Almes or Matt Mathis. I don't know (or care) who came up with
184 * the idea first. I envy the originators' perspicacity and I'm
185 * glad they didn't keep the idea a secret.
186 *
187 * Tim Seaver, Ken Adelman and C. Philip Wood provided bug fixes and/or
188 * enhancements to the original distribution.
189 *
190 * I've hacked up a round-trip-route version of this that works by
191 * sending a loose-source-routed udp datagram through the destination
192 * back to yourself. Unfortunately, SO many gateways botch source
193 * routing, the thing is almost worthless. Maybe one day...
194 *
195 * -- Van Jacobson (van@ee.lbl.gov)
196 * Tue Dec 20 03:50:13 PST 1988
197 */
198
199#define TRACEROUTE_SO_DEBUG 0
200
201/* TODO: undefs were uncommented - ??! we have config system for that! */
202/* probably ok to remove altogether */
203//#undef CONFIG_FEATURE_TRACEROUTE_VERBOSE
204//#define CONFIG_FEATURE_TRACEROUTE_VERBOSE
205//#undef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
206//#define CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
207//#undef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
208//#define CONFIG_FEATURE_TRACEROUTE_USE_ICMP
209
210#include "inet_common.h"
211
212#include <net/if.h>
213#include <arpa/inet.h>
214#include <netinet/in.h>
215#include <netinet/udp.h>
216#include <netinet/ip.h>
217#include <netinet/ip_icmp.h>
218
219#include "busybox.h"
220
221
222/*
223 * Definitions for internet protocol version 4.
224 * Per RFC 791, September 1981.
225 */
226#define IPVERSION 4
227
228#ifndef IPPROTO_ICMP
229/* Grrrr.... */
230#define IPPROTO_ICMP 1
231#endif
232#ifndef IPPROTO_IP
233#define IPPROTO_IP 0
234#endif
235
236/*
237 * Overlay for ip header used by other protocols (tcp, udp).
238 */
239struct ipovly {
240 unsigned char ih_x1[9]; /* (unused) */
241 unsigned char ih_pr; /* protocol */
242 short ih_len; /* protocol length */
243 struct in_addr ih_src; /* source internet address */
244 struct in_addr ih_dst; /* destination internet address */
245};
246
247/*
248 * UDP kernel structures and variables.
249 */
250struct udpiphdr {
251 struct ipovly ui_i; /* overlaid ip structure */
252 struct udphdr ui_u; /* udp header */
253};
254#define ui_next ui_i.ih_next
255#define ui_prev ui_i.ih_prev
256#define ui_x1 ui_i.ih_x1
257#define ui_pr ui_i.ih_pr
258#define ui_len ui_i.ih_len
259#define ui_src ui_i.ih_src
260#define ui_dst ui_i.ih_dst
261#define ui_sport ui_u.uh_sport
262#define ui_dport ui_u.uh_dport
263#define ui_ulen ui_u.uh_ulen
264#define ui_sum ui_u.uh_sum
265
266
267/* Host name and address list */
268struct hostinfo {
269 char *name;
270 int n;
271 u_int32_t *addrs;
272};
273
274/* Data section of the probe packet */
275struct outdata {
276 unsigned char seq; /* sequence number of this packet */
277 unsigned char ttl; /* ttl packet left with */
278 struct timeval tv ATTRIBUTE_PACKED; /* time packet left */
279};
280
281struct IFADDRLIST {
282 u_int32_t addr;
283 char device[sizeof(struct ifreq)];
284};
285
286
287static const char route[] = "/proc/net/route";
288
289/* last inbound (icmp) packet */
290static unsigned char packet[512] ATTRIBUTE_ALIGNED(32);
291
292static struct ip *outip; /* last output (udp) packet */
293static struct udphdr *outudp; /* last output (udp) packet */
294static struct outdata *outdata; /* last output (udp) packet */
295
296#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
297static struct icmp *outicmp; /* last output (icmp) packet */
298#endif
299
300#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
301/* Maximum number of gateways (include room for one noop) */
302#define NGATEWAYS ((int)((MAX_IPOPTLEN - IPOPT_MINOFF - 1) / sizeof(u_int32_t)))
303/* loose source route gateway list (including room for final destination) */
304static u_int32_t gwlist[NGATEWAYS + 1];
305#endif
306
307static int s; /* receive (icmp) socket file descriptor */
308static int sndsock; /* send (udp/icmp) socket file descriptor */
309
310static struct sockaddr_storage whereto; /* Who to try to reach */
311static struct sockaddr_storage wherefrom; /* Who we are */
312static int packlen; /* total length of packet */
313static int minpacket; /* min ip packet size */
314static int maxpacket = 32 * 1024; /* max ip packet size */
315static int pmtu; /* Path MTU Discovery (RFC1191) */
316
317static char *hostname;
318
319static u_short ident;
320static u_short port = 32768 + 666; /* start udp dest port # for probe packets */
321
322static int waittime = 5; /* time to wait for response (in seconds) */
323static int nflag; /* print addresses numerically */
324static int doipcksum = 1; /* calculate ip checksums by default */
325
326#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
327static int optlen; /* length of ip options */
328#else
329#define optlen 0
330#endif
331
332#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
333static int useicmp; /* use icmp echo instead of udp packets */
334#endif
335#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
336static int verbose;
337#endif
338
339/*
340 * Return the interface list
341 */
342static int
343ifaddrlist(struct IFADDRLIST **ipaddrp)
344{
345 int fd, nipaddr;
346#ifdef HAVE_SOCKADDR_SA_LEN
347 int n;
348#endif
349 struct ifreq *ifrp, *ifend, *ifnext;
350 struct sockaddr_in *addr_sin;
351 struct IFADDRLIST *al;
352 struct ifconf ifc;
353 struct ifreq ibuf[(32 * 1024) / sizeof(struct ifreq)], ifr;
354 struct IFADDRLIST *st_ifaddrlist;
355
356 fd = xsocket(AF_INET, SOCK_DGRAM, 0);
357
358 ifc.ifc_len = sizeof(ibuf);
359 ifc.ifc_buf = (caddr_t)ibuf;
360
361 if (ioctl(fd, SIOCGIFCONF, (char *)&ifc) < 0 ||
362 ifc.ifc_len < sizeof(struct ifreq)) {
363 if (errno == EINVAL)
364 bb_error_msg_and_die(
365 "SIOCGIFCONF: ifreq struct too small (%d bytes)",
366 (int)sizeof(ibuf));
367 else
368 bb_perror_msg_and_die("SIOCGIFCONF");
369 }
370 ifrp = ibuf;
371 ifend = (struct ifreq *)((char *)ibuf + ifc.ifc_len);
372
373 nipaddr = 1 + (ifc.ifc_len / sizeof(struct ifreq));
374 st_ifaddrlist = xzalloc(nipaddr * sizeof(struct IFADDRLIST));
375 al = st_ifaddrlist;
376 nipaddr = 0;
377
378 for (; ifrp < ifend; ifrp = ifnext) {
379#ifdef HAVE_SOCKADDR_SA_LEN
380 n = ifrp->ifr_addr.sa_len + sizeof(ifrp->ifr_name);
381 if (n < sizeof(*ifrp))
382 ifnext = ifrp + 1;
383 else
384 ifnext = (struct ifreq *)((char *)ifrp + n);
385 if (ifrp->ifr_addr.sa_family != AF_INET)
386 continue;
387#else
388 ifnext = ifrp + 1;
389#endif
390 /*
391 * Need a template to preserve address info that is
392 * used below to locate the next entry. (Otherwise,
393 * SIOCGIFFLAGS stomps over it because the requests
394 * are returned in a union.)
395 */
396 strncpy(ifr.ifr_name, ifrp->ifr_name, sizeof(ifr.ifr_name));
397 if (ioctl(fd, SIOCGIFFLAGS, (char *)&ifr) < 0) {
398 if (errno == ENXIO)
399 continue;
400 bb_perror_msg_and_die("SIOCGIFFLAGS: %.*s",
401 (int)sizeof(ifr.ifr_name), ifr.ifr_name);
402 }
403
404 /* Must be up */
405 if ((ifr.ifr_flags & IFF_UP) == 0)
406 continue;
407
408 safe_strncpy(al->device, ifr.ifr_name, sizeof(ifr.ifr_name) + 1);
409#ifdef sun
410 /* Ignore sun virtual interfaces */
411 if (strchr(al->device, ':') != NULL)
412 continue;
413#endif
414 if (ioctl(fd, SIOCGIFADDR, (char *)&ifr) < 0)
415 bb_perror_msg_and_die("SIOCGIFADDR: %s", al->device);
416
417 addr_sin = (struct sockaddr_in *)&ifr.ifr_addr;
418 al->addr = addr_sin->sin_addr.s_addr;
419 ++al;
420 ++nipaddr;
421 }
422 if (nipaddr == 0)
423 bb_error_msg_and_die ("can't find any network interfaces");
424 (void)close(fd);
425
426 *ipaddrp = st_ifaddrlist;
427 return nipaddr;
428}
429
430
431static void
432setsin(struct sockaddr_in *addr_sin, u_int32_t addr)
433{
434 memset(addr_sin, 0, sizeof(*addr_sin));
435#ifdef HAVE_SOCKADDR_SA_LEN
436 addr_sin->sin_len = sizeof(*addr_sin);
437#endif
438 addr_sin->sin_family = AF_INET;
439 addr_sin->sin_addr.s_addr = addr;
440}
441
442
443/*
444 * Return the source address for the given destination address
445 */
446static void
447findsaddr(const struct sockaddr_in *to, struct sockaddr_in *from)
448{
449 int i, n;
450 FILE *f;
451 u_int32_t mask;
452 u_int32_t dest, tmask;
453 struct IFADDRLIST *al;
454 char buf[256], tdevice[256], device[256];
455
456 f = xfopen(route, "r");
457
458 /* Find the appropriate interface */
459 n = 0;
460 mask = 0;
461 device[0] = '\0';
462 while (fgets(buf, sizeof(buf), f) != NULL) {
463 ++n;
464 if (n == 1 && strncmp(buf, "Iface", 5) == 0)
465 continue;
466 if ((i = sscanf(buf, "%255s %x %*s %*s %*s %*s %*s %x",
467 tdevice, &dest, &tmask)) != 3)
468 bb_error_msg_and_die ("junk in buffer");
469 if ((to->sin_addr.s_addr & tmask) == dest &&
470 (tmask > mask || mask == 0)) {
471 mask = tmask;
472 strcpy(device, tdevice);
473 }
474 }
475 fclose(f);
476
477 if (device[0] == '\0')
478 bb_error_msg_and_die ("can't find interface");
479
480 /* Get the interface address list */
481 n = ifaddrlist(&al);
482
483 /* Find our appropriate source address */
484 for (i = n; i > 0; --i, ++al)
485 if (strcmp(device, al->device) == 0)
486 break;
487 if (i <= 0)
488 bb_error_msg_and_die("can't find interface %s", device);
489
490 setsin(from, al->addr);
491}
492
493/*
494"Usage: %s [-dFIlnrvx] [-g gateway] [-i iface] [-f first_ttl]\n"
495"\t[-m max_ttl] [ -p port] [-q nqueries] [-s src_addr] [-t tos]\n"
496"\t[-w waittime] [-z pausemsecs] host [packetlen]"
497
498*/
499
500/*
501 * Subtract 2 timeval structs: out = out - in.
502 * Out is assumed to be >= in.
503 */
504static inline void
505tvsub(struct timeval *out, struct timeval *in)
506{
507
508 if ((out->tv_usec -= in->tv_usec) < 0) {
509 --out->tv_sec;
510 out->tv_usec += 1000000;
511 }
512 out->tv_sec -= in->tv_sec;
513}
514
515static int
516wait_for_reply(int sock, struct sockaddr_in *fromp, const struct timeval *tp)
517{
518 fd_set fds;
519 struct timeval now, tvwait;
520 struct timezone tz;
521 int cc = 0;
522 socklen_t fromlen = sizeof(*fromp);
523
524 FD_ZERO(&fds);
525 FD_SET(sock, &fds);
526
527 tvwait.tv_sec = tp->tv_sec + waittime;
528 tvwait.tv_usec = tp->tv_usec;
529 (void)gettimeofday(&now, &tz);
530 tvsub(&tvwait, &now);
531
532 if (select(sock + 1, &fds, NULL, NULL, &tvwait) > 0)
533 cc = recvfrom(sock, (char *)packet, sizeof(packet), 0,
534 (struct sockaddr *)fromp, &fromlen);
535
536 return cc;
537}
538
539/*
540 * Checksum routine for Internet Protocol family headers (C Version)
541 */
542static u_short
543in_cksum(u_short *addr, int len)
544{
545 int nleft = len;
546 u_short *w = addr;
547 u_short answer;
548 int sum = 0;
549
550 /*
551 * Our algorithm is simple, using a 32 bit accumulator (sum),
552 * we add sequential 16 bit words to it, and at the end, fold
553 * back all the carry bits from the top 16 bits into the lower
554 * 16 bits.
555 */
556 while (nleft > 1) {
557 sum += *w++;
558 nleft -= 2;
559 }
560
561 /* mop up an odd byte, if necessary */
562 if (nleft == 1)
563 sum += *(unsigned char *)w;
564
565 /*
566 * add back carry outs from top 16 bits to low 16 bits
567 */
568 sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
569 sum += (sum >> 16); /* add carry */
570 answer = ~sum; /* truncate to 16 bits */
571 return answer;
572}
573
574
575static void
576send_probe(int seq, int ttl, struct timeval *tp)
577{
578 int cc;
579 struct udpiphdr *ui, *oui;
580 struct ip tip;
581
582 outip->ip_ttl = ttl;
583 outip->ip_id = htons(ident + seq);
584
585 /*
586 * In most cases, the kernel will recalculate the ip checksum.
587 * But we must do it anyway so that the udp checksum comes out
588 * right.
589 */
590 if (doipcksum) {
591 outip->ip_sum =
592 in_cksum((u_short *)outip, sizeof(*outip) + optlen);
593 if (outip->ip_sum == 0)
594 outip->ip_sum = 0xffff;
595 }
596
597 /* Payload */
598 outdata->seq = seq;
599 outdata->ttl = ttl;
600 memcpy(&outdata->tv, tp, sizeof(outdata->tv));
601
602#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
603 if (useicmp)
604 outicmp->icmp_seq = htons(seq);
605 else
606#endif
607 outudp->dest = htons(port + seq);
608
609#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
610 if (useicmp) {
611 /* Always calculate checksum for icmp packets */
612 outicmp->icmp_cksum = 0;
613 outicmp->icmp_cksum = in_cksum((u_short *)outicmp,
614 packlen - (sizeof(*outip) + optlen));
615 if (outicmp->icmp_cksum == 0)
616 outicmp->icmp_cksum = 0xffff;
617 } else
618#endif
619 if (doipcksum) {
620 /* Checksum (we must save and restore ip header) */
621 tip = *outip;
622 ui = (struct udpiphdr *)outip;
623 oui = (struct udpiphdr *)&tip;
624 /* Easier to zero and put back things that are ok */
625 memset((char *)ui, 0, sizeof(ui->ui_i));
626 ui->ui_src = oui->ui_src;
627 ui->ui_dst = oui->ui_dst;
628 ui->ui_pr = oui->ui_pr;
629 ui->ui_len = outudp->len;
630 outudp->check = 0;
631 outudp->check = in_cksum((u_short *)ui, packlen);
632 if (outudp->check == 0)
633 outudp->check = 0xffff;
634 *outip = tip;
635 }
636
637#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
638 /* XXX undocumented debugging hack */
639 if (verbose > 1) {
640 const u_short *sp;
641 int nshorts, i;
642
643 sp = (u_short *)outip;
644 nshorts = (u_int)packlen / sizeof(u_short);
645 i = 0;
646 printf("[ %d bytes", packlen);
647 while (--nshorts >= 0) {
648 if ((i++ % 8) == 0)
649 printf("\n\t");
650 printf(" %04x", ntohs(*sp));
651 sp++;
652 }
653 if (packlen & 1) {
654 if ((i % 8) == 0)
655 printf("\n\t");
656 printf(" %02x", *(unsigned char *)sp);
657 }
658 printf("]\n");
659 }
660#endif
661
662#if !defined(IP_HDRINCL) && defined(IP_TTL)
663 if (setsockopt(sndsock, IPPROTO_IP, IP_TTL,
664 (char *)&ttl, sizeof(ttl)) < 0) {
665 bb_perror_msg_and_die("setsockopt ttl %d", ttl);
666 }
667#endif
668
669 cc = sendto(sndsock, (char *)outip,
670 packlen, 0, (struct sockaddr *)&whereto, sizeof(whereto));
671 if (cc < 0 || cc != packlen) {
672 if (cc < 0)
673 bb_perror_msg_and_die("sendto");
674 printf("%s: wrote %s %d chars, ret=%d\n",
675 applet_name, hostname, packlen, cc);
676 (void)fflush(stdout);
677 }
678}
679
680static inline double
681deltaT(struct timeval *t1p, struct timeval *t2p)
682{
683 double dt;
684
685 dt = (double)(t2p->tv_sec - t1p->tv_sec) * 1000.0 +
686 (double)(t2p->tv_usec - t1p->tv_usec) / 1000.0;
687 return dt;
688}
689
690#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
691/*
692 * Convert an ICMP "type" field to a printable string.
693 */
694static inline const char *
695pr_type(unsigned char t)
696{
697 static const char * const ttab[] = {
698 "Echo Reply", "ICMP 1", "ICMP 2", "Dest Unreachable",
699 "Source Quench", "Redirect", "ICMP 6", "ICMP 7",
700 "Echo", "Router Advert", "Router Solicit", "Time Exceeded",
701 "Param Problem", "Timestamp", "Timestamp Reply", "Info Request",
702 "Info Reply", "Mask Request", "Mask Reply"
703 };
704
705 if (t > 18)
706 return "OUT-OF-RANGE";
707
708 return ttab[t];
709}
710#endif
711
712static int
713packet_ok(unsigned char *buf, int cc, struct sockaddr_in *from, int seq)
714{
715 struct icmp *icp;
716 unsigned char type, code;
717 int hlen;
718 struct ip *ip;
719
720 ip = (struct ip *) buf;
721 hlen = ip->ip_hl << 2;
722 if (cc < hlen + ICMP_MINLEN) {
723#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
724 if (verbose)
725 printf("packet too short (%d bytes) from %s\n", cc,
726 inet_ntoa(from->sin_addr));
727#endif
728 return 0;
729 }
730 cc -= hlen;
731 icp = (struct icmp *)(buf + hlen);
732 type = icp->icmp_type;
733 code = icp->icmp_code;
734 /* Path MTU Discovery (RFC1191) */
735 if (code != ICMP_UNREACH_NEEDFRAG)
736 pmtu = 0;
737 else {
738 pmtu = ntohs(icp->icmp_nextmtu);
739 }
740 if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS) ||
741 type == ICMP_UNREACH || type == ICMP_ECHOREPLY) {
742 struct ip *hip;
743 struct udphdr *up;
744
745 hip = &icp->icmp_ip;
746 hlen = hip->ip_hl << 2;
747#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
748 if (useicmp) {
749 struct icmp *hicmp;
750
751 /* XXX */
752 if (type == ICMP_ECHOREPLY &&
753 icp->icmp_id == htons(ident) &&
754 icp->icmp_seq == htons(seq))
755 return -2;
756
757 hicmp = (struct icmp *)((unsigned char *)hip + hlen);
758 /* XXX 8 is a magic number */
759 if (hlen + 8 <= cc &&
760 hip->ip_p == IPPROTO_ICMP &&
761 hicmp->icmp_id == htons(ident) &&
762 hicmp->icmp_seq == htons(seq))
763 return (type == ICMP_TIMXCEED ? -1 : code + 1);
764 } else
765#endif
766 {
767 up = (struct udphdr *)((unsigned char *)hip + hlen);
768 /* XXX 8 is a magic number */
769 if (hlen + 12 <= cc &&
770 hip->ip_p == IPPROTO_UDP &&
771 up->source == htons(ident) &&
772 up->dest == htons(port + seq))
773 return (type == ICMP_TIMXCEED ? -1 : code + 1);
774 }
775 }
776#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
777 if (verbose) {
778 int i;
779 u_int32_t *lp = (u_int32_t *)&icp->icmp_ip;
780
781 printf("\n%d bytes from %s to "
782 "%s: icmp type %d (%s) code %d\n",
783 cc, inet_ntoa(from->sin_addr),
784 inet_ntoa(ip->ip_dst), type, pr_type(type), icp->icmp_code);
785 for (i = 4; i < cc ; i += sizeof(*lp))
786 printf("%2d: x%8.8x\n", i, *lp++);
787 }
788#endif
789 return 0;
790}
791
792
793/*
794 * Construct an Internet address representation.
795 * If the nflag has been supplied, give
796 * numeric value, otherwise try for symbolic name.
797 */
798static inline void
799inetname(struct sockaddr_in *from)
800{
801 const char *n = NULL;
802 const char *ina;
803 char name[257];
804
805 if (!nflag && from->sin_addr.s_addr != INADDR_ANY) {
806 if (INET_rresolve(name, sizeof(name), from, 0x4000, 0xffffffff) >= 0)
807 n = name;
808 }
809 ina = inet_ntoa(from->sin_addr);
810 if (nflag)
811 printf(" %s", ina);
812 else
813 printf(" %s (%s)", (n ? n : ina), ina);
814}
815
816static inline void
817print(unsigned char *buf, int cc, struct sockaddr_in *from)
818{
819 struct ip *ip;
820 int hlen;
821
822 ip = (struct ip *) buf;
823 hlen = ip->ip_hl << 2;
824 cc -= hlen;
825
826 inetname(from);
827#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
828 if (verbose)
829 printf(" %d bytes to %s", cc, inet_ntoa (ip->ip_dst));
830#endif
831}
832
833
834static struct hostinfo *
835gethostinfo(const char *host)
836{
837 int n;
838 struct hostent *hp;
839 struct hostinfo *hi;
840 char **p;
841 u_int32_t addr, *ap;
842
843 hi = xzalloc(sizeof(*hi));
844 addr = inet_addr(host);
845 if ((int32_t)addr != -1) {
846 hi->name = xstrdup(host);
847 hi->n = 1;
848 hi->addrs = xzalloc(sizeof(hi->addrs[0]));
849 hi->addrs[0] = addr;
850 return hi;
851 }
852
853 hp = xgethostbyname(host);
854 if (hp->h_addrtype != AF_INET || hp->h_length != 4)
855 bb_perror_msg_and_die("bad host %s", host);
856 hi->name = xstrdup(hp->h_name);
857 for (n = 0, p = hp->h_addr_list; *p != NULL; ++n, ++p)
858 continue;
859 hi->n = n;
860 hi->addrs = xzalloc(n * sizeof(hi->addrs[0]));
861 for (ap = hi->addrs, p = hp->h_addr_list; *p != NULL; ++ap, ++p)
862 memcpy(ap, *p, sizeof(*ap));
863 return hi;
864}
865
866static void
867freehostinfo(struct hostinfo *hi)
868{
869 free(hi->name);
870 hi->name = NULL;
871 free((char *)hi->addrs);
872 free((char *)hi);
873}
874
875#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
876static void
877getaddr(u_int32_t *ap, const char *host)
878{
879 struct hostinfo *hi;
880
881 hi = gethostinfo(host);
882 *ap = hi->addrs[0];
883 freehostinfo(hi);
884}
885#endif
886
887
888int
889traceroute_main(int argc, char *argv[])
890{
891 static const int on = 1;
892
893 int code, n;
894 unsigned char *outp;
895 u_int32_t *ap;
896 struct sockaddr_in *from = (struct sockaddr_in *)&wherefrom;
897 struct sockaddr_in *to = (struct sockaddr_in *)&whereto;
898 struct hostinfo *hi;
899 int ttl, probe, i;
900 int seq = 0;
901 int tos = 0;
902 char *tos_str = NULL;
903 char *source = NULL;
904 unsigned long op;
905
906#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
907 int lsrr = 0;
908#endif
909 u_short off = 0;
910 struct IFADDRLIST *al;
911 char *device = NULL;
912 int max_ttl = 30;
913 char *max_ttl_str = NULL;
914 char *port_str = NULL;
915 int nprobes = 3;
916 char *nprobes_str = NULL;
917 char *waittime_str = NULL;
918 u_int pausemsecs = 0;
919 char *pausemsecs_str = NULL;
920 int first_ttl = 1;
921 char *first_ttl_str = NULL;
922#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
923 llist_t *sourse_route_list = NULL;
924#endif
925
926 opterr = 0;
927#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
928 opt_complementary = "x-x:g::";
929#else
930 opt_complementary = "x-x";
931#endif
932
933 op = getopt32(argc, argv, "FIlnrdvxt:i:m:p:q:s:w:z:f:"
934#define USAGE_OP_DONT_FRAGMNT (1<<0) /* F */
935#define USAGE_OP_USE_ICMP (1<<1) /* I */
936#define USAGE_OP_TTL_FLAG (1<<2) /* l */
937#define USAGE_OP_ADDR_NUM (1<<3) /* n */
938#define USAGE_OP_BYPASS_ROUTE (1<<4) /* r */
939#define USAGE_OP_DEBUG (1<<5) /* d */
940#define USAGE_OP_VERBOSE (1<<6) /* v */
941#define USAGE_OP_IP_CHKSUM (1<<7) /* x */
942
943#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
944 "g:"
945#endif
946 , &tos_str, &device, &max_ttl_str, &port_str, &nprobes_str,
947 &source, &waittime_str, &pausemsecs_str, &first_ttl_str
948#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
949 , &sourse_route_list
950#endif
951 );
952
953 if (op & USAGE_OP_DONT_FRAGMNT)
954 off = IP_DF;
955#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
956 useicmp = op & USAGE_OP_USE_ICMP;
957#endif
958 nflag = op & USAGE_OP_ADDR_NUM;
959#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
960 verbose = op & USAGE_OP_VERBOSE;
961#endif
962 if (op & USAGE_OP_IP_CHKSUM) {
963 doipcksum = 0;
964 bb_error_msg("warning: ip checksums disabled");
965 }
966 if (tos_str)
967 tos = xatoul_range(tos_str, 0, 255);
968 if (max_ttl_str)
969 max_ttl = xatoul_range(max_ttl_str, 1, 255);
970 if (port_str)
971 port = xatou16(port_str);
972 if (nprobes_str)
973 nprobes = xatoul_range(nprobes_str, 1, INT_MAX);
974 if (source) {
975 /*
976 * set the ip source address of the outbound
977 * probe (e.g., on a multi-homed host).
978 */
979 if (getuid()) bb_error_msg_and_die("-s %s: permission denied", source);
980 }
981 if (waittime_str)
982 waittime = xatoul_range(waittime_str, 2, 24 * 60 * 60);
983 if (pausemsecs_str)
984 pausemsecs = xatoul_range(pausemsecs_str, 0, 60 * 60 * 1000);
985 if (first_ttl_str)
986 first_ttl = xatoul_range(first_ttl_str, 1, 255);
987
988#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
989 if (sourse_route_list) {
990 llist_t *l_sr;
991
992 for(l_sr = sourse_route_list; l_sr; ) {
993 if (lsrr >= NGATEWAYS)
994 bb_error_msg_and_die("no more than %d gateways", NGATEWAYS);
995 getaddr(gwlist + lsrr, l_sr->data);
996 ++lsrr;
997 l_sr = l_sr->link;
998 free(sourse_route_list);
999 sourse_route_list = l_sr;
1000 }
1001 optlen = (lsrr + 1) * sizeof(gwlist[0]);
1002 }
1003#endif
1004
1005 if (first_ttl > max_ttl) {
1006 bb_error_msg_and_die(
1007 "first ttl (%d) may not be greater than max ttl (%d)",
1008 first_ttl, max_ttl);
1009 }
1010
1011 minpacket = sizeof(*outip) + sizeof(*outdata) + optlen;
1012
1013#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
1014 if (useicmp)
1015 minpacket += 8; /* XXX magic number */
1016 else
1017#endif
1018 minpacket += sizeof(*outudp);
1019 packlen = minpacket; /* minimum sized packet */
1020
1021 /* Process destination and optional packet size */
1022 switch (argc - optind) {
1023
1024 case 2:
1025 packlen = xatoul_range(argv[optind + 1], minpacket, maxpacket);
1026 /* Fall through */
1027
1028 case 1:
1029 hostname = argv[optind];
1030 hi = gethostinfo(hostname);
1031 setsin(to, hi->addrs[0]);
1032 if (hi->n > 1)
1033 bb_error_msg("warning: %s has multiple addresses; using %s",
1034 hostname, inet_ntoa(to->sin_addr));
1035 hostname = hi->name;
1036 hi->name = NULL;
1037 freehostinfo(hi);
1038 break;
1039
1040 default:
1041 bb_show_usage();
1042 }
1043
1044 /* Insure the socket fds won't be 0, 1 or 2 */
1045 do n = xopen(bb_dev_null, O_RDONLY); while (n < 2);
1046 if (n > 2)
1047 close(n);
1048
1049 s = xsocket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
1050
1051#if TRACEROUTE_SO_DEBUG
1052 if (op & USAGE_OP_DEBUG)
1053 (void)setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&on,
1054 sizeof(on));
1055#endif
1056 if (op & USAGE_OP_BYPASS_ROUTE)
1057 (void)setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
1058 sizeof(on));
1059
1060 sndsock = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);
1061
1062#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
1063#if defined(IP_OPTIONS)
1064 if (lsrr > 0) {
1065 unsigned char optlist[MAX_IPOPTLEN];
1066
1067 /* final hop */
1068 gwlist[lsrr] = to->sin_addr.s_addr;
1069 ++lsrr;
1070
1071 /* force 4 byte alignment */
1072 optlist[0] = IPOPT_NOP;
1073 /* loose source route option */
1074 optlist[1] = IPOPT_LSRR;
1075 i = lsrr * sizeof(gwlist[0]);
1076 optlist[2] = i + 3;
1077 /* Pointer to LSRR addresses */
1078 optlist[3] = IPOPT_MINOFF;
1079 memcpy(optlist + 4, gwlist, i);
1080
1081 if ((setsockopt(sndsock, IPPROTO_IP, IP_OPTIONS,
1082 (char *)optlist, i + sizeof(gwlist[0]))) < 0) {
1083 bb_perror_msg_and_die("IP_OPTIONS");
1084 }
1085 }
1086#endif /* IP_OPTIONS */
1087#endif /* CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE */
1088
1089#ifdef SO_SNDBUF
1090 if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, (char *)&packlen,
1091 sizeof(packlen)) < 0) {
1092 bb_perror_msg_and_die("SO_SNDBUF");
1093 }
1094#endif
1095#ifdef IP_HDRINCL
1096 if (setsockopt(sndsock, IPPROTO_IP, IP_HDRINCL, (char *)&on,
1097 sizeof(on)) < 0 && errno != ENOPROTOOPT) {
1098 bb_perror_msg_and_die("IP_HDRINCL");
1099 }
1100#else
1101#ifdef IP_TOS
1102 if (tos_str && setsockopt(sndsock, IPPROTO_IP, IP_TOS,
1103 (char *)&tos, sizeof(tos)) < 0) {
1104 bb_perror_msg_and_die("setsockopt tos %d", tos);
1105 }
1106#endif
1107#endif
1108#if TRACEROUTE_SO_DEBUG
1109 if (op & USAGE_OP_DEBUG)
1110 (void)setsockopt(sndsock, SOL_SOCKET, SO_DEBUG, (char *)&on,
1111 sizeof(on));
1112#endif
1113 if (op & USAGE_OP_BYPASS_ROUTE)
1114 (void)setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
1115 sizeof(on));
1116
1117 /* Revert to non-privileged user after opening sockets */
1118 xsetgid(getgid());
1119 xsetuid(getuid());
1120
1121 outip = (struct ip *)xzalloc(packlen);
1122
1123 outip->ip_v = IPVERSION;
1124 if (tos_str)
1125 outip->ip_tos = tos;
1126 outip->ip_len = htons(packlen);
1127 outip->ip_off = htons(off);
1128 outp = (unsigned char *)(outip + 1);
1129 outip->ip_dst = to->sin_addr;
1130
1131 outip->ip_hl = (outp - (unsigned char *)outip) >> 2;
1132 ident = (getpid() & 0xffff) | 0x8000;
1133#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
1134 if (useicmp) {
1135 outip->ip_p = IPPROTO_ICMP;
1136
1137 outicmp = (struct icmp *)outp;
1138 outicmp->icmp_type = ICMP_ECHO;
1139 outicmp->icmp_id = htons(ident);
1140
1141 outdata = (struct outdata *)(outp + 8); /* XXX magic number */
1142 } else
1143#endif
1144 {
1145 outip->ip_p = IPPROTO_UDP;
1146
1147 outudp = (struct udphdr *)outp;
1148 outudp->source = htons(ident);
1149 outudp->len =
1150 htons((u_short)(packlen - (sizeof(*outip) + optlen)));
1151 outdata = (struct outdata *)(outudp + 1);
1152 }
1153
1154 /* Get the interface address list */
1155 n = ifaddrlist(&al);
1156
1157 /* Look for a specific device */
1158 if (device != NULL) {
1159 for (i = n; i > 0; --i, ++al)
1160 if (strcmp(device, al->device) == 0)
1161 break;
1162 if (i <= 0) {
1163 bb_error_msg_and_die("can't find interface %s", device);
1164 }
1165 }
1166
1167 /* Determine our source address */
1168 if (source == NULL) {
1169 /*
1170 * If a device was specified, use the interface address.
1171 * Otherwise, try to determine our source address.
1172 */
1173 if (device != NULL)
1174 setsin(from, al->addr);
1175 findsaddr(to, from);
1176 } else {
1177 hi = gethostinfo(source);
1178 source = hi->name;
1179 hi->name = NULL;
1180 /*
1181 * If the device was specified make sure it
1182 * corresponds to the source address specified.
1183 * Otherwise, use the first address (and warn if
1184 * there are more than one).
1185 */
1186 if (device != NULL) {
1187 for (i = hi->n, ap = hi->addrs; i > 0; --i, ++ap)
1188 if (*ap == al->addr)
1189 break;
1190 if (i <= 0) {
1191 bb_error_msg_and_die(
1192 "%s is not on interface %s",
1193 source, device);
1194 }
1195 setsin(from, *ap);
1196 } else {
1197 setsin(from, hi->addrs[0]);
1198 if (hi->n > 1)
1199 bb_error_msg(
1200 "Warning: %s has multiple addresses; using %s",
1201 source, inet_ntoa(from->sin_addr));
1202 }
1203 freehostinfo(hi);
1204 }
1205
1206 outip->ip_src = from->sin_addr;
1207#ifndef IP_HDRINCL
1208 xbind(sndsock, (struct sockaddr *)from, sizeof(*from));
1209#endif
1210
1211 fprintf(stderr, "traceroute to %s (%s)", hostname, inet_ntoa(to->sin_addr));
1212 if (source)
1213 fprintf(stderr, " from %s", source);
1214 fprintf(stderr, ", %d hops max, %d byte packets\n", max_ttl, packlen);
1215 (void)fflush(stderr);
1216
1217 for (ttl = first_ttl; ttl <= max_ttl; ++ttl) {
1218 u_int32_t lastaddr = 0;
1219 int gotlastaddr = 0;
1220 int got_there = 0;
1221 int unreachable = 0;
1222 int sentfirst = 0;
1223
1224 printf("%2d ", ttl);
1225 for (probe = 0; probe < nprobes; ++probe) {
1226 int cc;
1227 struct timeval t1, t2;
1228 struct timezone tz;
1229 struct ip *ip;
1230
1231 if (sentfirst && pausemsecs > 0)
1232 usleep(pausemsecs * 1000);
1233 (void)gettimeofday(&t1, &tz);
1234 send_probe(++seq, ttl, &t1);
1235 ++sentfirst;
1236 while ((cc = wait_for_reply(s, from, &t1)) != 0) {
1237 (void)gettimeofday(&t2, &tz);
1238 i = packet_ok(packet, cc, from, seq);
1239 /* Skip short packet */
1240 if (i == 0)
1241 continue;
1242 if (!gotlastaddr ||
1243 from->sin_addr.s_addr != lastaddr) {
1244 print(packet, cc, from);
1245 lastaddr = from->sin_addr.s_addr;
1246 ++gotlastaddr;
1247 }
1248 printf(" %.3f ms", deltaT(&t1, &t2));
1249 ip = (struct ip *)packet;
1250 if (op & USAGE_OP_TTL_FLAG)
1251 printf(" (%d)", ip->ip_ttl);
1252 if (i == -2) {
1253 if (ip->ip_ttl <= 1)
1254 printf(" !");
1255 ++got_there;
1256 break;
1257 }
1258 /* time exceeded in transit */
1259 if (i == -1)
1260 break;
1261 code = i - 1;
1262 switch (code) {
1263
1264 case ICMP_UNREACH_PORT:
1265 if (ip->ip_ttl <= 1)
1266 printf(" !");
1267 ++got_there;
1268 break;
1269
1270 case ICMP_UNREACH_NET:
1271 ++unreachable;
1272 printf(" !N");
1273 break;
1274
1275 case ICMP_UNREACH_HOST:
1276 ++unreachable;
1277 printf(" !H");
1278 break;
1279
1280 case ICMP_UNREACH_PROTOCOL:
1281 ++got_there;
1282 printf(" !P");
1283 break;
1284
1285 case ICMP_UNREACH_NEEDFRAG:
1286 ++unreachable;
1287 printf(" !F-%d", pmtu);
1288 break;
1289
1290 case ICMP_UNREACH_SRCFAIL:
1291 ++unreachable;
1292 printf(" !S");
1293 break;
1294
1295 case ICMP_UNREACH_FILTER_PROHIB:
1296 case ICMP_UNREACH_NET_PROHIB: /* misuse */
1297 ++unreachable;
1298 printf(" !A");
1299 break;
1300
1301 case ICMP_UNREACH_HOST_PROHIB:
1302 ++unreachable;
1303 printf(" !C");
1304 break;
1305
1306 case ICMP_UNREACH_HOST_PRECEDENCE:
1307 ++unreachable;
1308 printf(" !V");
1309 break;
1310
1311 case ICMP_UNREACH_PRECEDENCE_CUTOFF:
1312 ++unreachable;
1313 printf(" !C");
1314 break;
1315
1316 case ICMP_UNREACH_NET_UNKNOWN:
1317 case ICMP_UNREACH_HOST_UNKNOWN:
1318 ++unreachable;
1319 printf(" !U");
1320 break;
1321
1322 case ICMP_UNREACH_ISOLATED:
1323 ++unreachable;
1324 printf(" !I");
1325 break;
1326
1327 case ICMP_UNREACH_TOSNET:
1328 case ICMP_UNREACH_TOSHOST:
1329 ++unreachable;
1330 printf(" !T");
1331 break;
1332
1333 default:
1334 ++unreachable;
1335 printf(" !<%d>", code);
1336 break;
1337 }
1338 break;
1339 }
1340 if (cc == 0)
1341 printf(" *");
1342 (void)fflush(stdout);
1343 }
1344 putchar('\n');
1345 if (got_there ||
1346 (unreachable > 0 && unreachable >= nprobes - 1))
1347 break;
1348 }
1349 return 0;
1350}