Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 1 | /* vi: set sw=4 ts=4: */ |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 2 | /* |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 3 | * Mini ping implementation for busybox |
| 4 | * |
| 5 | * Copyright (C) 1999 by Randolph Chung <tausq@debian.org> |
| 6 | * |
Rob Landley | 42eddba | 2005-12-15 08:04:17 +0000 | [diff] [blame] | 7 | * Adapted from the ping in netkit-base 0.10: |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 8 | * Copyright (c) 1989 The Regents of the University of California. |
Denis Vlasenko | 35d4da0 | 2007-01-22 14:04:27 +0000 | [diff] [blame] | 9 | * All rights reserved. |
| 10 | * |
| 11 | * This code is derived from software contributed to Berkeley by |
| 12 | * Mike Muuss. |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 13 | * |
Rob Landley | 42eddba | 2005-12-15 08:04:17 +0000 | [diff] [blame] | 14 | * Licensed under GPLv2 or later, see file LICENSE in this tarball for details. |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 15 | */ |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 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 | */ |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 27 | |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 28 | #include <net/if.h> |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 29 | #include <netinet/ip_icmp.h> |
Denis Vlasenko | b6adbf1 | 2007-05-26 19:00:18 +0000 | [diff] [blame] | 30 | #include "libbb.h" |
Denis Vlasenko | e935602 | 2007-01-29 18:03:54 +0000 | [diff] [blame] | 31 | |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 32 | #if ENABLE_PING6 |
| 33 | #include <netinet/icmp6.h> |
| 34 | /* I see RENUMBERED constants in bits/in.h - !!? |
| 35 | * What a fuck is going on with libc? Is it a glibc joke? */ |
| 36 | #ifdef IPV6_2292HOPLIMIT |
| 37 | #undef IPV6_HOPLIMIT |
| 38 | #define IPV6_HOPLIMIT IPV6_2292HOPLIMIT |
| 39 | #endif |
| 40 | #endif |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 41 | |
Rob Landley | bc68cd1 | 2006-03-10 19:22:06 +0000 | [diff] [blame] | 42 | enum { |
| 43 | DEFDATALEN = 56, |
| 44 | MAXIPLEN = 60, |
| 45 | MAXICMPLEN = 76, |
| 46 | MAXPACKET = 65468, |
| 47 | MAX_DUP_CHK = (8 * 128), |
| 48 | MAXWAIT = 10, |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 49 | PINGINTERVAL = 1, /* 1 second */ |
Rob Landley | bc68cd1 | 2006-03-10 19:22:06 +0000 | [diff] [blame] | 50 | }; |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 51 | |
Eric Andersen | 19db07b | 1999-12-11 08:41:28 +0000 | [diff] [blame] | 52 | /* common routines */ |
Denis Vlasenko | 4a5cf16 | 2006-11-20 00:48:22 +0000 | [diff] [blame] | 53 | |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 54 | static int in_cksum(unsigned short *buf, int sz) |
| 55 | { |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 56 | int nleft = sz; |
| 57 | int sum = 0; |
| 58 | unsigned short *w = buf; |
| 59 | unsigned short ans = 0; |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 60 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 61 | while (nleft > 1) { |
| 62 | sum += *w++; |
| 63 | nleft -= 2; |
| 64 | } |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 65 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 66 | if (nleft == 1) { |
| 67 | *(unsigned char *) (&ans) = *(unsigned char *) w; |
| 68 | sum += ans; |
| 69 | } |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 70 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 71 | sum = (sum >> 16) + (sum & 0xFFFF); |
| 72 | sum += (sum >> 16); |
| 73 | ans = ~sum; |
Denis Vlasenko | d9e15f2 | 2006-11-27 16:49:55 +0000 | [diff] [blame] | 74 | return ans; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 75 | } |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 76 | |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 77 | #if !ENABLE_FEATURE_FANCY_PING |
Denis Vlasenko | 4a5cf16 | 2006-11-20 00:48:22 +0000 | [diff] [blame] | 78 | |
| 79 | /* simple version */ |
| 80 | |
Denis Vlasenko | cb6874c | 2006-09-02 16:13:36 +0000 | [diff] [blame] | 81 | static char *hostname; |
| 82 | |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 83 | static void noresp(int ign ATTRIBUTE_UNUSED) |
Eric Andersen | b5474c4 | 2002-03-20 11:59:28 +0000 | [diff] [blame] | 84 | { |
Eric Andersen | b888682 | 2002-03-21 14:04:43 +0000 | [diff] [blame] | 85 | printf("No response from %s\n", hostname); |
Eric Andersen | 4e486a5 | 2003-01-12 06:08:33 +0000 | [diff] [blame] | 86 | exit(EXIT_FAILURE); |
Eric Andersen | b5474c4 | 2002-03-20 11:59:28 +0000 | [diff] [blame] | 87 | } |
Eric Andersen | 19db07b | 1999-12-11 08:41:28 +0000 | [diff] [blame] | 88 | |
Denis Vlasenko | e935602 | 2007-01-29 18:03:54 +0000 | [diff] [blame] | 89 | static void ping4(len_and_sockaddr *lsa) |
Eric Andersen | 19db07b | 1999-12-11 08:41:28 +0000 | [diff] [blame] | 90 | { |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 91 | struct sockaddr_in pingaddr; |
| 92 | struct icmp *pkt; |
| 93 | int pingsock, c; |
| 94 | char packet[DEFDATALEN + MAXIPLEN + MAXICMPLEN]; |
Eric Andersen | 19db07b | 1999-12-11 08:41:28 +0000 | [diff] [blame] | 95 | |
Matt Kraai | 06ef165 | 2001-07-13 20:56:27 +0000 | [diff] [blame] | 96 | pingsock = create_icmp_socket(); |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 97 | pingaddr = lsa->sin; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 98 | |
| 99 | pkt = (struct icmp *) packet; |
| 100 | memset(pkt, 0, sizeof(packet)); |
| 101 | pkt->icmp_type = ICMP_ECHO; |
| 102 | pkt->icmp_cksum = in_cksum((unsigned short *) pkt, sizeof(packet)); |
| 103 | |
Bernhard Reutner-Fischer | b290889 | 2007-04-12 11:34:39 +0000 | [diff] [blame] | 104 | c = xsendto(pingsock, packet, DEFDATALEN + ICMP_MINLEN, |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 105 | (struct sockaddr *) &pingaddr, sizeof(pingaddr)); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 106 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 107 | /* listen for replies */ |
| 108 | while (1) { |
| 109 | struct sockaddr_in from; |
Mike Frysinger | 03e827a | 2005-07-26 23:00:59 +0000 | [diff] [blame] | 110 | socklen_t fromlen = sizeof(from); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 111 | |
Denis Vlasenko | 806116b | 2006-12-31 12:14:16 +0000 | [diff] [blame] | 112 | c = recvfrom(pingsock, packet, sizeof(packet), 0, |
| 113 | (struct sockaddr *) &from, &fromlen); |
| 114 | if (c < 0) { |
Denis Vlasenko | 44c2eb2 | 2007-01-08 23:55:33 +0000 | [diff] [blame] | 115 | if (errno != EINTR) |
| 116 | bb_perror_msg("recvfrom"); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 117 | continue; |
| 118 | } |
| 119 | if (c >= 76) { /* ip + icmp */ |
| 120 | struct iphdr *iphdr = (struct iphdr *) packet; |
| 121 | |
| 122 | pkt = (struct icmp *) (packet + (iphdr->ihl << 2)); /* skip ip hdr */ |
| 123 | if (pkt->icmp_type == ICMP_ECHOREPLY) |
| 124 | break; |
| 125 | } |
| 126 | } |
Denis Vlasenko | 9adc6ce | 2007-01-22 22:45:27 +0000 | [diff] [blame] | 127 | if (ENABLE_FEATURE_CLEAN_UP) |
| 128 | close(pingsock); |
Eric Andersen | 19db07b | 1999-12-11 08:41:28 +0000 | [diff] [blame] | 129 | } |
| 130 | |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 131 | #if ENABLE_PING6 |
| 132 | static void ping6(len_and_sockaddr *lsa) |
| 133 | { |
| 134 | struct sockaddr_in6 pingaddr; |
| 135 | struct icmp6_hdr *pkt; |
| 136 | int pingsock, c; |
| 137 | int sockopt; |
| 138 | char packet[DEFDATALEN + MAXIPLEN + MAXICMPLEN]; |
| 139 | |
| 140 | pingsock = create_icmp6_socket(); |
| 141 | pingaddr = lsa->sin6; |
| 142 | |
| 143 | pkt = (struct icmp6_hdr *) packet; |
| 144 | memset(pkt, 0, sizeof(packet)); |
| 145 | pkt->icmp6_type = ICMP6_ECHO_REQUEST; |
| 146 | |
| 147 | sockopt = offsetof(struct icmp6_hdr, icmp6_cksum); |
| 148 | setsockopt(pingsock, SOL_RAW, IPV6_CHECKSUM, &sockopt, sizeof(sockopt)); |
| 149 | |
Bernhard Reutner-Fischer | b290889 | 2007-04-12 11:34:39 +0000 | [diff] [blame] | 150 | c = xsendto(pingsock, packet, DEFDATALEN + sizeof (struct icmp6_hdr), |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 151 | (struct sockaddr *) &pingaddr, sizeof(pingaddr)); |
| 152 | |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 153 | /* listen for replies */ |
| 154 | while (1) { |
| 155 | struct sockaddr_in6 from; |
| 156 | socklen_t fromlen = sizeof(from); |
| 157 | |
| 158 | c = recvfrom(pingsock, packet, sizeof(packet), 0, |
| 159 | (struct sockaddr *) &from, &fromlen); |
| 160 | if (c < 0) { |
| 161 | if (errno != EINTR) |
| 162 | bb_perror_msg("recvfrom"); |
| 163 | continue; |
| 164 | } |
| 165 | if (c >= 8) { /* icmp6_hdr */ |
| 166 | pkt = (struct icmp6_hdr *) packet; |
| 167 | if (pkt->icmp6_type == ICMP6_ECHO_REPLY) |
| 168 | break; |
| 169 | } |
| 170 | } |
| 171 | if (ENABLE_FEATURE_CLEAN_UP) |
| 172 | close(pingsock); |
| 173 | } |
| 174 | #endif |
| 175 | |
Denis Vlasenko | 9b49a5e | 2007-10-11 10:05:36 +0000 | [diff] [blame] | 176 | int ping_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; |
Rob Landley | dfba741 | 2006-03-06 20:47:33 +0000 | [diff] [blame] | 177 | int ping_main(int argc, char **argv) |
Eric Andersen | 19db07b | 1999-12-11 08:41:28 +0000 | [diff] [blame] | 178 | { |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 179 | len_and_sockaddr *lsa; |
| 180 | #if ENABLE_PING6 |
| 181 | sa_family_t af = AF_UNSPEC; |
Denis Vlasenko | 3483e85 | 2007-07-02 15:47:52 +0000 | [diff] [blame] | 182 | |
| 183 | while ((++argv)[0] && argv[0][0] == '-') { |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 184 | if (argv[0][1] == '4') { |
| 185 | af = AF_INET; |
| 186 | continue; |
| 187 | } |
| 188 | if (argv[0][1] == '6') { |
| 189 | af = AF_INET6; |
| 190 | continue; |
| 191 | } |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 192 | bb_show_usage(); |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 193 | } |
| 194 | #else |
| 195 | argv++; |
| 196 | #endif |
| 197 | |
| 198 | hostname = *argv; |
| 199 | if (!hostname) |
| 200 | bb_show_usage(); |
| 201 | |
| 202 | #if ENABLE_PING6 |
Denis Vlasenko | 42823d5 | 2007-02-04 02:39:08 +0000 | [diff] [blame] | 203 | lsa = xhost_and_af2sockaddr(hostname, 0, af); |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 204 | #else |
Denis Vlasenko | 42823d5 | 2007-02-04 02:39:08 +0000 | [diff] [blame] | 205 | lsa = xhost_and_af2sockaddr(hostname, 0, AF_INET); |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 206 | #endif |
| 207 | /* Set timer _after_ DNS resolution */ |
| 208 | signal(SIGALRM, noresp); |
| 209 | alarm(5); /* give the host 5000ms to respond */ |
| 210 | |
| 211 | #if ENABLE_PING6 |
| 212 | if (lsa->sa.sa_family == AF_INET6) |
| 213 | ping6(lsa); |
| 214 | else |
| 215 | #endif |
Denis Vlasenko | e935602 | 2007-01-29 18:03:54 +0000 | [diff] [blame] | 216 | ping4(lsa); |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 217 | printf("%s is alive!\n", hostname); |
Matt Kraai | 3e856ce | 2000-12-01 02:55:13 +0000 | [diff] [blame] | 218 | return EXIT_SUCCESS; |
Eric Andersen | 19db07b | 1999-12-11 08:41:28 +0000 | [diff] [blame] | 219 | } |
| 220 | |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 221 | |
| 222 | #else /* FEATURE_FANCY_PING */ |
| 223 | |
Denis Vlasenko | 4a5cf16 | 2006-11-20 00:48:22 +0000 | [diff] [blame] | 224 | |
Eric Andersen | 19db07b | 1999-12-11 08:41:28 +0000 | [diff] [blame] | 225 | /* full(er) version */ |
Denis Vlasenko | 4a5cf16 | 2006-11-20 00:48:22 +0000 | [diff] [blame] | 226 | |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 227 | #define OPT_STRING ("qvc:s:I:4" USE_PING6("6")) |
Denis Vlasenko | 4a5cf16 | 2006-11-20 00:48:22 +0000 | [diff] [blame] | 228 | enum { |
| 229 | OPT_QUIET = 1 << 0, |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 230 | OPT_VERBOSE = 1 << 1, |
| 231 | OPT_c = 1 << 2, |
| 232 | OPT_s = 1 << 3, |
| 233 | OPT_I = 1 << 4, |
| 234 | OPT_IPV4 = 1 << 5, |
| 235 | OPT_IPV6 = (1 << 6) * ENABLE_PING6, |
Denis Vlasenko | 4a5cf16 | 2006-11-20 00:48:22 +0000 | [diff] [blame] | 236 | }; |
| 237 | |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 238 | |
Denis Vlasenko | 821cc25 | 2007-06-04 10:33:48 +0000 | [diff] [blame] | 239 | struct globals { |
| 240 | int pingsock; |
Denis Vlasenko | 1a7afb4 | 2007-10-19 21:39:25 +0000 | [diff] [blame] | 241 | int if_index; |
| 242 | char *opt_I; |
Denis Vlasenko | 821cc25 | 2007-06-04 10:33:48 +0000 | [diff] [blame] | 243 | len_and_sockaddr *source_lsa; |
| 244 | unsigned datalen; |
Denis Vlasenko | 821cc25 | 2007-06-04 10:33:48 +0000 | [diff] [blame] | 245 | unsigned long ntransmitted, nreceived, nrepeats, pingcount; |
| 246 | uint16_t myid; |
Denis Vlasenko | 7679145 | 2007-06-18 08:55:57 +0000 | [diff] [blame] | 247 | unsigned tmin, tmax; /* in us */ |
| 248 | unsigned long long tsum; /* in us, sum of all times */ |
Denis Vlasenko | 821cc25 | 2007-06-04 10:33:48 +0000 | [diff] [blame] | 249 | const char *hostname; |
| 250 | const char *dotted; |
| 251 | union { |
| 252 | struct sockaddr sa; |
| 253 | struct sockaddr_in sin; |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 254 | #if ENABLE_PING6 |
Denis Vlasenko | 821cc25 | 2007-06-04 10:33:48 +0000 | [diff] [blame] | 255 | struct sockaddr_in6 sin6; |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 256 | #endif |
Denis Vlasenko | 821cc25 | 2007-06-04 10:33:48 +0000 | [diff] [blame] | 257 | } pingaddr; |
| 258 | char rcvd_tbl[MAX_DUP_CHK / 8]; |
| 259 | }; |
| 260 | #define G (*(struct globals*)&bb_common_bufsiz1) |
| 261 | #define pingsock (G.pingsock ) |
Denis Vlasenko | 821cc25 | 2007-06-04 10:33:48 +0000 | [diff] [blame] | 262 | #define if_index (G.if_index ) |
Denis Vlasenko | 1a7afb4 | 2007-10-19 21:39:25 +0000 | [diff] [blame] | 263 | #define source_lsa (G.source_lsa ) |
| 264 | #define opt_I (G.opt_I ) |
| 265 | #define datalen (G.datalen ) |
Denis Vlasenko | 821cc25 | 2007-06-04 10:33:48 +0000 | [diff] [blame] | 266 | #define ntransmitted (G.ntransmitted) |
| 267 | #define nreceived (G.nreceived ) |
| 268 | #define nrepeats (G.nrepeats ) |
| 269 | #define pingcount (G.pingcount ) |
| 270 | #define myid (G.myid ) |
| 271 | #define tmin (G.tmin ) |
| 272 | #define tmax (G.tmax ) |
| 273 | #define tsum (G.tsum ) |
| 274 | #define hostname (G.hostname ) |
| 275 | #define dotted (G.dotted ) |
| 276 | #define pingaddr (G.pingaddr ) |
| 277 | #define rcvd_tbl (G.rcvd_tbl ) |
| 278 | void BUG_ping_globals_too_big(void); |
| 279 | #define INIT_G() do { \ |
Denis Vlasenko | 6b40443 | 2008-01-07 16:13:14 +0000 | [diff] [blame] | 280 | if (sizeof(G) > COMMON_BUFSIZE) \ |
| 281 | BUG_ping_globals_too_big(); \ |
Denis Vlasenko | 821cc25 | 2007-06-04 10:33:48 +0000 | [diff] [blame] | 282 | pingsock = -1; \ |
| 283 | tmin = UINT_MAX; \ |
| 284 | } while (0) |
Eric Andersen | 19db07b | 1999-12-11 08:41:28 +0000 | [diff] [blame] | 285 | |
Eric Andersen | 19db07b | 1999-12-11 08:41:28 +0000 | [diff] [blame] | 286 | |
Denis Vlasenko | 4a5cf16 | 2006-11-20 00:48:22 +0000 | [diff] [blame] | 287 | #define A(bit) rcvd_tbl[(bit)>>3] /* identify byte in array */ |
| 288 | #define B(bit) (1 << ((bit) & 0x07)) /* identify bit in byte */ |
| 289 | #define SET(bit) (A(bit) |= B(bit)) |
| 290 | #define CLR(bit) (A(bit) &= (~B(bit))) |
| 291 | #define TST(bit) (A(bit) & B(bit)) |
| 292 | |
Eric Andersen | 19db07b | 1999-12-11 08:41:28 +0000 | [diff] [blame] | 293 | /**************************************************************************/ |
| 294 | |
Denis Vlasenko | aeb4bdd | 2007-01-25 00:00:02 +0000 | [diff] [blame] | 295 | static void pingstats(int junk ATTRIBUTE_UNUSED) |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 296 | { |
| 297 | signal(SIGINT, SIG_IGN); |
| 298 | |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 299 | printf("\n--- %s ping statistics ---\n", hostname); |
Denis Vlasenko | 1385899 | 2006-10-08 12:49:22 +0000 | [diff] [blame] | 300 | printf("%lu packets transmitted, ", ntransmitted); |
| 301 | printf("%lu packets received, ", nreceived); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 302 | if (nrepeats) |
Denis Vlasenko | 1385899 | 2006-10-08 12:49:22 +0000 | [diff] [blame] | 303 | printf("%lu duplicates, ", nrepeats); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 304 | if (ntransmitted) |
Denis Vlasenko | aeb4bdd | 2007-01-25 00:00:02 +0000 | [diff] [blame] | 305 | ntransmitted = (ntransmitted - nreceived) * 100 / ntransmitted; |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 306 | printf("%lu%% packet loss\n", ntransmitted); |
Denis Vlasenko | 7679145 | 2007-06-18 08:55:57 +0000 | [diff] [blame] | 307 | if (tmin != UINT_MAX) { |
| 308 | unsigned tavg = tsum / (nreceived + nrepeats); |
| 309 | printf("round-trip min/avg/max = %u.%03u/%u.%03u/%u.%03u ms\n", |
| 310 | tmin / 1000, tmin % 1000, |
| 311 | tavg / 1000, tavg % 1000, |
| 312 | tmax / 1000, tmax % 1000); |
| 313 | } |
Denis Vlasenko | 19c238b | 2007-03-03 00:36:35 +0000 | [diff] [blame] | 314 | exit(nreceived == 0); /* (nreceived == 0) is true (1) -- 'failure' */ |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 315 | } |
| 316 | |
Denis Vlasenko | c8e9993 | 2007-02-09 18:14:42 +0000 | [diff] [blame] | 317 | static void sendping_tail(void (*sp)(int), const void *pkt, int size_pkt) |
Denis Vlasenko | e935602 | 2007-01-29 18:03:54 +0000 | [diff] [blame] | 318 | { |
Denis Vlasenko | c8e9993 | 2007-02-09 18:14:42 +0000 | [diff] [blame] | 319 | int sz; |
| 320 | |
| 321 | CLR((uint16_t)ntransmitted % MAX_DUP_CHK); |
| 322 | ntransmitted++; |
| 323 | |
| 324 | /* sizeof(pingaddr) can be larger than real sa size, but I think |
| 325 | * it doesn't matter */ |
Bernhard Reutner-Fischer | b290889 | 2007-04-12 11:34:39 +0000 | [diff] [blame] | 326 | sz = xsendto(pingsock, pkt, size_pkt, &pingaddr.sa, sizeof(pingaddr)); |
Denis Vlasenko | c8e9993 | 2007-02-09 18:14:42 +0000 | [diff] [blame] | 327 | if (sz != size_pkt) |
Bernhard Reutner-Fischer | b290889 | 2007-04-12 11:34:39 +0000 | [diff] [blame] | 328 | bb_error_msg_and_die(bb_msg_write_error); |
Denis Vlasenko | e935602 | 2007-01-29 18:03:54 +0000 | [diff] [blame] | 329 | |
| 330 | signal(SIGALRM, sp); |
Bernhard Reutner-Fischer | b290889 | 2007-04-12 11:34:39 +0000 | [diff] [blame] | 331 | if (pingcount == 0 || ntransmitted < pingcount) { /* schedule next in 1s */ |
Denis Vlasenko | e935602 | 2007-01-29 18:03:54 +0000 | [diff] [blame] | 332 | alarm(PINGINTERVAL); |
| 333 | } else { /* done, wait for the last ping to come back */ |
| 334 | /* todo, don't necessarily need to wait so long... */ |
| 335 | signal(SIGALRM, pingstats); |
| 336 | alarm(MAXWAIT); |
| 337 | } |
| 338 | } |
| 339 | |
| 340 | static void sendping4(int junk ATTRIBUTE_UNUSED) |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 341 | { |
Denis Vlasenko | 7679145 | 2007-06-18 08:55:57 +0000 | [diff] [blame] | 342 | /* +4 reserves a place for timestamp, which may end up sitting |
| 343 | * *after* packet. Saves one if() */ |
| 344 | struct icmp *pkt = alloca(datalen + ICMP_MINLEN + 4); |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 345 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 346 | pkt->icmp_type = ICMP_ECHO; |
| 347 | pkt->icmp_code = 0; |
| 348 | pkt->icmp_cksum = 0; |
Denis Vlasenko | 919c10d | 2007-01-03 22:14:18 +0000 | [diff] [blame] | 349 | pkt->icmp_seq = htons(ntransmitted); /* don't ++ here, it can be a macro */ |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 350 | pkt->icmp_id = myid; |
Denis Vlasenko | 7b72fc1 | 2007-06-16 13:37:59 +0000 | [diff] [blame] | 351 | |
Denis Vlasenko | 7679145 | 2007-06-18 08:55:57 +0000 | [diff] [blame] | 352 | /* We don't do hton, because we will read it back on the same machine */ |
| 353 | /*if (datalen >= 4)*/ |
| 354 | *(uint32_t*)&pkt->icmp_dun = monotonic_us(); |
Denis Vlasenko | 7b72fc1 | 2007-06-16 13:37:59 +0000 | [diff] [blame] | 355 | |
Denis Vlasenko | c8e9993 | 2007-02-09 18:14:42 +0000 | [diff] [blame] | 356 | pkt->icmp_cksum = in_cksum((unsigned short *) pkt, datalen + ICMP_MINLEN); |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 357 | |
Denis Vlasenko | c8e9993 | 2007-02-09 18:14:42 +0000 | [diff] [blame] | 358 | sendping_tail(sendping4, pkt, datalen + ICMP_MINLEN); |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 359 | } |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 360 | #if ENABLE_PING6 |
| 361 | static void sendping6(int junk ATTRIBUTE_UNUSED) |
| 362 | { |
Denis Vlasenko | 7679145 | 2007-06-18 08:55:57 +0000 | [diff] [blame] | 363 | struct icmp6_hdr *pkt = alloca(datalen + sizeof(struct icmp6_hdr) + 4); |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 364 | |
| 365 | pkt->icmp6_type = ICMP6_ECHO_REQUEST; |
| 366 | pkt->icmp6_code = 0; |
| 367 | pkt->icmp6_cksum = 0; |
| 368 | pkt->icmp6_seq = htons(ntransmitted); /* don't ++ here, it can be a macro */ |
| 369 | pkt->icmp6_id = myid; |
Denis Vlasenko | 7b72fc1 | 2007-06-16 13:37:59 +0000 | [diff] [blame] | 370 | |
Denis Vlasenko | 7679145 | 2007-06-18 08:55:57 +0000 | [diff] [blame] | 371 | /*if (datalen >= 4)*/ |
| 372 | *(uint32_t*)(&pkt->icmp6_data8[4]) = monotonic_us(); |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 373 | |
Denis Vlasenko | c8e9993 | 2007-02-09 18:14:42 +0000 | [diff] [blame] | 374 | sendping_tail(sendping6, pkt, datalen + sizeof(struct icmp6_hdr)); |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 375 | } |
| 376 | #endif |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 377 | |
Denis Vlasenko | 89ef65f | 2007-01-29 23:43:18 +0000 | [diff] [blame] | 378 | static const char *icmp_type_name(int id) |
Erik Andersen | 227a59b | 2000-04-25 23:24:55 +0000 | [diff] [blame] | 379 | { |
| 380 | switch (id) { |
Denis Vlasenko | 35d4da0 | 2007-01-22 14:04:27 +0000 | [diff] [blame] | 381 | case ICMP_ECHOREPLY: return "Echo Reply"; |
| 382 | case ICMP_DEST_UNREACH: return "Destination Unreachable"; |
| 383 | case ICMP_SOURCE_QUENCH: return "Source Quench"; |
| 384 | case ICMP_REDIRECT: return "Redirect (change route)"; |
| 385 | case ICMP_ECHO: return "Echo Request"; |
| 386 | case ICMP_TIME_EXCEEDED: return "Time Exceeded"; |
| 387 | case ICMP_PARAMETERPROB: return "Parameter Problem"; |
| 388 | case ICMP_TIMESTAMP: return "Timestamp Request"; |
| 389 | case ICMP_TIMESTAMPREPLY: return "Timestamp Reply"; |
| 390 | case ICMP_INFO_REQUEST: return "Information Request"; |
| 391 | case ICMP_INFO_REPLY: return "Information Reply"; |
| 392 | case ICMP_ADDRESS: return "Address Mask Request"; |
| 393 | case ICMP_ADDRESSREPLY: return "Address Mask Reply"; |
| 394 | default: return "unknown ICMP type"; |
Erik Andersen | 227a59b | 2000-04-25 23:24:55 +0000 | [diff] [blame] | 395 | } |
| 396 | } |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 397 | #if ENABLE_PING6 |
| 398 | /* RFC3542 changed some definitions from RFC2292 for no good reason, whee! |
| 399 | * the newer 3542 uses a MLD_ prefix where as 2292 uses ICMP6_ prefix */ |
| 400 | #ifndef MLD_LISTENER_QUERY |
| 401 | # define MLD_LISTENER_QUERY ICMP6_MEMBERSHIP_QUERY |
| 402 | #endif |
| 403 | #ifndef MLD_LISTENER_REPORT |
| 404 | # define MLD_LISTENER_REPORT ICMP6_MEMBERSHIP_REPORT |
| 405 | #endif |
| 406 | #ifndef MLD_LISTENER_REDUCTION |
| 407 | # define MLD_LISTENER_REDUCTION ICMP6_MEMBERSHIP_REDUCTION |
| 408 | #endif |
Denis Vlasenko | 89ef65f | 2007-01-29 23:43:18 +0000 | [diff] [blame] | 409 | static const char *icmp6_type_name(int id) |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 410 | { |
| 411 | switch (id) { |
| 412 | case ICMP6_DST_UNREACH: return "Destination Unreachable"; |
| 413 | case ICMP6_PACKET_TOO_BIG: return "Packet too big"; |
| 414 | case ICMP6_TIME_EXCEEDED: return "Time Exceeded"; |
| 415 | case ICMP6_PARAM_PROB: return "Parameter Problem"; |
| 416 | case ICMP6_ECHO_REPLY: return "Echo Reply"; |
| 417 | case ICMP6_ECHO_REQUEST: return "Echo Request"; |
| 418 | case MLD_LISTENER_QUERY: return "Listener Query"; |
| 419 | case MLD_LISTENER_REPORT: return "Listener Report"; |
| 420 | case MLD_LISTENER_REDUCTION: return "Listener Reduction"; |
| 421 | default: return "unknown ICMP type"; |
| 422 | } |
| 423 | } |
| 424 | #endif |
Erik Andersen | 227a59b | 2000-04-25 23:24:55 +0000 | [diff] [blame] | 425 | |
Denis Vlasenko | 7679145 | 2007-06-18 08:55:57 +0000 | [diff] [blame] | 426 | static void unpack_tail(int sz, uint32_t *tp, |
Denis Vlasenko | 19c238b | 2007-03-03 00:36:35 +0000 | [diff] [blame] | 427 | const char *from_str, |
| 428 | uint16_t recv_seq, int ttl) |
| 429 | { |
| 430 | const char *dupmsg = " (DUP!)"; |
| 431 | unsigned triptime = triptime; /* for gcc */ |
| 432 | |
| 433 | ++nreceived; |
| 434 | |
| 435 | if (tp) { |
Denis Vlasenko | 7679145 | 2007-06-18 08:55:57 +0000 | [diff] [blame] | 436 | /* (int32_t) cast is for hypothetical 64-bit unsigned */ |
| 437 | /* (doesn't hurt 32-bit real-world anyway) */ |
| 438 | triptime = (int32_t) ((uint32_t)monotonic_us() - *tp); |
Denis Vlasenko | 19c238b | 2007-03-03 00:36:35 +0000 | [diff] [blame] | 439 | tsum += triptime; |
| 440 | if (triptime < tmin) |
| 441 | tmin = triptime; |
| 442 | if (triptime > tmax) |
| 443 | tmax = triptime; |
| 444 | } |
| 445 | |
| 446 | if (TST(recv_seq % MAX_DUP_CHK)) { |
| 447 | ++nrepeats; |
| 448 | --nreceived; |
| 449 | } else { |
| 450 | SET(recv_seq % MAX_DUP_CHK); |
| 451 | dupmsg += 7; |
| 452 | } |
| 453 | |
| 454 | if (option_mask32 & OPT_QUIET) |
| 455 | return; |
| 456 | |
| 457 | printf("%d bytes from %s: seq=%u ttl=%d", sz, |
| 458 | from_str, recv_seq, ttl); |
| 459 | if (tp) |
Denis Vlasenko | 7679145 | 2007-06-18 08:55:57 +0000 | [diff] [blame] | 460 | printf(" time=%u.%03u ms", triptime / 1000, triptime % 1000); |
Denis Vlasenko | 19c238b | 2007-03-03 00:36:35 +0000 | [diff] [blame] | 461 | puts(dupmsg); |
| 462 | fflush(stdout); |
| 463 | } |
Denis Vlasenko | e935602 | 2007-01-29 18:03:54 +0000 | [diff] [blame] | 464 | static void unpack4(char *buf, int sz, struct sockaddr_in *from) |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 465 | { |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 466 | struct icmp *icmppkt; |
| 467 | struct iphdr *iphdr; |
Denis Vlasenko | 19c238b | 2007-03-03 00:36:35 +0000 | [diff] [blame] | 468 | int hlen; |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 469 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 470 | /* discard if too short */ |
Pavel Roskin | 0024abc | 2000-06-07 20:38:15 +0000 | [diff] [blame] | 471 | if (sz < (datalen + ICMP_MINLEN)) |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 472 | return; |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 473 | |
Denis Vlasenko | 2cbe6e6 | 2006-09-02 16:17:30 +0000 | [diff] [blame] | 474 | /* check IP header */ |
| 475 | iphdr = (struct iphdr *) buf; |
| 476 | hlen = iphdr->ihl << 2; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 477 | sz -= hlen; |
| 478 | icmppkt = (struct icmp *) (buf + hlen); |
Erik Andersen | 227a59b | 2000-04-25 23:24:55 +0000 | [diff] [blame] | 479 | if (icmppkt->icmp_id != myid) |
Denis Vlasenko | cb6874c | 2006-09-02 16:13:36 +0000 | [diff] [blame] | 480 | return; /* not our ping */ |
Erik Andersen | 227a59b | 2000-04-25 23:24:55 +0000 | [diff] [blame] | 481 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 482 | if (icmppkt->icmp_type == ICMP_ECHOREPLY) { |
Denis Vlasenko | 35d4da0 | 2007-01-22 14:04:27 +0000 | [diff] [blame] | 483 | uint16_t recv_seq = ntohs(icmppkt->icmp_seq); |
Denis Vlasenko | 7679145 | 2007-06-18 08:55:57 +0000 | [diff] [blame] | 484 | uint32_t *tp = NULL; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 485 | |
Denis Vlasenko | 7679145 | 2007-06-18 08:55:57 +0000 | [diff] [blame] | 486 | if (sz >= ICMP_MINLEN + sizeof(uint32_t)) |
| 487 | tp = (uint32_t *) icmppkt->icmp_data; |
Denis Vlasenko | 19c238b | 2007-03-03 00:36:35 +0000 | [diff] [blame] | 488 | unpack_tail(sz, tp, |
| 489 | inet_ntoa(*(struct in_addr *) &from->sin_addr.s_addr), |
| 490 | recv_seq, iphdr->ttl); |
| 491 | } else if (icmppkt->icmp_type != ICMP_ECHO) { |
| 492 | bb_error_msg("warning: got ICMP %d (%s)", |
| 493 | icmppkt->icmp_type, |
| 494 | icmp_type_name(icmppkt->icmp_type)); |
Denis Vlasenko | 35d4da0 | 2007-01-22 14:04:27 +0000 | [diff] [blame] | 495 | } |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 496 | } |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 497 | #if ENABLE_PING6 |
| 498 | static void unpack6(char *packet, int sz, struct sockaddr_in6 *from, int hoplimit) |
| 499 | { |
| 500 | struct icmp6_hdr *icmppkt; |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 501 | char buf[INET6_ADDRSTRLEN]; |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 502 | |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 503 | /* discard if too short */ |
| 504 | if (sz < (datalen + sizeof(struct icmp6_hdr))) |
| 505 | return; |
| 506 | |
| 507 | icmppkt = (struct icmp6_hdr *) packet; |
| 508 | if (icmppkt->icmp6_id != myid) |
| 509 | return; /* not our ping */ |
| 510 | |
| 511 | if (icmppkt->icmp6_type == ICMP6_ECHO_REPLY) { |
| 512 | uint16_t recv_seq = ntohs(icmppkt->icmp6_seq); |
Denis Vlasenko | 7679145 | 2007-06-18 08:55:57 +0000 | [diff] [blame] | 513 | uint32_t *tp = NULL; |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 514 | |
Denis Vlasenko | 7679145 | 2007-06-18 08:55:57 +0000 | [diff] [blame] | 515 | if (sz >= sizeof(struct icmp6_hdr) + sizeof(uint32_t)) |
| 516 | tp = (uint32_t *) &icmppkt->icmp6_data8[4]; |
Denis Vlasenko | 19c238b | 2007-03-03 00:36:35 +0000 | [diff] [blame] | 517 | unpack_tail(sz, tp, |
| 518 | inet_ntop(AF_INET6, &pingaddr.sin6.sin6_addr, |
| 519 | buf, sizeof(buf)), |
| 520 | recv_seq, hoplimit); |
| 521 | } else if (icmppkt->icmp6_type != ICMP6_ECHO_REQUEST) { |
| 522 | bb_error_msg("warning: got ICMP %d (%s)", |
| 523 | icmppkt->icmp6_type, |
| 524 | icmp6_type_name(icmppkt->icmp6_type)); |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 525 | } |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 526 | } |
| 527 | #endif |
| 528 | |
Denis Vlasenko | e935602 | 2007-01-29 18:03:54 +0000 | [diff] [blame] | 529 | static void ping4(len_and_sockaddr *lsa) |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 530 | { |
Pavel Roskin | 0024abc | 2000-06-07 20:38:15 +0000 | [diff] [blame] | 531 | char packet[datalen + MAXIPLEN + MAXICMPLEN]; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 532 | int sockopt; |
| 533 | |
Matt Kraai | 06ef165 | 2001-07-13 20:56:27 +0000 | [diff] [blame] | 534 | pingsock = create_icmp_socket(); |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 535 | pingaddr.sin = lsa->sin; |
Denis Vlasenko | 5ad1048 | 2007-06-19 22:54:21 +0000 | [diff] [blame] | 536 | if (source_lsa) { |
| 537 | if (setsockopt(pingsock, IPPROTO_IP, IP_MULTICAST_IF, |
| 538 | &source_lsa->sa, source_lsa->len)) |
| 539 | bb_error_msg_and_die("can't set multicast source interface"); |
| 540 | xbind(pingsock, &source_lsa->sa, source_lsa->len); |
| 541 | } |
Denis Vlasenko | 1a7afb4 | 2007-10-19 21:39:25 +0000 | [diff] [blame] | 542 | if (opt_I) |
Denis Vlasenko | 2edbc2a | 2007-10-20 02:00:49 +0000 | [diff] [blame] | 543 | setsockopt(pingsock, SOL_SOCKET, SO_BINDTODEVICE, opt_I, strlen(opt_I) + 1); |
Denis Vlasenko | 2cbe6e6 | 2006-09-02 16:17:30 +0000 | [diff] [blame] | 544 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 545 | /* enable broadcast pings */ |
Denis Vlasenko | 48237b0 | 2006-11-22 23:22:06 +0000 | [diff] [blame] | 546 | setsockopt_broadcast(pingsock); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 547 | |
| 548 | /* set recv buf for broadcast pings */ |
Denis Vlasenko | 35d4da0 | 2007-01-22 14:04:27 +0000 | [diff] [blame] | 549 | sockopt = 48 * 1024; /* explain why 48k? */ |
Denis Vlasenko | 703e202 | 2007-01-22 14:12:08 +0000 | [diff] [blame] | 550 | setsockopt(pingsock, SOL_SOCKET, SO_RCVBUF, &sockopt, sizeof(sockopt)); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 551 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 552 | signal(SIGINT, pingstats); |
| 553 | |
| 554 | /* start the ping's going ... */ |
Denis Vlasenko | e935602 | 2007-01-29 18:03:54 +0000 | [diff] [blame] | 555 | sendping4(0); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 556 | |
| 557 | /* listen for replies */ |
| 558 | while (1) { |
| 559 | struct sockaddr_in from; |
Erik Andersen | 1d1d950 | 2000-04-21 01:26:49 +0000 | [diff] [blame] | 560 | socklen_t fromlen = (socklen_t) sizeof(from); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 561 | int c; |
| 562 | |
Denis Vlasenko | 44c2eb2 | 2007-01-08 23:55:33 +0000 | [diff] [blame] | 563 | c = recvfrom(pingsock, packet, sizeof(packet), 0, |
| 564 | (struct sockaddr *) &from, &fromlen); |
| 565 | if (c < 0) { |
| 566 | if (errno != EINTR) |
| 567 | bb_perror_msg("recvfrom"); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 568 | continue; |
| 569 | } |
Denis Vlasenko | e935602 | 2007-01-29 18:03:54 +0000 | [diff] [blame] | 570 | unpack4(packet, c, &from); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 571 | if (pingcount > 0 && nreceived >= pingcount) |
| 572 | break; |
| 573 | } |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 574 | } |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 575 | #if ENABLE_PING6 |
| 576 | extern int BUG_bad_offsetof_icmp6_cksum(void); |
| 577 | static void ping6(len_and_sockaddr *lsa) |
| 578 | { |
| 579 | char packet[datalen + MAXIPLEN + MAXICMPLEN]; |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 580 | int sockopt; |
| 581 | struct msghdr msg; |
| 582 | struct sockaddr_in6 from; |
| 583 | struct iovec iov; |
| 584 | char control_buf[CMSG_SPACE(36)]; |
| 585 | |
| 586 | pingsock = create_icmp6_socket(); |
| 587 | pingaddr.sin6 = lsa->sin6; |
Denis Vlasenko | 9ca26d3 | 2007-02-09 17:32:16 +0000 | [diff] [blame] | 588 | /* untested whether "-I addr" really works for IPv6: */ |
| 589 | if (source_lsa) |
Denis Vlasenko | 5ad1048 | 2007-06-19 22:54:21 +0000 | [diff] [blame] | 590 | xbind(pingsock, &source_lsa->sa, source_lsa->len); |
Denis Vlasenko | 1a7afb4 | 2007-10-19 21:39:25 +0000 | [diff] [blame] | 591 | if (opt_I) |
Denis Vlasenko | 2edbc2a | 2007-10-20 02:00:49 +0000 | [diff] [blame] | 592 | setsockopt(pingsock, SOL_SOCKET, SO_BINDTODEVICE, opt_I, strlen(opt_I) + 1); |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 593 | |
| 594 | #ifdef ICMP6_FILTER |
| 595 | { |
| 596 | struct icmp6_filter filt; |
| 597 | if (!(option_mask32 & OPT_VERBOSE)) { |
| 598 | ICMP6_FILTER_SETBLOCKALL(&filt); |
| 599 | ICMP6_FILTER_SETPASS(ICMP6_ECHO_REPLY, &filt); |
| 600 | } else { |
| 601 | ICMP6_FILTER_SETPASSALL(&filt); |
| 602 | } |
| 603 | if (setsockopt(pingsock, IPPROTO_ICMPV6, ICMP6_FILTER, &filt, |
| 604 | sizeof(filt)) < 0) |
| 605 | bb_error_msg_and_die("setsockopt(ICMP6_FILTER)"); |
| 606 | } |
| 607 | #endif /*ICMP6_FILTER*/ |
| 608 | |
| 609 | /* enable broadcast pings */ |
| 610 | setsockopt_broadcast(pingsock); |
| 611 | |
| 612 | /* set recv buf for broadcast pings */ |
| 613 | sockopt = 48 * 1024; /* explain why 48k? */ |
| 614 | setsockopt(pingsock, SOL_SOCKET, SO_RCVBUF, &sockopt, sizeof(sockopt)); |
| 615 | |
| 616 | sockopt = offsetof(struct icmp6_hdr, icmp6_cksum); |
| 617 | if (offsetof(struct icmp6_hdr, icmp6_cksum) != 2) |
| 618 | BUG_bad_offsetof_icmp6_cksum(); |
| 619 | setsockopt(pingsock, SOL_RAW, IPV6_CHECKSUM, &sockopt, sizeof(sockopt)); |
| 620 | |
| 621 | /* request ttl info to be returned in ancillary data */ |
| 622 | setsockopt(pingsock, SOL_IPV6, IPV6_HOPLIMIT, &const_int_1, sizeof(const_int_1)); |
| 623 | |
| 624 | if (if_index) |
Denis Vlasenko | aeb4bdd | 2007-01-25 00:00:02 +0000 | [diff] [blame] | 625 | pingaddr.sin6.sin6_scope_id = if_index; |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 626 | |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 627 | signal(SIGINT, pingstats); |
| 628 | |
| 629 | /* start the ping's going ... */ |
| 630 | sendping6(0); |
| 631 | |
| 632 | /* listen for replies */ |
| 633 | msg.msg_name = &from; |
| 634 | msg.msg_namelen = sizeof(from); |
| 635 | msg.msg_iov = &iov; |
| 636 | msg.msg_iovlen = 1; |
| 637 | msg.msg_control = control_buf; |
| 638 | iov.iov_base = packet; |
| 639 | iov.iov_len = sizeof(packet); |
| 640 | while (1) { |
| 641 | int c; |
| 642 | struct cmsghdr *mp; |
| 643 | int hoplimit = -1; |
| 644 | msg.msg_controllen = sizeof(control_buf); |
| 645 | |
| 646 | c = recvmsg(pingsock, &msg, 0); |
| 647 | if (c < 0) { |
| 648 | if (errno != EINTR) |
| 649 | bb_perror_msg("recvfrom"); |
| 650 | continue; |
| 651 | } |
| 652 | for (mp = CMSG_FIRSTHDR(&msg); mp; mp = CMSG_NXTHDR(&msg, mp)) { |
| 653 | if (mp->cmsg_level == SOL_IPV6 |
| 654 | && mp->cmsg_type == IPV6_HOPLIMIT |
| 655 | /* don't check len - we trust the kernel: */ |
| 656 | /* && mp->cmsg_len >= CMSG_LEN(sizeof(int)) */ |
| 657 | ) { |
| 658 | hoplimit = *(int*)CMSG_DATA(mp); |
| 659 | } |
| 660 | } |
| 661 | unpack6(packet, c, &from, hoplimit); |
| 662 | if (pingcount > 0 && nreceived >= pingcount) |
| 663 | break; |
| 664 | } |
| 665 | } |
| 666 | #endif |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 667 | |
Denis Vlasenko | 9ca26d3 | 2007-02-09 17:32:16 +0000 | [diff] [blame] | 668 | static void ping(len_and_sockaddr *lsa) |
Denis Vlasenko | 2cbe6e6 | 2006-09-02 16:17:30 +0000 | [diff] [blame] | 669 | { |
Denis Vlasenko | 9ca26d3 | 2007-02-09 17:32:16 +0000 | [diff] [blame] | 670 | printf("PING %s (%s)", hostname, dotted); |
| 671 | if (source_lsa) { |
| 672 | printf(" from %s", |
Denis Vlasenko | a27a11b | 2007-08-18 14:16:39 +0000 | [diff] [blame] | 673 | xmalloc_sockaddr2dotted_noport(&source_lsa->sa)); |
Denis Vlasenko | 2cbe6e6 | 2006-09-02 16:17:30 +0000 | [diff] [blame] | 674 | } |
Denis Vlasenko | 9ca26d3 | 2007-02-09 17:32:16 +0000 | [diff] [blame] | 675 | printf(": %d data bytes\n", datalen); |
| 676 | |
| 677 | #if ENABLE_PING6 |
| 678 | if (lsa->sa.sa_family == AF_INET6) |
| 679 | ping6(lsa); |
| 680 | else |
| 681 | #endif |
| 682 | ping4(lsa); |
Denis Vlasenko | 2cbe6e6 | 2006-09-02 16:17:30 +0000 | [diff] [blame] | 683 | } |
| 684 | |
Denis Vlasenko | 9b49a5e | 2007-10-11 10:05:36 +0000 | [diff] [blame] | 685 | int ping_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; |
Rob Landley | dfba741 | 2006-03-06 20:47:33 +0000 | [diff] [blame] | 686 | int ping_main(int argc, char **argv) |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 687 | { |
Denis Vlasenko | aeb4bdd | 2007-01-25 00:00:02 +0000 | [diff] [blame] | 688 | len_and_sockaddr *lsa; |
Denis Vlasenko | 1a7afb4 | 2007-10-19 21:39:25 +0000 | [diff] [blame] | 689 | char *opt_c, *opt_s; |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 690 | USE_PING6(sa_family_t af = AF_UNSPEC;) |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 691 | |
Denis Vlasenko | 821cc25 | 2007-06-04 10:33:48 +0000 | [diff] [blame] | 692 | INIT_G(); |
| 693 | |
Denis Vlasenko | 1a7afb4 | 2007-10-19 21:39:25 +0000 | [diff] [blame] | 694 | datalen = DEFDATALEN; |
Mark Whitley | 59ab025 | 2001-01-23 22:30:04 +0000 | [diff] [blame] | 695 | |
Denis Vlasenko | e935602 | 2007-01-29 18:03:54 +0000 | [diff] [blame] | 696 | /* exactly one argument needed, -v and -q don't mix */ |
Denis Vlasenko | 581930c | 2007-01-24 23:55:34 +0000 | [diff] [blame] | 697 | opt_complementary = "=1:q--v:v--q"; |
Denis Vlasenko | fe7cd64 | 2007-08-18 15:32:12 +0000 | [diff] [blame] | 698 | getopt32(argv, OPT_STRING, &opt_c, &opt_s, &opt_I); |
Denis Vlasenko | 1a7afb4 | 2007-10-19 21:39:25 +0000 | [diff] [blame] | 699 | if (option_mask32 & OPT_c) |
| 700 | pingcount = xatoul(opt_c); // -c |
| 701 | if (option_mask32 & OPT_s) |
| 702 | datalen = xatou16(opt_s); // -s |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 703 | if (option_mask32 & OPT_I) { // -I |
| 704 | if_index = if_nametoindex(opt_I); |
Denis Vlasenko | 9ca26d3 | 2007-02-09 17:32:16 +0000 | [diff] [blame] | 705 | if (!if_index) { |
| 706 | /* TODO: I'm not sure it takes IPv6 unless in [XX:XX..] format */ |
Denis Vlasenko | 9ca26d3 | 2007-02-09 17:32:16 +0000 | [diff] [blame] | 707 | source_lsa = xdotted2sockaddr(opt_I, 0); |
Denis Vlasenko | 1a7afb4 | 2007-10-19 21:39:25 +0000 | [diff] [blame] | 708 | opt_I = NULL; /* don't try to bind to device later */ |
Denis Vlasenko | 9ca26d3 | 2007-02-09 17:32:16 +0000 | [diff] [blame] | 709 | } |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 710 | } |
Denis Vlasenko | 1c9ad62 | 2007-05-27 00:53:41 +0000 | [diff] [blame] | 711 | myid = (uint16_t) getpid(); |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 712 | hostname = argv[optind]; |
| 713 | #if ENABLE_PING6 |
| 714 | if (option_mask32 & OPT_IPV4) |
| 715 | af = AF_INET; |
| 716 | if (option_mask32 & OPT_IPV6) |
| 717 | af = AF_INET6; |
Denis Vlasenko | 42823d5 | 2007-02-04 02:39:08 +0000 | [diff] [blame] | 718 | lsa = xhost_and_af2sockaddr(hostname, 0, af); |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 719 | #else |
Denis Vlasenko | 42823d5 | 2007-02-04 02:39:08 +0000 | [diff] [blame] | 720 | lsa = xhost_and_af2sockaddr(hostname, 0, AF_INET); |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 721 | #endif |
Denis Vlasenko | 9ca26d3 | 2007-02-09 17:32:16 +0000 | [diff] [blame] | 722 | |
| 723 | if (source_lsa && source_lsa->sa.sa_family != lsa->sa.sa_family) |
| 724 | /* leaking it here... */ |
| 725 | source_lsa = NULL; |
| 726 | |
Denis Vlasenko | a27a11b | 2007-08-18 14:16:39 +0000 | [diff] [blame] | 727 | dotted = xmalloc_sockaddr2dotted_noport(&lsa->sa); |
Denis Vlasenko | 9ca26d3 | 2007-02-09 17:32:16 +0000 | [diff] [blame] | 728 | ping(lsa); |
Denis Vlasenko | aeb4bdd | 2007-01-25 00:00:02 +0000 | [diff] [blame] | 729 | pingstats(0); |
Eric Andersen | e90e741 | 2002-06-06 11:47:00 +0000 | [diff] [blame] | 730 | return EXIT_SUCCESS; |
Eric Andersen | 485b955 | 1999-12-07 23:14:59 +0000 | [diff] [blame] | 731 | } |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 732 | #endif /* FEATURE_FANCY_PING */ |
| 733 | |
| 734 | |
| 735 | #if ENABLE_PING6 |
Denis Vlasenko | 9b49a5e | 2007-10-11 10:05:36 +0000 | [diff] [blame] | 736 | int ping6_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 737 | int ping6_main(int argc, char **argv) |
| 738 | { |
Denis Vlasenko | 89ef65f | 2007-01-29 23:43:18 +0000 | [diff] [blame] | 739 | argv[0] = (char*)"-6"; |
Denis Vlasenko | b9a279b | 2007-01-24 23:53:22 +0000 | [diff] [blame] | 740 | return ping_main(argc + 1, argv - 1); |
| 741 | } |
| 742 | #endif |
| 743 | |
| 744 | /* from ping6.c: |
| 745 | * Copyright (c) 1989 The Regents of the University of California. |
| 746 | * All rights reserved. |
| 747 | * |
| 748 | * This code is derived from software contributed to Berkeley by |
| 749 | * Mike Muuss. |
| 750 | * |
| 751 | * Redistribution and use in source and binary forms, with or without |
| 752 | * modification, are permitted provided that the following conditions |
| 753 | * are met: |
| 754 | * 1. Redistributions of source code must retain the above copyright |
| 755 | * notice, this list of conditions and the following disclaimer. |
| 756 | * 2. Redistributions in binary form must reproduce the above copyright |
| 757 | * notice, this list of conditions and the following disclaimer in the |
| 758 | * documentation and/or other materials provided with the distribution. |
| 759 | * |
| 760 | * 3. <BSD Advertising Clause omitted per the July 22, 1999 licensing change |
| 761 | * ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change> |
| 762 | * |
| 763 | * 4. Neither the name of the University nor the names of its contributors |
| 764 | * may be used to endorse or promote products derived from this software |
| 765 | * without specific prior written permission. |
| 766 | * |
| 767 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
| 768 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 769 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 770 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
| 771 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| 772 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| 773 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 774 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| 775 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| 776 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 777 | * SUCH DAMAGE. |
| 778 | */ |