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.
26 * traceroute host - trace the route ip packets follow going to "host".
28 * Attempt to trace the route an ip packet would follow to some
29 * internet host. We find out intermediate hops by launching probe
30 * packets with a small ttl (time to live) then listening for an
31 * icmp "time exceeded" reply from a gateway. We start our probes
32 * with a ttl of one and increase by one until we get an icmp "port
33 * unreachable" (which means we got to "host") or hit a max (which
34 * defaults to 30 hops & can be changed with the -m flag). Three
35 * probes (change with -q flag) are sent at each ttl setting and a
36 * line is printed showing the ttl, address of the gateway and
37 * round trip time of each probe. If the probe answers come from
38 * different gateways, the address of each responding system will
39 * be printed. If there is no response within a 5 sec. timeout
40 * interval (changed with the -w flag), a "*" is printed for that
43 * Probe packets are UDP format. We don't want the destination
44 * host to process them so the destination port is set to an
45 * unlikely value (if some clod on the destination is using that
46 * value, it can be changed with the -p flag).
48 * A sample use might be:
50 * [yak 71]% traceroute nis.nsf.net.
51 * traceroute to nis.nsf.net (35.1.1.48), 30 hops max, 56 byte packet
52 * 1 helios.ee.lbl.gov (128.3.112.1) 19 ms 19 ms 0 ms
53 * 2 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 39 ms 19 ms
54 * 3 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 39 ms 19 ms
55 * 4 ccngw-ner-cc.Berkeley.EDU (128.32.136.23) 39 ms 40 ms 39 ms
56 * 5 ccn-nerif22.Berkeley.EDU (128.32.168.22) 39 ms 39 ms 39 ms
57 * 6 128.32.197.4 (128.32.197.4) 40 ms 59 ms 59 ms
58 * 7 131.119.2.5 (131.119.2.5) 59 ms 59 ms 59 ms
59 * 8 129.140.70.13 (129.140.70.13) 99 ms 99 ms 80 ms
60 * 9 129.140.71.6 (129.140.71.6) 139 ms 239 ms 319 ms
61 * 10 129.140.81.7 (129.140.81.7) 220 ms 199 ms 199 ms
62 * 11 nic.merit.edu (35.1.1.48) 239 ms 239 ms 239 ms
64 * Note that lines 2 & 3 are the same. This is due to a buggy
65 * kernel on the 2nd hop system -- lbl-csam.arpa -- that forwards
66 * packets with a zero ttl.
68 * A more interesting example is:
70 * [yak 72]% traceroute allspice.lcs.mit.edu.
71 * traceroute to allspice.lcs.mit.edu (18.26.0.115), 30 hops max
72 * 1 helios.ee.lbl.gov (128.3.112.1) 0 ms 0 ms 0 ms
73 * 2 lilac-dmc.Berkeley.EDU (128.32.216.1) 19 ms 19 ms 19 ms
74 * 3 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 19 ms 19 ms
75 * 4 ccngw-ner-cc.Berkeley.EDU (128.32.136.23) 19 ms 39 ms 39 ms
76 * 5 ccn-nerif22.Berkeley.EDU (128.32.168.22) 20 ms 39 ms 39 ms
77 * 6 128.32.197.4 (128.32.197.4) 59 ms 119 ms 39 ms
78 * 7 131.119.2.5 (131.119.2.5) 59 ms 59 ms 39 ms
79 * 8 129.140.70.13 (129.140.70.13) 80 ms 79 ms 99 ms
80 * 9 129.140.71.6 (129.140.71.6) 139 ms 139 ms 159 ms
81 * 10 129.140.81.7 (129.140.81.7) 199 ms 180 ms 300 ms
82 * 11 129.140.72.17 (129.140.72.17) 300 ms 239 ms 239 ms
84 * 13 128.121.54.72 (128.121.54.72) 259 ms 499 ms 279 ms
89 * 18 ALLSPICE.LCS.MIT.EDU (18.26.0.115) 339 ms 279 ms 279 ms
91 * (I start to see why I'm having so much trouble with mail to
92 * MIT.) Note that the gateways 12, 14, 15, 16 & 17 hops away
93 * either don't send ICMP "time exceeded" messages or send them
94 * with a ttl too small to reach us. 14 - 17 are running the
95 * MIT C Gateway code that doesn't send "time exceeded"s. God
96 * only knows what's going on with 12.
98 * The silent gateway 12 in the above may be the result of a bug in
99 * the 4.[23]BSD network code (and its derivatives): 4.x (x <= 3)
100 * sends an unreachable message using whatever ttl remains in the
101 * original datagram. Since, for gateways, the remaining ttl is
102 * zero, the icmp "time exceeded" is guaranteed to not make it back
103 * to us. The behavior of this bug is slightly more interesting
104 * when it appears on the destination system:
106 * 1 helios.ee.lbl.gov (128.3.112.1) 0 ms 0 ms 0 ms
107 * 2 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 19 ms 39 ms
108 * 3 lilac-dmc.Berkeley.EDU (128.32.216.1) 19 ms 39 ms 19 ms
109 * 4 ccngw-ner-cc.Berkeley.EDU (128.32.136.23) 39 ms 40 ms 19 ms
110 * 5 ccn-nerif35.Berkeley.EDU (128.32.168.35) 39 ms 39 ms 39 ms
111 * 6 csgw.Berkeley.EDU (128.32.133.254) 39 ms 59 ms 39 ms
118 * 13 rip.Berkeley.EDU (128.32.131.22) 59 ms ! 39 ms ! 39 ms !
120 * Notice that there are 12 "gateways" (13 is the final
121 * destination) and exactly the last half of them are "missing".
122 * What's really happening is that rip (a Sun-3 running Sun OS3.5)
123 * is using the ttl from our arriving datagram as the ttl in its
124 * icmp reply. So, the reply will time out on the return path
125 * (with no notice sent to anyone since icmp's aren't sent for
126 * icmp's) until we probe with a ttl that's at least twice the path
127 * length. I.e., rip is really only 7 hops away. A reply that
128 * returns with a ttl of 1 is a clue this problem exists.
129 * Traceroute prints a "!" after the time if the ttl is <= 1.
130 * Since vendors ship a lot of obsolete (DEC's Ultrix, Sun 3.x) or
131 * non-standard (HPUX) software, expect to see this problem
132 * frequently and/or take care picking the target host of your
135 * Other possible annotations after the time are !H, !N, !P (got a host,
136 * network or protocol unreachable, respectively), !S or !F (source
137 * route failed or fragmentation needed -- neither of these should
138 * ever occur and the associated gateway is busted if you see one). If
139 * almost all the probes result in some kind of unreachable, traceroute
140 * will give up and exit.
144 * This program must be run by root or be setuid. (I suggest that
145 * you *don't* make it setuid -- casual use could result in a lot
146 * of unnecessary traffic on our poor, congested nets.)
148 * This program requires a kernel mod that does not appear in any
149 * system available from Berkeley: A raw ip socket using proto
150 * IPPROTO_RAW must interpret the data sent as an ip datagram (as
151 * opposed to data to be wrapped in a ip datagram). See the README
152 * file that came with the source to this program for a description
153 * of the mods I made to /sys/netinet/raw_ip.c. Your mileage may
154 * vary. But, again, ANY 4.x (x < 4) BSD KERNEL WILL HAVE TO BE
155 * MODIFIED TO RUN THIS PROGRAM.
157 * The udp port usage may appear bizarre (well, ok, it is bizarre).
158 * The problem is that an icmp message only contains 8 bytes of
159 * data from the original datagram. 8 bytes is the size of a udp
160 * header so, if we want to associate replies with the original
161 * datagram, the necessary information must be encoded into the
162 * udp header (the ip id could be used but there's no way to
163 * interlock with the kernel's assignment of ip id's and, anyway,
164 * it would have taken a lot more kernel hacking to allow this
165 * code to set the ip id). So, to allow two or more users to
166 * use traceroute simultaneously, we use this task's pid as the
167 * source port (the high bit is set to move the port number out
168 * of the "likely" range). To keep track of which probe is being
169 * replied to (so times and/or hop counts don't get confused by a
170 * reply that was delayed in transit), we increment the destination
171 * port number before each probe.
173 * Don't use this as a coding example. I was trying to find a
174 * routing problem and this code sort-of popped out after 48 hours
175 * without sleep. I was amazed it ever compiled, much less ran.
177 * I stole the idea for this program from Steve Deering. Since
178 * the first release, I've learned that had I attended the right
179 * IETF working group meetings, I also could have stolen it from Guy
180 * Almes or Matt Mathis. I don't know (or care) who came up with
181 * the idea first. I envy the originators' perspicacity and I'm
182 * glad they didn't keep the idea a secret.
184 * Tim Seaver, Ken Adelman and C. Philip Wood provided bug fixes and/or
185 * enhancements to the original distribution.
187 * I've hacked up a round-trip-route version of this that works by
188 * sending a loose-source-routed udp datagram through the destination
189 * back to yourself. Unfortunately, SO many gateways botch source
190 * routing, the thing is almost worthless. Maybe one day...
192 * -- Van Jacobson (van@ee.lbl.gov)
193 * Tue Dec 20 03:50:13 PST 1988
196 #define TRACEROUTE_SO_DEBUG 0
198 /* TODO: undefs were uncommented - ??! we have config system for that! */
199 /* probably ok to remove altogether */
200 //#undef CONFIG_FEATURE_TRACEROUTE_VERBOSE
201 //#define CONFIG_FEATURE_TRACEROUTE_VERBOSE
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
209 #include <arpa/inet.h>
210 #include <netinet/in.h>
211 #include <netinet/udp.h>
212 #include <netinet/ip.h>
213 #include <netinet/ip_icmp.h>
216 #include "inet_common.h"
220 * Definitions for internet protocol version 4.
221 * Per RFC 791, September 1981.
227 #define IPPROTO_ICMP 1
234 * Overlay for ip header used by other protocols (tcp, udp).
237 unsigned char ih_x1[9]; /* (unused) */
238 unsigned char ih_pr; /* protocol */
239 short ih_len; /* protocol length */
240 struct in_addr ih_src; /* source internet address */
241 struct in_addr ih_dst; /* destination internet address */
245 * UDP kernel structures and variables.
248 struct ipovly ui_i; /* overlaid ip structure */
249 struct udphdr ui_u; /* udp header */
251 #define ui_next ui_i.ih_next
252 #define ui_prev ui_i.ih_prev
253 #define ui_x1 ui_i.ih_x1
254 #define ui_pr ui_i.ih_pr
255 #define ui_len ui_i.ih_len
256 #define ui_src ui_i.ih_src
257 #define ui_dst ui_i.ih_dst
258 #define ui_sport ui_u.uh_sport
259 #define ui_dport ui_u.uh_dport
260 #define ui_ulen ui_u.uh_ulen
261 #define ui_sum ui_u.uh_sum
264 /* Host name and address list */
271 /* Data section of the probe packet */
272 typedef struct outdata {
273 unsigned char seq; /* sequence number of this packet */
274 unsigned char ttl; /* ttl packet left with */
275 // UNUSED. Retaining to have the same packet size.
276 struct timeval tv_UNUSED ATTRIBUTE_PACKED; /* time packet left */
281 char device[sizeof(struct ifreq)];
285 /* Keep in sync with getopt32 call! */
286 #define OPT_DONT_FRAGMNT (1<<0) /* F */
287 #define OPT_USE_ICMP (1<<1) /* I */
288 #define OPT_TTL_FLAG (1<<2) /* l */
289 #define OPT_ADDR_NUM (1<<3) /* n */
290 #define OPT_BYPASS_ROUTE (1<<4) /* r */
291 #define OPT_DEBUG (1<<5) /* d */
292 #define OPT_VERBOSE (1<<6) /* v */
293 #define OPT_IP_CHKSUM (1<<7) /* x */
294 #define OPT_TOS (1<<8) /* t */
295 #define OPT_DEVICE (1<<9) /* i */
296 #define OPT_MAX_TTL (1<<10) /* m */
297 #define OPT_PORT (1<<11) /* p */
298 #define OPT_NPROBES (1<<12) /* q */
299 #define OPT_SOURCE (1<<13) /* s */
300 #define OPT_WAITTIME (1<<14) /* w */
301 #define OPT_PAUSE_MS (1<<15) /* z */
302 #define OPT_FIRST_TTL (1<<16) /* f */
304 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
305 /* use icmp echo instead of udp packets */
306 #define useicmp (option_mask32 & OPT_USE_ICMP)
308 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
309 #define verbose (option_mask32 & OPT_VERBOSE)
311 #define nflag (option_mask32 & OPT_ADDR_NUM)
315 struct ip *outip; /* last output (udp) packet */
316 struct udphdr *outudp; /* last output (udp) packet */
317 struct outdata *outdata; /* last output (udp) packet */
319 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
320 struct icmp *outicmp; /* last output (icmp) packet */
323 int rcvsock; /* receive (icmp) socket file descriptor */
324 int sndsock; /* send (udp/icmp) socket file descriptor */
326 int packlen; /* total length of packet */
327 int minpacket; /* min ip packet size */
328 int maxpacket; // 32 * 1024; /* max ip packet size */
329 int pmtu; /* Path MTU Discovery (RFC1191) */
334 uint16_t port; // 32768 + 666; /* start udp dest port # for probe packets */
336 int waittime; // 5; /* time to wait for response (in seconds) */
337 int doipcksum; // 1; /* calculate ip checksums by default */
339 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
340 int optlen; /* length of ip options */
345 struct sockaddr_storage whereto; /* Who to try to reach */
346 struct sockaddr_storage wherefrom; /* Who we are */
347 /* last inbound (icmp) packet */
348 unsigned char packet[512];
349 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
350 /* Maximum number of gateways (include room for one noop) */
351 #define NGATEWAYS ((int)((MAX_IPOPTLEN - IPOPT_MINOFF - 1) / sizeof(uint32_t)))
352 /* loose source route gateway list (including room for final destination) */
353 uint32_t gwlist[NGATEWAYS + 1];
357 #define G (*ptr_to_globals)
358 #define outip (G.outip )
359 #define outudp (G.outudp )
360 #define outdata (G.outdata )
361 #define outicmp (G.outicmp )
362 #define rcvsock (G.rcvsock )
363 #define sndsock (G.sndsock )
364 #define packlen (G.packlen )
365 #define minpacket (G.minpacket)
366 #define maxpacket (G.maxpacket)
367 #define pmtu (G.pmtu )
368 #define hostname (G.hostname )
369 #define ident (G.ident )
370 #define port (G.port )
371 #define waittime (G.waittime )
372 #define doipcksum (G.doipcksum)
373 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
374 #define optlen (G.optlen )
376 #define packet (G.packet )
377 #define whereto (G.whereto )
378 #define wherefrom (G.wherefrom)
379 #define gwlist (G.gwlist )
380 #define INIT_G() do { \
381 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
382 maxpacket = 32 * 1024; \
383 port = 32768 + 666; \
390 * Return the interface list
393 ifaddrlist(struct IFADDRLIST **ipaddrp)
395 enum { IFREQ_BUFSIZE = (32 * 1024) / sizeof(struct ifreq) };
398 #ifdef HAVE_SOCKADDR_SA_LEN
401 struct ifreq *ifrp, *ifend, *ifnext;
402 struct sockaddr_in *addr_sin;
403 struct IFADDRLIST *al;
406 /* Was on stack, but 32k is a bit too much: */
407 struct ifreq *ibuf = xmalloc(IFREQ_BUFSIZE * sizeof(ibuf[0]));
408 struct IFADDRLIST *st_ifaddrlist;
410 fd = xsocket(AF_INET, SOCK_DGRAM, 0);
412 ifc.ifc_len = IFREQ_BUFSIZE * sizeof(ibuf[0]);
413 ifc.ifc_buf = (caddr_t)ibuf;
415 if (ioctl(fd, SIOCGIFCONF, (char *)&ifc) < 0
416 || ifc.ifc_len < sizeof(struct ifreq)
419 bb_error_msg_and_die(
420 "SIOCGIFCONF: ifreq struct too small (%u bytes)",
421 (unsigned)(IFREQ_BUFSIZE * sizeof(ibuf[0])));
422 bb_perror_msg_and_die("SIOCGIFCONF");
425 ifend = (struct ifreq *)((char *)ibuf + ifc.ifc_len);
427 nipaddr = 1 + (ifc.ifc_len / sizeof(struct ifreq));
428 st_ifaddrlist = xzalloc(nipaddr * sizeof(struct IFADDRLIST));
432 for (; ifrp < ifend; ifrp = ifnext) {
433 #ifdef HAVE_SOCKADDR_SA_LEN
434 n = ifrp->ifr_addr.sa_len + sizeof(ifrp->ifr_name);
435 if (n < sizeof(*ifrp))
438 ifnext = (struct ifreq *)((char *)ifrp + n);
439 if (ifrp->ifr_addr.sa_family != AF_INET)
445 * Need a template to preserve address info that is
446 * used below to locate the next entry. (Otherwise,
447 * SIOCGIFFLAGS stomps over it because the requests
448 * are returned in a union.)
450 strncpy(ifr.ifr_name, ifrp->ifr_name, sizeof(ifr.ifr_name));
451 if (ioctl(fd, SIOCGIFFLAGS, (char *)&ifr) < 0) {
454 bb_perror_msg_and_die("SIOCGIFFLAGS: %.*s",
455 (int)sizeof(ifr.ifr_name), ifr.ifr_name);
459 if ((ifr.ifr_flags & IFF_UP) == 0)
462 safe_strncpy(al->device, ifr.ifr_name, sizeof(ifr.ifr_name) + 1);
464 /* Ignore sun virtual interfaces */
465 if (strchr(al->device, ':') != NULL)
468 ioctl_or_perror_and_die(fd, SIOCGIFADDR, (char *)&ifr,
469 "SIOCGIFADDR: %s", al->device);
471 addr_sin = (struct sockaddr_in *)&ifr.ifr_addr;
472 al->addr = addr_sin->sin_addr.s_addr;
477 bb_error_msg_and_die("can't find any network interfaces");
481 *ipaddrp = st_ifaddrlist;
487 setsin(struct sockaddr_in *addr_sin, uint32_t addr)
489 memset(addr_sin, 0, sizeof(*addr_sin));
490 #ifdef HAVE_SOCKADDR_SA_LEN
491 addr_sin->sin_len = sizeof(*addr_sin);
493 addr_sin->sin_family = AF_INET;
494 addr_sin->sin_addr.s_addr = addr;
499 * Return the source address for the given destination address
502 findsaddr(const struct sockaddr_in *to, struct sockaddr_in *from)
507 uint32_t dest, tmask;
508 struct IFADDRLIST *al;
509 char buf[256], tdevice[256], device[256];
511 f = xfopen("/proc/net/route", "r");
513 /* Find the appropriate interface */
517 while (fgets(buf, sizeof(buf), f) != NULL) {
519 if (n == 1 && strncmp(buf, "Iface", 5) == 0)
521 i = sscanf(buf, "%255s %x %*s %*s %*s %*s %*s %x",
522 tdevice, &dest, &tmask);
524 bb_error_msg_and_die("junk in buffer");
525 if ((to->sin_addr.s_addr & tmask) == dest
526 && (tmask > mask || mask == 0)
529 strcpy(device, tdevice);
534 if (device[0] == '\0')
535 bb_error_msg_and_die("can't find interface");
537 /* Get the interface address list */
540 /* Find our appropriate source address */
541 for (i = n; i > 0; --i, ++al)
542 if (strcmp(device, al->device) == 0)
545 bb_error_msg_and_die("can't find interface %s", device);
547 setsin(from, al->addr);
551 "Usage: %s [-dFIlnrvx] [-g gateway] [-i iface] [-f first_ttl]\n"
552 "\t[-m max_ttl] [ -p port] [-q nqueries] [-s src_addr] [-t tos]\n"
553 "\t[-w waittime] [-z pausemsecs] host [packetlen]"
558 wait_for_reply(int sock, struct sockaddr_in *fromp)
560 struct pollfd pfd[1];
562 socklen_t fromlen = sizeof(*fromp);
565 pfd[0].events = POLLIN;
566 if (safe_poll(pfd, 1, waittime * 1000) > 0)
567 cc = recvfrom(sock, packet, sizeof(packet), 0,
568 (struct sockaddr *)fromp, &fromlen);
573 * Checksum routine for Internet Protocol family headers (C Version)
576 in_cksum(uint16_t *addr, int len)
584 * Our algorithm is simple, using a 32 bit accumulator (sum),
585 * we add sequential 16 bit words to it, and at the end, fold
586 * back all the carry bits from the top 16 bits into the lower
594 /* mop up an odd byte, if necessary */
596 sum += *(unsigned char *)w;
599 * add back carry outs from top 16 bits to low 16 bits
601 sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
602 sum += (sum >> 16); /* add carry */
603 answer = ~sum; /* truncate to 16 bits */
609 send_probe(int seq, int ttl)
612 struct udpiphdr *ui, *oui;
616 outip->ip_id = htons(ident + seq);
619 * In most cases, the kernel will recalculate the ip checksum.
620 * But we must do it anyway so that the udp checksum comes out
625 in_cksum((uint16_t *)outip, sizeof(*outip) + optlen);
626 if (outip->ip_sum == 0)
627 outip->ip_sum = 0xffff;
633 // UNUSED: was storing gettimeofday's result there, but never ever checked it
634 /*memcpy(&outdata->tv, tp, sizeof(outdata->tv));*/
636 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
638 outicmp->icmp_seq = htons(seq);
641 outudp->dest = htons(port + seq);
643 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
645 /* Always calculate checksum for icmp packets */
646 outicmp->icmp_cksum = 0;
647 outicmp->icmp_cksum = in_cksum((uint16_t *)outicmp,
648 packlen - (sizeof(*outip) + optlen));
649 if (outicmp->icmp_cksum == 0)
650 outicmp->icmp_cksum = 0xffff;
654 /* Checksum (we must save and restore ip header) */
656 ui = (struct udpiphdr *)outip;
657 oui = (struct udpiphdr *)&tip;
658 /* Easier to zero and put back things that are ok */
659 memset((char *)ui, 0, sizeof(ui->ui_i));
660 ui->ui_src = oui->ui_src;
661 ui->ui_dst = oui->ui_dst;
662 ui->ui_pr = oui->ui_pr;
663 ui->ui_len = outudp->len;
665 outudp->check = in_cksum((uint16_t *)ui, packlen);
666 if (outudp->check == 0)
667 outudp->check = 0xffff;
671 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
672 /* XXX undocumented debugging hack */
677 sp = (uint16_t *)outip;
678 nshorts = (unsigned)packlen / sizeof(uint16_t);
680 printf("[ %d bytes", packlen);
681 while (--nshorts >= 0) {
684 printf(" %04x", ntohs(*sp));
690 printf(" %02x", *(unsigned char *)sp);
696 #if !defined(IP_HDRINCL) && defined(IP_TTL)
697 if (setsockopt(sndsock, IPPROTO_IP, IP_TTL,
698 (char *)&ttl, sizeof(ttl)) < 0) {
699 bb_perror_msg_and_die("setsockopt ttl %d", ttl);
703 cc = xsendto(sndsock, (char *)outip,
704 packlen, (struct sockaddr *)&whereto, sizeof(whereto));
706 bb_info_msg("wrote %s %d chars, ret=%d", hostname, packlen, cc);
710 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
712 * Convert an ICMP "type" field to a printable string.
714 static inline const char *
715 pr_type(unsigned char t)
717 static const char *const ttab[] = {
718 "Echo Reply", "ICMP 1", "ICMP 2", "Dest Unreachable",
719 "Source Quench", "Redirect", "ICMP 6", "ICMP 7",
720 "Echo", "Router Advert", "Router Solicit", "Time Exceeded",
721 "Param Problem", "Timestamp", "Timestamp Reply", "Info Request",
722 "Info Reply", "Mask Request", "Mask Reply"
726 return "OUT-OF-RANGE";
732 #if !ENABLE_FEATURE_TRACEROUTE_VERBOSE
733 #define packet_ok(buf, cc, from, seq) \
734 packet_ok(buf, cc, seq)
737 packet_ok(unsigned char *buf, int cc, struct sockaddr_in *from, int seq)
740 unsigned char type, code;
744 ip = (struct ip *) buf;
745 hlen = ip->ip_hl << 2;
746 if (cc < hlen + ICMP_MINLEN) {
747 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
749 printf("packet too short (%d bytes) from %s\n", cc,
750 inet_ntoa(from->sin_addr));
755 icp = (struct icmp *)(buf + hlen);
756 type = icp->icmp_type;
757 code = icp->icmp_code;
758 /* Path MTU Discovery (RFC1191) */
759 if (code != ICMP_UNREACH_NEEDFRAG)
762 pmtu = ntohs(icp->icmp_nextmtu);
764 if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS) ||
765 type == ICMP_UNREACH || type == ICMP_ECHOREPLY) {
770 hlen = hip->ip_hl << 2;
771 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
776 if (type == ICMP_ECHOREPLY &&
777 icp->icmp_id == htons(ident) &&
778 icp->icmp_seq == htons(seq))
781 hicmp = (struct icmp *)((unsigned char *)hip + hlen);
782 /* XXX 8 is a magic number */
783 if (hlen + 8 <= cc &&
784 hip->ip_p == IPPROTO_ICMP &&
785 hicmp->icmp_id == htons(ident) &&
786 hicmp->icmp_seq == htons(seq))
787 return (type == ICMP_TIMXCEED ? -1 : code + 1);
791 up = (struct udphdr *)((unsigned char *)hip + hlen);
792 /* XXX 8 is a magic number */
793 if (hlen + 12 <= cc &&
794 hip->ip_p == IPPROTO_UDP &&
795 up->source == htons(ident) &&
796 up->dest == htons(port + seq))
797 return (type == ICMP_TIMXCEED ? -1 : code + 1);
800 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
803 uint32_t *lp = (uint32_t *)&icp->icmp_ip;
805 printf("\n%d bytes from %s to "
806 "%s: icmp type %d (%s) code %d\n",
807 cc, inet_ntoa(from->sin_addr),
808 inet_ntoa(ip->ip_dst), type, pr_type(type), icp->icmp_code);
809 for (i = 4; i < cc; i += sizeof(*lp))
810 printf("%2d: x%8.8x\n", i, *lp++);
818 * Construct an Internet address representation.
819 * If the nflag has been supplied, give
820 * numeric value, otherwise try for symbolic name.
823 print_inetname(struct sockaddr_in *from)
827 ina = inet_ntoa(from->sin_addr);
832 if (from->sin_addr.s_addr != INADDR_ANY)
833 n = xmalloc_sockaddr2host_noport((struct sockaddr*)from);
834 printf(" %s (%s)", (n ? n : ina), ina);
840 print(unsigned char *buf, int cc, struct sockaddr_in *from)
845 ip = (struct ip *) buf;
846 hlen = ip->ip_hl << 2;
849 print_inetname(from);
850 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
852 printf(" %d bytes to %s", cc, inet_ntoa(ip->ip_dst));
857 static struct hostinfo *
858 gethostinfo(const char *host)
866 hi = xzalloc(sizeof(*hi));
867 addr = inet_addr(host);
868 if (addr != 0xffffffff) {
869 hi->name = xstrdup(host);
871 hi->addrs = xzalloc(sizeof(hi->addrs[0]));
876 hp = xgethostbyname(host);
877 if (hp->h_addrtype != AF_INET || hp->h_length != 4)
878 bb_perror_msg_and_die("bad host %s", host);
879 hi->name = xstrdup(hp->h_name);
880 for (n = 0, p = hp->h_addr_list; *p != NULL; ++n, ++p)
883 hi->addrs = xzalloc(n * sizeof(hi->addrs[0]));
884 for (ap = hi->addrs, p = hp->h_addr_list; *p != NULL; ++ap, ++p)
885 memcpy(ap, *p, sizeof(*ap));
890 freehostinfo(struct hostinfo *hi)
897 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
899 getaddr(uint32_t *ap, const char *host)
903 hi = gethostinfo(host);
910 print_delta_ms(unsigned t1p, unsigned t2p)
912 unsigned tt = t2p - t1p;
913 printf(" %u.%03u ms", tt/1000, tt%1000);
916 int traceroute_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
917 int traceroute_main(int argc, char **argv)
922 struct sockaddr_in *from;
923 struct sockaddr_in *to;
931 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
935 struct IFADDRLIST *al;
943 unsigned pausemsecs = 0;
944 char *pausemsecs_str;
947 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
948 llist_t *source_route_list = NULL;
952 from = (struct sockaddr_in *)&wherefrom;
953 to = (struct sockaddr_in *)&whereto;
956 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
957 opt_complementary = "x-x:g::";
959 opt_complementary = "x-x";
962 op = getopt32(argv, "FIlnrdvxt:i:m:p:q:s:w:z:f:"
963 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
966 , &tos_str, &device, &max_ttl_str, &port_str, &nprobes_str
967 , &source, &waittime_str, &pausemsecs_str, &first_ttl_str
968 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
973 if (op & OPT_DONT_FRAGMNT)
975 if (op & OPT_IP_CHKSUM) {
977 bb_error_msg("warning: ip checksums disabled");
980 tos = xatou_range(tos_str, 0, 255);
981 if (op & OPT_MAX_TTL)
982 max_ttl = xatou_range(max_ttl_str, 1, 255);
984 port = xatou16(port_str);
985 if (op & OPT_NPROBES)
986 nprobes = xatou_range(nprobes_str, 1, INT_MAX);
987 if (op & OPT_SOURCE) {
989 * set the ip source address of the outbound
990 * probe (e.g., on a multi-homed host).
993 bb_error_msg_and_die("-s %s: permission denied", source);
995 if (op & OPT_WAITTIME)
996 waittime = xatou_range(waittime_str, 2, 24 * 60 * 60);
997 if (op & OPT_PAUSE_MS)
998 pausemsecs = xatou_range(pausemsecs_str, 0, 60 * 60 * 1000);
999 if (op & OPT_FIRST_TTL)
1000 first_ttl = xatou_range(first_ttl_str, 1, 255);
1002 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
1003 if (source_route_list) {
1006 l_sr = source_route_list;
1008 if (lsrr >= NGATEWAYS)
1009 bb_error_msg_and_die("no more than %d gateways", NGATEWAYS);
1010 getaddr(gwlist + lsrr, l_sr->data);
1013 free(source_route_list);
1014 source_route_list = l_sr;
1016 optlen = (lsrr + 1) * sizeof(gwlist[0]);
1020 if (first_ttl > max_ttl) {
1021 bb_error_msg_and_die(
1022 "first ttl (%d) may not be greater than max ttl (%d)",
1023 first_ttl, max_ttl);
1026 minpacket = sizeof(*outip) + sizeof(*outdata) + optlen;
1028 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
1030 minpacket += 8; /* XXX magic number */
1033 minpacket += sizeof(*outudp);
1034 packlen = minpacket; /* minimum sized packet */
1036 /* Process destination and optional packet size */
1037 switch (argc - optind) {
1040 packlen = xatoul_range(argv[optind + 1], minpacket, maxpacket);
1044 hostname = argv[optind];
1045 hi = gethostinfo(hostname);
1046 setsin(to, hi->addrs[0]);
1048 bb_error_msg("warning: %s has multiple addresses; using %s",
1049 hostname, inet_ntoa(to->sin_addr));
1050 hostname = hi->name;
1059 /* Ensure the socket fds won't be 0, 1 or 2 */
1060 bb_sanitize_stdio();
1062 rcvsock = xsocket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
1064 #if TRACEROUTE_SO_DEBUG
1066 setsockopt(rcvsock, SOL_SOCKET, SO_DEBUG,
1067 &const_int_1, sizeof(const_int_1));
1069 if (op & OPT_BYPASS_ROUTE)
1070 setsockopt(rcvsock, SOL_SOCKET, SO_DONTROUTE,
1071 &const_int_1, sizeof(const_int_1));
1073 sndsock = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);
1075 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
1076 #if defined(IP_OPTIONS)
1078 unsigned char optlist[MAX_IPOPTLEN];
1081 gwlist[lsrr] = to->sin_addr.s_addr;
1084 /* force 4 byte alignment */
1085 optlist[0] = IPOPT_NOP;
1086 /* loose source route option */
1087 optlist[1] = IPOPT_LSRR;
1088 i = lsrr * sizeof(gwlist[0]);
1090 /* Pointer to LSRR addresses */
1091 optlist[3] = IPOPT_MINOFF;
1092 memcpy(optlist + 4, gwlist, i);
1094 if ((setsockopt(sndsock, IPPROTO_IP, IP_OPTIONS,
1095 (char *)optlist, i + sizeof(gwlist[0]))) < 0) {
1096 bb_perror_msg_and_die("IP_OPTIONS");
1099 #endif /* IP_OPTIONS */
1100 #endif /* CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE */
1103 if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, &packlen, sizeof(packlen)) < 0) {
1104 bb_perror_msg_and_die("SO_SNDBUF");
1108 if (setsockopt(sndsock, IPPROTO_IP, IP_HDRINCL, &const_int_1, sizeof(const_int_1)) < 0
1109 && errno != ENOPROTOOPT
1111 bb_perror_msg_and_die("IP_HDRINCL");
1115 if (tos_str && setsockopt(sndsock, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)) < 0) {
1116 bb_perror_msg_and_die("setsockopt tos %d", tos);
1120 #if TRACEROUTE_SO_DEBUG
1122 setsockopt(sndsock, SOL_SOCKET, SO_DEBUG,
1123 &const_int_1, sizeof(const_int_1));
1125 if (op & OPT_BYPASS_ROUTE)
1126 setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE,
1127 &const_int_1, sizeof(const_int_1));
1129 /* Revert to non-privileged user after opening sockets */
1133 outip = xzalloc(packlen);
1135 outip->ip_v = IPVERSION;
1137 outip->ip_tos = tos;
1138 outip->ip_len = htons(packlen);
1139 outip->ip_off = htons(off);
1140 outp = (unsigned char *)(outip + 1);
1141 outip->ip_dst = to->sin_addr;
1143 outip->ip_hl = (outp - (unsigned char *)outip) >> 2;
1144 ident = (getpid() & 0xffff) | 0x8000;
1145 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
1147 outip->ip_p = IPPROTO_ICMP;
1148 outicmp = (struct icmp *)outp;
1149 outicmp->icmp_type = ICMP_ECHO;
1150 outicmp->icmp_id = htons(ident);
1151 outdata = (outdata_t *)(outp + 8); /* XXX magic number */
1155 outip->ip_p = IPPROTO_UDP;
1156 outudp = (struct udphdr *)outp;
1157 outudp->source = htons(ident);
1158 outudp->len = htons((uint16_t)(packlen - (sizeof(*outip) + optlen)));
1159 outdata = (outdata_t *)(outudp + 1);
1162 /* Get the interface address list */
1163 n = ifaddrlist(&al);
1165 /* Look for a specific device */
1166 if (op & OPT_DEVICE) {
1167 for (i = n; i > 0; --i, ++al)
1168 if (strcmp(device, al->device) == 0)
1170 bb_error_msg_and_die("can't find interface %s", device);
1174 /* Determine our source address */
1175 if (!(op & OPT_SOURCE)) {
1177 * If a device was specified, use the interface address.
1178 * Otherwise, try to determine our source address.
1180 if (op & OPT_DEVICE)
1181 setsin(from, al->addr);
1182 findsaddr(to, from);
1184 hi = gethostinfo(source);
1188 * If the device was specified make sure it
1189 * corresponds to the source address specified.
1190 * Otherwise, use the first address (and warn if
1191 * there are more than one).
1193 if (op & OPT_DEVICE) {
1194 for (i = hi->n, ap = hi->addrs; i > 0; --i, ++ap)
1195 if (*ap == al->addr)
1197 bb_error_msg_and_die("%s is not on interface %s",
1202 setsin(from, hi->addrs[0]);
1205 "warning: %s has multiple addresses; using %s",
1206 source, inet_ntoa(from->sin_addr));
1211 outip->ip_src = from->sin_addr;
1213 xbind(sndsock, (struct sockaddr *)from, sizeof(*from));
1216 printf("traceroute to %s (%s)", hostname, inet_ntoa(to->sin_addr));
1217 if (op & OPT_SOURCE)
1218 printf(" from %s", source);
1219 printf(", %d hops max, %d byte packets\n", max_ttl, packlen);
1222 for (ttl = first_ttl; ttl <= max_ttl; ++ttl) {
1223 uint32_t lastaddr = 0;
1224 int gotlastaddr = 0;
1226 int unreachable = 0;
1229 printf("%2d ", ttl);
1230 for (probe = 0; probe < nprobes; ++probe) {
1236 if (sentfirst && pausemsecs > 0)
1237 usleep(pausemsecs * 1000);
1238 t1 = monotonic_us();
1239 send_probe(++seq, ttl);
1241 while ((cc = wait_for_reply(rcvsock, from)) != 0) {
1242 t2 = monotonic_us();
1243 i = packet_ok(packet, cc, from, seq);
1244 /* Skip short packet */
1248 from->sin_addr.s_addr != lastaddr) {
1249 print(packet, cc, from);
1250 lastaddr = from->sin_addr.s_addr;
1253 print_delta_ms(t1, t2);
1254 ip = (struct ip *)packet;
1255 if (op & OPT_TTL_FLAG)
1256 printf(" (%d)", ip->ip_ttl);
1258 if (ip->ip_ttl <= 1)
1263 /* time exceeded in transit */
1269 case ICMP_UNREACH_PORT:
1270 if (ip->ip_ttl <= 1)
1275 case ICMP_UNREACH_NET:
1280 case ICMP_UNREACH_HOST:
1285 case ICMP_UNREACH_PROTOCOL:
1290 case ICMP_UNREACH_NEEDFRAG:
1292 printf(" !F-%d", pmtu);
1295 case ICMP_UNREACH_SRCFAIL:
1300 case ICMP_UNREACH_FILTER_PROHIB:
1301 case ICMP_UNREACH_NET_PROHIB: /* misuse */
1306 case ICMP_UNREACH_HOST_PROHIB:
1311 case ICMP_UNREACH_HOST_PRECEDENCE:
1316 case ICMP_UNREACH_PRECEDENCE_CUTOFF:
1321 case ICMP_UNREACH_NET_UNKNOWN:
1322 case ICMP_UNREACH_HOST_UNKNOWN:
1327 case ICMP_UNREACH_ISOLATED:
1332 case ICMP_UNREACH_TOSNET:
1333 case ICMP_UNREACH_TOSHOST:
1340 printf(" !<%d>", code);
1347 (void)fflush(stdout);
1351 (unreachable > 0 && unreachable >= nprobes - 1))