networking/traceroute.c

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