1 /* vi: set sw=4 ts=4: */
3 * Copyright (c) 1988, 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999, 2000
4 * The Regents of the University of California. All rights reserved.
6 * Busybox port by Vladimir Oleynik (C) 2005 <dzo@simtreas.ru>
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
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.
25 //#define version "1.4a12"
29 * traceroute host - trace the route ip packets follow going to "host".
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
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).
51 * A sample use might be:
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
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.
71 * A more interesting example is:
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
87 * 13 128.121.54.72 (128.121.54.72) 259 ms 499 ms 279 ms
92 * 18 ALLSPICE.LCS.MIT.EDU (18.26.0.115) 339 ms 279 ms 279 ms
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.
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:
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
121 * 13 rip.Berkeley.EDU (128.32.131.22) 59 ms ! 39 ms ! 39 ms !
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
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.
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.)
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.
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.
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.
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.
187 * Tim Seaver, Ken Adelman and C. Philip Wood provided bug fixes and/or
188 * enhancements to the original distribution.
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...
195 * -- Van Jacobson (van@ee.lbl.gov)
196 * Tue Dec 20 03:50:13 PST 1988
199 #undef CONFIG_FEATURE_TRACEROUTE_VERBOSE
200 //#define CONFIG_FEATURE_TRACEROUTE_VERBOSE
201 #undef CONFIG_FEATURE_TRACEROUTE_SO_DEBUG /* not in documentation man */
202 #undef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
203 //#define CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
204 #undef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
205 //#define CONFIG_FEATURE_TRACEROUTE_USE_ICMP
217 #include <sys/param.h>
218 #include <sys/file.h>
219 #include <sys/ioctl.h>
220 #include <sys/socket.h>
221 #include <sys/select.h>
222 #include "inet_common.h"
225 #include <netinet/in.h>
226 #include <arpa/inet.h>
227 #include <netinet/udp.h>
228 #include <netinet/ip.h>
229 #include <netinet/ip_icmp.h>
235 * Definitions for internet protocol version 4.
236 * Per RFC 791, September 1981.
241 * Overlay for ip header used by other protocols (tcp, udp).
244 unsigned char ih_x1[9]; /* (unused) */
245 unsigned char ih_pr; /* protocol */
246 short ih_len; /* protocol length */
247 struct in_addr ih_src; /* source internet address */
248 struct in_addr ih_dst; /* destination internet address */
252 * UDP kernel structures and variables.
255 struct ipovly ui_i; /* overlaid ip structure */
256 struct udphdr ui_u; /* udp header */
258 #define ui_next ui_i.ih_next
259 #define ui_prev ui_i.ih_prev
260 #define ui_x1 ui_i.ih_x1
261 #define ui_pr ui_i.ih_pr
262 #define ui_len ui_i.ih_len
263 #define ui_src ui_i.ih_src
264 #define ui_dst ui_i.ih_dst
265 #define ui_sport ui_u.uh_sport
266 #define ui_dport ui_u.uh_dport
267 #define ui_ulen ui_u.uh_ulen
268 #define ui_sum ui_u.uh_sum
271 /* Host name and address list */
278 /* Data section of the probe packet */
280 unsigned char seq; /* sequence number of this packet */
281 unsigned char ttl; /* ttl packet left with */
282 struct timeval tv ATTRIBUTE_PACKED; /* time packet left */
287 char device[sizeof(struct ifreq)];
291 static const char route[] = "/proc/net/route";
293 /* last inbound (icmp) packet */
294 static unsigned char packet[512] ATTRIBUTE_ALIGNED(32);
296 static struct ip *outip; /* last output (udp) packet */
297 static struct udphdr *outudp; /* last output (udp) packet */
298 static struct outdata *outdata; /* last output (udp) packet */
300 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
301 static struct icmp *outicmp; /* last output (icmp) packet */
304 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
305 /* Maximum number of gateways (include room for one noop) */
306 #define NGATEWAYS ((int)((MAX_IPOPTLEN - IPOPT_MINOFF - 1) / sizeof(u_int32_t)))
307 /* loose source route gateway list (including room for final destination) */
308 static u_int32_t gwlist[NGATEWAYS + 1];
311 static int s; /* receive (icmp) socket file descriptor */
312 static int sndsock; /* send (udp/icmp) socket file descriptor */
314 static struct sockaddr_storage whereto; /* Who to try to reach */
315 static struct sockaddr_storage wherefrom; /* Who we are */
316 static int packlen; /* total length of packet */
317 static int minpacket; /* min ip packet size */
318 static int maxpacket = 32 * 1024; /* max ip packet size */
319 static int pmtu; /* Path MTU Discovery (RFC1191) */
321 static char *hostname;
323 static u_short ident;
324 static u_short port = 32768 + 666; /* start udp dest port # for probe packets */
326 static int waittime = 5; /* time to wait for response (in seconds) */
327 static int nflag; /* print addresses numerically */
328 static int doipcksum = 1; /* calculate ip checksums by default */
330 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
331 static int optlen; /* length of ip options */
336 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
337 static int useicmp; /* use icmp echo instead of udp packets */
339 #ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
344 * Return the interface list
347 ifaddrlist(struct IFADDRLIST **ipaddrp)
350 #ifdef HAVE_SOCKADDR_SA_LEN
353 struct ifreq *ifrp, *ifend, *ifnext;
354 struct sockaddr_in *addr_sin;
355 struct IFADDRLIST *al;
357 struct ifreq ibuf[(32 * 1024) / sizeof(struct ifreq)], ifr;
358 struct IFADDRLIST *st_ifaddrlist;
360 fd = bb_xsocket(AF_INET, SOCK_DGRAM, 0);
362 ifc.ifc_len = sizeof(ibuf);
363 ifc.ifc_buf = (caddr_t)ibuf;
365 if (ioctl(fd, SIOCGIFCONF, (char *)&ifc) < 0 ||
366 ifc.ifc_len < sizeof(struct ifreq)) {
368 bb_error_msg_and_die(
369 "SIOCGIFCONF: ifreq struct too small (%d bytes)",
372 bb_perror_msg_and_die("SIOCGIFCONF");
375 ifend = (struct ifreq *)((char *)ibuf + ifc.ifc_len);
377 nipaddr = 1 + (ifc.ifc_len / sizeof(struct ifreq));
378 st_ifaddrlist = xcalloc(nipaddr, sizeof(struct IFADDRLIST));
382 for (; ifrp < ifend; ifrp = ifnext) {
383 #ifdef HAVE_SOCKADDR_SA_LEN
384 n = ifrp->ifr_addr.sa_len + sizeof(ifrp->ifr_name);
385 if (n < sizeof(*ifrp))
388 ifnext = (struct ifreq *)((char *)ifrp + n);
389 if (ifrp->ifr_addr.sa_family != AF_INET)
395 * Need a template to preserve address info that is
396 * used below to locate the next entry. (Otherwise,
397 * SIOCGIFFLAGS stomps over it because the requests
398 * are returned in a union.)
400 strncpy(ifr.ifr_name, ifrp->ifr_name, sizeof(ifr.ifr_name));
401 if (ioctl(fd, SIOCGIFFLAGS, (char *)&ifr) < 0) {
404 bb_perror_msg_and_die("SIOCGIFFLAGS: %.*s",
405 (int)sizeof(ifr.ifr_name), ifr.ifr_name);
409 if ((ifr.ifr_flags & IFF_UP) == 0)
412 safe_strncpy(al->device, ifr.ifr_name, sizeof(ifr.ifr_name) + 1);
414 /* Ignore sun virtual interfaces */
415 if (strchr(al->device, ':') != NULL)
418 if (ioctl(fd, SIOCGIFADDR, (char *)&ifr) < 0)
419 bb_perror_msg_and_die("SIOCGIFADDR: %s", al->device);
421 addr_sin = (struct sockaddr_in *)&ifr.ifr_addr;
422 al->addr = addr_sin->sin_addr.s_addr;
427 bb_error_msg_and_die ("Can't find any network interfaces");
430 *ipaddrp = st_ifaddrlist;
436 setsin(struct sockaddr_in *addr_sin, u_int32_t addr)
438 memset(addr_sin, 0, sizeof(*addr_sin));
439 #ifdef HAVE_SOCKADDR_SA_LEN
440 addr_sin->sin_len = sizeof(*addr_sin);
442 addr_sin->sin_family = AF_INET;
443 addr_sin->sin_addr.s_addr = addr;
448 * Return the source address for the given destination address
451 findsaddr(const struct sockaddr_in *to, struct sockaddr_in *from)
456 u_int32_t dest, tmask;
457 struct IFADDRLIST *al;
458 char buf[256], tdevice[256], device[256];
460 f = bb_xfopen(route, "r");
462 /* Find the appropriate interface */
466 while (fgets(buf, sizeof(buf), f) != NULL) {
468 if (n == 1 && strncmp(buf, "Iface", 5) == 0)
470 if ((i = sscanf(buf, "%255s %x %*s %*s %*s %*s %*s %x",
471 tdevice, &dest, &tmask)) != 3)
472 bb_error_msg_and_die ("junk in buffer");
473 if ((to->sin_addr.s_addr & tmask) == dest &&
474 (tmask > mask || mask == 0)) {
476 strcpy(device, tdevice);
481 if (device[0] == '\0')
482 bb_error_msg_and_die ("Can't find interface");
484 /* Get the interface address list */
487 /* Find our appropriate source address */
488 for (i = n; i > 0; --i, ++al)
489 if (strcmp(device, al->device) == 0)
492 bb_error_msg_and_die("Can't find interface %s", device);
494 setsin(from, al->addr);
498 "Usage: %s [-dFIlnrvx] [-g gateway] [-i iface] [-f first_ttl]\n"
499 "\t[-m max_ttl] [ -p port] [-q nqueries] [-s src_addr] [-t tos]\n"
500 "\t[-w waittime] [-z pausemsecs] host [packetlen]"
504 /* String to value with optional min and max. Handles decimal and hex. */
506 str2val(const char *str, const char *what, int mi, int ma)
512 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
514 val = (int)strtol(cp, &ep, 16);
516 val = (int)strtol(str, &ep, 10);
518 bb_error_msg_and_die("\"%s\" bad value for %s \n", str, what);
520 if (val < mi && mi >= 0) {
522 bb_error_msg_and_die("%s must be >= %d\n", what, mi);
524 bb_error_msg_and_die("%s must be > %d\n", what, mi - 1);
526 if (val > ma && ma >= 0)
527 bb_error_msg_and_die("%s must be <= %d\n", what, ma);
533 * Subtract 2 timeval structs: out = out - in.
534 * Out is assumed to be >= in.
537 tvsub(struct timeval *out, struct timeval *in)
540 if ((out->tv_usec -= in->tv_usec) < 0) {
542 out->tv_usec += 1000000;
544 out->tv_sec -= in->tv_sec;
548 wait_for_reply(int sock, struct sockaddr_in *fromp, const struct timeval *tp)
551 struct timeval now, wait;
554 socklen_t fromlen = sizeof(*fromp);
559 wait.tv_sec = tp->tv_sec + waittime;
560 wait.tv_usec = tp->tv_usec;
561 (void)gettimeofday(&now, &tz);
564 if (select(sock + 1, &fds, NULL, NULL, &wait) > 0)
565 cc = recvfrom(sock, (char *)packet, sizeof(packet), 0,
566 (struct sockaddr *)fromp, &fromlen);
572 * Checksum routine for Internet Protocol family headers (C Version)
575 in_cksum(u_short *addr, int len)
583 * Our algorithm is simple, using a 32 bit accumulator (sum),
584 * we add sequential 16 bit words to it, and at the end, fold
585 * back all the carry bits from the top 16 bits into the lower
593 /* mop up an odd byte, if necessary */
595 sum += *(unsigned char *)w;
598 * add back carry outs from top 16 bits to low 16 bits
600 sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
601 sum += (sum >> 16); /* add carry */
602 answer = ~sum; /* truncate to 16 bits */
608 send_probe(int seq, int ttl, struct timeval *tp)
611 struct udpiphdr *ui, *oui;
615 outip->ip_id = htons(ident + seq);
618 * In most cases, the kernel will recalculate the ip checksum.
619 * But we must do it anyway so that the udp checksum comes out
624 in_cksum((u_short *)outip, sizeof(*outip) + optlen);
625 if (outip->ip_sum == 0)
626 outip->ip_sum = 0xffff;
632 memcpy(&outdata->tv, tp, sizeof(outdata->tv));
634 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
636 outicmp->icmp_seq = htons(seq);
639 outudp->dest = htons(port + seq);
641 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
643 /* Always calculate checksum for icmp packets */
644 outicmp->icmp_cksum = 0;
645 outicmp->icmp_cksum = in_cksum((u_short *)outicmp,
646 packlen - (sizeof(*outip) + optlen));
647 if (outicmp->icmp_cksum == 0)
648 outicmp->icmp_cksum = 0xffff;
652 /* Checksum (we must save and restore ip header) */
654 ui = (struct udpiphdr *)outip;
655 oui = (struct udpiphdr *)&tip;
656 /* Easier to zero and put back things that are ok */
657 memset((char *)ui, 0, sizeof(ui->ui_i));
658 ui->ui_src = oui->ui_src;
659 ui->ui_dst = oui->ui_dst;
660 ui->ui_pr = oui->ui_pr;
661 ui->ui_len = outudp->len;
663 outudp->check = in_cksum((u_short *)ui, packlen);
664 if (outudp->check == 0)
665 outudp->check = 0xffff;
669 #ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
670 /* XXX undocumented debugging hack */
675 sp = (u_short *)outip;
676 nshorts = (u_int)packlen / sizeof(u_short);
678 printf("[ %d bytes", packlen);
679 while (--nshorts >= 0) {
682 printf(" %04x", ntohs(*sp));
688 printf(" %02x", *(unsigned char *)sp);
694 #if !defined(IP_HDRINCL) && defined(IP_TTL)
695 if (setsockopt(sndsock, IPPROTO_IP, IP_TTL,
696 (char *)&ttl, sizeof(ttl)) < 0) {
697 bb_perror_msg_and_die("setsockopt ttl %d", ttl);
701 cc = sendto(sndsock, (char *)outip,
702 packlen, 0, (struct sockaddr *)&whereto, sizeof(whereto));
703 if (cc < 0 || cc != packlen) {
705 bb_perror_msg_and_die("sendto");
706 printf("%s: wrote %s %d chars, ret=%d\n",
707 bb_applet_name, hostname, packlen, cc);
708 (void)fflush(stdout);
713 deltaT(struct timeval *t1p, struct timeval *t2p)
717 dt = (double)(t2p->tv_sec - t1p->tv_sec) * 1000.0 +
718 (double)(t2p->tv_usec - t1p->tv_usec) / 1000.0;
722 #ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
724 * Convert an ICMP "type" field to a printable string.
726 static inline const char *
727 pr_type(unsigned char t)
729 static const char * const ttab[] = {
730 "Echo Reply", "ICMP 1", "ICMP 2", "Dest Unreachable",
731 "Source Quench", "Redirect", "ICMP 6", "ICMP 7",
732 "Echo", "Router Advert", "Router Solicit", "Time Exceeded",
733 "Param Problem", "Timestamp", "Timestamp Reply", "Info Request",
734 "Info Reply", "Mask Request", "Mask Reply"
738 return "OUT-OF-RANGE";
745 packet_ok(unsigned char *buf, int cc, struct sockaddr_in *from, int seq)
748 unsigned char type, code;
752 ip = (struct ip *) buf;
753 hlen = ip->ip_hl << 2;
754 if (cc < hlen + ICMP_MINLEN) {
755 #ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
757 printf("packet too short (%d bytes) from %s\n", cc,
758 inet_ntoa(from->sin_addr));
763 icp = (struct icmp *)(buf + hlen);
764 type = icp->icmp_type;
765 code = icp->icmp_code;
766 /* Path MTU Discovery (RFC1191) */
767 if (code != ICMP_UNREACH_NEEDFRAG)
770 pmtu = ntohs(icp->icmp_nextmtu);
772 if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS) ||
773 type == ICMP_UNREACH || type == ICMP_ECHOREPLY) {
778 hlen = hip->ip_hl << 2;
779 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
784 if (type == ICMP_ECHOREPLY &&
785 icp->icmp_id == htons(ident) &&
786 icp->icmp_seq == htons(seq))
789 hicmp = (struct icmp *)((unsigned char *)hip + hlen);
790 /* XXX 8 is a magic number */
791 if (hlen + 8 <= cc &&
792 hip->ip_p == IPPROTO_ICMP &&
793 hicmp->icmp_id == htons(ident) &&
794 hicmp->icmp_seq == htons(seq))
795 return (type == ICMP_TIMXCEED ? -1 : code + 1);
799 up = (struct udphdr *)((unsigned char *)hip + hlen);
800 /* XXX 8 is a magic number */
801 if (hlen + 12 <= cc &&
802 hip->ip_p == IPPROTO_UDP &&
803 up->source == htons(ident) &&
804 up->dest == htons(port + seq))
805 return (type == ICMP_TIMXCEED ? -1 : code + 1);
808 #ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
811 u_int32_t *lp = (u_int32_t *)&icp->icmp_ip;
813 printf("\n%d bytes from %s to "
814 "%s: icmp type %d (%s) code %d\n",
815 cc, inet_ntoa(from->sin_addr),
816 inet_ntoa(ip->ip_dst), type, pr_type(type), icp->icmp_code);
817 for (i = 4; i < cc ; i += sizeof(*lp))
818 printf("%2d: x%8.8x\n", i, *lp++);
826 * Construct an Internet address representation.
827 * If the nflag has been supplied, give
828 * numeric value, otherwise try for symbolic name.
831 inetname(struct sockaddr_in *from)
833 const char *n = NULL;
837 if (!nflag && from->sin_addr.s_addr != INADDR_ANY) {
838 if(INET_rresolve(name, sizeof(name), from, 0x4000, 0xffffffff) >= 0)
841 ina = inet_ntoa(from->sin_addr);
845 printf(" %s (%s)", (n ? n : ina), ina);
849 print(unsigned char *buf, int cc, struct sockaddr_in *from)
854 ip = (struct ip *) buf;
855 hlen = ip->ip_hl << 2;
859 #ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
861 printf(" %d bytes to %s", cc, inet_ntoa (ip->ip_dst));
866 static struct hostinfo *
867 gethostinfo(const char *host)
875 hi = xcalloc(1, sizeof(*hi));
876 addr = inet_addr(host);
877 if ((int32_t)addr != -1) {
878 hi->name = bb_xstrdup(host);
880 hi->addrs = xcalloc(1, sizeof(hi->addrs[0]));
885 hp = xgethostbyname(host);
886 if (hp->h_addrtype != AF_INET || hp->h_length != 4)
887 bb_perror_msg_and_die("bad host %s", host);
888 hi->name = bb_xstrdup(hp->h_name);
889 for (n = 0, p = hp->h_addr_list; *p != NULL; ++n, ++p)
892 hi->addrs = xcalloc(n, sizeof(hi->addrs[0]));
893 for (ap = hi->addrs, p = hp->h_addr_list; *p != NULL; ++ap, ++p)
894 memcpy(ap, *p, sizeof(*ap));
899 freehostinfo(struct hostinfo *hi)
903 free((char *)hi->addrs);
907 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
909 getaddr(u_int32_t *ap, const char *host)
913 hi = gethostinfo(host);
921 traceroute_main(int argc, char *argv[])
927 struct sockaddr_in *from = (struct sockaddr_in *)&wherefrom;
928 struct sockaddr_in *to = (struct sockaddr_in *)&whereto;
935 char *tos_str = NULL;
939 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
943 struct IFADDRLIST *al;
947 char *max_ttl_str = NULL;
948 char *port_str = NULL;
950 char *nprobes_str = NULL;
951 char *waittime_str = NULL;
952 u_int pausemsecs = 0;
953 char *pausemsecs_str = NULL;
955 char *first_ttl_str = NULL;
956 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
957 llist_t *sourse_route_list = NULL;
961 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
962 bb_opt_complementally = "x-x:g::";
964 bb_opt_complementally = "x-x";
967 op = bb_getopt_ulflags(argc, argv, "FIlnrdvxt:i:m:p:q:s:w:z:f:"
968 #define USAGE_OP_DONT_FRAGMNT (1<<0) /* F */
969 #define USAGE_OP_USE_ICMP (1<<1) /* I */
970 #define USAGE_OP_TTL_FLAG (1<<2) /* l */
971 #define USAGE_OP_ADDR_NUM (1<<3) /* n */
972 #define USAGE_OP_BYPASS_ROUTE (1<<4) /* r */
973 #define USAGE_OP_DEBUG (1<<5) /* d */
974 #define USAGE_OP_VERBOSE (1<<6) /* v */
975 #define USAGE_OP_IP_CHKSUM (1<<7) /* x */
977 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
980 , &tos_str, &device, &max_ttl_str, &port_str, &nprobes_str,
981 &source, &waittime_str, &pausemsecs_str, &first_ttl_str
982 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
987 if(op & USAGE_OP_DONT_FRAGMNT)
989 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
990 useicmp = op & USAGE_OP_USE_ICMP;
992 nflag = op & USAGE_OP_ADDR_NUM;
993 #ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
994 verbose = op & USAGE_OP_VERBOSE;
996 if(op & USAGE_OP_IP_CHKSUM) {
998 bb_error_msg("Warning: ip checksums disabled");
1001 tos = str2val(tos_str, "tos", 0, 255);
1003 max_ttl = str2val(max_ttl_str, "max ttl", 1, 255);
1005 port = (u_short)str2val(port_str, "port", 1, (1 << 16) - 1);
1007 nprobes = str2val(optarg, "nprobes", 1, -1);
1010 * set the ip source address of the outbound
1011 * probe (e.g., on a multi-homed host).
1014 bb_error_msg_and_die("-s %s: Permission denied", source);
1017 waittime = str2val(waittime_str, "wait time", 2, 24 * 60 * 60);
1019 pausemsecs = str2val(pausemsecs_str, "pause msecs", 0, 60 * 60 * 1000);
1021 first_ttl = str2val(first_ttl_str, "first ttl", 1, 255);
1023 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
1024 if(sourse_route_list) {
1027 for(l_sr = sourse_route_list; l_sr; ) {
1028 if (lsrr >= NGATEWAYS)
1029 bb_error_msg_and_die("No more than %d gateways", NGATEWAYS);
1030 getaddr(gwlist + lsrr, l_sr->data);
1033 free(sourse_route_list);
1034 sourse_route_list = l_sr;
1036 optlen = (lsrr + 1) * sizeof(gwlist[0]);
1040 if (first_ttl > max_ttl) {
1041 bb_error_msg_and_die(
1042 "first ttl (%d) may not be greater than max ttl (%d)",
1043 first_ttl, max_ttl);
1046 minpacket = sizeof(*outip) + sizeof(*outdata) + optlen;
1048 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
1050 minpacket += 8; /* XXX magic number */
1053 minpacket += sizeof(*outudp);
1054 packlen = minpacket; /* minimum sized packet */
1056 /* Process destination and optional packet size */
1057 switch (argc - optind) {
1060 packlen = str2val(argv[optind + 1],
1061 "packet length", minpacket, maxpacket);
1065 hostname = argv[optind];
1066 hi = gethostinfo(hostname);
1067 setsin(to, hi->addrs[0]);
1070 "Warning: %s has multiple addresses; using %s",
1071 hostname, inet_ntoa(to->sin_addr));
1072 hostname = hi->name;
1082 if ((pe = getprotobyname(cp)) == NULL)
1083 bb_perror_msg_and_die("unknown protocol %s", cp);
1085 /* Insure the socket fds won't be 0, 1 or 2 */
1086 do n = bb_xopen(bb_dev_null, O_RDONLY); while (n < 2);
1090 s = bb_xsocket(AF_INET, SOCK_RAW, pe->p_proto);
1092 #ifdef CONFIG_FEATURE_TRACEROUTE_SO_DEBUG
1093 if (op & USAGE_OP_DEBUG)
1094 (void)setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&on,
1097 if (op & USAGE_OP_BYPASS_ROUTE)
1098 (void)setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
1101 sndsock = bb_xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);
1103 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
1104 #if defined(IP_OPTIONS)
1106 unsigned char optlist[MAX_IPOPTLEN];
1109 if ((pe = getprotobyname(cp)) == NULL)
1110 bb_perror_msg_and_die("unknown protocol");
1113 gwlist[lsrr] = to->sin_addr.s_addr;
1116 /* force 4 byte alignment */
1117 optlist[0] = IPOPT_NOP;
1118 /* loose source route option */
1119 optlist[1] = IPOPT_LSRR;
1120 i = lsrr * sizeof(gwlist[0]);
1122 /* Pointer to LSRR addresses */
1123 optlist[3] = IPOPT_MINOFF;
1124 memcpy(optlist + 4, gwlist, i);
1126 if ((setsockopt(sndsock, pe->p_proto, IP_OPTIONS,
1127 (char *)optlist, i + sizeof(gwlist[0]))) < 0) {
1128 bb_perror_msg_and_die("IP_OPTIONS");
1131 #endif /* IP_OPTIONS */
1132 #endif /* CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE */
1135 if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, (char *)&packlen,
1136 sizeof(packlen)) < 0) {
1137 bb_perror_msg_and_die("SO_SNDBUF");
1141 if (setsockopt(sndsock, IPPROTO_IP, IP_HDRINCL, (char *)&on,
1142 sizeof(on)) < 0 && errno != ENOPROTOOPT) {
1143 bb_perror_msg_and_die("IP_HDRINCL");
1147 if (tos_str && setsockopt(sndsock, IPPROTO_IP, IP_TOS,
1148 (char *)&tos, sizeof(tos)) < 0) {
1149 bb_perror_msg_and_die("setsockopt tos %d", tos);
1153 #ifdef CONFIG_FEATURE_TRACEROUTE_SO_DEBUG
1154 if (op & USAGE_OP_DEBUG)
1155 (void)setsockopt(sndsock, SOL_SOCKET, SO_DEBUG, (char *)&on,
1158 if (op & USAGE_OP_BYPASS_ROUTE)
1159 (void)setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
1162 /* Revert to non-privileged user after opening sockets */
1166 outip = (struct ip *)xcalloc(1, (unsigned)packlen);
1168 outip->ip_v = IPVERSION;
1170 outip->ip_tos = tos;
1171 outip->ip_len = htons(packlen);
1172 outip->ip_off = htons(off);
1173 outp = (unsigned char *)(outip + 1);
1174 outip->ip_dst = to->sin_addr;
1176 outip->ip_hl = (outp - (unsigned char *)outip) >> 2;
1177 ident = (getpid() & 0xffff) | 0x8000;
1178 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
1180 outip->ip_p = IPPROTO_ICMP;
1182 outicmp = (struct icmp *)outp;
1183 outicmp->icmp_type = ICMP_ECHO;
1184 outicmp->icmp_id = htons(ident);
1186 outdata = (struct outdata *)(outp + 8); /* XXX magic number */
1190 outip->ip_p = IPPROTO_UDP;
1192 outudp = (struct udphdr *)outp;
1193 outudp->source = htons(ident);
1195 htons((u_short)(packlen - (sizeof(*outip) + optlen)));
1196 outdata = (struct outdata *)(outudp + 1);
1199 /* Get the interface address list */
1200 n = ifaddrlist(&al);
1202 /* Look for a specific device */
1203 if (device != NULL) {
1204 for (i = n; i > 0; --i, ++al)
1205 if (strcmp(device, al->device) == 0)
1208 bb_error_msg_and_die("Can't find interface %s", device);
1212 /* Determine our source address */
1213 if (source == NULL) {
1215 * If a device was specified, use the interface address.
1216 * Otherwise, try to determine our source address.
1219 setsin(from, al->addr);
1220 findsaddr(to, from);
1222 hi = gethostinfo(source);
1226 * If the device was specified make sure it
1227 * corresponds to the source address specified.
1228 * Otherwise, use the first address (and warn if
1229 * there are more than one).
1231 if (device != NULL) {
1232 for (i = hi->n, ap = hi->addrs; i > 0; --i, ++ap)
1233 if (*ap == al->addr)
1236 bb_error_msg_and_die(
1237 "%s is not on interface %s",
1242 setsin(from, hi->addrs[0]);
1245 "Warning: %s has multiple addresses; using %s",
1246 source, inet_ntoa(from->sin_addr));
1251 outip->ip_src = from->sin_addr;
1253 bb_xbind(sndsock, (struct sockaddr *)from, sizeof(*from));
1256 fprintf(stderr, "traceroute to %s (%s)", hostname, inet_ntoa(to->sin_addr));
1258 fprintf(stderr, " from %s", source);
1259 fprintf(stderr, ", %d hops max, %d byte packets\n", max_ttl, packlen);
1260 (void)fflush(stderr);
1262 for (ttl = first_ttl; ttl <= max_ttl; ++ttl) {
1263 u_int32_t lastaddr = 0;
1264 int gotlastaddr = 0;
1266 int unreachable = 0;
1269 printf("%2d ", ttl);
1270 for (probe = 0; probe < nprobes; ++probe) {
1272 struct timeval t1, t2;
1276 if (sentfirst && pausemsecs > 0)
1277 usleep(pausemsecs * 1000);
1278 (void)gettimeofday(&t1, &tz);
1279 send_probe(++seq, ttl, &t1);
1281 while ((cc = wait_for_reply(s, from, &t1)) != 0) {
1282 (void)gettimeofday(&t2, &tz);
1283 i = packet_ok(packet, cc, from, seq);
1284 /* Skip short packet */
1288 from->sin_addr.s_addr != lastaddr) {
1289 print(packet, cc, from);
1290 lastaddr = from->sin_addr.s_addr;
1293 printf(" %.3f ms", deltaT(&t1, &t2));
1294 ip = (struct ip *)packet;
1295 if (op & USAGE_OP_TTL_FLAG)
1296 printf(" (%d)", ip->ip_ttl);
1298 if (ip->ip_ttl <= 1)
1303 /* time exceeded in transit */
1309 case ICMP_UNREACH_PORT:
1310 if (ip->ip_ttl <= 1)
1315 case ICMP_UNREACH_NET:
1320 case ICMP_UNREACH_HOST:
1325 case ICMP_UNREACH_PROTOCOL:
1330 case ICMP_UNREACH_NEEDFRAG:
1332 printf(" !F-%d", pmtu);
1335 case ICMP_UNREACH_SRCFAIL:
1340 case ICMP_UNREACH_FILTER_PROHIB:
1341 case ICMP_UNREACH_NET_PROHIB: /* misuse */
1346 case ICMP_UNREACH_HOST_PROHIB:
1351 case ICMP_UNREACH_HOST_PRECEDENCE:
1356 case ICMP_UNREACH_PRECEDENCE_CUTOFF:
1361 case ICMP_UNREACH_NET_UNKNOWN:
1362 case ICMP_UNREACH_HOST_UNKNOWN:
1367 case ICMP_UNREACH_ISOLATED:
1372 case ICMP_UNREACH_TOSNET:
1373 case ICMP_UNREACH_TOSHOST:
1380 printf(" !<%d>", code);
1387 (void)fflush(stdout);
1391 (unreachable > 0 && unreachable >= nprobes - 1))