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  *      traceroute6
  27  *
  28  *      Modified for NRL 4.4BSD IPv6 release.
  29  *      07/31/96 bgp
  30  *
  31  *      Modified for Linux IPv6 by Pedro Roque <roque@di.fc.ul.pt>
  32  *      31/07/1996
  33  *
  34  *      As ICMP error messages for IPv6 now include more than 8 bytes
  35  *      UDP datagrams are now sent via an UDP socket instead of magic
  36  *      RAW socket tricks.
  37  *
  38  *      Converted to busybox applet by Leonid Lisovskiy <lly@sf.net>
  39  *      2009-11-16
  40  */
  41
  42 /*
  43  * traceroute host  - trace the route ip packets follow going to "host".
  44  *
  45  * Attempt to trace the route an ip packet would follow to some
  46  * internet host.  We find out intermediate hops by launching probe
  47  * packets with a small ttl (time to live) then listening for an
  48  * icmp "time exceeded" reply from a gateway.  We start our probes
  49  * with a ttl of one and increase by one until we get an icmp "port
  50  * unreachable" (which means we got to "host") or hit a max (which
  51  * defaults to 30 hops & can be changed with the -m flag).  Three
  52  * probes (change with -q flag) are sent at each ttl setting and a
  53  * line is printed showing the ttl, address of the gateway and
  54  * round trip time of each probe.  If the probe answers come from
  55  * different gateways, the address of each responding system will
  56  * be printed.  If there is no response within a 5 sec. timeout
  57  * interval (changed with the -w flag), a "*" is printed for that
  58  * probe.
  59  *
  60  * Probe packets are UDP format.  We don't want the destination
  61  * host to process them so the destination port is set to an
  62  * unlikely value (if some clod on the destination is using that
  63  * value, it can be changed with the -p flag).
  64  *
  65  * A sample use might be:
  66  *
  67  *     [yak 71]% traceroute nis.nsf.net.
  68  *     traceroute to nis.nsf.net (35.1.1.48), 30 hops max, 56 byte packet
  69  *      1  helios.ee.lbl.gov (128.3.112.1)  19 ms  19 ms  0 ms
  70  *      2  lilac-dmc.Berkeley.EDU (128.32.216.1)  39 ms  39 ms  19 ms
  71  *      3  lilac-dmc.Berkeley.EDU (128.32.216.1)  39 ms  39 ms  19 ms
  72  *      4  ccngw-ner-cc.Berkeley.EDU (128.32.136.23)  39 ms  40 ms  39 ms
  73  *      5  ccn-nerif22.Berkeley.EDU (128.32.168.22)  39 ms  39 ms  39 ms
  74  *      6  128.32.197.4 (128.32.197.4)  40 ms  59 ms  59 ms
  75  *      7  131.119.2.5 (131.119.2.5)  59 ms  59 ms  59 ms
  76  *      8  129.140.70.13 (129.140.70.13)  99 ms  99 ms  80 ms
  77  *      9  129.140.71.6 (129.140.71.6)  139 ms  239 ms  319 ms
  78  *     10  129.140.81.7 (129.140.81.7)  220 ms  199 ms  199 ms
  79  *     11  nic.merit.edu (35.1.1.48)  239 ms  239 ms  239 ms
  80  *
  81  * Note that lines 2 & 3 are the same.  This is due to a buggy
  82  * kernel on the 2nd hop system -- lbl-csam.arpa -- that forwards
  83  * packets with a zero ttl.
  84  *
  85  * A more interesting example is:
  86  *
  87  *     [yak 72]% traceroute allspice.lcs.mit.edu.
  88  *     traceroute to allspice.lcs.mit.edu (18.26.0.115), 30 hops max
  89  *      1  helios.ee.lbl.gov (128.3.112.1)  0 ms  0 ms  0 ms
  90  *      2  lilac-dmc.Berkeley.EDU (128.32.216.1)  19 ms  19 ms  19 ms
  91  *      3  lilac-dmc.Berkeley.EDU (128.32.216.1)  39 ms  19 ms  19 ms
  92  *      4  ccngw-ner-cc.Berkeley.EDU (128.32.136.23)  19 ms  39 ms  39 ms
  93  *      5  ccn-nerif22.Berkeley.EDU (128.32.168.22)  20 ms  39 ms  39 ms
  94  *      6  128.32.197.4 (128.32.197.4)  59 ms  119 ms  39 ms
  95  *      7  131.119.2.5 (131.119.2.5)  59 ms  59 ms  39 ms
  96  *      8  129.140.70.13 (129.140.70.13)  80 ms  79 ms  99 ms
  97  *      9  129.140.71.6 (129.140.71.6)  139 ms  139 ms  159 ms
  98  *     10  129.140.81.7 (129.140.81.7)  199 ms  180 ms  300 ms
  99  *     11  129.140.72.17 (129.140.72.17)  300 ms  239 ms  239 ms
 100  *     12  * * *
 101  *     13  128.121.54.72 (128.121.54.72)  259 ms  499 ms  279 ms
 102  *     14  * * *
 103  *     15  * * *
 104  *     16  * * *
 105  *     17  * * *
 106  *     18  ALLSPICE.LCS.MIT.EDU (18.26.0.115)  339 ms  279 ms  279 ms
 107  *
 108  * (I start to see why I'm having so much trouble with mail to
 109  * MIT.)  Note that the gateways 12, 14, 15, 16 & 17 hops away
 110  * either don't send ICMP "time exceeded" messages or send them
 111  * with a ttl too small to reach us.  14 - 17 are running the
 112  * MIT C Gateway code that doesn't send "time exceeded"s.  God
 113  * only knows what's going on with 12.
 114  *
 115  * The silent gateway 12 in the above may be the result of a bug in
 116  * the 4.[23]BSD network code (and its derivatives):  4.x (x <= 3)
 117  * sends an unreachable message using whatever ttl remains in the
 118  * original datagram.  Since, for gateways, the remaining ttl is
 119  * zero, the icmp "time exceeded" is guaranteed to not make it back
 120  * to us.  The behavior of this bug is slightly more interesting
 121  * when it appears on the destination system:
 122  *
 123  *      1  helios.ee.lbl.gov (128.3.112.1)  0 ms  0 ms  0 ms
 124  *      2  lilac-dmc.Berkeley.EDU (128.32.216.1)  39 ms  19 ms  39 ms
 125  *      3  lilac-dmc.Berkeley.EDU (128.32.216.1)  19 ms  39 ms  19 ms
 126  *      4  ccngw-ner-cc.Berkeley.EDU (128.32.136.23)  39 ms  40 ms  19 ms
 127  *      5  ccn-nerif35.Berkeley.EDU (128.32.168.35)  39 ms  39 ms  39 ms
 128  *      6  csgw.Berkeley.EDU (128.32.133.254)  39 ms  59 ms  39 ms
 129  *      7  * * *
 130  *      8  * * *
 131  *      9  * * *
 132  *     10  * * *
 133  *     11  * * *
 134  *     12  * * *
 135  *     13  rip.Berkeley.EDU (128.32.131.22)  59 ms !  39 ms !  39 ms !
 136  *
 137  * Notice that there are 12 "gateways" (13 is the final
 138  * destination) and exactly the last half of them are "missing".
 139  * What's really happening is that rip (a Sun-3 running Sun OS3.5)
 140  * is using the ttl from our arriving datagram as the ttl in its
 141  * icmp reply.  So, the reply will time out on the return path
 142  * (with no notice sent to anyone since icmp's aren't sent for
 143  * icmp's) until we probe with a ttl that's at least twice the path
 144  * length.  I.e., rip is really only 7 hops away.  A reply that
 145  * returns with a ttl of 1 is a clue this problem exists.
 146  * Traceroute prints a "!" after the time if the ttl is <= 1.
 147  * Since vendors ship a lot of obsolete (DEC's Ultrix, Sun 3.x) or
 148  * non-standard (HPUX) software, expect to see this problem
 149  * frequently and/or take care picking the target host of your
 150  * probes.
 151  *
 152  * Other possible annotations after the time are !H, !N, !P (got a host,
 153  * network or protocol unreachable, respectively), !S or !F (source
 154  * route failed or fragmentation needed -- neither of these should
 155  * ever occur and the associated gateway is busted if you see one).  If
 156  * almost all the probes result in some kind of unreachable, traceroute
 157  * will give up and exit.
 158  *
 159  * Notes
 160  * -----
 161  * This program must be run by root or be setuid.  (I suggest that
 162  * you *don't* make it setuid -- casual use could result in a lot
 163  * of unnecessary traffic on our poor, congested nets.)
 164  *
 165  * This program requires a kernel mod that does not appear in any
 166  * system available from Berkeley:  A raw ip socket using proto
 167  * IPPROTO_RAW must interpret the data sent as an ip datagram (as
 168  * opposed to data to be wrapped in a ip datagram).  See the README
 169  * file that came with the source to this program for a description
 170  * of the mods I made to /sys/netinet/raw_ip.c.  Your mileage may
 171  * vary.  But, again, ANY 4.x (x < 4) BSD KERNEL WILL HAVE TO BE
 172  * MODIFIED TO RUN THIS PROGRAM.
 173  *
 174  * The udp port usage may appear bizarre (well, ok, it is bizarre).
 175  * The problem is that an icmp message only contains 8 bytes of
 176  * data from the original datagram.  8 bytes is the size of a udp
 177  * header so, if we want to associate replies with the original
 178  * datagram, the necessary information must be encoded into the
 179  * udp header (the ip id could be used but there's no way to
 180  * interlock with the kernel's assignment of ip id's and, anyway,
 181  * it would have taken a lot more kernel hacking to allow this
 182  * code to set the ip id).  So, to allow two or more users to
 183  * use traceroute simultaneously, we use this task's pid as the
 184  * source port (the high bit is set to move the port number out
 185  * of the "likely" range).  To keep track of which probe is being
 186  * replied to (so times and/or hop counts don't get confused by a
 187  * reply that was delayed in transit), we increment the destination
 188  * port number before each probe.
 189  *
 190  * Don't use this as a coding example.  I was trying to find a
 191  * routing problem and this code sort-of popped out after 48 hours
 192  * without sleep.  I was amazed it ever compiled, much less ran.
 193  *
 194  * I stole the idea for this program from Steve Deering.  Since
 195  * the first release, I've learned that had I attended the right
 196  * IETF working group meetings, I also could have stolen it from Guy
 197  * Almes or Matt Mathis.  I don't know (or care) who came up with
 198  * the idea first.  I envy the originators' perspicacity and I'm
 199  * glad they didn't keep the idea a secret.
 200  *
 201  * Tim Seaver, Ken Adelman and C. Philip Wood provided bug fixes and/or
 202  * enhancements to the original distribution.
 203  *
 204  * I've hacked up a round-trip-route version of this that works by
 205  * sending a loose-source-routed udp datagram through the destination
 206  * back to yourself.  Unfortunately, SO many gateways botch source
 207  * routing, the thing is almost worthless.  Maybe one day...
 208  *
 209  *  -- Van Jacobson (van@ee.lbl.gov)
 210  *     Tue Dec 20 03:50:13 PST 1988
 211  */
 212
 213 //usage:#define traceroute_trivial_usage
 214 //usage:       "[-"IF_TRACEROUTE6("46")"FIldnrv] [-f 1ST_TTL] [-m MAXTTL] [-p PORT] [-q PROBES]\n"
 215 //usage:       "        [-s SRC_IP] [-t TOS] [-w WAIT_SEC] [-g GATEWAY] [-i IFACE]\n"
 216 //usage:       "        [-z PAUSE_MSEC] HOST [BYTES]"
 217 //usage:#define traceroute_full_usage "\n\n"
 218 //usage:       "Trace the route to HOST\n"
 219 //usage:        IF_TRACEROUTE6(
 220 //usage:     "\n        -4,-6   Force IP or IPv6 name resolution"
 221 //usage:        )
 222 //usage:     "\n        -F      Set the don't fragment bit"
 223 //usage:     "\n        -I      Use ICMP ECHO instead of UDP datagrams"
 224 //usage:     "\n        -l      Display the TTL value of the returned packet"
 225 //usage:     "\n        -d      Set SO_DEBUG options to socket"
 226 //usage:     "\n        -n      Print numeric addresses"
 227 //usage:     "\n        -r      Bypass routing tables, send directly to HOST"
 228 //usage:     "\n        -v      Verbose"
 229 //usage:     "\n        -m      Max time-to-live (max number of hops)"
 230 //usage:     "\n        -p      Base UDP port number used in probes"
 231 //usage:     "\n                (default 33434)"
 232 //usage:     "\n        -q      Number of probes per TTL (default 3)"
 233 //usage:     "\n        -s      IP address to use as the source address"
 234 //usage:     "\n        -t      Type-of-service in probe packets (default 0)"
 235 //usage:     "\n        -w      Time in seconds to wait for a response (default 3)"
 236 //usage:     "\n        -g      Loose source route gateway (8 max)"
 237 //usage:
 238 //usage:#define traceroute6_trivial_usage
 239 //usage:       "[-dnrv] [-m MAXTTL] [-p PORT] [-q PROBES]\n"
 240 //usage:       "        [-s SRC_IP] [-t TOS] [-w WAIT_SEC] [-i IFACE]\n"
 241 //usage:       "        HOST [BYTES]"
 242 //usage:#define traceroute6_full_usage "\n\n"
 243 //usage:       "Trace the route to HOST\n"
 244 //usage:     "\n        -d      Set SO_DEBUG options to socket"
 245 //usage:     "\n        -n      Print numeric addresses"
 246 //usage:     "\n        -r      Bypass routing tables, send directly to HOST"
 247 //usage:     "\n        -v      Verbose"
 248 //usage:     "\n        -m      Max time-to-live (max number of hops)"
 249 //usage:     "\n        -p      Base UDP port number used in probes"
 250 //usage:     "\n                (default is 33434)"
 251 //usage:     "\n        -q      Number of probes per TTL (default 3)"
 252 //usage:     "\n        -s      IP address to use as the source address"
 253 //usage:     "\n        -t      Type-of-service in probe packets (default 0)"
 254 //usage:     "\n        -w      Time in seconds to wait for a response (default 3)"
 255
 256 #define TRACEROUTE_SO_DEBUG 0
 257
 258 /* TODO: undefs were uncommented - ??! we have config system for that! */
 259 /* probably ok to remove altogether */
 260 //#undef CONFIG_FEATURE_TRACEROUTE_VERBOSE
 261 //#define CONFIG_FEATURE_TRACEROUTE_VERBOSE
 262 //#undef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
 263 //#define CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
 264 //#undef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
 265 //#define CONFIG_FEATURE_TRACEROUTE_USE_ICMP
 266
 267
 268 #include <net/if.h>
 269 #include <arpa/inet.h>
 270 #include <netinet/in.h>
 271 #include <netinet/udp.h>
 272 #include <netinet/ip.h>
 273 #include <netinet/ip_icmp.h>
 274 #if ENABLE_FEATURE_IPV6
 275 # include <netinet/ip6.h>
 276 # include <netinet/icmp6.h>
 277 # ifndef SOL_IPV6
 278 #  define SOL_IPV6 IPPROTO_IPV6
 279 # endif
 280 #endif
 281
 282 #include "libbb.h"
 283 #include "inet_common.h"
 284
 285 #ifndef IPPROTO_ICMP
 286 # define IPPROTO_ICMP 1
 287 #endif
 288 #ifndef IPPROTO_IP
 289 # define IPPROTO_IP 0
 290 #endif
 291
 292
 293 #define OPT_STRING \
 294         "FIlnrdvxt:i:m:p:q:s:w:z:f:" \
 295         IF_FEATURE_TRACEROUTE_SOURCE_ROUTE("g:") \
 296         "4" IF_TRACEROUTE6("6")
 297 enum {
 298         OPT_DONT_FRAGMNT = (1 << 0),    /* F */
 299         OPT_USE_ICMP     = (1 << 1) * ENABLE_FEATURE_TRACEROUTE_USE_ICMP, /* I */
 300         OPT_TTL_FLAG     = (1 << 2),    /* l */
 301         OPT_ADDR_NUM     = (1 << 3),    /* n */
 302         OPT_BYPASS_ROUTE = (1 << 4),    /* r */
 303         OPT_DEBUG        = (1 << 5),    /* d */
 304         OPT_VERBOSE      = (1 << 6) * ENABLE_FEATURE_TRACEROUTE_VERBOSE, /* v */
 305         OPT_IP_CHKSUM    = (1 << 7),    /* x */
 306         OPT_TOS          = (1 << 8),    /* t */
 307         OPT_DEVICE       = (1 << 9),    /* i */
 308         OPT_MAX_TTL      = (1 << 10),   /* m */
 309         OPT_PORT         = (1 << 11),   /* p */
 310         OPT_NPROBES      = (1 << 12),   /* q */
 311         OPT_SOURCE       = (1 << 13),   /* s */
 312         OPT_WAITTIME     = (1 << 14),   /* w */
 313         OPT_PAUSE_MS     = (1 << 15),   /* z */
 314         OPT_FIRST_TTL    = (1 << 16),   /* f */
 315         OPT_SOURCE_ROUTE = (1 << 17) * ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE, /* g */
 316         OPT_IPV4         = (1 << (17+ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE)),   /* 4 */
 317         OPT_IPV6         = (1 << (18+ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE)) * ENABLE_TRACEROUTE6, /* 6 */
 318 };
 319 #define verbose (option_mask32 & OPT_VERBOSE)
 320
 321 enum {
 322         SIZEOF_ICMP_HDR = 8,
 323         rcvsock = 3, /* receive (icmp) socket file descriptor */
 324         sndsock = 4, /* send (udp/icmp) socket file descriptor */
 325 };
 326
 327 /* Data section of the probe packet */
 328 struct outdata_t {
 329         unsigned char seq;             /* sequence number of this packet */
 330         unsigned char ttl;             /* ttl packet left with */
 331 // UNUSED. Retaining to have the same packet size.
 332         struct timeval tv_UNUSED PACKED; /* time packet left */
 333 };
 334
 335 #if ENABLE_TRACEROUTE6
 336 struct outdata6_t {
 337         uint32_t ident6;
 338         uint32_t seq6;
 339         struct timeval tv_UNUSED PACKED; /* time packet left */
 340 };
 341 #endif
 342
 343 struct globals {
 344         struct ip *outip;
 345         struct outdata_t *outdata;
 346         len_and_sockaddr *dest_lsa;
 347         int packlen;                    /* total length of packet */
 348         int pmtu;                       /* Path MTU Discovery (RFC1191) */
 349         uint32_t ident;
 350         uint16_t port; // 32768 + 666;  /* start udp dest port # for probe packets */
 351         int waittime; // 5;             /* time to wait for response (in seconds) */
 352 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 353         int optlen;                     /* length of ip options */
 354 #else
 355 #define optlen 0
 356 #endif
 357         unsigned char recv_pkt[512];    /* last inbound (icmp) packet */
 358 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 359         /* Maximum number of gateways (include room for one noop) */
 360 #define NGATEWAYS ((int)((MAX_IPOPTLEN - IPOPT_MINOFF - 1) / sizeof(uint32_t)))
 361         /* loose source route gateway list (including room for final destination) */
 362         uint32_t gwlist[NGATEWAYS + 1];
 363 #endif
 364 };
 365
 366 #define G (*ptr_to_globals)
 367 #define outip     (G.outip    )
 368 #define outdata   (G.outdata  )
 369 #define dest_lsa  (G.dest_lsa )
 370 #define packlen   (G.packlen  )
 371 #define pmtu      (G.pmtu     )
 372 #define ident     (G.ident    )
 373 #define port      (G.port     )
 374 #define waittime  (G.waittime )
 375 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 376 # define optlen   (G.optlen   )
 377 #endif
 378 #define recv_pkt  (G.recv_pkt )
 379 #define gwlist    (G.gwlist   )
 380 #define INIT_G() do { \
 381         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
 382         port = 32768 + 666; \
 383         waittime = 5; \
 384 } while (0)
 385
 386 #define outicmp ((struct icmp *)(outip + 1))
 387 #define outudp  ((struct udphdr *)(outip + 1))
 388
 389
 390 static int
 391 wait_for_reply(len_and_sockaddr *from_lsa, struct sockaddr *to, unsigned *timestamp_us, int *left_ms)
 392 {
 393         struct pollfd pfd[1];
 394         int read_len = 0;
 395
 396         pfd[0].fd = rcvsock;
 397         pfd[0].events = POLLIN;
 398         if (*left_ms >= 0 && safe_poll(pfd, 1, *left_ms) > 0) {
 399                 unsigned t;
 400
 401                 read_len = recv_from_to(rcvsock,
 402                                 recv_pkt, sizeof(recv_pkt),
 403                                 /*flags:*/ MSG_DONTWAIT,
 404                                 &from_lsa->u.sa, to, from_lsa->len);
 405                 t = monotonic_us();
 406                 *left_ms -= (t - *timestamp_us) / 1000;
 407                 *timestamp_us = t;
 408         }
 409
 410         return read_len;
 411 }
 412
 413 static void
 414 send_probe(int seq, int ttl)
 415 {
 416         int len, res;
 417         void *out;
 418
 419         /* Payload */
 420 #if ENABLE_TRACEROUTE6
 421         if (dest_lsa->u.sa.sa_family == AF_INET6) {
 422                 struct outdata6_t *pkt = (struct outdata6_t *) outip;
 423                 pkt->ident6 = htonl(ident);
 424                 pkt->seq6   = htonl(seq);
 425                 /*gettimeofday(&pkt->tv, &tz);*/
 426         } else
 427 #endif
 428         {
 429                 outdata->seq = seq;
 430                 outdata->ttl = ttl;
 431 // UNUSED: was storing gettimeofday's result there, but never ever checked it
 432                 /*memcpy(&outdata->tv, tp, sizeof(outdata->tv));*/
 433
 434                 if (option_mask32 & OPT_USE_ICMP) {
 435                         outicmp->icmp_seq = htons(seq);
 436
 437                         /* Always calculate checksum for icmp packets */
 438                         outicmp->icmp_cksum = 0;
 439                         outicmp->icmp_cksum = inet_cksum((uint16_t *)outicmp,
 440                                                 packlen - (sizeof(*outip) + optlen));
 441                         if (outicmp->icmp_cksum == 0)
 442                                 outicmp->icmp_cksum = 0xffff;
 443                 }
 444         }
 445
 446 //BUG! verbose is (x & OPT_VERBOSE), not a counter!
 447 #if 0 //ENABLE_FEATURE_TRACEROUTE_VERBOSE
 448         /* XXX undocumented debugging hack */
 449         if (verbose > 1) {
 450                 const uint16_t *sp;
 451                 int nshorts, i;
 452
 453                 sp = (uint16_t *)outip;
 454                 nshorts = (unsigned)packlen / sizeof(uint16_t);
 455                 i = 0;
 456                 printf("[ %d bytes", packlen);
 457                 while (--nshorts >= 0) {
 458                         if ((i++ % 8) == 0)
 459                                 printf("\n\t");
 460                         printf(" %04x", ntohs(*sp));
 461                         sp++;
 462                 }
 463                 if (packlen & 1) {
 464                         if ((i % 8) == 0)
 465                                 printf("\n\t");
 466                         printf(" %02x", *(unsigned char *)sp);
 467                 }
 468                 printf("]\n");
 469         }
 470 #endif
 471
 472 #if ENABLE_TRACEROUTE6
 473         if (dest_lsa->u.sa.sa_family == AF_INET6) {
 474                 res = setsockopt(sndsock, SOL_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl));
 475                 if (res < 0)
 476                         bb_perror_msg_and_die("setsockopt UNICAST_HOPS %d", ttl);
 477                 out = outip;
 478                 len = packlen;
 479         } else
 480 #endif
 481         {
 482 #if defined IP_TTL
 483                 res = setsockopt(sndsock, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl));
 484                 if (res < 0)
 485                         bb_perror_msg_and_die("setsockopt ttl %d", ttl);
 486 #endif
 487                 out = outicmp;
 488                 len = packlen - sizeof(*outip);
 489                 if (!(option_mask32 & OPT_USE_ICMP)) {
 490                         out = outdata;
 491                         len -= sizeof(*outudp);
 492                         set_nport(&dest_lsa->u.sa, htons(port + seq));
 493                 }
 494         }
 495
 496         res = xsendto(sndsock, out, len, &dest_lsa->u.sa, dest_lsa->len);
 497         if (res != len)
 498                 bb_info_msg("sent %d octets, ret=%d", len, res);
 499 }
 500
 501 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 502 /*
 503  * Convert an ICMP "type" field to a printable string.
 504  */
 505 static const char *
 506 pr_type(unsigned char t)
 507 {
 508         static const char *const ttab[] = {
 509         "Echo Reply",   "ICMP 1",       "ICMP 2",       "Dest Unreachable",
 510         "Source Quench", "Redirect",    "ICMP 6",       "ICMP 7",
 511         "Echo",         "Router Advert", "Router Solicit", "Time Exceeded",
 512         "Param Problem", "Timestamp",   "Timestamp Reply", "Info Request",
 513         "Info Reply",   "Mask Request", "Mask Reply"
 514         };
 515 # if ENABLE_TRACEROUTE6
 516         static const char *const ttab6[] = {
 517 [0]     "Error", "Dest Unreachable", "Packet Too Big", "Time Exceeded",
 518 [4]     "Param Problem",
 519 [8]     "Echo Request", "Echo Reply", "Membership Query", "Membership Report",
 520 [12]    "Membership Reduction", "Router Solicit", "Router Advert", "Neighbor Solicit",
 521 [16]    "Neighbor Advert", "Redirect",
 522         };
 523
 524         if (dest_lsa->u.sa.sa_family == AF_INET6) {
 525                 if (t < 5)
 526                         return ttab6[t];
 527                 if (t < 128 || t > ND_REDIRECT)
 528                         return "OUT-OF-RANGE";
 529                 return ttab6[(t & 63) + 8];
 530         }
 531 # endif
 532         if (t >= ARRAY_SIZE(ttab))
 533                 return "OUT-OF-RANGE";
 534
 535         return ttab[t];
 536 }
 537 #endif
 538
 539 #if !ENABLE_FEATURE_TRACEROUTE_VERBOSE
 540 #define packet4_ok(read_len, from, seq) \
 541         packet4_ok(read_len, seq)
 542 #endif
 543 static int
 544 packet4_ok(int read_len, const struct sockaddr_in *from, int seq)
 545 {
 546         const struct icmp *icp;
 547         unsigned char type, code;
 548         int hlen;
 549         const struct ip *ip;
 550
 551         ip = (struct ip *) recv_pkt;
 552         hlen = ip->ip_hl << 2;
 553         if (read_len < hlen + ICMP_MINLEN) {
 554 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 555                 if (verbose)
 556                         printf("packet too short (%d bytes) from %s\n", read_len,
 557                                 inet_ntoa(from->sin_addr));
 558 #endif
 559                 return 0;
 560         }
 561         read_len -= hlen;
 562         icp = (struct icmp *)(recv_pkt + hlen);
 563         type = icp->icmp_type;
 564         code = icp->icmp_code;
 565         /* Path MTU Discovery (RFC1191) */
 566         pmtu = 0;
 567         if (code == ICMP_UNREACH_NEEDFRAG)
 568                 pmtu = ntohs(icp->icmp_nextmtu);
 569
 570         if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS)
 571          || type == ICMP_UNREACH
 572          || type == ICMP_ECHOREPLY
 573         ) {
 574                 const struct ip *hip;
 575                 const struct udphdr *up;
 576
 577                 hip = &icp->icmp_ip;
 578                 hlen = hip->ip_hl << 2;
 579                 if (option_mask32 & OPT_USE_ICMP) {
 580                         struct icmp *hicmp;
 581
 582                         /* XXX */
 583                         if (type == ICMP_ECHOREPLY
 584                          && icp->icmp_id == htons(ident)
 585                          && icp->icmp_seq == htons(seq)
 586                         ) {
 587                                 return ICMP_UNREACH_PORT+1;
 588                         }
 589
 590                         hicmp = (struct icmp *)((unsigned char *)hip + hlen);
 591                         if (hlen + SIZEOF_ICMP_HDR <= read_len
 592                          && hip->ip_p == IPPROTO_ICMP
 593                          && hicmp->icmp_id == htons(ident)
 594                          && hicmp->icmp_seq == htons(seq)
 595                         ) {
 596                                 return (type == ICMP_TIMXCEED ? -1 : code + 1);
 597                         }
 598                 } else {
 599                         up = (struct udphdr *)((char *)hip + hlen);
 600                         if (hlen + 12 <= read_len
 601                          && hip->ip_p == IPPROTO_UDP
 602 // Off: since we do not form the entire IP packet,
 603 // but defer it to kernel, we can't set source port,
 604 // and thus can't check it here in the reply
 605                         /* && up->source == htons(ident) */
 606                          && up->dest == htons(port + seq)
 607                         ) {
 608                                 return (type == ICMP_TIMXCEED ? -1 : code + 1);
 609                         }
 610                 }
 611         }
 612 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 613         if (verbose) {
 614                 int i;
 615                 uint32_t *lp = (uint32_t *)&icp->icmp_ip;
 616
 617                 printf("\n%d bytes from %s to "
 618                        "%s: icmp type %d (%s) code %d\n",
 619                         read_len, inet_ntoa(from->sin_addr),
 620                         inet_ntoa(ip->ip_dst),
 621                         type, pr_type(type), icp->icmp_code);
 622                 for (i = 4; i < read_len; i += sizeof(*lp))
 623                         printf("%2d: x%8.8x\n", i, *lp++);
 624         }
 625 #endif
 626         return 0;
 627 }
 628
 629 #if ENABLE_TRACEROUTE6
 630 # if !ENABLE_FEATURE_TRACEROUTE_VERBOSE
 631 #define packet_ok(read_len, from_lsa, to, seq) \
 632         packet_ok(read_len, from_lsa, seq)
 633 # endif
 634 static int
 635 packet_ok(int read_len, len_and_sockaddr *from_lsa,
 636                         struct sockaddr *to,
 637                         int seq)
 638 {
 639         const struct icmp6_hdr *icp;
 640         unsigned char type, code;
 641
 642         if (from_lsa->u.sa.sa_family == AF_INET)
 643                 return packet4_ok(read_len, &from_lsa->u.sin, seq);
 644
 645         icp = (struct icmp6_hdr *) recv_pkt;
 646
 647         type = icp->icmp6_type;
 648         code = icp->icmp6_code;
 649
 650         if ((type == ICMP6_TIME_EXCEEDED && code == ICMP6_TIME_EXCEED_TRANSIT)
 651          || type == ICMP6_DST_UNREACH
 652         ) {
 653                 struct ip6_hdr *hip;
 654                 struct udphdr *up;
 655                 int nexthdr;
 656
 657                 hip = (struct ip6_hdr *)(icp + 1);
 658                 up  = (struct udphdr *) (hip + 1);
 659                 nexthdr = hip->ip6_nxt;
 660
 661                 if (nexthdr == IPPROTO_FRAGMENT) {
 662                         nexthdr = *(unsigned char*)up;
 663                         up++;
 664                 }
 665                 if (nexthdr == IPPROTO_UDP) {
 666                         struct outdata6_t *pkt;
 667
 668                         pkt = (struct outdata6_t *) (up + 1);
 669
 670                         if (ntohl(pkt->ident6) == ident
 671                          && ntohl(pkt->seq6) == seq
 672                         ) {
 673                                 return (type == ICMP6_TIME_EXCEEDED ? -1 : (code<<8)+1);
 674                         }
 675                 }
 676         }
 677
 678 # if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 679         if (verbose) {
 680                 unsigned char *p;
 681                 char pa1[MAXHOSTNAMELEN];
 682                 char pa2[MAXHOSTNAMELEN];
 683                 int i;
 684
 685                 p = (unsigned char *) (icp + 1);
 686
 687                 printf("\n%d bytes from %s to "
 688                        "%s: icmp type %d (%s) code %d\n",
 689                         read_len,
 690                         inet_ntop(AF_INET6, &from_lsa->u.sin6.sin6_addr, pa1, sizeof(pa1)),
 691                         inet_ntop(AF_INET6, &((struct sockaddr_in6*)to)->sin6_addr, pa2, sizeof(pa2)),
 692                         type, pr_type(type), icp->icmp6_code);
 693
 694                 read_len -= sizeof(struct icmp6_hdr);
 695                 for (i = 0; i < read_len; i++) {
 696                         if (i % 16 == 0)
 697                                 printf("%04x:", i);
 698                         if (i % 4 == 0)
 699                                 bb_putchar(' ');
 700                         printf("%02x", p[i]);
 701                         if ((i % 16 == 15) && (i + 1 < read_len))
 702                                 bb_putchar('\n');
 703                 }
 704                 bb_putchar('\n');
 705         }
 706 # endif
 707
 708         return 0;
 709 }
 710 #else /* !ENABLE_TRACEROUTE6 */
 711 static ALWAYS_INLINE int
 712 packet_ok(int read_len,
 713                 len_and_sockaddr *from_lsa IF_NOT_FEATURE_TRACEROUTE_VERBOSE(UNUSED_PARAM),
 714                 struct sockaddr *to UNUSED_PARAM,
 715                 int seq)
 716 {
 717         return packet4_ok(read_len, &from_lsa->u.sin, seq);
 718 }
 719 #endif
 720
 721 /*
 722  * Construct an Internet address representation.
 723  * If the -n flag has been supplied, give
 724  * numeric value, otherwise try for symbolic name.
 725  */
 726 static void
 727 print_inetname(const struct sockaddr *from)
 728 {
 729         char *ina = xmalloc_sockaddr2dotted_noport(from);
 730
 731         if (option_mask32 & OPT_ADDR_NUM) {
 732                 printf("  %s", ina);
 733         } else {
 734                 char *n = NULL;
 735
 736                 if (from->sa_family != AF_INET
 737                  || ((struct sockaddr_in*)from)->sin_addr.s_addr != INADDR_ANY
 738                 ) {
 739                         /* Try to reverse resolve if it is not 0.0.0.0 */
 740                         n = xmalloc_sockaddr2host_noport((struct sockaddr*)from);
 741                 }
 742                 printf("  %s (%s)", (n ? n : ina), ina);
 743                 free(n);
 744         }
 745         free(ina);
 746 }
 747
 748 static void
 749 print(int read_len, const struct sockaddr *from, const struct sockaddr *to)
 750 {
 751         print_inetname(from);
 752
 753         if (verbose) {
 754                 char *ina = xmalloc_sockaddr2dotted_noport(to);
 755 #if ENABLE_TRACEROUTE6
 756                 if (to->sa_family == AF_INET6) {
 757                         read_len -= sizeof(struct ip6_hdr);
 758                 } else
 759 #endif
 760                 {
 761                         struct ip *ip4packet = (struct ip*)recv_pkt;
 762                         read_len -= ip4packet->ip_hl << 2;
 763                 }
 764                 printf(" %d bytes to %s", read_len, ina);
 765                 free(ina);
 766         }
 767 }
 768
 769 static void
 770 print_delta_ms(unsigned t1p, unsigned t2p)
 771 {
 772         unsigned tt = t2p - t1p;
 773         printf("  %u.%03u ms", tt / 1000, tt % 1000);
 774 }
 775
 776 /*
 777  * Usage: [-dFIlnrvx] [-g gateway] [-i iface] [-f first_ttl]
 778  * [-m max_ttl] [ -p port] [-q nqueries] [-s src_addr] [-t tos]
 779  * [-w waittime] [-z pausemsecs] host [packetlen]"
 780  */
 781 static int
 782 common_traceroute_main(int op, char **argv)
 783 {
 784         int minpacket;
 785 #ifdef IP_TOS
 786         int tos = 0;
 787 #endif
 788         int max_ttl = 30;
 789         int nprobes = 3;
 790         int first_ttl = 1;
 791         unsigned pausemsecs = 0;
 792         char *source;
 793         char *device;
 794         char *tos_str;
 795         char *max_ttl_str;
 796         char *port_str;
 797         char *nprobes_str;
 798         char *waittime_str;
 799         char *pausemsecs_str;
 800         char *first_ttl_str;
 801         char *dest_str;
 802 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 803         llist_t *source_route_list = NULL;
 804         int lsrr = 0;
 805 #endif
 806 #if ENABLE_TRACEROUTE6
 807         sa_family_t af;
 808 #else
 809         enum { af = AF_INET };
 810 #endif
 811         int ttl;
 812         int seq;
 813         len_and_sockaddr *from_lsa;
 814         struct sockaddr *lastaddr;
 815         struct sockaddr *to;
 816
 817         INIT_G();
 818
 819         /* minimum 1 arg */
 820         opt_complementary = "-1:x-x" IF_FEATURE_TRACEROUTE_SOURCE_ROUTE(":g::");
 821         op |= getopt32(argv, OPT_STRING
 822                 , &tos_str, &device, &max_ttl_str, &port_str, &nprobes_str
 823                 , &source, &waittime_str, &pausemsecs_str, &first_ttl_str
 824 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 825                 , &source_route_list
 826 #endif
 827         );
 828         argv += optind;
 829
 830 #if 0 /* IGNORED */
 831         if (op & OPT_IP_CHKSUM)
 832                 bb_error_msg("warning: ip checksums disabled");
 833 #endif
 834 #ifdef IP_TOS
 835         if (op & OPT_TOS)
 836                 tos = xatou_range(tos_str, 0, 255);
 837 #endif
 838         if (op & OPT_MAX_TTL)
 839                 max_ttl = xatou_range(max_ttl_str, 1, 255);
 840         if (op & OPT_PORT)
 841                 port = xatou16(port_str);
 842         if (op & OPT_NPROBES)
 843                 nprobes = xatou_range(nprobes_str, 1, INT_MAX);
 844         if (op & OPT_SOURCE) {
 845                 /*
 846                  * set the ip source address of the outbound
 847                  * probe (e.g., on a multi-homed host).
 848                  */
 849                 if (getuid() != 0)
 850                         bb_error_msg_and_die(bb_msg_you_must_be_root);
 851         }
 852         if (op & OPT_WAITTIME)
 853                 waittime = xatou_range(waittime_str, 1, 24 * 60 * 60);
 854         if (op & OPT_PAUSE_MS)
 855                 pausemsecs = xatou_range(pausemsecs_str, 0, 60 * 60 * 1000);
 856         if (op & OPT_FIRST_TTL)
 857                 first_ttl = xatou_range(first_ttl_str, 1, max_ttl);
 858
 859 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 860         if (source_route_list) {
 861                 while (source_route_list) {
 862                         len_and_sockaddr *lsa;
 863
 864                         if (lsrr >= NGATEWAYS)
 865                                 bb_error_msg_and_die("no more than %d gateways", NGATEWAYS);
 866                         lsa = xhost_and_af2sockaddr(llist_pop(&source_route_list), 0, AF_INET);
 867                         gwlist[lsrr] = lsa->u.sin.sin_addr.s_addr;
 868                         free(lsa);
 869                         ++lsrr;
 870                 }
 871                 optlen = (lsrr + 1) * sizeof(gwlist[0]);
 872         }
 873 #endif
 874
 875         /* Process destination and optional packet size */
 876         minpacket = sizeof(*outip) + SIZEOF_ICMP_HDR + sizeof(*outdata) + optlen;
 877         if (!(op & OPT_USE_ICMP))
 878                 minpacket += sizeof(*outudp) - SIZEOF_ICMP_HDR;
 879 #if ENABLE_TRACEROUTE6
 880         af = AF_UNSPEC;
 881         if (op & OPT_IPV4)
 882                 af = AF_INET;
 883         if (op & OPT_IPV6)
 884                 af = AF_INET6;
 885         dest_lsa = xhost_and_af2sockaddr(argv[0], port, af);
 886         af = dest_lsa->u.sa.sa_family;
 887         if (af == AF_INET6)
 888                 minpacket = sizeof(struct outdata6_t);
 889 #else
 890         dest_lsa = xhost2sockaddr(argv[0], port);
 891 #endif
 892         packlen = minpacket;
 893         if (argv[1])
 894                 packlen = xatoul_range(argv[1], minpacket, 32 * 1024);
 895
 896         /* Ensure the socket fds won't be 0, 1 or 2 */
 897         bb_sanitize_stdio();
 898
 899 #if ENABLE_TRACEROUTE6
 900         if (af == AF_INET6) {
 901                 xmove_fd(xsocket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6), rcvsock);
 902 # ifdef IPV6_RECVPKTINFO
 903                 setsockopt(rcvsock, SOL_IPV6, IPV6_RECVPKTINFO,
 904                                 &const_int_1, sizeof(const_int_1));
 905                 setsockopt(rcvsock, SOL_IPV6, IPV6_2292PKTINFO,
 906                                 &const_int_1, sizeof(const_int_1));
 907 # else
 908                 setsockopt(rcvsock, SOL_IPV6, IPV6_PKTINFO,
 909                                 &const_int_1, sizeof(const_int_1));
 910 # endif
 911         } else
 912 #endif
 913         {
 914                 xmove_fd(xsocket(AF_INET, SOCK_RAW, IPPROTO_ICMP), rcvsock);
 915         }
 916
 917 #if TRACEROUTE_SO_DEBUG
 918         if (op & OPT_DEBUG)
 919                 setsockopt(rcvsock, SOL_SOCKET, SO_DEBUG,
 920                                 &const_int_1, sizeof(const_int_1));
 921 #endif
 922         if (op & OPT_BYPASS_ROUTE)
 923                 setsockopt(rcvsock, SOL_SOCKET, SO_DONTROUTE,
 924                                 &const_int_1, sizeof(const_int_1));
 925
 926 #if ENABLE_TRACEROUTE6
 927         if (af == AF_INET6) {
 928                 static const int two = 2;
 929                 if (setsockopt(rcvsock, SOL_RAW, IPV6_CHECKSUM, &two, sizeof(two)) < 0)
 930                         bb_perror_msg_and_die("setsockopt RAW_CHECKSUM");
 931                 xmove_fd(xsocket(af, SOCK_DGRAM, 0), sndsock);
 932         } else
 933 #endif
 934         {
 935                 if (op & OPT_USE_ICMP)
 936                         xmove_fd(xsocket(AF_INET, SOCK_RAW, IPPROTO_ICMP), sndsock);
 937                 else
 938                         xmove_fd(xsocket(AF_INET, SOCK_DGRAM, 0), sndsock);
 939 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE && defined IP_OPTIONS
 940                 if (lsrr > 0) {
 941                         unsigned char optlist[MAX_IPOPTLEN];
 942                         unsigned size;
 943
 944                         /* final hop */
 945                         gwlist[lsrr] = dest_lsa->u.sin.sin_addr.s_addr;
 946                         ++lsrr;
 947
 948                         /* force 4 byte alignment */
 949                         optlist[0] = IPOPT_NOP;
 950                         /* loose source route option */
 951                         optlist[1] = IPOPT_LSRR;
 952                         size = lsrr * sizeof(gwlist[0]);
 953                         optlist[2] = size + 3;
 954                         /* pointer to LSRR addresses */
 955                         optlist[3] = IPOPT_MINOFF;
 956                         memcpy(optlist + 4, gwlist, size);
 957
 958                         if (setsockopt(sndsock, IPPROTO_IP, IP_OPTIONS,
 959                                         (char *)optlist, size + sizeof(gwlist[0])) < 0) {
 960                                 bb_perror_msg_and_die("IP_OPTIONS");
 961                         }
 962                 }
 963 #endif
 964         }
 965
 966 #ifdef SO_SNDBUF
 967         if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, &packlen, sizeof(packlen)) < 0) {
 968                 bb_perror_msg_and_die("SO_SNDBUF");
 969         }
 970 #endif
 971 #ifdef IP_TOS
 972         if ((op & OPT_TOS) && setsockopt(sndsock, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)) < 0) {
 973                 bb_perror_msg_and_die("setsockopt tos %d", tos);
 974         }
 975 #endif
 976 #ifdef IP_DONTFRAG
 977         if (op & OPT_DONT_FRAGMNT)
 978                 setsockopt(sndsock, IPPROTO_IP, IP_DONTFRAG,
 979                                 &const_int_1, sizeof(const_int_1));
 980 #endif
 981 #if TRACEROUTE_SO_DEBUG
 982         if (op & OPT_DEBUG)
 983                 setsockopt(sndsock, SOL_SOCKET, SO_DEBUG,
 984                                 &const_int_1, sizeof(const_int_1));
 985 #endif
 986         if (op & OPT_BYPASS_ROUTE)
 987                 setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE,
 988                                 &const_int_1, sizeof(const_int_1));
 989
 990         outip = xzalloc(packlen);
 991
 992         ident = getpid();
 993
 994         if (af == AF_INET) {
 995                 if (op & OPT_USE_ICMP) {
 996                         ident |= 0x8000;
 997                         outicmp->icmp_type = ICMP_ECHO;
 998                         outicmp->icmp_id = htons(ident);
 999                         outdata = (struct outdata_t *)((char *)outicmp + SIZEOF_ICMP_HDR);
1000                 } else {
1001                         outdata = (struct outdata_t *)(outudp + 1);
1002                 }
1003         }
1004
1005         if (op & OPT_DEVICE) /* hmm, do we need error check? */
1006                 setsockopt_bindtodevice(sndsock, device);
1007
1008         if (op & OPT_SOURCE) {
1009 #if ENABLE_TRACEROUTE6
1010 // TODO: need xdotted_and_af2sockaddr?
1011                 len_and_sockaddr *source_lsa = xhost_and_af2sockaddr(source, 0, af);
1012 #else
1013                 len_and_sockaddr *source_lsa = xdotted2sockaddr(source, 0);
1014 #endif
1015                 /* Ping4 does this (why?) */
1016                 if (af == AF_INET)
1017                         if (setsockopt(sndsock, IPPROTO_IP, IP_MULTICAST_IF,
1018                                         &source_lsa->u.sa, source_lsa->len))
1019                                 bb_error_msg_and_die("can't set multicast source interface");
1020 //TODO: we can query source port we bound to,
1021 // and check it in replies... if we care enough
1022                 xbind(sndsock, &source_lsa->u.sa, source_lsa->len);
1023                 free(source_lsa);
1024         }
1025 #if ENABLE_TRACEROUTE6
1026         else if (af == AF_INET6) {
1027 //TODO: why we don't do it for IPv4?
1028                 len_and_sockaddr *source_lsa;
1029
1030                 int probe_fd = xsocket(af, SOCK_DGRAM, 0);
1031                 if (op & OPT_DEVICE)
1032                         setsockopt_bindtodevice(probe_fd, device);
1033                 set_nport(&dest_lsa->u.sa, htons(1025));
1034                 /* dummy connect. makes kernel pick source IP (and port) */
1035                 xconnect(probe_fd, &dest_lsa->u.sa, dest_lsa->len);
1036                 set_nport(&dest_lsa->u.sa, htons(port));
1037
1038                 /* read IP and port */
1039                 source_lsa = get_sock_lsa(probe_fd);
1040                 if (source_lsa == NULL)
1041                         bb_error_msg_and_die("can't get probe addr");
1042
1043                 close(probe_fd);
1044
1045                 /* bind our sockets to this IP (but not port) */
1046                 set_nport(&source_lsa->u.sa, 0);
1047                 xbind(sndsock, &source_lsa->u.sa, source_lsa->len);
1048                 xbind(rcvsock, &source_lsa->u.sa, source_lsa->len);
1049
1050                 free(source_lsa);
1051         }
1052 #endif
1053
1054         /* Revert to non-privileged user after opening sockets */
1055         xsetgid(getgid());
1056         xsetuid(getuid());
1057
1058         dest_str = xmalloc_sockaddr2dotted_noport(&dest_lsa->u.sa);
1059         printf("traceroute to %s (%s)", argv[0], dest_str);
1060         if (ENABLE_FEATURE_CLEAN_UP) {
1061                 free(dest_str);
1062         }
1063
1064         if (op & OPT_SOURCE)
1065                 printf(" from %s", source);
1066         printf(", %d hops max, %d byte packets\n", max_ttl, packlen);
1067
1068         from_lsa = xmemdup(dest_lsa, LSA_LEN_SIZE + dest_lsa->len);
1069         lastaddr = xzalloc(dest_lsa->len);
1070         to = xzalloc(dest_lsa->len);
1071         seq = 0;
1072         for (ttl = first_ttl; ttl <= max_ttl; ++ttl) {
1073                 int probe;
1074                 int unreachable = 0; /* counter */
1075                 int gotlastaddr = 0; /* flags */
1076                 int got_there = 0;
1077
1078                 printf("%2d", ttl);
1079                 for (probe = 0; probe < nprobes; ++probe) {
1080                         int read_len;
1081                         unsigned t1;
1082                         unsigned t2;
1083                         int left_ms;
1084                         struct ip *ip;
1085
1086                         fflush_all();
1087                         if (probe != 0 && pausemsecs > 0)
1088                                 usleep(pausemsecs * 1000);
1089
1090                         send_probe(++seq, ttl);
1091                         t2 = t1 = monotonic_us();
1092
1093                         left_ms = waittime * 1000;
1094                         while ((read_len = wait_for_reply(from_lsa, to, &t2, &left_ms)) != 0) {
1095                                 int icmp_code;
1096
1097                                 /* Recv'ed a packet, or read error */
1098                                 /* t2 = monotonic_us() - set by wait_for_reply */
1099
1100                                 if (read_len < 0)
1101                                         continue;
1102                                 icmp_code = packet_ok(read_len, from_lsa, to, seq);
1103                                 /* Skip short packet */
1104                                 if (icmp_code == 0)
1105                                         continue;
1106
1107                                 if (!gotlastaddr
1108                                  || (memcmp(lastaddr, &from_lsa->u.sa, from_lsa->len) != 0)
1109                                 ) {
1110                                         print(read_len, &from_lsa->u.sa, to);
1111                                         memcpy(lastaddr, &from_lsa->u.sa, from_lsa->len);
1112                                         gotlastaddr = 1;
1113                                 }
1114
1115                                 print_delta_ms(t1, t2);
1116                                 ip = (struct ip *)recv_pkt;
1117
1118                                 if (from_lsa->u.sa.sa_family == AF_INET)
1119                                         if (op & OPT_TTL_FLAG)
1120                                                 printf(" (%d)", ip->ip_ttl);
1121
1122                                 /* time exceeded in transit */
1123                                 if (icmp_code == -1)
1124                                         break;
1125                                 icmp_code--;
1126                                 switch (icmp_code) {
1127 #if ENABLE_TRACEROUTE6
1128                                 case ICMP6_DST_UNREACH_NOPORT << 8:
1129                                         got_there = 1;
1130                                         break;
1131 #endif
1132                                 case ICMP_UNREACH_PORT:
1133                                         if (ip->ip_ttl <= 1)
1134                                                 printf(" !");
1135                                         got_there = 1;
1136                                         break;
1137
1138                                 case ICMP_UNREACH_NET:
1139 #if ENABLE_TRACEROUTE6 && (ICMP6_DST_UNREACH_NOROUTE != ICMP_UNREACH_NET)
1140                                 case ICMP6_DST_UNREACH_NOROUTE << 8:
1141 #endif
1142                                         printf(" !N");
1143                                         ++unreachable;
1144                                         break;
1145                                 case ICMP_UNREACH_HOST:
1146 #if ENABLE_TRACEROUTE6
1147                                 case ICMP6_DST_UNREACH_ADDR << 8:
1148 #endif
1149                                         printf(" !H");
1150                                         ++unreachable;
1151                                         break;
1152                                 case ICMP_UNREACH_PROTOCOL:
1153                                         printf(" !P");
1154                                         got_there = 1;
1155                                         break;
1156                                 case ICMP_UNREACH_NEEDFRAG:
1157                                         printf(" !F-%d", pmtu);
1158                                         ++unreachable;
1159                                         break;
1160                                 case ICMP_UNREACH_SRCFAIL:
1161 #if ENABLE_TRACEROUTE6
1162                                 case ICMP6_DST_UNREACH_ADMIN << 8:
1163 #endif
1164                                         printf(" !S");
1165                                         ++unreachable;
1166                                         break;
1167                                 case ICMP_UNREACH_FILTER_PROHIB:
1168                                 case ICMP_UNREACH_NET_PROHIB:   /* misuse */
1169                                         printf(" !A");
1170                                         ++unreachable;
1171                                         break;
1172                                 case ICMP_UNREACH_HOST_PROHIB:
1173                                         printf(" !C");
1174                                         ++unreachable;
1175                                         break;
1176                                 case ICMP_UNREACH_HOST_PRECEDENCE:
1177                                         printf(" !V");
1178                                         ++unreachable;
1179                                         break;
1180                                 case ICMP_UNREACH_PRECEDENCE_CUTOFF:
1181                                         printf(" !C");
1182                                         ++unreachable;
1183                                         break;
1184                                 case ICMP_UNREACH_NET_UNKNOWN:
1185                                 case ICMP_UNREACH_HOST_UNKNOWN:
1186                                         printf(" !U");
1187                                         ++unreachable;
1188                                         break;
1189                                 case ICMP_UNREACH_ISOLATED:
1190                                         printf(" !I");
1191                                         ++unreachable;
1192                                         break;
1193                                 case ICMP_UNREACH_TOSNET:
1194                                 case ICMP_UNREACH_TOSHOST:
1195                                         printf(" !T");
1196                                         ++unreachable;
1197                                         break;
1198                                 default:
1199                                         printf(" !<%d>", icmp_code);
1200                                         ++unreachable;
1201                                         break;
1202                                 }
1203                                 break;
1204                         } /* while (wait and read a packet) */
1205
1206                         /* there was no packet at all? */
1207                         if (read_len == 0)
1208                                 printf("  *");
1209                 } /* for (nprobes) */
1210
1211                 bb_putchar('\n');
1212                 if (got_there
1213                  || (unreachable > 0 && unreachable >= nprobes - 1)
1214                 ) {
1215                         break;
1216                 }
1217         }
1218
1219         if (ENABLE_FEATURE_CLEAN_UP) {
1220                 free(to);
1221                 free(lastaddr);
1222                 free(from_lsa);
1223         }
1224
1225         return 0;
1226 }
1227
1228 int traceroute_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1229 int traceroute_main(int argc UNUSED_PARAM, char **argv)
1230 {
1231         return common_traceroute_main(0, argv);
1232 }
1233
1234 #if ENABLE_TRACEROUTE6
1235 int traceroute6_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1236 int traceroute6_main(int argc UNUSED_PARAM, char **argv)
1237 {
1238         return common_traceroute_main(OPT_IPV6, argv);
1239 }
1240 #endif