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 //config:config TRACEROUTE
 213 //config:       bool "traceroute"
 214 //config:       default y
 215 //config:       select PLATFORM_LINUX
 216 //config:       help
 217 //config:         Utility to trace the route of IP packets.
 218 //config:
 219 //config:config TRACEROUTE6
 220 //config:       bool "traceroute6"
 221 //config:       default y
 222 //config:       depends on FEATURE_IPV6 && TRACEROUTE
 223 //config:       help
 224 //config:         Utility to trace the route of IPv6 packets.
 225 //config:
 226 //config:config FEATURE_TRACEROUTE_VERBOSE
 227 //config:       bool "Enable verbose output"
 228 //config:       default y
 229 //config:       depends on TRACEROUTE
 230 //config:       help
 231 //config:         Add some verbosity to traceroute. This includes among other things
 232 //config:         hostnames and ICMP response types.
 233 //config:
 234 //config:config FEATURE_TRACEROUTE_USE_ICMP
 235 //config:       bool "Enable -I option (use ICMP instead of UDP)"
 236 //config:       default y
 237 //config:       depends on TRACEROUTE
 238 //config:       help
 239 //config:         Add option -I to use ICMP ECHO instead of UDP datagrams.
 240
 241 /* Needs socket(AF_INET, SOCK_RAW, IPPROTO_ICMP), therefore BB_SUID_MAYBE: */
 242 //applet:IF_TRACEROUTE(APPLET(traceroute, BB_DIR_USR_BIN, BB_SUID_MAYBE))
 243 //applet:IF_TRACEROUTE6(APPLET(traceroute6, BB_DIR_USR_BIN, BB_SUID_MAYBE))
 244
 245 //kbuild:lib-$(CONFIG_TRACEROUTE) += traceroute.o
 246
 247 //usage:#define traceroute_trivial_usage
 248 //usage:       "[-"IF_TRACEROUTE6("46")"FIlnrv] [-f 1ST_TTL] [-m MAXTTL] [-q PROBES] [-p PORT]\n"
 249 //usage:       "        [-t TOS] [-w WAIT_SEC] [-s SRC_IP] [-i IFACE]\n"
 250 //usage:       "        [-z PAUSE_MSEC] HOST [BYTES]"
 251 //usage:#define traceroute_full_usage "\n\n"
 252 //usage:       "Trace the route to HOST\n"
 253 //usage:        IF_TRACEROUTE6(
 254 //usage:     "\n        -4,-6   Force IP or IPv6 name resolution"
 255 //usage:        )
 256 //usage:     "\n        -F      Set don't fragment bit"
 257 //usage:        IF_FEATURE_TRACEROUTE_USE_ICMP(
 258 //usage:     "\n        -I      Use ICMP ECHO instead of UDP datagrams"
 259 //usage:        )
 260 //usage:     "\n        -l      Display TTL value of the returned packet"
 261 //Currently disabled (TRACEROUTE_SO_DEBUG==0)
 262 ////usage:     "\n      -d      Set SO_DEBUG options to socket"
 263 //usage:     "\n        -n      Print numeric addresses"
 264 //usage:     "\n        -r      Bypass routing tables, send directly to HOST"
 265 //usage:        IF_FEATURE_TRACEROUTE_VERBOSE(
 266 //usage:     "\n        -v      Verbose"
 267 //usage:        )
 268 //usage:     "\n        -f N    First number of hops (default 1)"
 269 //usage:     "\n        -m N    Max number of hops"
 270 //usage:     "\n        -q N    Number of probes per hop (default 3)"
 271 //usage:     "\n        -p N    Base UDP port number used in probes"
 272 //usage:     "\n                (default 33434)"
 273 //usage:     "\n        -s IP   Source address"
 274 //usage:     "\n        -i IFACE Source interface"
 275 //usage:     "\n        -t N    Type-of-service in probe packets (default 0)"
 276 //usage:     "\n        -w SEC  Time to wait for a response (default 3)"
 277 //usage:     "\n        -g IP   Loose source route gateway (8 max)"
 278 //usage:
 279 //usage:#define traceroute6_trivial_usage
 280 //usage:       "[-nrv] [-m MAXTTL] [-q PROBES] [-p PORT]\n"
 281 //usage:       "        [-t TOS] [-w WAIT_SEC] [-s SRC_IP] [-i IFACE]\n"
 282 //usage:       "        HOST [BYTES]"
 283 //usage:#define traceroute6_full_usage "\n\n"
 284 //usage:       "Trace the route to HOST\n"
 285 //Currently disabled (TRACEROUTE_SO_DEBUG==0)
 286 ////usage:     "\n      -d      Set SO_DEBUG options to socket"
 287 //usage:     "\n        -n      Print numeric addresses"
 288 //usage:     "\n        -r      Bypass routing tables, send directly to HOST"
 289 //usage:        IF_FEATURE_TRACEROUTE_VERBOSE(
 290 //usage:     "\n        -v      Verbose"
 291 //usage:        )
 292 //usage:     "\n        -m N    Max number of hops"
 293 //usage:     "\n        -q N    Number of probes per hop (default 3)"
 294 //usage:     "\n        -p N    Base UDP port number used in probes"
 295 //usage:     "\n                (default 33434)"
 296 //usage:     "\n        -s IP   Source address"
 297 //usage:     "\n        -i IFACE Source interface"
 298 //usage:     "\n        -t N    Type-of-service in probe packets (default 0)"
 299 //usage:     "\n        -w SEC  Time wait for a response (default 3)"
 300
 301 #define TRACEROUTE_SO_DEBUG 0
 302
 303 #include <net/if.h>
 304 #include <arpa/inet.h>
 305 #include <netinet/in.h>
 306 #include <netinet/udp.h>
 307 #include <netinet/ip.h>
 308 #include <netinet/ip_icmp.h>
 309 #if ENABLE_FEATURE_IPV6
 310 # include <netinet/ip6.h>
 311 # include <netinet/icmp6.h>
 312 # ifndef SOL_IPV6
 313 #  define SOL_IPV6 IPPROTO_IPV6
 314 # endif
 315 #endif
 316
 317 #include "libbb.h"
 318 #include "inet_common.h"
 319
 320 #ifndef IPPROTO_ICMP
 321 # define IPPROTO_ICMP 1
 322 #endif
 323 #ifndef IPPROTO_IP
 324 # define IPPROTO_IP 0
 325 #endif
 326
 327
 328 #define OPT_STRING \
 329         "FIlnrdvxt:i:m:p:q:s:w:z:f:" \
 330         "4" IF_TRACEROUTE6("6")
 331 enum {
 332         OPT_DONT_FRAGMNT = (1 << 0),    /* F */
 333         OPT_USE_ICMP     = (1 << 1) * ENABLE_FEATURE_TRACEROUTE_USE_ICMP, /* I */
 334         OPT_TTL_FLAG     = (1 << 2),    /* l */
 335         OPT_ADDR_NUM     = (1 << 3),    /* n */
 336         OPT_BYPASS_ROUTE = (1 << 4),    /* r */
 337         OPT_DEBUG        = (1 << 5),    /* d */
 338         OPT_VERBOSE      = (1 << 6) * ENABLE_FEATURE_TRACEROUTE_VERBOSE, /* v */
 339         OPT_IP_CHKSUM    = (1 << 7),    /* x */
 340         OPT_TOS          = (1 << 8),    /* t */
 341         OPT_DEVICE       = (1 << 9),    /* i */
 342         OPT_MAX_TTL      = (1 << 10),   /* m */
 343         OPT_PORT         = (1 << 11),   /* p */
 344         OPT_NPROBES      = (1 << 12),   /* q */
 345         OPT_SOURCE       = (1 << 13),   /* s */
 346         OPT_WAITTIME     = (1 << 14),   /* w */
 347         OPT_PAUSE_MS     = (1 << 15),   /* z */
 348         OPT_FIRST_TTL    = (1 << 16),   /* f */
 349         OPT_IPV4         = (1 << 17),   /* 4 */
 350         OPT_IPV6         = (1 << 18) * ENABLE_TRACEROUTE6, /* 6 */
 351 };
 352 #define verbose (option_mask32 & OPT_VERBOSE)
 353
 354 enum {
 355         SIZEOF_ICMP_HDR = 8,
 356         rcvsock = 3, /* receive (icmp) socket file descriptor */
 357         sndsock = 4, /* send (udp/icmp) socket file descriptor */
 358 };
 359
 360 /* Data section of the probe packet */
 361 struct outdata_t {
 362         unsigned char seq;             /* sequence number of this packet */
 363         unsigned char ttl;             /* ttl packet left with */
 364 // UNUSED. Retaining to have the same packet size.
 365         struct timeval tv_UNUSED PACKED; /* time packet left */
 366 };
 367
 368 #if ENABLE_TRACEROUTE6
 369 struct outdata6_t {
 370         uint32_t ident6;
 371         uint32_t seq6;
 372         struct timeval tv_UNUSED PACKED; /* time packet left */
 373 };
 374 #endif
 375
 376 struct globals {
 377         /* Pointer to entire malloced IP packet, "packlen" bytes long: */
 378         struct ip *outip;
 379         /* Pointer to ICMP or UDP payload (not header): */
 380         struct outdata_t *outdata;
 381
 382         len_and_sockaddr *dest_lsa;
 383         int packlen;                    /* total length of packet */
 384         int pmtu;                       /* Path MTU Discovery (RFC1191) */
 385         uint32_t ident;
 386         uint16_t port; // 33434;        /* start udp dest port # for probe packets */
 387         int waittime; // 5;             /* time to wait for response (in seconds) */
 388         unsigned char recv_pkt[512];    /* last inbound (icmp) packet */
 389 };
 390
 391 #define G (*ptr_to_globals)
 392 #define outip     (G.outip    )
 393 #define outdata   (G.outdata  )
 394 #define dest_lsa  (G.dest_lsa )
 395 #define packlen   (G.packlen  )
 396 #define pmtu      (G.pmtu     )
 397 #define ident     (G.ident    )
 398 #define port      (G.port     )
 399 #define waittime  (G.waittime )
 400 #define recv_pkt  (G.recv_pkt )
 401 #define gwlist    (G.gwlist   )
 402 #define INIT_G() do { \
 403         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
 404         port = 33434; \
 405         waittime = 5; \
 406 } while (0)
 407
 408 #define outicmp ((struct icmp *)(outip + 1))
 409 #define outudp  ((struct udphdr *)(outip + 1))
 410
 411
 412 static int
 413 wait_for_reply(len_and_sockaddr *from_lsa, struct sockaddr *to, unsigned *timestamp_us, int *left_ms)
 414 {
 415         struct pollfd pfd[1];
 416         int read_len = 0;
 417
 418         pfd[0].fd = rcvsock;
 419         pfd[0].events = POLLIN;
 420         if (*left_ms >= 0 && safe_poll(pfd, 1, *left_ms) > 0) {
 421                 unsigned t;
 422
 423                 read_len = recv_from_to(rcvsock,
 424                                 recv_pkt, sizeof(recv_pkt),
 425                                 /*flags:*/ MSG_DONTWAIT,
 426                                 &from_lsa->u.sa, to, from_lsa->len);
 427                 t = monotonic_us();
 428                 *left_ms -= (t - *timestamp_us) / 1000;
 429                 *timestamp_us = t;
 430         }
 431
 432         return read_len;
 433 }
 434
 435 static void
 436 send_probe(int seq, int ttl)
 437 {
 438         int len, res;
 439         void *out;
 440
 441         /* Payload */
 442 #if ENABLE_TRACEROUTE6
 443         if (dest_lsa->u.sa.sa_family == AF_INET6) {
 444                 struct outdata6_t *pkt = (struct outdata6_t *) outdata;
 445                 pkt->ident6 = htonl(ident);
 446                 pkt->seq6   = htonl(seq);
 447                 /*gettimeofday(&pkt->tv, &tz);*/
 448         } else
 449 #endif
 450         {
 451                 outdata->seq = seq;
 452                 outdata->ttl = ttl;
 453 // UNUSED: was storing gettimeofday's result there, but never ever checked it
 454                 /*memcpy(&outdata->tv, tp, sizeof(outdata->tv));*/
 455
 456                 if (option_mask32 & OPT_USE_ICMP) {
 457                         outicmp->icmp_seq = htons(seq);
 458
 459                         /* Always calculate checksum for icmp packets */
 460                         outicmp->icmp_cksum = 0;
 461                         outicmp->icmp_cksum = inet_cksum(
 462                                         (uint16_t *)outicmp,
 463                                         ((char*)outip + packlen) - (char*)outicmp
 464                         );
 465                         if (outicmp->icmp_cksum == 0)
 466                                 outicmp->icmp_cksum = 0xffff;
 467                 }
 468         }
 469
 470 //BUG! verbose is (x & OPT_VERBOSE), not a counter!
 471 #if 0 //ENABLE_FEATURE_TRACEROUTE_VERBOSE
 472         /* XXX undocumented debugging hack */
 473         if (verbose > 1) {
 474                 const uint16_t *sp;
 475                 int nshorts, i;
 476
 477                 sp = (uint16_t *)outip;
 478                 nshorts = (unsigned)packlen / sizeof(uint16_t);
 479                 i = 0;
 480                 printf("[ %d bytes", packlen);
 481                 while (--nshorts >= 0) {
 482                         if ((i++ % 8) == 0)
 483                                 printf("\n\t");
 484                         printf(" %04x", ntohs(*sp));
 485                         sp++;
 486                 }
 487                 if (packlen & 1) {
 488                         if ((i % 8) == 0)
 489                                 printf("\n\t");
 490                         printf(" %02x", *(unsigned char *)sp);
 491                 }
 492                 printf("]\n");
 493         }
 494 #endif
 495
 496         out = outdata;
 497 #if ENABLE_TRACEROUTE6
 498         if (dest_lsa->u.sa.sa_family == AF_INET6) {
 499                 res = setsockopt_int(sndsock, SOL_IPV6, IPV6_UNICAST_HOPS, ttl);
 500                 if (res != 0)
 501                         bb_perror_msg_and_die("setsockopt(%s) %d", "UNICAST_HOPS", ttl);
 502         } else
 503 #endif
 504         {
 505 #if defined IP_TTL
 506                 res = setsockopt_int(sndsock, IPPROTO_IP, IP_TTL, ttl);
 507                 if (res != 0)
 508                         bb_perror_msg_and_die("setsockopt(%s) %d", "TTL", ttl);
 509 #endif
 510                 if (option_mask32 & OPT_USE_ICMP)
 511                         out = outicmp;
 512         }
 513
 514         if (!(option_mask32 & OPT_USE_ICMP)) {
 515                 set_nport(&dest_lsa->u.sa, htons(port + seq));
 516         }
 517         len = ((char*)outip + packlen) - (char*)out;
 518         res = xsendto(sndsock, out, len, &dest_lsa->u.sa, dest_lsa->len);
 519         if (res != len)
 520                 bb_error_msg("sent %d octets, ret=%d", len, res);
 521 }
 522
 523 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 524 /*
 525  * Convert an ICMP "type" field to a printable string.
 526  */
 527 static const char *
 528 pr_type(unsigned char t)
 529 {
 530         static const char *const ttab[] = {
 531         "Echo Reply",   "ICMP 1",       "ICMP 2",       "Dest Unreachable",
 532         "Source Quench", "Redirect",    "ICMP 6",       "ICMP 7",
 533         "Echo",         "Router Advert", "Router Solicit", "Time Exceeded",
 534         "Param Problem", "Timestamp",   "Timestamp Reply", "Info Request",
 535         "Info Reply",   "Mask Request", "Mask Reply"
 536         };
 537 # if ENABLE_TRACEROUTE6
 538         static const char *const ttab6[] = {
 539 [0]     "Error", "Dest Unreachable", "Packet Too Big", "Time Exceeded",
 540 [4]     "Param Problem",
 541 [8]     "Echo Request", "Echo Reply", "Membership Query", "Membership Report",
 542 [12]    "Membership Reduction", "Router Solicit", "Router Advert", "Neighbor Solicit",
 543 [16]    "Neighbor Advert", "Redirect",
 544         };
 545
 546         if (dest_lsa->u.sa.sa_family == AF_INET6) {
 547                 if (t < 5)
 548                         return ttab6[t];
 549                 if (t < 128 || t > ND_REDIRECT)
 550                         return "OUT-OF-RANGE";
 551                 return ttab6[(t & 63) + 8];
 552         }
 553 # endif
 554         if (t >= ARRAY_SIZE(ttab))
 555                 return "OUT-OF-RANGE";
 556
 557         return ttab[t];
 558 }
 559 #endif
 560
 561 #if !ENABLE_FEATURE_TRACEROUTE_VERBOSE
 562 #define packet4_ok(read_len, from, seq) \
 563         packet4_ok(read_len, seq)
 564 #endif
 565 static int
 566 packet4_ok(int read_len, const struct sockaddr_in *from, int seq)
 567 {
 568         const struct icmp *icp;
 569         unsigned char type, code;
 570         int hlen;
 571         const struct ip *ip;
 572
 573         ip = (struct ip *) recv_pkt;
 574         hlen = ip->ip_hl << 2;
 575         if (read_len < hlen + ICMP_MINLEN) {
 576 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 577                 if (verbose)
 578                         printf("packet too short (%d bytes) from %s\n", read_len,
 579                                 inet_ntoa(from->sin_addr));
 580 #endif
 581                 return 0;
 582         }
 583         read_len -= hlen;
 584         icp = (struct icmp *)(recv_pkt + hlen);
 585         type = icp->icmp_type;
 586         code = icp->icmp_code;
 587         /* Path MTU Discovery (RFC1191) */
 588         pmtu = 0;
 589         if (code == ICMP_UNREACH_NEEDFRAG)
 590                 pmtu = ntohs(icp->icmp_nextmtu);
 591
 592         if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS)
 593          || type == ICMP_UNREACH
 594          || type == ICMP_ECHOREPLY
 595         ) {
 596                 const struct ip *hip;
 597                 const struct udphdr *up;
 598
 599                 hip = &icp->icmp_ip;
 600                 hlen = hip->ip_hl << 2;
 601                 if (option_mask32 & OPT_USE_ICMP) {
 602                         struct icmp *hicmp;
 603
 604                         /* XXX */
 605                         if (type == ICMP_ECHOREPLY
 606                          && icp->icmp_id == htons(ident)
 607                          && icp->icmp_seq == htons(seq)
 608                         ) {
 609                                 return ICMP_UNREACH_PORT+1;
 610                         }
 611
 612                         hicmp = (struct icmp *)((unsigned char *)hip + hlen);
 613                         if (hlen + SIZEOF_ICMP_HDR <= read_len
 614                          && hip->ip_p == IPPROTO_ICMP
 615                          && hicmp->icmp_id == htons(ident)
 616                          && hicmp->icmp_seq == htons(seq)
 617                         ) {
 618                                 return (type == ICMP_TIMXCEED ? -1 : code + 1);
 619                         }
 620                 } else {
 621                         up = (struct udphdr *)((char *)hip + hlen);
 622                         if (hlen + 12 <= read_len
 623                          && hip->ip_p == IPPROTO_UDP
 624 // Off: since we do not form the entire IP packet,
 625 // but defer it to kernel, we can't set source port,
 626 // and thus can't check it here in the reply
 627                         /* && up->source == htons(ident) */
 628                          && up->dest == htons(port + seq)
 629                         ) {
 630                                 return (type == ICMP_TIMXCEED ? -1 : code + 1);
 631                         }
 632                 }
 633         }
 634 #if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 635         if (verbose) {
 636                 int i;
 637                 uint32_t *lp = (uint32_t *)&icp->icmp_ip;
 638
 639                 printf("\n%d bytes from %s to "
 640                        "%s: icmp type %d (%s) code %d\n",
 641                         read_len, inet_ntoa(from->sin_addr),
 642                         inet_ntoa(ip->ip_dst),
 643                         type, pr_type(type), icp->icmp_code);
 644                 for (i = 4; i < read_len; i += sizeof(*lp))
 645                         printf("%2d: x%8.8x\n", i, *lp++);
 646         }
 647 #endif
 648         return 0;
 649 }
 650
 651 #if ENABLE_TRACEROUTE6
 652 # if !ENABLE_FEATURE_TRACEROUTE_VERBOSE
 653 #define packet_ok(read_len, from_lsa, to, seq) \
 654         packet_ok(read_len, from_lsa, seq)
 655 # endif
 656 static int
 657 packet_ok(int read_len, len_and_sockaddr *from_lsa,
 658                         struct sockaddr *to,
 659                         int seq)
 660 {
 661         const struct icmp6_hdr *icp;
 662         unsigned char type, code;
 663
 664         if (from_lsa->u.sa.sa_family == AF_INET)
 665                 return packet4_ok(read_len, &from_lsa->u.sin, seq);
 666
 667         icp = (struct icmp6_hdr *) recv_pkt;
 668
 669         type = icp->icmp6_type;
 670         code = icp->icmp6_code;
 671
 672         if ((type == ICMP6_TIME_EXCEEDED && code == ICMP6_TIME_EXCEED_TRANSIT)
 673          || type == ICMP6_DST_UNREACH
 674         ) {
 675                 struct ip6_hdr *hip;
 676                 struct udphdr *up;
 677                 int nexthdr;
 678
 679                 hip = (struct ip6_hdr *)(icp + 1);
 680                 up  = (struct udphdr *) (hip + 1);
 681                 nexthdr = hip->ip6_nxt;
 682
 683                 if (nexthdr == IPPROTO_FRAGMENT) {
 684                         nexthdr = *(unsigned char*)up;
 685                         up++;
 686                 }
 687                 if (nexthdr == IPPROTO_UDP) {
 688                         struct outdata6_t *pkt;
 689
 690                         pkt = (struct outdata6_t *) (up + 1);
 691
 692                         if (ntohl(pkt->ident6) == ident
 693                          && ntohl(pkt->seq6) == seq
 694                         ) {
 695                                 return (type == ICMP6_TIME_EXCEEDED ? -1 : (code<<8)+1);
 696                         }
 697                 }
 698         }
 699
 700 # if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 701         if (verbose) {
 702                 unsigned char *p;
 703                 char pa1[MAXHOSTNAMELEN];
 704                 char pa2[MAXHOSTNAMELEN];
 705                 int i;
 706
 707                 p = (unsigned char *) (icp + 1);
 708
 709                 printf("\n%d bytes from %s to "
 710                        "%s: icmp type %d (%s) code %d\n",
 711                         read_len,
 712                         inet_ntop(AF_INET6, &from_lsa->u.sin6.sin6_addr, pa1, sizeof(pa1)),
 713                         inet_ntop(AF_INET6, &((struct sockaddr_in6*)to)->sin6_addr, pa2, sizeof(pa2)),
 714                         type, pr_type(type), icp->icmp6_code);
 715
 716                 read_len -= sizeof(struct icmp6_hdr);
 717                 for (i = 0; i < read_len; i++) {
 718                         if (i % 16 == 0)
 719                                 printf("%04x:", i);
 720                         if (i % 4 == 0)
 721                                 bb_putchar(' ');
 722                         printf("%02x", p[i]);
 723                         if ((i % 16 == 15) && (i + 1 < read_len))
 724                                 bb_putchar('\n');
 725                 }
 726                 bb_putchar('\n');
 727         }
 728 # endif
 729
 730         return 0;
 731 }
 732 #else /* !ENABLE_TRACEROUTE6 */
 733 static ALWAYS_INLINE int
 734 packet_ok(int read_len,
 735                 len_and_sockaddr *from_lsa IF_NOT_FEATURE_TRACEROUTE_VERBOSE(UNUSED_PARAM),
 736                 struct sockaddr *to UNUSED_PARAM,
 737                 int seq)
 738 {
 739         return packet4_ok(read_len, &from_lsa->u.sin, seq);
 740 }
 741 #endif
 742
 743 /*
 744  * Construct an Internet address representation.
 745  * If the -n flag has been supplied, give
 746  * numeric value, otherwise try for symbolic name.
 747  */
 748 static void
 749 print_inetname(const struct sockaddr *from)
 750 {
 751         char *ina = xmalloc_sockaddr2dotted_noport(from);
 752
 753         if (option_mask32 & OPT_ADDR_NUM) {
 754                 printf("  %s", ina);
 755         } else {
 756                 char *n = NULL;
 757
 758                 if (from->sa_family != AF_INET
 759                  || ((struct sockaddr_in*)from)->sin_addr.s_addr != INADDR_ANY
 760                 ) {
 761                         /* Try to reverse resolve if it is not 0.0.0.0 */
 762                         n = xmalloc_sockaddr2host_noport((struct sockaddr*)from);
 763                 }
 764                 printf("  %s (%s)", (n ? n : ina), ina);
 765                 free(n);
 766         }
 767         free(ina);
 768 }
 769
 770 static void
 771 print(int read_len, const struct sockaddr *from, const struct sockaddr *to)
 772 {
 773         print_inetname(from);
 774
 775         if (verbose) {
 776                 char *ina = xmalloc_sockaddr2dotted_noport(to);
 777 #if ENABLE_TRACEROUTE6
 778                 if (to->sa_family == AF_INET6) {
 779                         read_len -= sizeof(struct ip6_hdr);
 780                 } else
 781 #endif
 782                 {
 783                         struct ip *ip4packet = (struct ip*)recv_pkt;
 784                         read_len -= ip4packet->ip_hl << 2;
 785                 }
 786                 printf(" %d bytes to %s", read_len, ina);
 787                 free(ina);
 788         }
 789 }
 790
 791 static void
 792 print_delta_ms(unsigned t1p, unsigned t2p)
 793 {
 794         unsigned tt = t2p - t1p;
 795         printf("  %u.%03u ms", tt / 1000, tt % 1000);
 796 }
 797
 798 /*
 799  * Usage: [-dFIlnrvx] [-g gateway] [-i iface] [-f first_ttl]
 800  * [-m max_ttl] [ -p port] [-q nqueries] [-s src_addr] [-t tos]
 801  * [-w waittime] [-z pausemsecs] host [packetlen]"
 802  */
 803 static int
 804 common_traceroute_main(int op, char **argv)
 805 {
 806         int minpacket;
 807 #ifdef IP_TOS
 808         int tos = 0;
 809 #endif
 810         int max_ttl = 30;
 811         int nprobes = 3;
 812         int first_ttl = 1;
 813         unsigned pausemsecs = 0;
 814         char *source;
 815         char *device;
 816         char *tos_str;
 817         char *max_ttl_str;
 818         char *port_str;
 819         char *nprobes_str;
 820         char *waittime_str;
 821         char *pausemsecs_str;
 822         char *first_ttl_str;
 823         char *dest_str;
 824 #if ENABLE_TRACEROUTE6
 825         sa_family_t af;
 826 #else
 827         enum { af = AF_INET };
 828 #endif
 829         int ttl;
 830         int seq;
 831         len_and_sockaddr *from_lsa;
 832         struct sockaddr *lastaddr;
 833         struct sockaddr *to;
 834
 835         INIT_G();
 836
 837         /* minimum 1 arg */
 838         opt_complementary = "-1:x-x";
 839         op |= getopt32(argv, OPT_STRING
 840                 , &tos_str, &device, &max_ttl_str, &port_str, &nprobes_str
 841                 , &source, &waittime_str, &pausemsecs_str, &first_ttl_str
 842         );
 843         argv += optind;
 844
 845 #if 0 /* IGNORED */
 846         if (op & OPT_IP_CHKSUM)
 847                 bb_error_msg("warning: ip checksums disabled");
 848 #endif
 849 #ifdef IP_TOS
 850         if (op & OPT_TOS)
 851                 tos = xatou_range(tos_str, 0, 255);
 852 #endif
 853         if (op & OPT_MAX_TTL)
 854                 max_ttl = xatou_range(max_ttl_str, 1, 255);
 855         if (op & OPT_PORT)
 856                 port = xatou16(port_str);
 857         if (op & OPT_NPROBES)
 858                 nprobes = xatou_range(nprobes_str, 1, INT_MAX);
 859         if (op & OPT_SOURCE) {
 860                 /*
 861                  * set the ip source address of the outbound
 862                  * probe (e.g., on a multi-homed host).
 863                  */
 864                 if (getuid() != 0)
 865                         bb_error_msg_and_die(bb_msg_you_must_be_root);
 866         }
 867         if (op & OPT_WAITTIME)
 868                 waittime = xatou_range(waittime_str, 1, 24 * 60 * 60);
 869         if (op & OPT_PAUSE_MS)
 870                 pausemsecs = xatou_range(pausemsecs_str, 0, 60 * 60 * 1000);
 871         if (op & OPT_FIRST_TTL)
 872                 first_ttl = xatou_range(first_ttl_str, 1, max_ttl);
 873
 874         /* Process destination and optional packet size */
 875         minpacket = sizeof(struct ip)
 876                         + SIZEOF_ICMP_HDR
 877                         + sizeof(struct outdata_t);
 878         if (!(op & OPT_USE_ICMP))
 879                 minpacket = sizeof(struct ip)
 880                         + sizeof(struct udphdr)
 881                         + sizeof(struct outdata_t);
 882 #if ENABLE_TRACEROUTE6
 883         af = AF_UNSPEC;
 884         if (op & OPT_IPV4)
 885                 af = AF_INET;
 886         if (op & OPT_IPV6)
 887                 af = AF_INET6;
 888         dest_lsa = xhost_and_af2sockaddr(argv[0], port, af);
 889         af = dest_lsa->u.sa.sa_family;
 890         if (af == AF_INET6)
 891                 minpacket = sizeof(struct ip6_hdr)
 892                         + sizeof(struct udphdr)
 893                         + sizeof(struct outdata6_t);
 894 #else
 895         dest_lsa = xhost2sockaddr(argv[0], port);
 896 #endif
 897         packlen = minpacket;
 898         if (argv[1])
 899                 packlen = xatoul_range(argv[1], minpacket, 32 * 1024);
 900
 901         /* Ensure the socket fds won't be 0, 1 or 2 */
 902         bb_sanitize_stdio();
 903
 904 #if ENABLE_TRACEROUTE6
 905         if (af == AF_INET6) {
 906                 xmove_fd(xsocket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6), rcvsock);
 907 # ifdef IPV6_RECVPKTINFO
 908                 setsockopt_1(rcvsock, SOL_IPV6, IPV6_RECVPKTINFO);
 909                 setsockopt_1(rcvsock, SOL_IPV6, IPV6_2292PKTINFO);
 910 # else
 911                 setsockopt_1(rcvsock, SOL_IPV6, IPV6_PKTINFO);
 912 # endif
 913         } else
 914 #endif
 915         {
 916                 xmove_fd(xsocket(AF_INET, SOCK_RAW, IPPROTO_ICMP), rcvsock);
 917         }
 918
 919 #if TRACEROUTE_SO_DEBUG
 920         if (op & OPT_DEBUG)
 921                 setsockopt_SOL_SOCKET_1(rcvsock, SO_DEBUG);
 922 #endif
 923         if (op & OPT_BYPASS_ROUTE)
 924                 setsockopt_SOL_SOCKET_1(rcvsock, SO_DONTROUTE);
 925
 926 #if ENABLE_TRACEROUTE6
 927         if (af == AF_INET6) {
 928                 if (setsockopt_int(rcvsock, SOL_RAW, IPV6_CHECKSUM, 2) != 0)
 929                         bb_perror_msg_and_die("setsockopt(%s)", "IPV6_CHECKSUM");
 930                 xmove_fd(xsocket(af, SOCK_DGRAM, 0), sndsock);
 931         } else
 932 #endif
 933         {
 934                 if (op & OPT_USE_ICMP)
 935                         xmove_fd(xsocket(AF_INET, SOCK_RAW, IPPROTO_ICMP), sndsock);
 936                 else
 937                         xmove_fd(xsocket(AF_INET, SOCK_DGRAM, 0), sndsock);
 938         }
 939
 940 #ifdef SO_SNDBUF
 941         if (setsockopt_SOL_SOCKET_int(sndsock, SO_SNDBUF, packlen) != 0) {
 942                 bb_perror_msg_and_die("setsockopt(%s)", "SO_SNDBUF");
 943         }
 944 #endif
 945 #ifdef IP_TOS
 946         if ((op & OPT_TOS) && setsockopt_int(sndsock, IPPROTO_IP, IP_TOS, tos) != 0) {
 947                 bb_perror_msg_and_die("setsockopt(%s) %d", "TOS", tos);
 948         }
 949 #endif
 950 #ifdef IP_DONTFRAG
 951         if (op & OPT_DONT_FRAGMNT)
 952                 setsockopt_1(sndsock, IPPROTO_IP, IP_DONTFRAG);
 953 #endif
 954 #if TRACEROUTE_SO_DEBUG
 955         if (op & OPT_DEBUG)
 956                 setsockopt_SOL_SOCKET_1(sndsock, SO_DEBUG);
 957 #endif
 958         if (op & OPT_BYPASS_ROUTE)
 959                 setsockopt_SOL_SOCKET_1(sndsock, SO_DONTROUTE);
 960
 961         outip = xzalloc(packlen);
 962
 963         ident = getpid();
 964
 965         if (!ENABLE_TRACEROUTE6 || af == AF_INET) {
 966                 if (op & OPT_USE_ICMP) {
 967                         ident |= 0x8000;
 968                         outicmp->icmp_type = ICMP_ECHO;
 969                         outicmp->icmp_id = htons(ident);
 970                         outdata = (struct outdata_t *)((char *)outicmp + SIZEOF_ICMP_HDR);
 971                 } else {
 972                         outdata = (struct outdata_t *)(outudp + 1);
 973                 }
 974         }
 975 #if ENABLE_TRACEROUTE6
 976         if (af == AF_INET6) {
 977                 outdata = (void*)((char*)outip
 978                                 + sizeof(struct ip6_hdr)
 979                                 + sizeof(struct udphdr)
 980                                 );
 981         }
 982 #endif
 983
 984         if (op & OPT_DEVICE) /* hmm, do we need error check? */
 985                 setsockopt_bindtodevice(sndsock, device);
 986
 987         if (op & OPT_SOURCE) {
 988 #if ENABLE_TRACEROUTE6
 989 // TODO: need xdotted_and_af2sockaddr?
 990                 len_and_sockaddr *source_lsa = xhost_and_af2sockaddr(source, 0, af);
 991 #else
 992                 len_and_sockaddr *source_lsa = xdotted2sockaddr(source, 0);
 993 #endif
 994                 /* Ping4 does this (why?) */
 995                 if (af == AF_INET)
 996                         if (setsockopt(sndsock, IPPROTO_IP, IP_MULTICAST_IF,
 997                                         &source_lsa->u.sa, source_lsa->len))
 998                                 bb_error_msg_and_die("can't set multicast source interface");
 999 //TODO: we can query source port we bound to,
1000 // and check it in replies... if we care enough
1001                 xbind(sndsock, &source_lsa->u.sa, source_lsa->len);
1002                 free(source_lsa);
1003         }
1004 #if ENABLE_TRACEROUTE6
1005         else if (af == AF_INET6) {
1006 //TODO: why we don't do it for IPv4?
1007                 len_and_sockaddr *source_lsa;
1008
1009                 int probe_fd = xsocket(af, SOCK_DGRAM, 0);
1010                 if (op & OPT_DEVICE)
1011                         setsockopt_bindtodevice(probe_fd, device);
1012                 set_nport(&dest_lsa->u.sa, htons(1025));
1013                 /* dummy connect. makes kernel pick source IP (and port) */
1014                 xconnect(probe_fd, &dest_lsa->u.sa, dest_lsa->len);
1015                 set_nport(&dest_lsa->u.sa, htons(port));
1016
1017                 /* read IP and port */
1018                 source_lsa = get_sock_lsa(probe_fd);
1019                 if (source_lsa == NULL)
1020                         bb_error_msg_and_die("can't get probe addr");
1021
1022                 close(probe_fd);
1023
1024                 /* bind our sockets to this IP (but not port) */
1025                 set_nport(&source_lsa->u.sa, 0);
1026                 xbind(sndsock, &source_lsa->u.sa, source_lsa->len);
1027                 xbind(rcvsock, &source_lsa->u.sa, source_lsa->len);
1028
1029                 free(source_lsa);
1030         }
1031 #endif
1032
1033         /* Revert to non-privileged user after opening sockets */
1034         xsetgid(getgid());
1035         xsetuid(getuid());
1036
1037         dest_str = xmalloc_sockaddr2dotted_noport(&dest_lsa->u.sa);
1038         printf("traceroute to %s (%s)", argv[0], dest_str);
1039         if (ENABLE_FEATURE_CLEAN_UP) {
1040                 free(dest_str);
1041         }
1042
1043         if (op & OPT_SOURCE)
1044                 printf(" from %s", source);
1045         printf(", %d hops max, %d byte packets\n", max_ttl, packlen);
1046
1047         from_lsa = xmemdup(dest_lsa, LSA_LEN_SIZE + dest_lsa->len);
1048         lastaddr = xzalloc(dest_lsa->len);
1049         to = xzalloc(dest_lsa->len);
1050         seq = 0;
1051         for (ttl = first_ttl; ttl <= max_ttl; ++ttl) {
1052                 int probe;
1053                 int unreachable = 0; /* counter */
1054                 int gotlastaddr = 0; /* flags */
1055                 int got_there = 0;
1056
1057                 printf("%2d", ttl);
1058                 for (probe = 0; probe < nprobes; ++probe) {
1059                         int read_len;
1060                         unsigned t1;
1061                         unsigned t2;
1062                         int left_ms;
1063                         struct ip *ip;
1064
1065                         fflush_all();
1066                         if (probe != 0 && pausemsecs > 0)
1067                                 usleep(pausemsecs * 1000);
1068
1069                         send_probe(++seq, ttl);
1070                         t2 = t1 = monotonic_us();
1071
1072                         left_ms = waittime * 1000;
1073                         while ((read_len = wait_for_reply(from_lsa, to, &t2, &left_ms)) != 0) {
1074                                 int icmp_code;
1075
1076                                 /* Recv'ed a packet, or read error */
1077                                 /* t2 = monotonic_us() - set by wait_for_reply */
1078
1079                                 if (read_len < 0)
1080                                         continue;
1081                                 icmp_code = packet_ok(read_len, from_lsa, to, seq);
1082                                 /* Skip short packet */
1083                                 if (icmp_code == 0)
1084                                         continue;
1085
1086                                 if (!gotlastaddr
1087                                  || (memcmp(lastaddr, &from_lsa->u.sa, from_lsa->len) != 0)
1088                                 ) {
1089                                         print(read_len, &from_lsa->u.sa, to);
1090                                         memcpy(lastaddr, &from_lsa->u.sa, from_lsa->len);
1091                                         gotlastaddr = 1;
1092                                 }
1093
1094                                 print_delta_ms(t1, t2);
1095                                 ip = (struct ip *)recv_pkt;
1096
1097                                 if (from_lsa->u.sa.sa_family == AF_INET)
1098                                         if (op & OPT_TTL_FLAG)
1099                                                 printf(" (%d)", ip->ip_ttl);
1100
1101                                 /* time exceeded in transit */
1102                                 if (icmp_code == -1)
1103                                         break;
1104                                 icmp_code--;
1105                                 switch (icmp_code) {
1106 #if ENABLE_TRACEROUTE6
1107                                 case ICMP6_DST_UNREACH_NOPORT << 8:
1108                                         got_there = 1;
1109                                         break;
1110 #endif
1111                                 case ICMP_UNREACH_PORT:
1112                                         if (ip->ip_ttl <= 1)
1113                                                 printf(" !");
1114                                         got_there = 1;
1115                                         break;
1116
1117                                 case ICMP_UNREACH_NET:
1118 #if ENABLE_TRACEROUTE6 && (ICMP6_DST_UNREACH_NOROUTE != ICMP_UNREACH_NET)
1119                                 case ICMP6_DST_UNREACH_NOROUTE << 8:
1120 #endif
1121                                         printf(" !N");
1122                                         ++unreachable;
1123                                         break;
1124                                 case ICMP_UNREACH_HOST:
1125 #if ENABLE_TRACEROUTE6
1126                                 case ICMP6_DST_UNREACH_ADDR << 8:
1127 #endif
1128                                         printf(" !H");
1129                                         ++unreachable;
1130                                         break;
1131                                 case ICMP_UNREACH_PROTOCOL:
1132                                         printf(" !P");
1133                                         got_there = 1;
1134                                         break;
1135                                 case ICMP_UNREACH_NEEDFRAG:
1136                                         printf(" !F-%d", pmtu);
1137                                         ++unreachable;
1138                                         break;
1139                                 case ICMP_UNREACH_SRCFAIL:
1140 #if ENABLE_TRACEROUTE6
1141                                 case ICMP6_DST_UNREACH_ADMIN << 8:
1142 #endif
1143                                         printf(" !S");
1144                                         ++unreachable;
1145                                         break;
1146                                 case ICMP_UNREACH_FILTER_PROHIB:
1147                                 case ICMP_UNREACH_NET_PROHIB:   /* misuse */
1148                                         printf(" !A");
1149                                         ++unreachable;
1150                                         break;
1151                                 case ICMP_UNREACH_HOST_PROHIB:
1152                                         printf(" !C");
1153                                         ++unreachable;
1154                                         break;
1155                                 case ICMP_UNREACH_HOST_PRECEDENCE:
1156                                         printf(" !V");
1157                                         ++unreachable;
1158                                         break;
1159                                 case ICMP_UNREACH_PRECEDENCE_CUTOFF:
1160                                         printf(" !C");
1161                                         ++unreachable;
1162                                         break;
1163                                 case ICMP_UNREACH_NET_UNKNOWN:
1164                                 case ICMP_UNREACH_HOST_UNKNOWN:
1165                                         printf(" !U");
1166                                         ++unreachable;
1167                                         break;
1168                                 case ICMP_UNREACH_ISOLATED:
1169                                         printf(" !I");
1170                                         ++unreachable;
1171                                         break;
1172                                 case ICMP_UNREACH_TOSNET:
1173                                 case ICMP_UNREACH_TOSHOST:
1174                                         printf(" !T");
1175                                         ++unreachable;
1176                                         break;
1177                                 default:
1178                                         printf(" !<%d>", icmp_code);
1179                                         ++unreachable;
1180                                         break;
1181                                 }
1182                                 break;
1183                         } /* while (wait and read a packet) */
1184
1185                         /* there was no packet at all? */
1186                         if (read_len == 0)
1187                                 printf("  *");
1188                 } /* for (nprobes) */
1189
1190                 bb_putchar('\n');
1191                 if (got_there
1192                  || (unreachable > 0 && unreachable >= nprobes - 1)
1193                 ) {
1194                         break;
1195                 }
1196         }
1197
1198         if (ENABLE_FEATURE_CLEAN_UP) {
1199                 free(to);
1200                 free(lastaddr);
1201                 free(from_lsa);
1202         }
1203
1204         return 0;
1205 }
1206
1207 int traceroute_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1208 int traceroute_main(int argc UNUSED_PARAM, char **argv)
1209 {
1210         return common_traceroute_main(0, argv);
1211 }
1212
1213 #if ENABLE_TRACEROUTE6
1214 int traceroute6_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1215 int traceroute6_main(int argc UNUSED_PARAM, char **argv)
1216 {
1217         return common_traceroute_main(OPT_IPV6, argv);
1218 }
1219 #endif