source: branches/2.2.9/mindi-busybox/networking/traceroute.c @ 2142

Last change on this file since 2142 was 1765, checked in by bruno, 12 years ago

Update to busybox 1.7.2

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