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 #include "inet_common.h"
 211
 212 #include <net/if.h>
 213 #include <arpa/inet.h>
 214 #include <netinet/in.h>
 215 #include <netinet/udp.h>
 216 #include <netinet/ip.h>
 217 #include <netinet/ip_icmp.h>
 218
 219 #include "busybox.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         u_int32_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         struct timeval tv ATTRIBUTE_PACKED; /* time packet left */
 279 };
 280
 281 struct IFADDRLIST {
 282         u_int32_t addr;
 283         char device[sizeof(struct ifreq)];
 284 };
 285
 286
 287 static const char route[] = "/proc/net/route";
 288
 289 /* last inbound (icmp) packet */
 290 static unsigned char packet[512] ATTRIBUTE_ALIGNED(32);
 291
 292 static struct ip *outip;               /* last output (udp) packet */
 293 static struct udphdr *outudp;          /* last output (udp) packet */
 294 static struct outdata *outdata;        /* last output (udp) packet */
 295
 296 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
 297 static struct icmp *outicmp;           /* last output (icmp) packet */
 298 #endif
 299
 300 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 301 /* Maximum number of gateways (include room for one noop) */
 302 #define NGATEWAYS ((int)((MAX_IPOPTLEN - IPOPT_MINOFF - 1) / sizeof(u_int32_t)))
 303 /* loose source route gateway list (including room for final destination) */
 304 static u_int32_t gwlist[NGATEWAYS + 1];
 305 #endif
 306
 307 static int s;                          /* receive (icmp) socket file descriptor */
 308 static int sndsock;                    /* send (udp/icmp) socket file descriptor */
 309
 310 static struct sockaddr_storage whereto;        /* Who to try to reach */
 311 static struct sockaddr_storage wherefrom;      /* Who we are */
 312 static int packlen;                    /* total length of packet */
 313 static int minpacket;                  /* min ip packet size */
 314 static int maxpacket = 32 * 1024;      /* max ip packet size */
 315 static int pmtu;                       /* Path MTU Discovery (RFC1191) */
 316
 317 static char *hostname;
 318
 319 static uint16_t ident;
 320 static uint16_t port = 32768 + 666;     /* start udp dest port # for probe packets */
 321
 322 static int waittime = 5;               /* time to wait for response (in seconds) */
 323 static int nflag;                      /* print addresses numerically */
 324 static int doipcksum = 1;              /* calculate ip checksums by default */
 325
 326 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 327 static int optlen;                     /* length of ip options */
 328 #else
 329 #define optlen 0
 330 #endif
 331
 332 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
 333 static int useicmp;                    /* use icmp echo instead of udp packets */
 334 #endif
 335 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 336 static int verbose;
 337 #endif
 338
 339 /*
 340  * Return the interface list
 341  */
 342 static int
 343 ifaddrlist(struct IFADDRLIST **ipaddrp)
 344 {
 345         int fd, nipaddr;
 346 #ifdef HAVE_SOCKADDR_SA_LEN
 347         int n;
 348 #endif
 349         struct ifreq *ifrp, *ifend, *ifnext;
 350         struct sockaddr_in *addr_sin;
 351         struct IFADDRLIST *al;
 352         struct ifconf ifc;
 353         struct ifreq ibuf[(32 * 1024) / sizeof(struct ifreq)], ifr;
 354         struct IFADDRLIST *st_ifaddrlist;
 355
 356         fd = xsocket(AF_INET, SOCK_DGRAM, 0);
 357
 358         ifc.ifc_len = sizeof(ibuf);
 359         ifc.ifc_buf = (caddr_t)ibuf;
 360
 361         if (ioctl(fd, SIOCGIFCONF, (char *)&ifc) < 0 ||
 362             ifc.ifc_len < sizeof(struct ifreq)) {
 363                 if (errno == EINVAL)
 364                         bb_error_msg_and_die(
 365                             "SIOCGIFCONF: ifreq struct too small (%d bytes)",
 366                             (int)sizeof(ibuf));
 367                 else
 368                         bb_perror_msg_and_die("SIOCGIFCONF");
 369         }
 370         ifrp = ibuf;
 371         ifend = (struct ifreq *)((char *)ibuf + ifc.ifc_len);
 372
 373         nipaddr = 1 + (ifc.ifc_len / sizeof(struct ifreq));
 374         st_ifaddrlist = xzalloc(nipaddr * sizeof(struct IFADDRLIST));
 375         al = st_ifaddrlist;
 376         nipaddr = 0;
 377
 378         for (; ifrp < ifend; ifrp = ifnext) {
 379 #ifdef HAVE_SOCKADDR_SA_LEN
 380                 n = ifrp->ifr_addr.sa_len + sizeof(ifrp->ifr_name);
 381                 if (n < sizeof(*ifrp))
 382                         ifnext = ifrp + 1;
 383                 else
 384                         ifnext = (struct ifreq *)((char *)ifrp + n);
 385                 if (ifrp->ifr_addr.sa_family != AF_INET)
 386                         continue;
 387 #else
 388                 ifnext = ifrp + 1;
 389 #endif
 390                 /*
 391                  * Need a template to preserve address info that is
 392                  * used below to locate the next entry.  (Otherwise,
 393                  * SIOCGIFFLAGS stomps over it because the requests
 394                  * are returned in a union.)
 395                  */
 396                 strncpy(ifr.ifr_name, ifrp->ifr_name, sizeof(ifr.ifr_name));
 397                 if (ioctl(fd, SIOCGIFFLAGS, (char *)&ifr) < 0) {
 398                         if (errno == ENXIO)
 399                                 continue;
 400                         bb_perror_msg_and_die("SIOCGIFFLAGS: %.*s",
 401                             (int)sizeof(ifr.ifr_name), ifr.ifr_name);
 402                 }
 403
 404                 /* Must be up */
 405                 if ((ifr.ifr_flags & IFF_UP) == 0)
 406                         continue;
 407
 408                 safe_strncpy(al->device, ifr.ifr_name, sizeof(ifr.ifr_name) + 1);
 409 #ifdef sun
 410                 /* Ignore sun virtual interfaces */
 411                 if (strchr(al->device, ':') != NULL)
 412                         continue;
 413 #endif
 414                 if (ioctl(fd, SIOCGIFADDR, (char *)&ifr) < 0)
 415                         bb_perror_msg_and_die("SIOCGIFADDR: %s", al->device);
 416
 417                 addr_sin = (struct sockaddr_in *)&ifr.ifr_addr;
 418                 al->addr = addr_sin->sin_addr.s_addr;
 419                 ++al;
 420                 ++nipaddr;
 421         }
 422         if (nipaddr == 0)
 423                 bb_error_msg_and_die ("can't find any network interfaces");
 424         (void)close(fd);
 425
 426         *ipaddrp = st_ifaddrlist;
 427         return nipaddr;
 428 }
 429
 430
 431 static void
 432 setsin(struct sockaddr_in *addr_sin, u_int32_t addr)
 433 {
 434         memset(addr_sin, 0, sizeof(*addr_sin));
 435 #ifdef HAVE_SOCKADDR_SA_LEN
 436         addr_sin->sin_len = sizeof(*addr_sin);
 437 #endif
 438         addr_sin->sin_family = AF_INET;
 439         addr_sin->sin_addr.s_addr = addr;
 440 }
 441
 442
 443 /*
 444  * Return the source address for the given destination address
 445  */
 446 static void
 447 findsaddr(const struct sockaddr_in *to, struct sockaddr_in *from)
 448 {
 449         int i, n;
 450         FILE *f;
 451         u_int32_t mask;
 452         u_int32_t dest, tmask;
 453         struct IFADDRLIST *al;
 454         char buf[256], tdevice[256], device[256];
 455
 456         f = xfopen(route, "r");
 457
 458         /* Find the appropriate interface */
 459         n = 0;
 460         mask = 0;
 461         device[0] = '\0';
 462         while (fgets(buf, sizeof(buf), f) != NULL) {
 463                 ++n;
 464                 if (n == 1 && strncmp(buf, "Iface", 5) == 0)
 465                         continue;
 466                 if ((i = sscanf(buf, "%255s %x %*s %*s %*s %*s %*s %x",
 467                     tdevice, &dest, &tmask)) != 3)
 468                         bb_error_msg_and_die ("junk in buffer");
 469                 if ((to->sin_addr.s_addr & tmask) == dest &&
 470                     (tmask > mask || mask == 0)) {
 471                         mask = tmask;
 472                         strcpy(device, tdevice);
 473                 }
 474         }
 475         fclose(f);
 476
 477         if (device[0] == '\0')
 478                 bb_error_msg_and_die ("can't find interface");
 479
 480         /* Get the interface address list */
 481         n = ifaddrlist(&al);
 482
 483         /* Find our appropriate source address */
 484         for (i = n; i > 0; --i, ++al)
 485                 if (strcmp(device, al->device) == 0)
 486                         break;
 487         if (i <= 0)
 488                 bb_error_msg_and_die("can't find interface %s", device);
 489
 490         setsin(from, al->addr);
 491 }
 492
 493 /*
 494 "Usage: %s [-dFIlnrvx] [-g gateway] [-i iface] [-f first_ttl]\n"
 495 "\t[-m max_ttl] [ -p port] [-q nqueries] [-s src_addr] [-t tos]\n"
 496 "\t[-w waittime] [-z pausemsecs] host [packetlen]"
 497
 498 */
 499
 500 /*
 501  * Subtract 2 timeval structs:  out = out - in.
 502  * Out is assumed to be >= in.
 503  */
 504 static inline void
 505 tvsub(struct timeval *out, struct timeval *in)
 506 {
 507
 508         if ((out->tv_usec -= in->tv_usec) < 0)   {
 509                 --out->tv_sec;
 510                 out->tv_usec += 1000000;
 511         }
 512         out->tv_sec -= in->tv_sec;
 513 }
 514
 515 static int
 516 wait_for_reply(int sock, struct sockaddr_in *fromp, const struct timeval *tp)
 517 {
 518         fd_set fds;
 519         struct timeval now, tvwait;
 520         struct timezone tz;
 521         int cc = 0;
 522         socklen_t fromlen = sizeof(*fromp);
 523
 524         FD_ZERO(&fds);
 525         FD_SET(sock, &fds);
 526
 527         tvwait.tv_sec = tp->tv_sec + waittime;
 528         tvwait.tv_usec = tp->tv_usec;
 529         (void)gettimeofday(&now, &tz);
 530         tvsub(&tvwait, &now);
 531
 532         if (select(sock + 1, &fds, NULL, NULL, &tvwait) > 0)
 533                 cc = recvfrom(sock, (char *)packet, sizeof(packet), 0,
 534                             (struct sockaddr *)fromp, &fromlen);
 535
 536         return cc;
 537 }
 538
 539 /*
 540  * Checksum routine for Internet Protocol family headers (C Version)
 541  */
 542 static uint16_t
 543 in_cksum(uint16_t *addr, int len)
 544 {
 545         int nleft = len;
 546         uint16_t *w = addr;
 547         uint16_t answer;
 548         int sum = 0;
 549
 550         /*
 551          *  Our algorithm is simple, using a 32 bit accumulator (sum),
 552          *  we add sequential 16 bit words to it, and at the end, fold
 553          *  back all the carry bits from the top 16 bits into the lower
 554          *  16 bits.
 555          */
 556         while (nleft > 1)  {
 557                 sum += *w++;
 558                 nleft -= 2;
 559         }
 560
 561         /* mop up an odd byte, if necessary */
 562         if (nleft == 1)
 563                 sum += *(unsigned char *)w;
 564
 565         /*
 566          * add back carry outs from top 16 bits to low 16 bits
 567          */
 568         sum = (sum >> 16) + (sum & 0xffff);     /* add hi 16 to low 16 */
 569         sum += (sum >> 16);                     /* add carry */
 570         answer = ~sum;                          /* truncate to 16 bits */
 571         return answer;
 572 }
 573
 574
 575 static void
 576 send_probe(int seq, int ttl, struct timeval *tp)
 577 {
 578         int cc;
 579         struct udpiphdr *ui, *oui;
 580         struct ip tip;
 581
 582         outip->ip_ttl = ttl;
 583         outip->ip_id = htons(ident + seq);
 584
 585         /*
 586          * In most cases, the kernel will recalculate the ip checksum.
 587          * But we must do it anyway so that the udp checksum comes out
 588          * right.
 589          */
 590         if (doipcksum) {
 591                 outip->ip_sum =
 592                     in_cksum((uint16_t *)outip, sizeof(*outip) + optlen);
 593                 if (outip->ip_sum == 0)
 594                         outip->ip_sum = 0xffff;
 595         }
 596
 597         /* Payload */
 598         outdata->seq = seq;
 599         outdata->ttl = ttl;
 600         memcpy(&outdata->tv, tp, sizeof(outdata->tv));
 601
 602 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
 603         if (useicmp)
 604                 outicmp->icmp_seq = htons(seq);
 605         else
 606 #endif
 607                 outudp->dest = htons(port + seq);
 608
 609 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
 610         if (useicmp) {
 611                 /* Always calculate checksum for icmp packets */
 612                 outicmp->icmp_cksum = 0;
 613                 outicmp->icmp_cksum = in_cksum((uint16_t *)outicmp,
 614                     packlen - (sizeof(*outip) + optlen));
 615                 if (outicmp->icmp_cksum == 0)
 616                         outicmp->icmp_cksum = 0xffff;
 617         } else
 618 #endif
 619         if (doipcksum) {
 620                 /* Checksum (we must save and restore ip header) */
 621                 tip = *outip;
 622                 ui = (struct udpiphdr *)outip;
 623                 oui = (struct udpiphdr *)&tip;
 624                 /* Easier to zero and put back things that are ok */
 625                 memset((char *)ui, 0, sizeof(ui->ui_i));
 626                 ui->ui_src = oui->ui_src;
 627                 ui->ui_dst = oui->ui_dst;
 628                 ui->ui_pr = oui->ui_pr;
 629                 ui->ui_len = outudp->len;
 630                 outudp->check = 0;
 631                 outudp->check = in_cksum((uint16_t *)ui, packlen);
 632                 if (outudp->check == 0)
 633                         outudp->check = 0xffff;
 634                 *outip = tip;
 635         }
 636
 637 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 638         /* XXX undocumented debugging hack */
 639         if (verbose > 1) {
 640                 const uint16_t *sp;
 641                 int nshorts, i;
 642
 643                 sp = (uint16_t *)outip;
 644                 nshorts = (u_int)packlen / sizeof(uint16_t);
 645                 i = 0;
 646                 printf("[ %d bytes", packlen);
 647                 while (--nshorts >= 0) {
 648                         if ((i++ % 8) == 0)
 649                                 printf("\n\t");
 650                         printf(" %04x", ntohs(*sp));
 651                         sp++;
 652                 }
 653                 if (packlen & 1) {
 654                         if ((i % 8) == 0)
 655                                 printf("\n\t");
 656                         printf(" %02x", *(unsigned char *)sp);
 657                 }
 658                 printf("]\n");
 659         }
 660 #endif
 661
 662 #if !defined(IP_HDRINCL) && defined(IP_TTL)
 663         if (setsockopt(sndsock, IPPROTO_IP, IP_TTL,
 664             (char *)&ttl, sizeof(ttl)) < 0) {
 665                 bb_perror_msg_and_die("setsockopt ttl %d", ttl);
 666         }
 667 #endif
 668
 669         cc = sendto(sndsock, (char *)outip,
 670             packlen, 0, (struct sockaddr *)&whereto, sizeof(whereto));
 671         if (cc < 0 || cc != packlen)  {
 672                 if (cc < 0)
 673                         bb_perror_msg_and_die("sendto");
 674                 printf("%s: wrote %s %d chars, ret=%d\n",
 675                     applet_name, hostname, packlen, cc);
 676                 (void)fflush(stdout);
 677         }
 678 }
 679
 680 static inline double
 681 deltaT(struct timeval *t1p, struct timeval *t2p)
 682 {
 683         double dt;
 684
 685         dt = (double)(t2p->tv_sec - t1p->tv_sec) * 1000.0 +
 686              (double)(t2p->tv_usec - t1p->tv_usec) / 1000.0;
 687         return dt;
 688 }
 689
 690 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 691 /*
 692  * Convert an ICMP "type" field to a printable string.
 693  */
 694 static inline const char *
 695 pr_type(unsigned char t)
 696 {
 697         static const char * const ttab[] = {
 698         "Echo Reply",   "ICMP 1",       "ICMP 2",       "Dest Unreachable",
 699         "Source Quench", "Redirect",    "ICMP 6",       "ICMP 7",
 700         "Echo",         "Router Advert", "Router Solicit", "Time Exceeded",
 701         "Param Problem", "Timestamp",   "Timestamp Reply", "Info Request",
 702         "Info Reply",   "Mask Request", "Mask Reply"
 703         };
 704
 705         if (t > 18)
 706                 return "OUT-OF-RANGE";
 707
 708         return ttab[t];
 709 }
 710 #endif
 711
 712 static int
 713 packet_ok(unsigned char *buf, int cc, struct sockaddr_in *from, int seq)
 714 {
 715         struct icmp *icp;
 716         unsigned char type, code;
 717         int hlen;
 718         struct ip *ip;
 719
 720         ip = (struct ip *) buf;
 721         hlen = ip->ip_hl << 2;
 722         if (cc < hlen + ICMP_MINLEN) {
 723 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 724                 if (verbose)
 725                         printf("packet too short (%d bytes) from %s\n", cc,
 726                                 inet_ntoa(from->sin_addr));
 727 #endif
 728                 return 0;
 729         }
 730         cc -= hlen;
 731         icp = (struct icmp *)(buf + hlen);
 732         type = icp->icmp_type;
 733         code = icp->icmp_code;
 734         /* Path MTU Discovery (RFC1191) */
 735         if (code != ICMP_UNREACH_NEEDFRAG)
 736                 pmtu = 0;
 737         else {
 738                 pmtu = ntohs(icp->icmp_nextmtu);
 739         }
 740         if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS) ||
 741             type == ICMP_UNREACH || type == ICMP_ECHOREPLY) {
 742                 struct ip *hip;
 743                 struct udphdr *up;
 744
 745                 hip = &icp->icmp_ip;
 746                 hlen = hip->ip_hl << 2;
 747 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
 748                 if (useicmp) {
 749                         struct icmp *hicmp;
 750
 751                         /* XXX */
 752                         if (type == ICMP_ECHOREPLY &&
 753                             icp->icmp_id == htons(ident) &&
 754                             icp->icmp_seq == htons(seq))
 755                                 return -2;
 756
 757                         hicmp = (struct icmp *)((unsigned char *)hip + hlen);
 758                         /* XXX 8 is a magic number */
 759                         if (hlen + 8 <= cc &&
 760                             hip->ip_p == IPPROTO_ICMP &&
 761                             hicmp->icmp_id == htons(ident) &&
 762                             hicmp->icmp_seq == htons(seq))
 763                                 return (type == ICMP_TIMXCEED ? -1 : code + 1);
 764                 } else
 765 #endif
 766                 {
 767                         up = (struct udphdr *)((unsigned char *)hip + hlen);
 768                         /* XXX 8 is a magic number */
 769                         if (hlen + 12 <= cc &&
 770                             hip->ip_p == IPPROTO_UDP &&
 771                             up->source == htons(ident) &&
 772                             up->dest == htons(port + seq))
 773                                 return (type == ICMP_TIMXCEED ? -1 : code + 1);
 774                 }
 775         }
 776 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 777         if (verbose) {
 778                 int i;
 779                 u_int32_t *lp = (u_int32_t *)&icp->icmp_ip;
 780
 781                 printf("\n%d bytes from %s to "
 782                        "%s: icmp type %d (%s) code %d\n",
 783                     cc, inet_ntoa(from->sin_addr),
 784                     inet_ntoa(ip->ip_dst), type, pr_type(type), icp->icmp_code);
 785                 for (i = 4; i < cc ; i += sizeof(*lp))
 786                         printf("%2d: x%8.8x\n", i, *lp++);
 787         }
 788 #endif
 789         return 0;
 790 }
 791
 792
 793 /*
 794  * Construct an Internet address representation.
 795  * If the nflag has been supplied, give
 796  * numeric value, otherwise try for symbolic name.
 797  */
 798 static inline void
 799 inetname(struct sockaddr_in *from)
 800 {
 801         const char *n = NULL;
 802         const char *ina;
 803         char name[257];
 804
 805         if (!nflag && from->sin_addr.s_addr != INADDR_ANY) {
 806                 if (INET_rresolve(name, sizeof(name), from, 0x4000, 0xffffffff) >= 0)
 807                         n = name;
 808         }
 809         ina = inet_ntoa(from->sin_addr);
 810         if (nflag)
 811                 printf(" %s", ina);
 812         else
 813                 printf(" %s (%s)", (n ? n : ina), ina);
 814 }
 815
 816 static inline void
 817 print(unsigned char *buf, int cc, struct sockaddr_in *from)
 818 {
 819         struct ip *ip;
 820         int hlen;
 821
 822         ip = (struct ip *) buf;
 823         hlen = ip->ip_hl << 2;
 824         cc -= hlen;
 825
 826         inetname(from);
 827 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 828         if (verbose)
 829                 printf(" %d bytes to %s", cc, inet_ntoa (ip->ip_dst));
 830 #endif
 831 }
 832
 833
 834 static struct hostinfo *
 835 gethostinfo(const char *host)
 836 {
 837         int n;
 838         struct hostent *hp;
 839         struct hostinfo *hi;
 840         char **p;
 841         u_int32_t addr, *ap;
 842
 843         hi = xzalloc(sizeof(*hi));
 844         addr = inet_addr(host);
 845         if ((int32_t)addr != -1) {
 846                 hi->name = xstrdup(host);
 847                 hi->n = 1;
 848                 hi->addrs = xzalloc(sizeof(hi->addrs[0]));
 849                 hi->addrs[0] = addr;
 850                 return hi;
 851         }
 852
 853         hp = xgethostbyname(host);
 854         if (hp->h_addrtype != AF_INET || hp->h_length != 4)
 855                 bb_perror_msg_and_die("bad host %s", host);
 856         hi->name = xstrdup(hp->h_name);
 857         for (n = 0, p = hp->h_addr_list; *p != NULL; ++n, ++p)
 858                 continue;
 859         hi->n = n;
 860         hi->addrs = xzalloc(n * sizeof(hi->addrs[0]));
 861         for (ap = hi->addrs, p = hp->h_addr_list; *p != NULL; ++ap, ++p)
 862                 memcpy(ap, *p, sizeof(*ap));
 863         return hi;
 864 }
 865
 866 static void
 867 freehostinfo(struct hostinfo *hi)
 868 {
 869         free(hi->name);
 870         hi->name = NULL;
 871         free((char *)hi->addrs);
 872         free((char *)hi);
 873 }
 874
 875 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 876 static void
 877 getaddr(u_int32_t *ap, const char *host)
 878 {
 879         struct hostinfo *hi;
 880
 881         hi = gethostinfo(host);
 882         *ap = hi->addrs[0];
 883         freehostinfo(hi);
 884 }
 885 #endif
 886
 887
 888 int
 889 traceroute_main(int argc, char *argv[])
 890 {
 891         static const int on = 1;
 892
 893         int code, n;
 894         unsigned char *outp;
 895         u_int32_t *ap;
 896         struct sockaddr_in *from = (struct sockaddr_in *)&wherefrom;
 897         struct sockaddr_in *to = (struct sockaddr_in *)&whereto;
 898         struct hostinfo *hi;
 899         int ttl, probe, i;
 900         int seq = 0;
 901         int tos = 0;
 902         char *tos_str = NULL;
 903         char *source = NULL;
 904         unsigned long op;
 905
 906 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 907         int lsrr = 0;
 908 #endif
 909         uint16_t off = 0;
 910         struct IFADDRLIST *al;
 911         char *device = NULL;
 912         int max_ttl = 30;
 913         char *max_ttl_str = NULL;
 914         char *port_str = NULL;
 915         int nprobes = 3;
 916         char *nprobes_str = NULL;
 917         char *waittime_str = NULL;
 918         u_int pausemsecs = 0;
 919         char *pausemsecs_str = NULL;
 920         int first_ttl = 1;
 921         char *first_ttl_str = NULL;
 922 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 923         llist_t *sourse_route_list = NULL;
 924 #endif
 925
 926         opterr = 0;
 927 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 928         opt_complementary = "x-x:g::";
 929 #else
 930         opt_complementary = "x-x";
 931 #endif
 932
 933         op = getopt32(argc, argv, "FIlnrdvxt:i:m:p:q:s:w:z:f:"
 934 #define USAGE_OP_DONT_FRAGMNT (1<<0)    /* F  */
 935 #define USAGE_OP_USE_ICMP     (1<<1)    /* I  */
 936 #define USAGE_OP_TTL_FLAG     (1<<2)    /* l  */
 937 #define USAGE_OP_ADDR_NUM     (1<<3)    /* n  */
 938 #define USAGE_OP_BYPASS_ROUTE (1<<4)    /* r  */
 939 #define USAGE_OP_DEBUG        (1<<5)    /* d */
 940 #define USAGE_OP_VERBOSE      (1<<6)    /* v */
 941 #define USAGE_OP_IP_CHKSUM    (1<<7)    /* x */
 942
 943 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 944                                         "g:"
 945 #endif
 946         , &tos_str, &device, &max_ttl_str, &port_str, &nprobes_str,
 947         &source, &waittime_str, &pausemsecs_str, &first_ttl_str
 948 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 949         , &sourse_route_list
 950 #endif
 951         );
 952
 953         if (op & USAGE_OP_DONT_FRAGMNT)
 954                 off = IP_DF;
 955 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
 956         useicmp = op & USAGE_OP_USE_ICMP;
 957 #endif
 958         nflag = op & USAGE_OP_ADDR_NUM;
 959 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 960         verbose = op &  USAGE_OP_VERBOSE;
 961 #endif
 962         if (op & USAGE_OP_IP_CHKSUM) {
 963                 doipcksum = 0;
 964                 bb_error_msg("warning: ip checksums disabled");
 965         }
 966         if (tos_str)
 967                 tos = xatoul_range(tos_str, 0, 255);
 968         if (max_ttl_str)
 969                 max_ttl = xatoul_range(max_ttl_str, 1, 255);
 970         if (port_str)
 971                 port = xatou16(port_str);
 972         if (nprobes_str)
 973                 nprobes = xatoul_range(nprobes_str, 1, INT_MAX);
 974         if (source) {
 975                 /*
 976                  * set the ip source address of the outbound
 977                  * probe (e.g., on a multi-homed host).
 978                  */
 979                 if (getuid()) bb_error_msg_and_die("-s %s: permission denied", source);
 980         }
 981         if (waittime_str)
 982                 waittime = xatoul_range(waittime_str, 2, 24 * 60 * 60);
 983         if (pausemsecs_str)
 984                 pausemsecs = xatoul_range(pausemsecs_str, 0, 60 * 60 * 1000);
 985         if (first_ttl_str)
 986                 first_ttl = xatoul_range(first_ttl_str, 1, 255);
 987
 988 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 989         if (sourse_route_list) {
 990                 llist_t *l_sr;
 991
 992                 for(l_sr = sourse_route_list; l_sr; ) {
 993                         if (lsrr >= NGATEWAYS)
 994                                 bb_error_msg_and_die("no more than %d gateways", NGATEWAYS);
 995                         getaddr(gwlist + lsrr, l_sr->data);
 996                         ++lsrr;
 997                         l_sr = l_sr->link;
 998                         free(sourse_route_list);
 999                         sourse_route_list = l_sr;
1000                 }
1001                 optlen = (lsrr + 1) * sizeof(gwlist[0]);
1002         }
1003 #endif
1004
1005         if (first_ttl > max_ttl) {
1006                 bb_error_msg_and_die(
1007                     "first ttl (%d) may not be greater than max ttl (%d)",
1008                     first_ttl, max_ttl);
1009         }
1010
1011         minpacket = sizeof(*outip) + sizeof(*outdata) + optlen;
1012
1013 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
1014         if (useicmp)
1015                 minpacket += 8;                 /* XXX magic number */
1016         else
1017 #endif
1018                 minpacket += sizeof(*outudp);
1019         packlen = minpacket;                    /* minimum sized packet */
1020
1021         /* Process destination and optional packet size */
1022         switch (argc - optind) {
1023
1024         case 2:
1025                 packlen = xatoul_range(argv[optind + 1], minpacket, maxpacket);
1026                 /* Fall through */
1027
1028         case 1:
1029                 hostname = argv[optind];
1030                 hi = gethostinfo(hostname);
1031                 setsin(to, hi->addrs[0]);
1032                 if (hi->n > 1)
1033                         bb_error_msg("warning: %s has multiple addresses; using %s",
1034                                 hostname, inet_ntoa(to->sin_addr));
1035                 hostname = hi->name;
1036                 hi->name = NULL;
1037                 freehostinfo(hi);
1038                 break;
1039
1040         default:
1041                 bb_show_usage();
1042         }
1043
1044         /* Insure the socket fds won't be 0, 1 or 2 */
1045         do n = xopen(bb_dev_null, O_RDONLY); while (n < 2);
1046         if (n > 2)
1047                 close(n);
1048
1049         s = xsocket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
1050
1051 #if TRACEROUTE_SO_DEBUG
1052         if (op & USAGE_OP_DEBUG)
1053                 (void)setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&on,
1054                     sizeof(on));
1055 #endif
1056         if (op & USAGE_OP_BYPASS_ROUTE)
1057                 (void)setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
1058                     sizeof(on));
1059
1060         sndsock = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);
1061
1062 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
1063 #if defined(IP_OPTIONS)
1064         if (lsrr > 0) {
1065                 unsigned char optlist[MAX_IPOPTLEN];
1066
1067                 /* final hop */
1068                 gwlist[lsrr] = to->sin_addr.s_addr;
1069                 ++lsrr;
1070
1071                 /* force 4 byte alignment */
1072                 optlist[0] = IPOPT_NOP;
1073                 /* loose source route option */
1074                 optlist[1] = IPOPT_LSRR;
1075                 i = lsrr * sizeof(gwlist[0]);
1076                 optlist[2] = i + 3;
1077                 /* Pointer to LSRR addresses */
1078                 optlist[3] = IPOPT_MINOFF;
1079                 memcpy(optlist + 4, gwlist, i);
1080
1081                 if ((setsockopt(sndsock, IPPROTO_IP, IP_OPTIONS,
1082                     (char *)optlist, i + sizeof(gwlist[0]))) < 0) {
1083                         bb_perror_msg_and_die("IP_OPTIONS");
1084                 }
1085         }
1086 #endif /* IP_OPTIONS */
1087 #endif /* CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE */
1088
1089 #ifdef SO_SNDBUF
1090         if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, (char *)&packlen,
1091             sizeof(packlen)) < 0) {
1092                 bb_perror_msg_and_die("SO_SNDBUF");
1093         }
1094 #endif
1095 #ifdef IP_HDRINCL
1096         if (setsockopt(sndsock, IPPROTO_IP, IP_HDRINCL, (char *)&on,
1097             sizeof(on)) < 0 && errno != ENOPROTOOPT) {
1098                 bb_perror_msg_and_die("IP_HDRINCL");
1099         }
1100 #else
1101 #ifdef IP_TOS
1102         if (tos_str && setsockopt(sndsock, IPPROTO_IP, IP_TOS,
1103             (char *)&tos, sizeof(tos)) < 0) {
1104                 bb_perror_msg_and_die("setsockopt tos %d", tos);
1105         }
1106 #endif
1107 #endif
1108 #if TRACEROUTE_SO_DEBUG
1109         if (op & USAGE_OP_DEBUG)
1110                 (void)setsockopt(sndsock, SOL_SOCKET, SO_DEBUG, (char *)&on,
1111                     sizeof(on));
1112 #endif
1113         if (op & USAGE_OP_BYPASS_ROUTE)
1114                 (void)setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
1115                     sizeof(on));
1116
1117         /* Revert to non-privileged user after opening sockets */
1118         xsetgid(getgid());
1119         xsetuid(getuid());
1120
1121         outip = xzalloc(packlen);
1122
1123         outip->ip_v = IPVERSION;
1124         if (tos_str)
1125                 outip->ip_tos = tos;
1126         outip->ip_len = htons(packlen);
1127         outip->ip_off = htons(off);
1128         outp = (unsigned char *)(outip + 1);
1129         outip->ip_dst = to->sin_addr;
1130
1131         outip->ip_hl = (outp - (unsigned char *)outip) >> 2;
1132         ident = (getpid() & 0xffff) | 0x8000;
1133 #if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
1134         if (useicmp) {
1135                 outip->ip_p = IPPROTO_ICMP;
1136                 outicmp = (struct icmp *)outp;
1137                 outicmp->icmp_type = ICMP_ECHO;
1138                 outicmp->icmp_id = htons(ident);
1139                 outdata = (struct outdata *)(outp + 8); /* XXX magic number */
1140         } else
1141 #endif
1142         {
1143                 outip->ip_p = IPPROTO_UDP;
1144                 outudp = (struct udphdr *)outp;
1145                 outudp->source = htons(ident);
1146                 outudp->len = htons((uint16_t)(packlen - (sizeof(*outip) + optlen)));
1147                 outdata = (struct outdata *)(outudp + 1);
1148         }
1149
1150         /* Get the interface address list */
1151         n = ifaddrlist(&al);
1152
1153         /* Look for a specific device */
1154         if (device != NULL) {
1155                 for (i = n; i > 0; --i, ++al)
1156                         if (strcmp(device, al->device) == 0)
1157                                 break;
1158                 if (i <= 0) {
1159                         bb_error_msg_and_die("can't find interface %s", device);
1160                 }
1161         }
1162
1163         /* Determine our source address */
1164         if (source == NULL) {
1165                 /*
1166                  * If a device was specified, use the interface address.
1167                  * Otherwise, try to determine our source address.
1168                  */
1169                 if (device != NULL)
1170                         setsin(from, al->addr);
1171                 findsaddr(to, from);
1172         } else {
1173                 hi = gethostinfo(source);
1174                 source = hi->name;
1175                 hi->name = NULL;
1176                 /*
1177                  * If the device was specified make sure it
1178                  * corresponds to the source address specified.
1179                  * Otherwise, use the first address (and warn if
1180                  * there are more than one).
1181                  */
1182                 if (device != NULL) {
1183                         for (i = hi->n, ap = hi->addrs; i > 0; --i, ++ap)
1184                                 if (*ap == al->addr)
1185                                         break;
1186                         if (i <= 0) {
1187                                 bb_error_msg_and_die(
1188                                     "%s is not on interface %s",
1189                                     source, device);
1190                         }
1191                         setsin(from, *ap);
1192                 } else {
1193                         setsin(from, hi->addrs[0]);
1194                         if (hi->n > 1)
1195                                 bb_error_msg(
1196                         "Warning: %s has multiple addresses; using %s",
1197                                     source, inet_ntoa(from->sin_addr));
1198                 }
1199                 freehostinfo(hi);
1200         }
1201
1202         outip->ip_src = from->sin_addr;
1203 #ifndef IP_HDRINCL
1204         xbind(sndsock, (struct sockaddr *)from, sizeof(*from));
1205 #endif
1206
1207         fprintf(stderr, "traceroute to %s (%s)", hostname, inet_ntoa(to->sin_addr));
1208         if (source)
1209                 fprintf(stderr, " from %s", source);
1210         fprintf(stderr, ", %d hops max, %d byte packets\n", max_ttl, packlen);
1211         (void)fflush(stderr);
1212
1213         for (ttl = first_ttl; ttl <= max_ttl; ++ttl) {
1214                 u_int32_t lastaddr = 0;
1215                 int gotlastaddr = 0;
1216                 int got_there = 0;
1217                 int unreachable = 0;
1218                 int sentfirst = 0;
1219
1220                 printf("%2d ", ttl);
1221                 for (probe = 0; probe < nprobes; ++probe) {
1222                         int cc;
1223                         struct timeval t1, t2;
1224                         struct timezone tz;
1225                         struct ip *ip;
1226
1227                         if (sentfirst && pausemsecs > 0)
1228                                 usleep(pausemsecs * 1000);
1229                         (void)gettimeofday(&t1, &tz);
1230                         send_probe(++seq, ttl, &t1);
1231                         ++sentfirst;
1232                         while ((cc = wait_for_reply(s, from, &t1)) != 0) {
1233                                 (void)gettimeofday(&t2, &tz);
1234                                 i = packet_ok(packet, cc, from, seq);
1235                                 /* Skip short packet */
1236                                 if (i == 0)
1237                                         continue;
1238                                 if (!gotlastaddr ||
1239                                     from->sin_addr.s_addr != lastaddr) {
1240                                         print(packet, cc, from);
1241                                         lastaddr = from->sin_addr.s_addr;
1242                                         ++gotlastaddr;
1243                                 }
1244                                 printf("  %.3f ms", deltaT(&t1, &t2));
1245                                 ip = (struct ip *)packet;
1246                                 if (op & USAGE_OP_TTL_FLAG)
1247                                         printf(" (%d)", ip->ip_ttl);
1248                                 if (i == -2) {
1249                                         if (ip->ip_ttl <= 1)
1250                                                 printf(" !");
1251                                         ++got_there;
1252                                         break;
1253                                 }
1254                                 /* time exceeded in transit */
1255                                 if (i == -1)
1256                                         break;
1257                                 code = i - 1;
1258                                 switch (code) {
1259
1260                                 case ICMP_UNREACH_PORT:
1261                                         if (ip->ip_ttl <= 1)
1262                                                 printf(" !");
1263                                         ++got_there;
1264                                         break;
1265
1266                                 case ICMP_UNREACH_NET:
1267                                         ++unreachable;
1268                                         printf(" !N");
1269                                         break;
1270
1271                                 case ICMP_UNREACH_HOST:
1272                                         ++unreachable;
1273                                         printf(" !H");
1274                                         break;
1275
1276                                 case ICMP_UNREACH_PROTOCOL:
1277                                         ++got_there;
1278                                         printf(" !P");
1279                                         break;
1280
1281                                 case ICMP_UNREACH_NEEDFRAG:
1282                                         ++unreachable;
1283                                         printf(" !F-%d", pmtu);
1284                                         break;
1285
1286                                 case ICMP_UNREACH_SRCFAIL:
1287                                         ++unreachable;
1288                                         printf(" !S");
1289                                         break;
1290
1291                                 case ICMP_UNREACH_FILTER_PROHIB:
1292                                 case ICMP_UNREACH_NET_PROHIB:   /* misuse */
1293                                         ++unreachable;
1294                                         printf(" !A");
1295                                         break;
1296
1297                                 case ICMP_UNREACH_HOST_PROHIB:
1298                                         ++unreachable;
1299                                         printf(" !C");
1300                                         break;
1301
1302                                 case ICMP_UNREACH_HOST_PRECEDENCE:
1303                                         ++unreachable;
1304                                         printf(" !V");
1305                                         break;
1306
1307                                 case ICMP_UNREACH_PRECEDENCE_CUTOFF:
1308                                         ++unreachable;
1309                                         printf(" !C");
1310                                         break;
1311
1312                                 case ICMP_UNREACH_NET_UNKNOWN:
1313                                 case ICMP_UNREACH_HOST_UNKNOWN:
1314                                         ++unreachable;
1315                                         printf(" !U");
1316                                         break;
1317
1318                                 case ICMP_UNREACH_ISOLATED:
1319                                         ++unreachable;
1320                                         printf(" !I");
1321                                         break;
1322
1323                                 case ICMP_UNREACH_TOSNET:
1324                                 case ICMP_UNREACH_TOSHOST:
1325                                         ++unreachable;
1326                                         printf(" !T");
1327                                         break;
1328
1329                                 default:
1330                                         ++unreachable;
1331                                         printf(" !<%d>", code);
1332                                         break;
1333                                 }
1334                                 break;
1335                         }
1336                         if (cc == 0)
1337                                 printf(" *");
1338                         (void)fflush(stdout);
1339                 }
1340                 putchar('\n');
1341                 if (got_there ||
1342                     (unreachable > 0 && unreachable >= nprobes - 1))
1343                         break;
1344         }
1345         return 0;
1346 }