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