networking/traceroute.c

   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  */
 239 struct 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  */
 250 struct 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 */
 268 struct hostinfo {
 269         char *name;
 270         int n;
 271         uint32_t *addrs;
 272 };
 273
 274 /* Data section of the probe packet */
 275 struct 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
 282 struct IFADDRLIST {
 283         uint32_t addr;
 284         char device[sizeof(struct ifreq)];
 285 };
 286
 287
 288 static struct ip *outip;               /* last output (udp) packet */
 289 static struct udphdr *outudp;          /* last output (udp) packet */
 290 static struct outdata *outdata;        /* last output (udp) packet */
 291
 292 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
 293 static struct icmp *outicmp;           /* last output (icmp) packet */
 294 #endif
 295
 296 static int s;                          /* receive (icmp) socket file descriptor */
 297 static int sndsock;                    /* send (udp/icmp) socket file descriptor */
 298
 299 static int packlen;                    /* total length of packet */
 300 static int minpacket;                  /* min ip packet size */
 301 static int maxpacket = 32 * 1024;      /* max ip packet size */
 302 static int pmtu;                       /* Path MTU Discovery (RFC1191) */
 303
 304 static char *hostname;
 305
 306 static uint16_t ident;
 307 static uint16_t port = 32768 + 666;     /* start udp dest port # for probe packets */
 308
 309 static int waittime = 5;               /* time to wait for response (in seconds) */
 310 static int doipcksum = 1;              /* calculate ip checksums by default */
 311
 312 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 313 static 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
 348 struct 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  */
 372 static int
 373 ifaddrlist(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 (%d bytes)",
 401                             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                 if (ioctl(fd, SIOCGIFADDR, (char *)&ifr) < 0)
 449                         bb_perror_msg_and_die("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
 466 static void
 467 setsin(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  */
 481 static void
 482 findsaddr(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
 537 static int
 538 wait_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  */
 561 static uint16_t
 562 in_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
 594 static void
 595 send_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  */
 700 static inline const char *
 701 pr_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
 718 static int
 719 packet_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  */
 804 static inline void
 805 inetname(struct sockaddr_in *from)
 806 {
 807         const char *n = NULL;
 808         const char *ina;
 809         char name[257];
 810
 811         if (!nflag && from->sin_addr.s_addr != INADDR_ANY) {
 812                 if (INET_rresolve(name, sizeof(name), from, 0x4000,
 813                                                 0xffffffff) >= 0)
 814                         n = name;
 815         }
 816         ina = inet_ntoa(from->sin_addr);
 817         if (nflag)
 818                 printf(" %s", ina);
 819         else
 820                 printf(" %s (%s)", (n ? n : ina), ina);
 821 }
 822
 823 static inline void
 824 print(unsigned char *buf, int cc, struct sockaddr_in *from)
 825 {
 826         struct ip *ip;
 827         int hlen;
 828
 829         ip = (struct ip *) buf;
 830         hlen = ip->ip_hl << 2;
 831         cc -= hlen;
 832
 833         inetname(from);
 834 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 835         if (verbose)
 836                 printf(" %d bytes to %s", cc, inet_ntoa(ip->ip_dst));
 837 #endif
 838 }
 839
 840
 841 static struct hostinfo *
 842 gethostinfo(const char *host)
 843 {
 844         int n;
 845         struct hostent *hp;
 846         struct hostinfo *hi;
 847         char **p;
 848         uint32_t addr, *ap;
 849
 850         hi = xzalloc(sizeof(*hi));
 851         addr = inet_addr(host);
 852         if (addr != 0xffffffff) {
 853                 hi->name = xstrdup(host);
 854                 hi->n = 1;
 855                 hi->addrs = xzalloc(sizeof(hi->addrs[0]));
 856                 hi->addrs[0] = addr;
 857                 return hi;
 858         }
 859
 860         hp = xgethostbyname(host);
 861         if (hp->h_addrtype != AF_INET || hp->h_length != 4)
 862                 bb_perror_msg_and_die("bad host %s", host);
 863         hi->name = xstrdup(hp->h_name);
 864         for (n = 0, p = hp->h_addr_list; *p != NULL; ++n, ++p)
 865                 continue;
 866         hi->n = n;
 867         hi->addrs = xzalloc(n * sizeof(hi->addrs[0]));
 868         for (ap = hi->addrs, p = hp->h_addr_list; *p != NULL; ++ap, ++p)
 869                 memcpy(ap, *p, sizeof(*ap));
 870         return hi;
 871 }
 872
 873 static void
 874 freehostinfo(struct hostinfo *hi)
 875 {
 876         free(hi->name);
 877         free(hi->addrs);
 878         free(hi);
 879 }
 880
 881 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 882 static void
 883 getaddr(uint32_t *ap, const char *host)
 884 {
 885         struct hostinfo *hi;
 886
 887         hi = gethostinfo(host);
 888         *ap = hi->addrs[0];
 889         freehostinfo(hi);
 890 }
 891 #endif
 892
 893 static void
 894 print_delta_ms(unsigned t1p, unsigned t2p)
 895 {
 896         unsigned tt = t2p - t1p;
 897         printf("  %u.%03u ms", tt/1000, tt%1000);
 898 }
 899
 900 int traceroute_main(int argc, char **argv);
 901 int traceroute_main(int argc, char **argv)
 902 {
 903         int code, n;
 904         unsigned char *outp;
 905         uint32_t *ap;
 906         struct sockaddr_in *from;
 907         struct sockaddr_in *to;
 908         struct hostinfo *hi;
 909         int ttl, probe, i;
 910         int seq = 0;
 911         int tos = 0;
 912         char *tos_str;
 913         char *source;
 914         unsigned op;
 915 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 916         int lsrr = 0;
 917 #endif
 918         uint16_t off = 0;
 919         struct IFADDRLIST *al;
 920         char *device;
 921         int max_ttl = 30;
 922         char *max_ttl_str;
 923         char *port_str;
 924         int nprobes = 3;
 925         char *nprobes_str;
 926         char *waittime_str;
 927         unsigned pausemsecs = 0;
 928         char *pausemsecs_str;
 929         int first_ttl = 1;
 930         char *first_ttl_str;
 931 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 932         llist_t *source_route_list = NULL;
 933 #endif
 934
 935         PTR_TO_GLOBALS = xzalloc(sizeof(G));
 936         from = (struct sockaddr_in *)&wherefrom;
 937         to = (struct sockaddr_in *)&whereto;
 938
 939         //opterr = 0;
 940 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 941         opt_complementary = "x-x:g::";
 942 #else
 943         opt_complementary = "x-x";
 944 #endif
 945
 946         op = getopt32(argc, argv, "FIlnrdvxt:i:m:p:q:s:w:z:f:"
 947 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 948                                         "g:"
 949 #endif
 950                 , &tos_str, &device, &max_ttl_str, &port_str, &nprobes_str
 951                 , &source, &waittime_str, &pausemsecs_str, &first_ttl_str
 952 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 953                 , &source_route_list
 954 #endif
 955         );
 956
 957         if (op & OPT_DONT_FRAGMNT)
 958                 off = IP_DF;
 959         if (op & OPT_IP_CHKSUM) {
 960                 doipcksum = 0;
 961                 bb_error_msg("warning: ip checksums disabled");
 962         }
 963         if (op & OPT_TOS)
 964                 tos = xatou_range(tos_str, 0, 255);
 965         if (op & OPT_MAX_TTL)
 966                 max_ttl = xatou_range(max_ttl_str, 1, 255);
 967         if (op & OPT_PORT)
 968                 port = xatou16(port_str);
 969         if (op & OPT_NPROBES)
 970                 nprobes = xatou_range(nprobes_str, 1, INT_MAX);
 971         if (op & OPT_SOURCE) {
 972                 /*
 973                  * set the ip source address of the outbound
 974                  * probe (e.g., on a multi-homed host).
 975                  */
 976                 if (getuid())
 977                         bb_error_msg_and_die("-s %s: permission denied", source);
 978         }
 979         if (op & OPT_WAITTIME)
 980                 waittime = xatou_range(waittime_str, 2, 24 * 60 * 60);
 981         if (op & OPT_PAUSE_MS)
 982                 pausemsecs = xatou_range(pausemsecs_str, 0, 60 * 60 * 1000);
 983         if (op & OPT_FIRST_TTL)
 984                 first_ttl = xatou_range(first_ttl_str, 1, 255);
 985
 986 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 987         if (source_route_list) {
 988                 llist_t *l_sr;
 989
 990                 l_sr = source_route_list;
 991                 while (l_sr) {
 992                         if (lsrr >= NGATEWAYS)
 993                                 bb_error_msg_and_die("no more than %d gateways", NGATEWAYS);
 994                         getaddr(gwlist + lsrr, l_sr->data);
 995                         ++lsrr;
 996                         l_sr = l_sr->link;
 997                         free(source_route_list);
 998                         source_route_list = l_sr;
 999                 }
1000                 optlen = (lsrr + 1) * sizeof(gwlist[0]);
1001         }
1002 #endif
1003
1004         if (first_ttl > max_ttl) {
1005                 bb_error_msg_and_die(
1006                     "first ttl (%d) may not be greater than max ttl (%d)",
1007                     first_ttl, max_ttl);
1008         }
1009
1010         minpacket = sizeof(*outip) + sizeof(*outdata) + optlen;
1011
1012 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
1013         if (useicmp)
1014                 minpacket += 8;                 /* XXX magic number */
1015         else
1016 #endif
1017                 minpacket += sizeof(*outudp);
1018         packlen = minpacket;                    /* minimum sized packet */
1019
1020         /* Process destination and optional packet size */
1021         switch (argc - optind) {
1022
1023         case 2:
1024                 packlen = xatoul_range(argv[optind + 1], minpacket, maxpacket);
1025                 /* Fall through */
1026
1027         case 1:
1028                 hostname = argv[optind];
1029                 hi = gethostinfo(hostname);
1030                 setsin(to, hi->addrs[0]);
1031                 if (hi->n > 1)
1032                         bb_error_msg("warning: %s has multiple addresses; using %s",
1033                                 hostname, inet_ntoa(to->sin_addr));
1034                 hostname = hi->name;
1035                 hi->name = NULL;
1036                 freehostinfo(hi);
1037                 break;
1038
1039         default:
1040                 bb_show_usage();
1041         }
1042
1043         /* Ensure the socket fds won't be 0, 1 or 2 */
1044         bb_sanitize_stdio();
1045
1046         s = xsocket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
1047
1048 #if TRACEROUTE_SO_DEBUG
1049         if (op & OPT_DEBUG)
1050                 setsockopt(s, SOL_SOCKET, SO_DEBUG,
1051                                 &const_int_1, sizeof(const_int_1));
1052 #endif
1053         if (op & OPT_BYPASS_ROUTE)
1054                 setsockopt(s, SOL_SOCKET, SO_DONTROUTE,
1055                                 &const_int_1, sizeof(const_int_1));
1056
1057         sndsock = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);
1058
1059 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
1060 #if defined(IP_OPTIONS)
1061         if (lsrr > 0) {
1062                 unsigned char optlist[MAX_IPOPTLEN];
1063
1064                 /* final hop */
1065                 gwlist[lsrr] = to->sin_addr.s_addr;
1066                 ++lsrr;
1067
1068                 /* force 4 byte alignment */
1069                 optlist[0] = IPOPT_NOP;
1070                 /* loose source route option */
1071                 optlist[1] = IPOPT_LSRR;
1072                 i = lsrr * sizeof(gwlist[0]);
1073                 optlist[2] = i + 3;
1074                 /* Pointer to LSRR addresses */
1075                 optlist[3] = IPOPT_MINOFF;
1076                 memcpy(optlist + 4, gwlist, i);
1077
1078                 if ((setsockopt(sndsock, IPPROTO_IP, IP_OPTIONS,
1079                     (char *)optlist, i + sizeof(gwlist[0]))) < 0) {
1080                         bb_perror_msg_and_die("IP_OPTIONS");
1081                 }
1082         }
1083 #endif /* IP_OPTIONS */
1084 #endif /* CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE */
1085
1086 #ifdef SO_SNDBUF
1087         if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, &packlen, sizeof(packlen)) < 0) {
1088                 bb_perror_msg_and_die("SO_SNDBUF");
1089         }
1090 #endif
1091 #ifdef IP_HDRINCL
1092         if (setsockopt(sndsock, IPPROTO_IP, IP_HDRINCL, &const_int_1, sizeof(const_int_1)) < 0
1093          && errno != ENOPROTOOPT
1094         ) {
1095                 bb_perror_msg_and_die("IP_HDRINCL");
1096         }
1097 #else
1098 #ifdef IP_TOS
1099         if (tos_str && setsockopt(sndsock, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)) < 0) {
1100                 bb_perror_msg_and_die("setsockopt tos %d", tos);
1101         }
1102 #endif
1103 #endif
1104 #if TRACEROUTE_SO_DEBUG
1105         if (op & OPT_DEBUG)
1106                 setsockopt(sndsock, SOL_SOCKET, SO_DEBUG,
1107                                 &const_int_1, sizeof(const_int_1));
1108 #endif
1109         if (op & OPT_BYPASS_ROUTE)
1110                 setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE,
1111                                 &const_int_1, sizeof(const_int_1));
1112
1113         /* Revert to non-privileged user after opening sockets */
1114         xsetgid(getgid());
1115         xsetuid(getuid());
1116
1117         outip = xzalloc(packlen);
1118
1119         outip->ip_v = IPVERSION;
1120         if (tos_str)
1121                 outip->ip_tos = tos;
1122         outip->ip_len = htons(packlen);
1123         outip->ip_off = htons(off);
1124         outp = (unsigned char *)(outip + 1);
1125         outip->ip_dst = to->sin_addr;
1126
1127         outip->ip_hl = (outp - (unsigned char *)outip) >> 2;
1128         ident = (getpid() & 0xffff) | 0x8000;
1129 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
1130         if (useicmp) {
1131                 outip->ip_p = IPPROTO_ICMP;
1132                 outicmp = (struct icmp *)outp;
1133                 outicmp->icmp_type = ICMP_ECHO;
1134                 outicmp->icmp_id = htons(ident);
1135                 outdata = (struct outdata *)(outp + 8); /* XXX magic number */
1136         } else
1137 #endif
1138         {
1139                 outip->ip_p = IPPROTO_UDP;
1140                 outudp = (struct udphdr *)outp;
1141                 outudp->source = htons(ident);
1142                 outudp->len = htons((uint16_t)(packlen - (sizeof(*outip) + optlen)));
1143                 outdata = (struct outdata *)(outudp + 1);
1144         }
1145
1146         /* Get the interface address list */
1147         n = ifaddrlist(&al);
1148
1149         /* Look for a specific device */
1150         if (op & OPT_DEVICE) {
1151                 for (i = n; i > 0; --i, ++al)
1152                         if (strcmp(device, al->device) == 0)
1153                                 goto found_dev;
1154                 bb_error_msg_and_die("can't find interface %s", device);
1155         }
1156  found_dev:
1157
1158         /* Determine our source address */
1159         if (!(op & OPT_SOURCE)) {
1160                 /*
1161                  * If a device was specified, use the interface address.
1162                  * Otherwise, try to determine our source address.
1163                  */
1164                 if (op & OPT_DEVICE)
1165                         setsin(from, al->addr);
1166                 findsaddr(to, from);
1167         } else {
1168                 hi = gethostinfo(source);
1169                 source = hi->name;
1170                 hi->name = NULL;
1171                 /*
1172                  * If the device was specified make sure it
1173                  * corresponds to the source address specified.
1174                  * Otherwise, use the first address (and warn if
1175                  * there are more than one).
1176                  */
1177                 if (op & OPT_DEVICE) {
1178                         for (i = hi->n, ap = hi->addrs; i > 0; --i, ++ap)
1179                                 if (*ap == al->addr)
1180                                         goto found_dev2;
1181                         bb_error_msg_and_die("%s is not on interface %s",
1182                                         source, device);
1183  found_dev2:
1184                         setsin(from, *ap);
1185                 } else {
1186                         setsin(from, hi->addrs[0]);
1187                         if (hi->n > 1)
1188                                 bb_error_msg(
1189                         "warning: %s has multiple addresses; using %s",
1190                                     source, inet_ntoa(from->sin_addr));
1191                 }
1192                 freehostinfo(hi);
1193         }
1194
1195         outip->ip_src = from->sin_addr;
1196 #ifndef IP_HDRINCL
1197         xbind(sndsock, (struct sockaddr *)from, sizeof(*from));
1198 #endif
1199
1200         printf("traceroute to %s (%s)", hostname, inet_ntoa(to->sin_addr));
1201         if (op & OPT_SOURCE)
1202                 printf(" from %s", source);
1203         printf(", %d hops max, %d byte packets\n", max_ttl, packlen);
1204         fflush(stdout);
1205
1206         for (ttl = first_ttl; ttl <= max_ttl; ++ttl) {
1207                 uint32_t lastaddr = 0;
1208                 int gotlastaddr = 0;
1209                 int got_there = 0;
1210                 int unreachable = 0;
1211                 int sentfirst = 0;
1212
1213                 printf("%2d ", ttl);
1214                 for (probe = 0; probe < nprobes; ++probe) {
1215                         int cc;
1216                         unsigned t1;
1217                         unsigned t2;
1218                         struct ip *ip;
1219
1220                         if (sentfirst && pausemsecs > 0)
1221                                 usleep(pausemsecs * 1000);
1222                         t1 = monotonic_us();
1223                         send_probe(++seq, ttl);
1224                         ++sentfirst;
1225                         while ((cc = wait_for_reply(s, from)) != 0) {
1226                                 t2 = monotonic_us();
1227                                 i = packet_ok(packet, cc, from, seq);
1228                                 /* Skip short packet */
1229                                 if (i == 0)
1230                                         continue;
1231                                 if (!gotlastaddr ||
1232                                     from->sin_addr.s_addr != lastaddr) {
1233                                         print(packet, cc, from);
1234                                         lastaddr = from->sin_addr.s_addr;
1235                                         ++gotlastaddr;
1236                                 }
1237                                 print_delta_ms(t1, t2);
1238                                 ip = (struct ip *)packet;
1239                                 if (op & OPT_TTL_FLAG)
1240                                         printf(" (%d)", ip->ip_ttl);
1241                                 if (i == -2) {
1242                                         if (ip->ip_ttl <= 1)
1243                                                 printf(" !");
1244                                         ++got_there;
1245                                         break;
1246                                 }
1247                                 /* time exceeded in transit */
1248                                 if (i == -1)
1249                                         break;
1250                                 code = i - 1;
1251                                 switch (code) {
1252
1253                                 case ICMP_UNREACH_PORT:
1254                                         if (ip->ip_ttl <= 1)
1255                                                 printf(" !");
1256                                         ++got_there;
1257                                         break;
1258
1259                                 case ICMP_UNREACH_NET:
1260                                         ++unreachable;
1261                                         printf(" !N");
1262                                         break;
1263
1264                                 case ICMP_UNREACH_HOST:
1265                                         ++unreachable;
1266                                         printf(" !H");
1267                                         break;
1268
1269                                 case ICMP_UNREACH_PROTOCOL:
1270                                         ++got_there;
1271                                         printf(" !P");
1272                                         break;
1273
1274                                 case ICMP_UNREACH_NEEDFRAG:
1275                                         ++unreachable;
1276                                         printf(" !F-%d", pmtu);
1277                                         break;
1278
1279                                 case ICMP_UNREACH_SRCFAIL:
1280                                         ++unreachable;
1281                                         printf(" !S");
1282                                         break;
1283
1284                                 case ICMP_UNREACH_FILTER_PROHIB:
1285                                 case ICMP_UNREACH_NET_PROHIB:   /* misuse */
1286                                         ++unreachable;
1287                                         printf(" !A");
1288                                         break;
1289
1290                                 case ICMP_UNREACH_HOST_PROHIB:
1291                                         ++unreachable;
1292                                         printf(" !C");
1293                                         break;
1294
1295                                 case ICMP_UNREACH_HOST_PRECEDENCE:
1296                                         ++unreachable;
1297                                         printf(" !V");
1298                                         break;
1299
1300                                 case ICMP_UNREACH_PRECEDENCE_CUTOFF:
1301                                         ++unreachable;
1302                                         printf(" !C");
1303                                         break;
1304
1305                                 case ICMP_UNREACH_NET_UNKNOWN:
1306                                 case ICMP_UNREACH_HOST_UNKNOWN:
1307                                         ++unreachable;
1308                                         printf(" !U");
1309                                         break;
1310
1311                                 case ICMP_UNREACH_ISOLATED:
1312                                         ++unreachable;
1313                                         printf(" !I");
1314                                         break;
1315
1316                                 case ICMP_UNREACH_TOSNET:
1317                                 case ICMP_UNREACH_TOSHOST:
1318                                         ++unreachable;
1319                                         printf(" !T");
1320                                         break;
1321
1322                                 default:
1323                                         ++unreachable;
1324                                         printf(" !<%d>", code);
1325                                         break;
1326                                 }
1327                                 break;
1328                         }
1329                         if (cc == 0)
1330                                 printf(" *");
1331                         (void)fflush(stdout);
1332                 }
1333                 putchar('\n');
1334                 if (got_there ||
1335                     (unreachable > 0 && unreachable >= nprobes - 1))
1336                         break;
1337         }
1338         return 0;
1339 }