networking/traceroute.c

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