source: MondoRescue/branches/3.0/mindi-busybox/networking/ping.c@ 2899

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