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