networking/ping.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Mini ping implementation for busybox
   4  *
   5  * Copyright (C) 1999 by Randolph Chung <tausq@debian.org>
   6  *
   7  * Adapted from the ping in netkit-base 0.10:
   8  * Copyright (c) 1989 The Regents of the University of California.
   9  * All rights reserved.
  10  *
  11  * This code is derived from software contributed to Berkeley by
  12  * Mike Muuss.
  13  *
  14  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  15  */
  16 /* from ping6.c:
  17  * Copyright (C) 1999 by Randolph Chung <tausq@debian.org>
  18  *
  19  * This version of ping is adapted from the ping in netkit-base 0.10,
  20  * which is:
  21  *
  22  * Original copyright notice is retained at the end of this file.
  23  *
  24  * This version is an adaptation of ping.c from busybox.
  25  * The code was modified by Bart Visscher <magick@linux-fan.com>
  26  */
  27
  28 #include <net/if.h>
  29 #include <netinet/ip_icmp.h>
  30 #include "libbb.h"
  31
  32 //config:config PING
  33 //config:       bool "ping"
  34 //config:       default y
  35 //config:       depends on PLATFORM_LINUX
  36 //config:       help
  37 //config:         ping uses the ICMP protocol's mandatory ECHO_REQUEST datagram to
  38 //config:         elicit an ICMP ECHO_RESPONSE from a host or gateway.
  39 //config:
  40 //config:config PING6
  41 //config:       bool "ping6"
  42 //config:       default y
  43 //config:       depends on FEATURE_IPV6 && PING
  44 //config:       help
  45 //config:         This will give you a ping that can talk IPv6.
  46 //config:
  47 //config:config FEATURE_FANCY_PING
  48 //config:       bool "Enable fancy ping output"
  49 //config:       default y
  50 //config:       depends on PING
  51 //config:       help
  52 //config:         Make the output from the ping applet include statistics, and at the
  53 //config:         same time provide full support for ICMP packets.
  54
  55 //applet:IF_PING(APPLET(ping, _BB_DIR_BIN, _BB_SUID_MAYBE))
  56 //applet:IF_PING6(APPLET(ping6, _BB_DIR_BIN, _BB_SUID_MAYBE))
  57
  58 //kbuild:lib-$(CONFIG_PING)  += ping.o
  59 //kbuild:lib-$(CONFIG_PING6) += ping.o
  60
  61 //usage:#if !ENABLE_FEATURE_FANCY_PING
  62 //usage:# define ping_trivial_usage
  63 //usage:       "HOST"
  64 //usage:# define ping_full_usage "\n\n"
  65 //usage:       "Send ICMP ECHO_REQUEST packets to network hosts"
  66 //usage:# define ping6_trivial_usage
  67 //usage:       "HOST"
  68 //usage:# define ping6_full_usage "\n\n"
  69 //usage:       "Send ICMP ECHO_REQUEST packets to network hosts"
  70 //usage:#else
  71 //usage:# define ping_trivial_usage
  72 //usage:       "[OPTIONS] HOST"
  73 //usage:# define ping_full_usage "\n\n"
  74 //usage:       "Send ICMP ECHO_REQUEST packets to network hosts\n"
  75 //usage:     "\nOptions:"
  76 //usage:     "\n        -4,-6           Force IP or IPv6 name resolution"
  77 //usage:     "\n        -c CNT          Send only CNT pings"
  78 //usage:     "\n        -s SIZE         Send SIZE data bytes in packets (default:56)"
  79 //usage:     "\n        -t TTL          Set TTL"
  80 //usage:     "\n        -I IFACE/IP     Use interface or IP address as source"
  81 //usage:     "\n        -W SEC          Seconds to wait for the first response (default:10)"
  82 //usage:     "\n                        (after all -c CNT packets are sent)"
  83 //usage:     "\n        -w SEC          Seconds until ping exits (default:infinite)"
  84 //usage:     "\n                        (can exit earlier with -c CNT)"
  85 //usage:     "\n        -q              Quiet, only displays output at start"
  86 //usage:     "\n                        and when finished"
  87 //usage:
  88 //usage:# define ping6_trivial_usage
  89 //usage:       "[OPTIONS] HOST"
  90 //usage:# define ping6_full_usage "\n\n"
  91 //usage:       "Send ICMP ECHO_REQUEST packets to network hosts\n"
  92 //usage:     "\nOptions:"
  93 //usage:     "\n        -c CNT          Send only CNT pings"
  94 //usage:     "\n        -s SIZE         Send SIZE data bytes in packets (default:56)"
  95 //usage:     "\n        -I IFACE/IP     Use interface or IP address as source"
  96 //usage:     "\n        -q              Quiet, only displays output at start"
  97 //usage:     "\n                        and when finished"
  98 //usage:
  99 //usage:#endif
 100 //usage:
 101 //usage:#define ping_example_usage
 102 //usage:       "$ ping localhost\n"
 103 //usage:       "PING slag (127.0.0.1): 56 data bytes\n"
 104 //usage:       "64 bytes from 127.0.0.1: icmp_seq=0 ttl=255 time=20.1 ms\n"
 105 //usage:       "\n"
 106 //usage:       "--- debian ping statistics ---\n"
 107 //usage:       "1 packets transmitted, 1 packets received, 0% packet loss\n"
 108 //usage:       "round-trip min/avg/max = 20.1/20.1/20.1 ms\n"
 109 //usage:#define ping6_example_usage
 110 //usage:       "$ ping6 ip6-localhost\n"
 111 //usage:       "PING ip6-localhost (::1): 56 data bytes\n"
 112 //usage:       "64 bytes from ::1: icmp6_seq=0 ttl=64 time=20.1 ms\n"
 113 //usage:       "\n"
 114 //usage:       "--- ip6-localhost ping statistics ---\n"
 115 //usage:       "1 packets transmitted, 1 packets received, 0% packet loss\n"
 116 //usage:       "round-trip min/avg/max = 20.1/20.1/20.1 ms\n"
 117
 118 #if ENABLE_PING6
 119 # include <netinet/icmp6.h>
 120 /* I see RENUMBERED constants in bits/in.h - !!?
 121  * What a fuck is going on with libc? Is it a glibc joke? */
 122 # ifdef IPV6_2292HOPLIMIT
 123 #  undef IPV6_HOPLIMIT
 124 #  define IPV6_HOPLIMIT IPV6_2292HOPLIMIT
 125 # endif
 126 #endif
 127
 128 enum {
 129         DEFDATALEN = 56,
 130         MAXIPLEN = 60,
 131         MAXICMPLEN = 76,
 132         MAX_DUP_CHK = (8 * 128),
 133         MAXWAIT = 10,
 134         PINGINTERVAL = 1, /* 1 second */
 135 };
 136
 137 /* Common routines */
 138
 139 static int in_cksum(unsigned short *buf, int sz)
 140 {
 141         int nleft = sz;
 142         int sum = 0;
 143         unsigned short *w = buf;
 144         unsigned short ans = 0;
 145
 146         while (nleft > 1) {
 147                 sum += *w++;
 148                 nleft -= 2;
 149         }
 150
 151         if (nleft == 1) {
 152                 *(unsigned char *) (&ans) = *(unsigned char *) w;
 153                 sum += ans;
 154         }
 155
 156         sum = (sum >> 16) + (sum & 0xFFFF);
 157         sum += (sum >> 16);
 158         ans = ~sum;
 159         return ans;
 160 }
 161
 162 #if !ENABLE_FEATURE_FANCY_PING
 163
 164 /* Simple version */
 165
 166 struct globals {
 167         char *hostname;
 168         char packet[DEFDATALEN + MAXIPLEN + MAXICMPLEN];
 169 } FIX_ALIASING;
 170 #define G (*(struct globals*)&bb_common_bufsiz1)
 171 #define INIT_G() do { } while (0)
 172
 173 static void noresp(int ign UNUSED_PARAM)
 174 {
 175         printf("No response from %s\n", G.hostname);
 176         exit(EXIT_FAILURE);
 177 }
 178
 179 static void ping4(len_and_sockaddr *lsa)
 180 {
 181         struct icmp *pkt;
 182         int pingsock, c;
 183
 184         pingsock = create_icmp_socket();
 185
 186         pkt = (struct icmp *) G.packet;
 187         memset(pkt, 0, sizeof(G.packet));
 188         pkt->icmp_type = ICMP_ECHO;
 189         pkt->icmp_cksum = in_cksum((unsigned short *) pkt, sizeof(G.packet));
 190
 191         xsendto(pingsock, G.packet, DEFDATALEN + ICMP_MINLEN, &lsa->u.sa, lsa->len);
 192
 193         /* listen for replies */
 194         while (1) {
 195                 struct sockaddr_in from;
 196                 socklen_t fromlen = sizeof(from);
 197
 198                 c = recvfrom(pingsock, G.packet, sizeof(G.packet), 0,
 199                                 (struct sockaddr *) &from, &fromlen);
 200                 if (c < 0) {
 201                         if (errno != EINTR)
 202                                 bb_perror_msg("recvfrom");
 203                         continue;
 204                 }
 205                 if (c >= 76) {                  /* ip + icmp */
 206                         struct iphdr *iphdr = (struct iphdr *) G.packet;
 207
 208                         pkt = (struct icmp *) (G.packet + (iphdr->ihl << 2));   /* skip ip hdr */
 209                         if (pkt->icmp_type == ICMP_ECHOREPLY)
 210                                 break;
 211                 }
 212         }
 213         if (ENABLE_FEATURE_CLEAN_UP)
 214                 close(pingsock);
 215 }
 216
 217 #if ENABLE_PING6
 218 static void ping6(len_and_sockaddr *lsa)
 219 {
 220         struct icmp6_hdr *pkt;
 221         int pingsock, c;
 222         int sockopt;
 223
 224         pingsock = create_icmp6_socket();
 225
 226         pkt = (struct icmp6_hdr *) G.packet;
 227         memset(pkt, 0, sizeof(G.packet));
 228         pkt->icmp6_type = ICMP6_ECHO_REQUEST;
 229
 230         sockopt = offsetof(struct icmp6_hdr, icmp6_cksum);
 231         setsockopt(pingsock, SOL_RAW, IPV6_CHECKSUM, &sockopt, sizeof(sockopt));
 232
 233         xsendto(pingsock, G.packet, DEFDATALEN + sizeof(struct icmp6_hdr), &lsa->u.sa, lsa->len);
 234
 235         /* listen for replies */
 236         while (1) {
 237                 struct sockaddr_in6 from;
 238                 socklen_t fromlen = sizeof(from);
 239
 240                 c = recvfrom(pingsock, G.packet, sizeof(G.packet), 0,
 241                                 (struct sockaddr *) &from, &fromlen);
 242                 if (c < 0) {
 243                         if (errno != EINTR)
 244                                 bb_perror_msg("recvfrom");
 245                         continue;
 246                 }
 247                 if (c >= ICMP_MINLEN) {                 /* icmp6_hdr */
 248                         pkt = (struct icmp6_hdr *) G.packet;
 249                         if (pkt->icmp6_type == ICMP6_ECHO_REPLY)
 250                                 break;
 251                 }
 252         }
 253         if (ENABLE_FEATURE_CLEAN_UP)
 254                 close(pingsock);
 255 }
 256 #endif
 257
 258 #if !ENABLE_PING6
 259 # define common_ping_main(af, argv) common_ping_main(argv)
 260 #endif
 261 static int common_ping_main(sa_family_t af, char **argv)
 262 {
 263         len_and_sockaddr *lsa;
 264
 265         INIT_G();
 266
 267 #if ENABLE_PING6
 268         while ((++argv)[0] && argv[0][0] == '-') {
 269                 if (argv[0][1] == '4') {
 270                         af = AF_INET;
 271                         continue;
 272                 }
 273                 if (argv[0][1] == '6') {
 274                         af = AF_INET6;
 275                         continue;
 276                 }
 277                 bb_show_usage();
 278         }
 279 #else
 280         argv++;
 281 #endif
 282
 283         G.hostname = *argv;
 284         if (!G.hostname)
 285                 bb_show_usage();
 286
 287 #if ENABLE_PING6
 288         lsa = xhost_and_af2sockaddr(G.hostname, 0, af);
 289 #else
 290         lsa = xhost_and_af2sockaddr(G.hostname, 0, AF_INET);
 291 #endif
 292         /* Set timer _after_ DNS resolution */
 293         signal(SIGALRM, noresp);
 294         alarm(5); /* give the host 5000ms to respond */
 295
 296 #if ENABLE_PING6
 297         if (lsa->u.sa.sa_family == AF_INET6)
 298                 ping6(lsa);
 299         else
 300 #endif
 301                 ping4(lsa);
 302         printf("%s is alive!\n", G.hostname);
 303         return EXIT_SUCCESS;
 304 }
 305
 306
 307 #else /* FEATURE_FANCY_PING */
 308
 309
 310 /* Full(er) version */
 311
 312 #define OPT_STRING ("qvc:s:t:w:W:I:4" IF_PING6("6"))
 313 enum {
 314         OPT_QUIET = 1 << 0,
 315         OPT_VERBOSE = 1 << 1,
 316         OPT_c = 1 << 2,
 317         OPT_s = 1 << 3,
 318         OPT_t = 1 << 4,
 319         OPT_w = 1 << 5,
 320         OPT_W = 1 << 6,
 321         OPT_I = 1 << 7,
 322         OPT_IPV4 = 1 << 8,
 323         OPT_IPV6 = (1 << 9) * ENABLE_PING6,
 324 };
 325
 326
 327 struct globals {
 328         int pingsock;
 329         int if_index;
 330         char *str_I;
 331         len_and_sockaddr *source_lsa;
 332         unsigned datalen;
 333         unsigned pingcount; /* must be int-sized */
 334         unsigned opt_ttl;
 335         unsigned long ntransmitted, nreceived, nrepeats;
 336         uint16_t myid;
 337         unsigned tmin, tmax; /* in us */
 338         unsigned long long tsum; /* in us, sum of all times */
 339         unsigned deadline;
 340         unsigned timeout;
 341         unsigned total_secs;
 342         unsigned sizeof_rcv_packet;
 343         char *rcv_packet; /* [datalen + MAXIPLEN + MAXICMPLEN] */
 344         void *snd_packet; /* [datalen + ipv4/ipv6_const] */
 345         const char *hostname;
 346         const char *dotted;
 347         union {
 348                 struct sockaddr sa;
 349                 struct sockaddr_in sin;
 350 #if ENABLE_PING6
 351                 struct sockaddr_in6 sin6;
 352 #endif
 353         } pingaddr;
 354         char rcvd_tbl[MAX_DUP_CHK / 8];
 355 } FIX_ALIASING;
 356 #define G (*(struct globals*)&bb_common_bufsiz1)
 357 #define pingsock     (G.pingsock    )
 358 #define if_index     (G.if_index    )
 359 #define source_lsa   (G.source_lsa  )
 360 #define str_I        (G.str_I       )
 361 #define datalen      (G.datalen     )
 362 #define ntransmitted (G.ntransmitted)
 363 #define nreceived    (G.nreceived   )
 364 #define nrepeats     (G.nrepeats    )
 365 #define pingcount    (G.pingcount   )
 366 #define opt_ttl      (G.opt_ttl     )
 367 #define myid         (G.myid        )
 368 #define tmin         (G.tmin        )
 369 #define tmax         (G.tmax        )
 370 #define tsum         (G.tsum        )
 371 #define deadline     (G.deadline    )
 372 #define timeout      (G.timeout     )
 373 #define total_secs   (G.total_secs  )
 374 #define hostname     (G.hostname    )
 375 #define dotted       (G.dotted      )
 376 #define pingaddr     (G.pingaddr    )
 377 #define rcvd_tbl     (G.rcvd_tbl    )
 378 void BUG_ping_globals_too_big(void);
 379 #define INIT_G() do { \
 380         if (sizeof(G) > COMMON_BUFSIZE) \
 381                 BUG_ping_globals_too_big(); \
 382         pingsock = -1; \
 383         datalen = DEFDATALEN; \
 384         timeout = MAXWAIT; \
 385         tmin = UINT_MAX; \
 386 } while (0)
 387
 388
 389 #define A(bit)          rcvd_tbl[(bit)>>3]      /* identify byte in array */
 390 #define B(bit)          (1 << ((bit) & 0x07))   /* identify bit in byte */
 391 #define SET(bit)        (A(bit) |= B(bit))
 392 #define CLR(bit)        (A(bit) &= (~B(bit)))
 393 #define TST(bit)        (A(bit) & B(bit))
 394
 395 /**************************************************************************/
 396
 397 static void print_stats_and_exit(int junk) NORETURN;
 398 static void print_stats_and_exit(int junk UNUSED_PARAM)
 399 {
 400         signal(SIGINT, SIG_IGN);
 401
 402         printf("\n--- %s ping statistics ---\n", hostname);
 403         printf("%lu packets transmitted, ", ntransmitted);
 404         printf("%lu packets received, ", nreceived);
 405         if (nrepeats)
 406                 printf("%lu duplicates, ", nrepeats);
 407         if (ntransmitted)
 408                 ntransmitted = (ntransmitted - nreceived) * 100 / ntransmitted;
 409         printf("%lu%% packet loss\n", ntransmitted);
 410         if (tmin != UINT_MAX) {
 411                 unsigned tavg = tsum / (nreceived + nrepeats);
 412                 printf("round-trip min/avg/max = %u.%03u/%u.%03u/%u.%03u ms\n",
 413                         tmin / 1000, tmin % 1000,
 414                         tavg / 1000, tavg % 1000,
 415                         tmax / 1000, tmax % 1000);
 416         }
 417         /* if condition is true, exit with 1 -- 'failure' */
 418         exit(nreceived == 0 || (deadline && nreceived < pingcount));
 419 }
 420
 421 static void sendping_tail(void (*sp)(int), const void *pkt, int size_pkt)
 422 {
 423         int sz;
 424
 425         CLR((uint16_t)ntransmitted % MAX_DUP_CHK);
 426         ntransmitted++;
 427
 428         /* sizeof(pingaddr) can be larger than real sa size, but I think
 429          * it doesn't matter */
 430         sz = xsendto(pingsock, pkt, size_pkt, &pingaddr.sa, sizeof(pingaddr));
 431         if (sz != size_pkt)
 432                 bb_error_msg_and_die(bb_msg_write_error);
 433
 434         if (pingcount == 0 || deadline || ntransmitted < pingcount) {
 435                 /* Didn't send all pings yet - schedule next in 1s */
 436                 signal(SIGALRM, sp);
 437                 if (deadline) {
 438                         total_secs += PINGINTERVAL;
 439                         if (total_secs >= deadline)
 440                                 signal(SIGALRM, print_stats_and_exit);
 441                 }
 442                 alarm(PINGINTERVAL);
 443         } else { /* -c NN, and all NN are sent (and no deadline) */
 444                 /* Wait for the last ping to come back.
 445                  * -W timeout: wait for a response in seconds.
 446                  * Affects only timeout in absense of any responses,
 447                  * otherwise ping waits for two RTTs. */
 448                 unsigned expire = timeout;
 449
 450                 if (nreceived) {
 451                         /* approx. 2*tmax, in seconds (2 RTT) */
 452                         expire = tmax / (512*1024);
 453                         if (expire == 0)
 454                                 expire = 1;
 455                 }
 456                 signal(SIGALRM, print_stats_and_exit);
 457                 alarm(expire);
 458         }
 459 }
 460
 461 static void sendping4(int junk UNUSED_PARAM)
 462 {
 463         struct icmp *pkt = G.snd_packet;
 464
 465         //memset(pkt, 0, datalen + ICMP_MINLEN + 4); - G.snd_packet was xzalloced
 466         pkt->icmp_type = ICMP_ECHO;
 467         /*pkt->icmp_code = 0;*/
 468         pkt->icmp_cksum = 0; /* cksum is calculated with this field set to 0 */
 469         pkt->icmp_seq = htons(ntransmitted); /* don't ++ here, it can be a macro */
 470         pkt->icmp_id = myid;
 471
 472         /* If datalen < 4, we store timestamp _past_ the packet,
 473          * but it's ok - we allocated 4 extra bytes in xzalloc() just in case.
 474          */
 475         /*if (datalen >= 4)*/
 476                 /* No hton: we'll read it back on the same machine */
 477                 *(uint32_t*)&pkt->icmp_dun = monotonic_us();
 478
 479         pkt->icmp_cksum = in_cksum((unsigned short *) pkt, datalen + ICMP_MINLEN);
 480
 481         sendping_tail(sendping4, pkt, datalen + ICMP_MINLEN);
 482 }
 483 #if ENABLE_PING6
 484 static void sendping6(int junk UNUSED_PARAM)
 485 {
 486         struct icmp6_hdr *pkt = alloca(datalen + sizeof(struct icmp6_hdr) + 4);
 487
 488         //memset(pkt, 0, datalen + sizeof(struct icmp6_hdr) + 4);
 489         pkt->icmp6_type = ICMP6_ECHO_REQUEST;
 490         /*pkt->icmp6_code = 0;*/
 491         /*pkt->icmp6_cksum = 0;*/
 492         pkt->icmp6_seq = htons(ntransmitted); /* don't ++ here, it can be a macro */
 493         pkt->icmp6_id = myid;
 494
 495         /*if (datalen >= 4)*/
 496                 *(uint32_t*)(&pkt->icmp6_data8[4]) = monotonic_us();
 497
 498         //TODO? pkt->icmp_cksum = in_cksum(...);
 499
 500         sendping_tail(sendping6, pkt, datalen + sizeof(struct icmp6_hdr));
 501 }
 502 #endif
 503
 504 static const char *icmp_type_name(int id)
 505 {
 506         switch (id) {
 507         case ICMP_ECHOREPLY:      return "Echo Reply";
 508         case ICMP_DEST_UNREACH:   return "Destination Unreachable";
 509         case ICMP_SOURCE_QUENCH:  return "Source Quench";
 510         case ICMP_REDIRECT:       return "Redirect (change route)";
 511         case ICMP_ECHO:           return "Echo Request";
 512         case ICMP_TIME_EXCEEDED:  return "Time Exceeded";
 513         case ICMP_PARAMETERPROB:  return "Parameter Problem";
 514         case ICMP_TIMESTAMP:      return "Timestamp Request";
 515         case ICMP_TIMESTAMPREPLY: return "Timestamp Reply";
 516         case ICMP_INFO_REQUEST:   return "Information Request";
 517         case ICMP_INFO_REPLY:     return "Information Reply";
 518         case ICMP_ADDRESS:        return "Address Mask Request";
 519         case ICMP_ADDRESSREPLY:   return "Address Mask Reply";
 520         default:                  return "unknown ICMP type";
 521         }
 522 }
 523 #if ENABLE_PING6
 524 /* RFC3542 changed some definitions from RFC2292 for no good reason, whee!
 525  * the newer 3542 uses a MLD_ prefix where as 2292 uses ICMP6_ prefix */
 526 #ifndef MLD_LISTENER_QUERY
 527 # define MLD_LISTENER_QUERY ICMP6_MEMBERSHIP_QUERY
 528 #endif
 529 #ifndef MLD_LISTENER_REPORT
 530 # define MLD_LISTENER_REPORT ICMP6_MEMBERSHIP_REPORT
 531 #endif
 532 #ifndef MLD_LISTENER_REDUCTION
 533 # define MLD_LISTENER_REDUCTION ICMP6_MEMBERSHIP_REDUCTION
 534 #endif
 535 static const char *icmp6_type_name(int id)
 536 {
 537         switch (id) {
 538         case ICMP6_DST_UNREACH:      return "Destination Unreachable";
 539         case ICMP6_PACKET_TOO_BIG:   return "Packet too big";
 540         case ICMP6_TIME_EXCEEDED:    return "Time Exceeded";
 541         case ICMP6_PARAM_PROB:       return "Parameter Problem";
 542         case ICMP6_ECHO_REPLY:       return "Echo Reply";
 543         case ICMP6_ECHO_REQUEST:     return "Echo Request";
 544         case MLD_LISTENER_QUERY:     return "Listener Query";
 545         case MLD_LISTENER_REPORT:    return "Listener Report";
 546         case MLD_LISTENER_REDUCTION: return "Listener Reduction";
 547         default:                     return "unknown ICMP type";
 548         }
 549 }
 550 #endif
 551
 552 static void unpack_tail(int sz, uint32_t *tp,
 553                 const char *from_str,
 554                 uint16_t recv_seq, int ttl)
 555 {
 556         const char *dupmsg = " (DUP!)";
 557         unsigned triptime = triptime; /* for gcc */
 558
 559         ++nreceived;
 560
 561         if (tp) {
 562                 /* (int32_t) cast is for hypothetical 64-bit unsigned */
 563                 /* (doesn't hurt 32-bit real-world anyway) */
 564                 triptime = (int32_t) ((uint32_t)monotonic_us() - *tp);
 565                 tsum += triptime;
 566                 if (triptime < tmin)
 567                         tmin = triptime;
 568                 if (triptime > tmax)
 569                         tmax = triptime;
 570         }
 571
 572         if (TST(recv_seq % MAX_DUP_CHK)) {
 573                 ++nrepeats;
 574                 --nreceived;
 575         } else {
 576                 SET(recv_seq % MAX_DUP_CHK);
 577                 dupmsg += 7;
 578         }
 579
 580         if (option_mask32 & OPT_QUIET)
 581                 return;
 582
 583         printf("%d bytes from %s: seq=%u ttl=%d", sz,
 584                 from_str, recv_seq, ttl);
 585         if (tp)
 586                 printf(" time=%u.%03u ms", triptime / 1000, triptime % 1000);
 587         puts(dupmsg);
 588         fflush_all();
 589 }
 590 static void unpack4(char *buf, int sz, struct sockaddr_in *from)
 591 {
 592         struct icmp *icmppkt;
 593         struct iphdr *iphdr;
 594         int hlen;
 595
 596         /* discard if too short */
 597         if (sz < (datalen + ICMP_MINLEN))
 598                 return;
 599
 600         /* check IP header */
 601         iphdr = (struct iphdr *) buf;
 602         hlen = iphdr->ihl << 2;
 603         sz -= hlen;
 604         icmppkt = (struct icmp *) (buf + hlen);
 605         if (icmppkt->icmp_id != myid)
 606                 return;                         /* not our ping */
 607
 608         if (icmppkt->icmp_type == ICMP_ECHOREPLY) {
 609                 uint16_t recv_seq = ntohs(icmppkt->icmp_seq);
 610                 uint32_t *tp = NULL;
 611
 612                 if (sz >= ICMP_MINLEN + sizeof(uint32_t))
 613                         tp = (uint32_t *) icmppkt->icmp_data;
 614                 unpack_tail(sz, tp,
 615                         inet_ntoa(*(struct in_addr *) &from->sin_addr.s_addr),
 616                         recv_seq, iphdr->ttl);
 617         } else if (icmppkt->icmp_type != ICMP_ECHO) {
 618                 bb_error_msg("warning: got ICMP %d (%s)",
 619                                 icmppkt->icmp_type,
 620                                 icmp_type_name(icmppkt->icmp_type));
 621         }
 622 }
 623 #if ENABLE_PING6
 624 static void unpack6(char *packet, int sz, /*struct sockaddr_in6 *from,*/ int hoplimit)
 625 {
 626         struct icmp6_hdr *icmppkt;
 627         char buf[INET6_ADDRSTRLEN];
 628
 629         /* discard if too short */
 630         if (sz < (datalen + sizeof(struct icmp6_hdr)))
 631                 return;
 632
 633         icmppkt = (struct icmp6_hdr *) packet;
 634         if (icmppkt->icmp6_id != myid)
 635                 return;                         /* not our ping */
 636
 637         if (icmppkt->icmp6_type == ICMP6_ECHO_REPLY) {
 638                 uint16_t recv_seq = ntohs(icmppkt->icmp6_seq);
 639                 uint32_t *tp = NULL;
 640
 641                 if (sz >= sizeof(struct icmp6_hdr) + sizeof(uint32_t))
 642                         tp = (uint32_t *) &icmppkt->icmp6_data8[4];
 643                 unpack_tail(sz, tp,
 644                         inet_ntop(AF_INET6, &pingaddr.sin6.sin6_addr,
 645                                         buf, sizeof(buf)),
 646                         recv_seq, hoplimit);
 647         } else if (icmppkt->icmp6_type != ICMP6_ECHO_REQUEST) {
 648                 bb_error_msg("warning: got ICMP %d (%s)",
 649                                 icmppkt->icmp6_type,
 650                                 icmp6_type_name(icmppkt->icmp6_type));
 651         }
 652 }
 653 #endif
 654
 655 static void ping4(len_and_sockaddr *lsa)
 656 {
 657         int sockopt;
 658
 659         pingsock = create_icmp_socket();
 660         pingaddr.sin = lsa->u.sin;
 661         if (source_lsa) {
 662                 if (setsockopt(pingsock, IPPROTO_IP, IP_MULTICAST_IF,
 663                                 &source_lsa->u.sa, source_lsa->len))
 664                         bb_error_msg_and_die("can't set multicast source interface");
 665                 xbind(pingsock, &source_lsa->u.sa, source_lsa->len);
 666         }
 667         if (str_I)
 668                 setsockopt_bindtodevice(pingsock, str_I);
 669
 670         /* enable broadcast pings */
 671         setsockopt_broadcast(pingsock);
 672
 673         /* set recv buf (needed if we can get lots of responses: flood ping,
 674          * broadcast ping etc) */
 675         sockopt = (datalen * 2) + 7 * 1024; /* giving it a bit of extra room */
 676         setsockopt(pingsock, SOL_SOCKET, SO_RCVBUF, &sockopt, sizeof(sockopt));
 677
 678         if (opt_ttl != 0) {
 679                 setsockopt(pingsock, IPPROTO_IP, IP_TTL, &opt_ttl, sizeof(opt_ttl));
 680                 /* above doesnt affect packets sent to bcast IP, so... */
 681                 setsockopt(pingsock, IPPROTO_IP, IP_MULTICAST_TTL, &opt_ttl, sizeof(opt_ttl));
 682         }
 683
 684         signal(SIGINT, print_stats_and_exit);
 685
 686         /* start the ping's going ... */
 687         sendping4(0);
 688
 689         /* listen for replies */
 690         while (1) {
 691                 struct sockaddr_in from;
 692                 socklen_t fromlen = (socklen_t) sizeof(from);
 693                 int c;
 694
 695                 c = recvfrom(pingsock, G.rcv_packet, G.sizeof_rcv_packet, 0,
 696                                 (struct sockaddr *) &from, &fromlen);
 697                 if (c < 0) {
 698                         if (errno != EINTR)
 699                                 bb_perror_msg("recvfrom");
 700                         continue;
 701                 }
 702                 unpack4(G.rcv_packet, c, &from);
 703                 if (pingcount && nreceived >= pingcount)
 704                         break;
 705         }
 706 }
 707 #if ENABLE_PING6
 708 extern int BUG_bad_offsetof_icmp6_cksum(void);
 709 static void ping6(len_and_sockaddr *lsa)
 710 {
 711         int sockopt;
 712         struct msghdr msg;
 713         struct sockaddr_in6 from;
 714         struct iovec iov;
 715         char control_buf[CMSG_SPACE(36)];
 716
 717         pingsock = create_icmp6_socket();
 718         pingaddr.sin6 = lsa->u.sin6;
 719         /* untested whether "-I addr" really works for IPv6: */
 720         if (source_lsa)
 721                 xbind(pingsock, &source_lsa->u.sa, source_lsa->len);
 722         if (str_I)
 723                 setsockopt_bindtodevice(pingsock, str_I);
 724
 725 #ifdef ICMP6_FILTER
 726         {
 727                 struct icmp6_filter filt;
 728                 if (!(option_mask32 & OPT_VERBOSE)) {
 729                         ICMP6_FILTER_SETBLOCKALL(&filt);
 730                         ICMP6_FILTER_SETPASS(ICMP6_ECHO_REPLY, &filt);
 731                 } else {
 732                         ICMP6_FILTER_SETPASSALL(&filt);
 733                 }
 734                 if (setsockopt(pingsock, IPPROTO_ICMPV6, ICMP6_FILTER, &filt,
 735                                            sizeof(filt)) < 0)
 736                         bb_error_msg_and_die("setsockopt(ICMP6_FILTER)");
 737         }
 738 #endif /*ICMP6_FILTER*/
 739
 740         /* enable broadcast pings */
 741         setsockopt_broadcast(pingsock);
 742
 743         /* set recv buf (needed if we can get lots of responses: flood ping,
 744          * broadcast ping etc) */
 745         sockopt = (datalen * 2) + 7 * 1024; /* giving it a bit of extra room */
 746         setsockopt(pingsock, SOL_SOCKET, SO_RCVBUF, &sockopt, sizeof(sockopt));
 747
 748         sockopt = offsetof(struct icmp6_hdr, icmp6_cksum);
 749         if (offsetof(struct icmp6_hdr, icmp6_cksum) != 2)
 750                 BUG_bad_offsetof_icmp6_cksum();
 751         setsockopt(pingsock, SOL_RAW, IPV6_CHECKSUM, &sockopt, sizeof(sockopt));
 752
 753         /* request ttl info to be returned in ancillary data */
 754         setsockopt(pingsock, SOL_IPV6, IPV6_HOPLIMIT, &const_int_1, sizeof(const_int_1));
 755
 756         if (if_index)
 757                 pingaddr.sin6.sin6_scope_id = if_index;
 758
 759         signal(SIGINT, print_stats_and_exit);
 760
 761         /* start the ping's going ... */
 762         sendping6(0);
 763
 764         /* listen for replies */
 765         msg.msg_name = &from;
 766         msg.msg_namelen = sizeof(from);
 767         msg.msg_iov = &iov;
 768         msg.msg_iovlen = 1;
 769         msg.msg_control = control_buf;
 770         iov.iov_base = G.rcv_packet;
 771         iov.iov_len = G.sizeof_rcv_packet;
 772         while (1) {
 773                 int c;
 774                 struct cmsghdr *mp;
 775                 int hoplimit = -1;
 776                 msg.msg_controllen = sizeof(control_buf);
 777
 778                 c = recvmsg(pingsock, &msg, 0);
 779                 if (c < 0) {
 780                         if (errno != EINTR)
 781                                 bb_perror_msg("recvfrom");
 782                         continue;
 783                 }
 784                 for (mp = CMSG_FIRSTHDR(&msg); mp; mp = CMSG_NXTHDR(&msg, mp)) {
 785                         if (mp->cmsg_level == SOL_IPV6
 786                          && mp->cmsg_type == IPV6_HOPLIMIT
 787                          /* don't check len - we trust the kernel: */
 788                          /* && mp->cmsg_len >= CMSG_LEN(sizeof(int)) */
 789                         ) {
 790                                 /*hoplimit = *(int*)CMSG_DATA(mp); - unaligned access */
 791                                 move_from_unaligned_int(hoplimit, CMSG_DATA(mp));
 792                         }
 793                 }
 794                 unpack6(G.rcv_packet, c, /*&from,*/ hoplimit);
 795                 if (pingcount && nreceived >= pingcount)
 796                         break;
 797         }
 798 }
 799 #endif
 800
 801 static void ping(len_and_sockaddr *lsa)
 802 {
 803         printf("PING %s (%s)", hostname, dotted);
 804         if (source_lsa) {
 805                 printf(" from %s",
 806                         xmalloc_sockaddr2dotted_noport(&source_lsa->u.sa));
 807         }
 808         printf(": %d data bytes\n", datalen);
 809
 810         G.sizeof_rcv_packet = datalen + MAXIPLEN + MAXICMPLEN;
 811         G.rcv_packet = xzalloc(G.sizeof_rcv_packet);
 812 #if ENABLE_PING6
 813         if (lsa->u.sa.sa_family == AF_INET6) {
 814                 /* +4 reserves a place for timestamp, which may end up sitting
 815                  * _after_ packet. Saves one if() - see sendping4/6() */
 816                 G.snd_packet = xzalloc(datalen + sizeof(struct icmp6_hdr) + 4);
 817                 ping6(lsa);
 818         } else
 819 #endif
 820         {
 821                 G.snd_packet = xzalloc(datalen + ICMP_MINLEN + 4);
 822                 ping4(lsa);
 823         }
 824 }
 825
 826 static int common_ping_main(int opt, char **argv)
 827 {
 828         len_and_sockaddr *lsa;
 829         char *str_s;
 830
 831         INIT_G();
 832
 833         /* exactly one argument needed; -v and -q don't mix; -c NUM, -t NUM, -w NUM, -W NUM */
 834         opt_complementary = "=1:q--v:v--q:c+:t+:w+:W+";
 835         opt |= getopt32(argv, OPT_STRING, &pingcount, &str_s, &opt_ttl, &deadline, &timeout, &str_I);
 836         if (opt & OPT_s)
 837                 datalen = xatou16(str_s); // -s
 838         if (opt & OPT_I) { // -I
 839                 if_index = if_nametoindex(str_I);
 840                 if (!if_index) {
 841                         /* TODO: I'm not sure it takes IPv6 unless in [XX:XX..] format */
 842                         source_lsa = xdotted2sockaddr(str_I, 0);
 843                         str_I = NULL; /* don't try to bind to device later */
 844                 }
 845         }
 846         myid = (uint16_t) getpid();
 847         hostname = argv[optind];
 848 #if ENABLE_PING6
 849         {
 850                 sa_family_t af = AF_UNSPEC;
 851                 if (opt & OPT_IPV4)
 852                         af = AF_INET;
 853                 if (opt & OPT_IPV6)
 854                         af = AF_INET6;
 855                 lsa = xhost_and_af2sockaddr(hostname, 0, af);
 856         }
 857 #else
 858         lsa = xhost_and_af2sockaddr(hostname, 0, AF_INET);
 859 #endif
 860
 861         if (source_lsa && source_lsa->u.sa.sa_family != lsa->u.sa.sa_family)
 862                 /* leaking it here... */
 863                 source_lsa = NULL;
 864
 865         dotted = xmalloc_sockaddr2dotted_noport(&lsa->u.sa);
 866         ping(lsa);
 867         print_stats_and_exit(EXIT_SUCCESS);
 868         /*return EXIT_SUCCESS;*/
 869 }
 870 #endif /* FEATURE_FANCY_PING */
 871
 872
 873 int ping_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 874 int ping_main(int argc UNUSED_PARAM, char **argv)
 875 {
 876 #if !ENABLE_FEATURE_FANCY_PING
 877         return common_ping_main(AF_UNSPEC, argv);
 878 #else
 879         return common_ping_main(0, argv);
 880 #endif
 881 }
 882
 883 #if ENABLE_PING6
 884 int ping6_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 885 int ping6_main(int argc UNUSED_PARAM, char **argv)
 886 {
 887 # if !ENABLE_FEATURE_FANCY_PING
 888         return common_ping_main(AF_INET6, argv);
 889 # else
 890         return common_ping_main(OPT_IPV6, argv);
 891 # endif
 892 }
 893 #endif
 894
 895 /* from ping6.c:
 896  * Copyright (c) 1989 The Regents of the University of California.
 897  * All rights reserved.
 898  *
 899  * This code is derived from software contributed to Berkeley by
 900  * Mike Muuss.
 901  *
 902  * Redistribution and use in source and binary forms, with or without
 903  * modification, are permitted provided that the following conditions
 904  * are met:
 905  * 1. Redistributions of source code must retain the above copyright
 906  *    notice, this list of conditions and the following disclaimer.
 907  * 2. Redistributions in binary form must reproduce the above copyright
 908  *    notice, this list of conditions and the following disclaimer in the
 909  *    documentation and/or other materials provided with the distribution.
 910  *
 911  * 3. <BSD Advertising Clause omitted per the July 22, 1999 licensing change
 912  *              ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change>
 913  *
 914  * 4. Neither the name of the University nor the names of its contributors
 915  *    may be used to endorse or promote products derived from this software
 916  *    without specific prior written permission.
 917  *
 918  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 919  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 920  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 921  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 922  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 923  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 924  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 925  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 926  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 927  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 928  * SUCH DAMAGE.
 929  */