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