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