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