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 = 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 = xzalloc(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 = 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, tvwait;
554 socklen_t fromlen = sizeof(*fromp);
559 tvwait.tv_sec = tp->tv_sec + waittime;
560 tvwait.tv_usec = tp->tv_usec;
561 (void)gettimeofday(&now, &tz);
562 tvsub(&tvwait, &now);
564 if (select(sock + 1, &fds, NULL, NULL, &tvwait) > 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 = xzalloc(sizeof(*hi));
876 addr = inet_addr(host);
877 if ((int32_t)addr != -1) {
878 hi->name = xstrdup(host);
880 hi->addrs = xzalloc(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 = xstrdup(hp->h_name);
889 for (n = 0, p = hp->h_addr_list; *p != NULL; ++n, ++p)
892 hi->addrs = xzalloc(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;
946 char *max_ttl_str = NULL;
947 char *port_str = NULL;
949 char *nprobes_str = NULL;
950 char *waittime_str = NULL;
951 u_int pausemsecs = 0;
952 char *pausemsecs_str = NULL;
954 char *first_ttl_str = NULL;
955 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
956 llist_t *sourse_route_list = NULL;
960 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
961 bb_opt_complementally = "x-x:g::";
963 bb_opt_complementally = "x-x";
966 op = bb_getopt_ulflags(argc, argv, "FIlnrdvxt:i:m:p:q:s:w:z:f:"
967 #define USAGE_OP_DONT_FRAGMNT (1<<0) /* F */
968 #define USAGE_OP_USE_ICMP (1<<1) /* I */
969 #define USAGE_OP_TTL_FLAG (1<<2) /* l */
970 #define USAGE_OP_ADDR_NUM (1<<3) /* n */
971 #define USAGE_OP_BYPASS_ROUTE (1<<4) /* r */
972 #define USAGE_OP_DEBUG (1<<5) /* d */
973 #define USAGE_OP_VERBOSE (1<<6) /* v */
974 #define USAGE_OP_IP_CHKSUM (1<<7) /* x */
976 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
979 , &tos_str, &device, &max_ttl_str, &port_str, &nprobes_str,
980 &source, &waittime_str, &pausemsecs_str, &first_ttl_str
981 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
986 if(op & USAGE_OP_DONT_FRAGMNT)
988 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
989 useicmp = op & USAGE_OP_USE_ICMP;
991 nflag = op & USAGE_OP_ADDR_NUM;
992 #ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
993 verbose = op & USAGE_OP_VERBOSE;
995 if(op & USAGE_OP_IP_CHKSUM) {
997 bb_error_msg("Warning: ip checksums disabled");
1000 tos = str2val(tos_str, "tos", 0, 255);
1002 max_ttl = str2val(max_ttl_str, "max ttl", 1, 255);
1004 port = (u_short)str2val(port_str, "port", 1, (1 << 16) - 1);
1006 nprobes = str2val(optarg, "nprobes", 1, -1);
1009 * set the ip source address of the outbound
1010 * probe (e.g., on a multi-homed host).
1012 if (getuid()) bb_error_msg_and_die("-s %s: Permission denied", source);
1015 waittime = str2val(waittime_str, "wait time", 2, 24 * 60 * 60);
1017 pausemsecs = str2val(pausemsecs_str, "pause msecs", 0, 60 * 60 * 1000);
1019 first_ttl = str2val(first_ttl_str, "first ttl", 1, 255);
1021 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
1022 if(sourse_route_list) {
1025 for(l_sr = sourse_route_list; l_sr; ) {
1026 if (lsrr >= NGATEWAYS)
1027 bb_error_msg_and_die("No more than %d gateways", NGATEWAYS);
1028 getaddr(gwlist + lsrr, l_sr->data);
1031 free(sourse_route_list);
1032 sourse_route_list = l_sr;
1034 optlen = (lsrr + 1) * sizeof(gwlist[0]);
1038 if (first_ttl > max_ttl) {
1039 bb_error_msg_and_die(
1040 "first ttl (%d) may not be greater than max ttl (%d)",
1041 first_ttl, max_ttl);
1044 minpacket = sizeof(*outip) + sizeof(*outdata) + optlen;
1046 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
1048 minpacket += 8; /* XXX magic number */
1051 minpacket += sizeof(*outudp);
1052 packlen = minpacket; /* minimum sized packet */
1054 /* Process destination and optional packet size */
1055 switch (argc - optind) {
1058 packlen = str2val(argv[optind + 1],
1059 "packet length", minpacket, maxpacket);
1063 hostname = argv[optind];
1064 hi = gethostinfo(hostname);
1065 setsin(to, hi->addrs[0]);
1068 "Warning: %s has multiple addresses; using %s",
1069 hostname, inet_ntoa(to->sin_addr));
1070 hostname = hi->name;
1080 if ((pe = getprotobyname(cp)) == NULL)
1081 bb_perror_msg_and_die("unknown protocol %s", cp);
1083 /* Insure the socket fds won't be 0, 1 or 2 */
1084 do n = xopen(bb_dev_null, O_RDONLY); while (n < 2);
1088 s = xsocket(AF_INET, SOCK_RAW, pe->p_proto);
1090 #ifdef CONFIG_FEATURE_TRACEROUTE_SO_DEBUG
1091 if (op & USAGE_OP_DEBUG)
1092 (void)setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&on,
1095 if (op & USAGE_OP_BYPASS_ROUTE)
1096 (void)setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
1099 sndsock = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);
1101 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
1102 #if defined(IP_OPTIONS)
1104 unsigned char optlist[MAX_IPOPTLEN];
1107 if ((pe = getprotobyname(cp)) == NULL)
1108 bb_perror_msg_and_die("unknown protocol");
1111 gwlist[lsrr] = to->sin_addr.s_addr;
1114 /* force 4 byte alignment */
1115 optlist[0] = IPOPT_NOP;
1116 /* loose source route option */
1117 optlist[1] = IPOPT_LSRR;
1118 i = lsrr * sizeof(gwlist[0]);
1120 /* Pointer to LSRR addresses */
1121 optlist[3] = IPOPT_MINOFF;
1122 memcpy(optlist + 4, gwlist, i);
1124 if ((setsockopt(sndsock, pe->p_proto, IP_OPTIONS,
1125 (char *)optlist, i + sizeof(gwlist[0]))) < 0) {
1126 bb_perror_msg_and_die("IP_OPTIONS");
1129 #endif /* IP_OPTIONS */
1130 #endif /* CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE */
1133 if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, (char *)&packlen,
1134 sizeof(packlen)) < 0) {
1135 bb_perror_msg_and_die("SO_SNDBUF");
1139 if (setsockopt(sndsock, IPPROTO_IP, IP_HDRINCL, (char *)&on,
1140 sizeof(on)) < 0 && errno != ENOPROTOOPT) {
1141 bb_perror_msg_and_die("IP_HDRINCL");
1145 if (tos_str && setsockopt(sndsock, IPPROTO_IP, IP_TOS,
1146 (char *)&tos, sizeof(tos)) < 0) {
1147 bb_perror_msg_and_die("setsockopt tos %d", tos);
1151 #ifdef CONFIG_FEATURE_TRACEROUTE_SO_DEBUG
1152 if (op & USAGE_OP_DEBUG)
1153 (void)setsockopt(sndsock, SOL_SOCKET, SO_DEBUG, (char *)&on,
1156 if (op & USAGE_OP_BYPASS_ROUTE)
1157 (void)setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
1160 /* Revert to non-privileged user after opening sockets */
1164 outip = (struct ip *)xzalloc(packlen);
1166 outip->ip_v = IPVERSION;
1168 outip->ip_tos = tos;
1169 outip->ip_len = htons(packlen);
1170 outip->ip_off = htons(off);
1171 outp = (unsigned char *)(outip + 1);
1172 outip->ip_dst = to->sin_addr;
1174 outip->ip_hl = (outp - (unsigned char *)outip) >> 2;
1175 ident = (getpid() & 0xffff) | 0x8000;
1176 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
1178 outip->ip_p = IPPROTO_ICMP;
1180 outicmp = (struct icmp *)outp;
1181 outicmp->icmp_type = ICMP_ECHO;
1182 outicmp->icmp_id = htons(ident);
1184 outdata = (struct outdata *)(outp + 8); /* XXX magic number */
1188 outip->ip_p = IPPROTO_UDP;
1190 outudp = (struct udphdr *)outp;
1191 outudp->source = htons(ident);
1193 htons((u_short)(packlen - (sizeof(*outip) + optlen)));
1194 outdata = (struct outdata *)(outudp + 1);
1197 /* Get the interface address list */
1198 n = ifaddrlist(&al);
1200 /* Look for a specific device */
1201 if (device != NULL) {
1202 for (i = n; i > 0; --i, ++al)
1203 if (strcmp(device, al->device) == 0)
1206 bb_error_msg_and_die("Can't find interface %s", device);
1210 /* Determine our source address */
1211 if (source == NULL) {
1213 * If a device was specified, use the interface address.
1214 * Otherwise, try to determine our source address.
1217 setsin(from, al->addr);
1218 findsaddr(to, from);
1220 hi = gethostinfo(source);
1224 * If the device was specified make sure it
1225 * corresponds to the source address specified.
1226 * Otherwise, use the first address (and warn if
1227 * there are more than one).
1229 if (device != NULL) {
1230 for (i = hi->n, ap = hi->addrs; i > 0; --i, ++ap)
1231 if (*ap == al->addr)
1234 bb_error_msg_and_die(
1235 "%s is not on interface %s",
1240 setsin(from, hi->addrs[0]);
1243 "Warning: %s has multiple addresses; using %s",
1244 source, inet_ntoa(from->sin_addr));
1249 outip->ip_src = from->sin_addr;
1251 xbind(sndsock, (struct sockaddr *)from, sizeof(*from));
1254 fprintf(stderr, "traceroute to %s (%s)", hostname, inet_ntoa(to->sin_addr));
1256 fprintf(stderr, " from %s", source);
1257 fprintf(stderr, ", %d hops max, %d byte packets\n", max_ttl, packlen);
1258 (void)fflush(stderr);
1260 for (ttl = first_ttl; ttl <= max_ttl; ++ttl) {
1261 u_int32_t lastaddr = 0;
1262 int gotlastaddr = 0;
1264 int unreachable = 0;
1267 printf("%2d ", ttl);
1268 for (probe = 0; probe < nprobes; ++probe) {
1270 struct timeval t1, t2;
1274 if (sentfirst && pausemsecs > 0)
1275 usleep(pausemsecs * 1000);
1276 (void)gettimeofday(&t1, &tz);
1277 send_probe(++seq, ttl, &t1);
1279 while ((cc = wait_for_reply(s, from, &t1)) != 0) {
1280 (void)gettimeofday(&t2, &tz);
1281 i = packet_ok(packet, cc, from, seq);
1282 /* Skip short packet */
1286 from->sin_addr.s_addr != lastaddr) {
1287 print(packet, cc, from);
1288 lastaddr = from->sin_addr.s_addr;
1291 printf(" %.3f ms", deltaT(&t1, &t2));
1292 ip = (struct ip *)packet;
1293 if (op & USAGE_OP_TTL_FLAG)
1294 printf(" (%d)", ip->ip_ttl);
1296 if (ip->ip_ttl <= 1)
1301 /* time exceeded in transit */
1307 case ICMP_UNREACH_PORT:
1308 if (ip->ip_ttl <= 1)
1313 case ICMP_UNREACH_NET:
1318 case ICMP_UNREACH_HOST:
1323 case ICMP_UNREACH_PROTOCOL:
1328 case ICMP_UNREACH_NEEDFRAG:
1330 printf(" !F-%d", pmtu);
1333 case ICMP_UNREACH_SRCFAIL:
1338 case ICMP_UNREACH_FILTER_PROHIB:
1339 case ICMP_UNREACH_NET_PROHIB: /* misuse */
1344 case ICMP_UNREACH_HOST_PROHIB:
1349 case ICMP_UNREACH_HOST_PRECEDENCE:
1354 case ICMP_UNREACH_PRECEDENCE_CUTOFF:
1359 case ICMP_UNREACH_NET_UNKNOWN:
1360 case ICMP_UNREACH_HOST_UNKNOWN:
1365 case ICMP_UNREACH_ISOLATED:
1370 case ICMP_UNREACH_TOSNET:
1371 case ICMP_UNREACH_TOSHOST:
1378 printf(" !<%d>", code);
1385 (void)fflush(stdout);
1389 (unreachable > 0 && unreachable >= nprobes - 1))