busybox/networking/ping.c

/* vi: set sw=4 ts=4: */
/*
 * $Id: ping.c,v 1.1 2007-09-01 22:43:53 niro Exp $
 * Mini ping implementation for busybox
 *
 * Copyright (C) 1999 by Randolph Chung <tausq@debian.org>
 *
 * Adapted from the ping in netkit-base 0.10:
 * Copyright (c) 1989 The Regents of the University of California.
 * Derived from software contributed to Berkeley by Mike Muuss.
 *
 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
 */

#include <netinet/ip_icmp.h>
#include "busybox.h"

enum {
	DEFDATALEN = 56,
	MAXIPLEN = 60,
	MAXICMPLEN = 76,
	MAXPACKET = 65468,
	MAX_DUP_CHK = (8 * 128),
	MAXWAIT = 10,
	PINGINTERVAL = 1		/* second */
};

static void ping(const char *host);

/* common routines */

static int in_cksum(unsigned short *buf, int sz)
{
	int nleft = sz;
	int sum = 0;
	unsigned short *w = buf;
	unsigned short ans = 0;

	while (nleft > 1) {
		sum += *w++;
		nleft -= 2;
	}

	if (nleft == 1) {
		*(unsigned char *) (&ans) = *(unsigned char *) w;
		sum += ans;
	}

	sum = (sum >> 16) + (sum & 0xFFFF);
	sum += (sum >> 16);
	ans = ~sum;
	return ans;
}

#ifndef CONFIG_FEATURE_FANCY_PING

/* simple version */

static char *hostname;

static void noresp(int ign)
{
	printf("No response from %s\n", hostname);
	exit(EXIT_FAILURE);
}

static void ping(const char *host)
{
	struct hostent *h;
	struct sockaddr_in pingaddr;
	struct icmp *pkt;
	int pingsock, c;
	char packet[DEFDATALEN + MAXIPLEN + MAXICMPLEN];

	pingsock = create_icmp_socket();

	memset(&pingaddr, 0, sizeof(struct sockaddr_in));

	pingaddr.sin_family = AF_INET;
	h = xgethostbyname(host);
	memcpy(&pingaddr.sin_addr, h->h_addr, sizeof(pingaddr.sin_addr));
	hostname = h->h_name;

	pkt = (struct icmp *) packet;
	memset(pkt, 0, sizeof(packet));
	pkt->icmp_type = ICMP_ECHO;
	pkt->icmp_cksum = in_cksum((unsigned short *) pkt, sizeof(packet));

	c = sendto(pingsock, packet, DEFDATALEN + ICMP_MINLEN, 0,
			   (struct sockaddr *) &pingaddr, sizeof(struct sockaddr_in));

	if (c < 0) {
		if (ENABLE_FEATURE_CLEAN_UP) close(pingsock);
		bb_perror_msg_and_die("sendto");
	}

	signal(SIGALRM, noresp);
	alarm(5);					/* give the host 5000ms to respond */
	/* listen for replies */
	while (1) {
		struct sockaddr_in from;
		socklen_t fromlen = sizeof(from);

		c = recvfrom(pingsock, packet, sizeof(packet), 0,
				(struct sockaddr *) &from, &fromlen);
		if (c < 0) {
			if (errno != EINTR)
				bb_perror_msg("recvfrom");
			continue;
		}
		if (c >= 76) {			/* ip + icmp */
			struct iphdr *iphdr = (struct iphdr *) packet;

			pkt = (struct icmp *) (packet + (iphdr->ihl << 2));	/* skip ip hdr */
			if (pkt->icmp_type == ICMP_ECHOREPLY)
				break;
		}
	}
	if (ENABLE_FEATURE_CLEAN_UP) close(pingsock);
	printf("%s is alive!\n", hostname);
}

int ping_main(int argc, char **argv)
{
	argc--;
	argv++;
	if (argc < 1)
		bb_show_usage();
	ping(*argv);
	return EXIT_SUCCESS;
}

#else /* ! CONFIG_FEATURE_FANCY_PING */

/* full(er) version */

#define OPT_STRING "qc:s:I:"
enum {
	OPT_QUIET = 1 << 0,
};

static struct sockaddr_in pingaddr;
static struct sockaddr_in sourceaddr;
static int pingsock = -1;
static unsigned datalen; /* intentionally uninitialized to work around gcc bug */

static unsigned long ntransmitted, nreceived, nrepeats, pingcount;
static int myid;
static unsigned long tmin = ULONG_MAX, tmax, tsum;
static char rcvd_tbl[MAX_DUP_CHK / 8];

static struct hostent *hostent;

static void sendping(int);
static void pingstats(int);
static void unpack(char *, int, struct sockaddr_in *);

#define	A(bit)		rcvd_tbl[(bit)>>3]	/* identify byte in array */
#define	B(bit)		(1 << ((bit) & 0x07))	/* identify bit in byte */
#define	SET(bit)	(A(bit) |= B(bit))
#define	CLR(bit)	(A(bit) &= (~B(bit)))
#define	TST(bit)	(A(bit) & B(bit))

/**************************************************************************/

static void pingstats(int junk)
{
	int status;

	signal(SIGINT, SIG_IGN);

	printf("\n--- %s ping statistics ---\n", hostent->h_name);
	printf("%lu packets transmitted, ", ntransmitted);
	printf("%lu packets received, ", nreceived);
	if (nrepeats)
		printf("%lu duplicates, ", nrepeats);
	if (ntransmitted)
		printf("%lu%% packet loss\n",
			   (ntransmitted - nreceived) * 100 / ntransmitted);
	if (nreceived)
		printf("round-trip min/avg/max = %lu.%lu/%lu.%lu/%lu.%lu ms\n",
			   tmin / 10, tmin % 10,
			   (tsum / (nreceived + nrepeats)) / 10,
			   (tsum / (nreceived + nrepeats)) % 10, tmax / 10, tmax % 10);
	if (nreceived != 0)
		status = EXIT_SUCCESS;
	else
		status = EXIT_FAILURE;
	exit(status);
}

static void sendping(int junk)
{
	struct icmp *pkt;
	int i;
	char packet[datalen + ICMP_MINLEN];

	pkt = (struct icmp *) packet;

	pkt->icmp_type = ICMP_ECHO;
	pkt->icmp_code = 0;
	pkt->icmp_cksum = 0;
	pkt->icmp_seq = htons(ntransmitted); /* don't ++ here, it can be a macro */
	pkt->icmp_id = myid;
	CLR(ntohs(pkt->icmp_seq) % MAX_DUP_CHK);
	ntransmitted++;

	gettimeofday((struct timeval *) &pkt->icmp_dun, NULL);
	pkt->icmp_cksum = in_cksum((unsigned short *) pkt, sizeof(packet));

	i = sendto(pingsock, packet, sizeof(packet), 0,
			   (struct sockaddr *) &pingaddr, sizeof(struct sockaddr_in));

	if (i < 0)
		bb_perror_msg_and_die("sendto");
	if ((size_t)i != sizeof(packet))
		bb_error_msg_and_die("ping wrote %d chars; %d expected", i,
			   (int)sizeof(packet));

	signal(SIGALRM, sendping);
	if (pingcount == 0 || ntransmitted < pingcount) {	/* schedule next in 1s */
		alarm(PINGINTERVAL);
	} else {					/* done, wait for the last ping to come back */
		/* todo, don't necessarily need to wait so long... */
		signal(SIGALRM, pingstats);
		alarm(MAXWAIT);
	}
}

static char *icmp_type_name(int id)
{
	switch (id) {
	case ICMP_ECHOREPLY:		return "Echo Reply";
	case ICMP_DEST_UNREACH:		return "Destination Unreachable";
	case ICMP_SOURCE_QUENCH:	return "Source Quench";
	case ICMP_REDIRECT:			return "Redirect (change route)";
	case ICMP_ECHO:				return "Echo Request";
	case ICMP_TIME_EXCEEDED:	return "Time Exceeded";
	case ICMP_PARAMETERPROB:	return "Parameter Problem";
	case ICMP_TIMESTAMP:		return "Timestamp Request";
	case ICMP_TIMESTAMPREPLY:	return "Timestamp Reply";
	case ICMP_INFO_REQUEST:		return "Information Request";
	case ICMP_INFO_REPLY:		return "Information Reply";
	case ICMP_ADDRESS:			return "Address Mask Request";
	case ICMP_ADDRESSREPLY:		return "Address Mask Reply";
	default:					return "unknown ICMP type";
	}
}

static void unpack(char *buf, int sz, struct sockaddr_in *from)
{
	struct icmp *icmppkt;
	struct iphdr *iphdr;
	struct timeval tv, *tp;
	int hlen, dupflag;
	unsigned long triptime;

	gettimeofday(&tv, NULL);

	/* discard if too short */
	if (sz < (datalen + ICMP_MINLEN))
		return;

	/* check IP header */
	iphdr = (struct iphdr *) buf;
	hlen = iphdr->ihl << 2;
	sz -= hlen;
	icmppkt = (struct icmp *) (buf + hlen);
	if (icmppkt->icmp_id != myid)
		return;				/* not our ping */

	if (icmppkt->icmp_type == ICMP_ECHOREPLY) {
		u_int16_t recv_seq = ntohs(icmppkt->icmp_seq);
		++nreceived;
		tp = (struct timeval *) icmppkt->icmp_data;

		if ((tv.tv_usec -= tp->tv_usec) < 0) {
			--tv.tv_sec;
			tv.tv_usec += 1000000;
		}
		tv.tv_sec -= tp->tv_sec;

		triptime = tv.tv_sec * 10000 + (tv.tv_usec / 100);
		tsum += triptime;
		if (triptime < tmin)
			tmin = triptime;
		if (triptime > tmax)
			tmax = triptime;

		if (TST(recv_seq % MAX_DUP_CHK)) {
			++nrepeats;
			--nreceived;
			dupflag = 1;
		} else {
			SET(recv_seq % MAX_DUP_CHK);
			dupflag = 0;
		}

		if (option_mask32 & OPT_QUIET)
			return;

		printf("%d bytes from %s: icmp_seq=%u", sz,
			   inet_ntoa(*(struct in_addr *) &from->sin_addr.s_addr),
			   recv_seq);
		printf(" ttl=%d", iphdr->ttl);
		printf(" time=%lu.%lu ms", triptime / 10, triptime % 10);
		if (dupflag)
			printf(" (DUP!)");
		puts("");
	} else
		if (icmppkt->icmp_type != ICMP_ECHO)
			bb_error_msg("warning: got ICMP %d (%s)",
					icmppkt->icmp_type,
					icmp_type_name(icmppkt->icmp_type));
	fflush(stdout);
}

static void ping(const char *host)
{
	char packet[datalen + MAXIPLEN + MAXICMPLEN];
	int sockopt;

	pingsock = create_icmp_socket();

	if (sourceaddr.sin_addr.s_addr) {
		xbind(pingsock, (struct sockaddr*)&sourceaddr, sizeof(sourceaddr));
	}

	memset(&pingaddr, 0, sizeof(struct sockaddr_in));

	pingaddr.sin_family = AF_INET;
	hostent = xgethostbyname(host);
	if (hostent->h_addrtype != AF_INET)
		bb_error_msg_and_die("unknown address type; only AF_INET is currently supported");

	memcpy(&pingaddr.sin_addr, hostent->h_addr, sizeof(pingaddr.sin_addr));

	/* enable broadcast pings */
	setsockopt_broadcast(pingsock);

	/* set recv buf for broadcast pings */
	sockopt = 48 * 1024;
	setsockopt(pingsock, SOL_SOCKET, SO_RCVBUF, (char *) &sockopt,
			   sizeof(sockopt));

	printf("PING %s (%s)",
			hostent->h_name,
			inet_ntoa(*(struct in_addr *) &pingaddr.sin_addr.s_addr));
	if (sourceaddr.sin_addr.s_addr) {
		printf(" from %s",
			inet_ntoa(*(struct in_addr *) &sourceaddr.sin_addr.s_addr));
	}
	printf(": %d data bytes\n", datalen);

	signal(SIGINT, pingstats);

	/* start the ping's going ... */
	sendping(0);

	/* listen for replies */
	while (1) {
		struct sockaddr_in from;
		socklen_t fromlen = (socklen_t) sizeof(from);
		int c;

		c = recvfrom(pingsock, packet, sizeof(packet), 0,
				(struct sockaddr *) &from, &fromlen);
		if (c < 0) {
			if (errno != EINTR)
				bb_perror_msg("recvfrom");
			continue;
		}
		unpack(packet, c, &from);
		if (pingcount > 0 && nreceived >= pingcount)
			break;
	}
	pingstats(0);
}

/* TODO: consolidate ether-wake.c, dnsd.c, ifupdown.c, nslookup.c
 * versions of below thing. BTW we have far too many "%u.%u.%u.%u" too...
*/
static int parse_nipquad(const char *str, struct sockaddr_in* addr)
{
	char dummy;
	unsigned i1, i2, i3, i4;
	if (sscanf(str, "%u.%u.%u.%u%c",
			   &i1, &i2, &i3, &i4, &dummy) == 4
	&& ( (i1|i2|i3|i4) <= 0xff )
	) {
		uint8_t* ptr = (uint8_t*)&addr->sin_addr;
		ptr[0] = i1;
		ptr[1] = i2;
		ptr[2] = i3;
		ptr[3] = i4;
		return 0;
	}
	return 1; /* error */
}

int ping_main(int argc, char **argv)
{
	char *opt_c, *opt_s, *opt_I;

	datalen = DEFDATALEN; /* initialized here rather than in global scope to work around gcc bug */

	/* exactly one argument needed */
	opt_complementary = "=1";
	getopt32(argc, argv, OPT_STRING, &opt_c, &opt_s, &opt_I);
	if (option_mask32 & 2) pingcount = xatoul(opt_c); // -c
	if (option_mask32 & 4) datalen = xatou16(opt_s); // -s
	if (option_mask32 & 8) { // -I
/* TODO: ping6 accepts iface too:
		if_index = if_nametoindex(*argv);
		if (!if_index) ...
make it true for ping. */
		if (parse_nipquad(opt_I, &sourceaddr))
			bb_show_usage();
	}

	myid = (int16_t) getpid();
	ping(argv[optind]);
	return EXIT_SUCCESS;
}
#endif /* ! CONFIG_FEATURE_FANCY_PING */
1	niro	532	/* vi: set sw=4 ts=4: */
2			/*
3			* $Id: ping.c,v 1.1 2007-09-01 22:43:53 niro Exp $
4			* Mini ping implementation for busybox
5			*
6			* Copyright (C) 1999 by Randolph Chung <tausq@debian.org>
7			*
8			* Adapted from the ping in netkit-base 0.10:
9			* Copyright (c) 1989 The Regents of the University of California.
10			* Derived from software contributed to Berkeley by Mike Muuss.
11			*
12			* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
13			*/
14
15			#include <netinet/ip_icmp.h>
16			#include "busybox.h"
17
18			enum {
19			DEFDATALEN = 56,
20			MAXIPLEN = 60,
21			MAXICMPLEN = 76,
22			MAXPACKET = 65468,
23			MAX_DUP_CHK = (8 * 128),
24			MAXWAIT = 10,
25			PINGINTERVAL = 1 /* second */
26			};
27
28			static void ping(const char *host);
29
30			/* common routines */
31
32			static int in_cksum(unsigned short *buf, int sz)
33			{
34			int nleft = sz;
35			int sum = 0;
36			unsigned short *w = buf;
37			unsigned short ans = 0;
38
39			while (nleft > 1) {
40			sum += *w++;
41			nleft -= 2;
42			}
43
44			if (nleft == 1) {
45			(unsigned char ) (&ans) = (unsigned char ) w;
46			sum += ans;
47			}
48
49			sum = (sum >> 16) + (sum & 0xFFFF);
50			sum += (sum >> 16);
51			ans = ~sum;
52			return ans;
53			}
54
55			#ifndef CONFIG_FEATURE_FANCY_PING
56
57			/* simple version */
58
59			static char *hostname;
60
61			static void noresp(int ign)
62			{
63			printf("No response from %s\n", hostname);
64			exit(EXIT_FAILURE);
65			}
66
67			static void ping(const char *host)
68			{
69			struct hostent *h;
70			struct sockaddr_in pingaddr;
71			struct icmp *pkt;
72			int pingsock, c;
73			char packet[DEFDATALEN + MAXIPLEN + MAXICMPLEN];
74
75			pingsock = create_icmp_socket();
76
77			memset(&pingaddr, 0, sizeof(struct sockaddr_in));
78
79			pingaddr.sin_family = AF_INET;
80			h = xgethostbyname(host);
81			memcpy(&pingaddr.sin_addr, h->h_addr, sizeof(pingaddr.sin_addr));
82			hostname = h->h_name;
83
84			pkt = (struct icmp *) packet;
85			memset(pkt, 0, sizeof(packet));
86			pkt->icmp_type = ICMP_ECHO;
87			pkt->icmp_cksum = in_cksum((unsigned short *) pkt, sizeof(packet));
88
89			c = sendto(pingsock, packet, DEFDATALEN + ICMP_MINLEN, 0,
90			(struct sockaddr *) &pingaddr, sizeof(struct sockaddr_in));
91
92			if (c < 0) {
93			if (ENABLE_FEATURE_CLEAN_UP) close(pingsock);
94			bb_perror_msg_and_die("sendto");
95			}
96
97			signal(SIGALRM, noresp);
98			alarm(5); /* give the host 5000ms to respond */
99			/* listen for replies */
100			while (1) {
101			struct sockaddr_in from;
102			socklen_t fromlen = sizeof(from);
103
104			c = recvfrom(pingsock, packet, sizeof(packet), 0,
105			(struct sockaddr *) &from, &fromlen);
106			if (c < 0) {
107			if (errno != EINTR)
108			bb_perror_msg("recvfrom");
109			continue;
110			}
111			if (c >= 76) { /* ip + icmp */
112			struct iphdr iphdr = (struct iphdr ) packet;
113
114			pkt = (struct icmp ) (packet + (iphdr->ihl << 2)); / skip ip hdr */
115			if (pkt->icmp_type == ICMP_ECHOREPLY)
116			break;
117			}
118			}
119			if (ENABLE_FEATURE_CLEAN_UP) close(pingsock);
120			printf("%s is alive!\n", hostname);
121			}
122
123			int ping_main(int argc, char **argv)
124			{
125			argc--;
126			argv++;
127			if (argc < 1)
128			bb_show_usage();
129			ping(*argv);
130			return EXIT_SUCCESS;
131			}
132
133			#else /* ! CONFIG_FEATURE_FANCY_PING */
134
135			/* full(er) version */
136
137			#define OPT_STRING "qc:s:I:"
138			enum {
139			OPT_QUIET = 1 << 0,
140			};
141
142			static struct sockaddr_in pingaddr;
143			static struct sockaddr_in sourceaddr;
144			static int pingsock = -1;
145			static unsigned datalen; /* intentionally uninitialized to work around gcc bug */
146
147			static unsigned long ntransmitted, nreceived, nrepeats, pingcount;
148			static int myid;
149			static unsigned long tmin = ULONG_MAX, tmax, tsum;
150			static char rcvd_tbl[MAX_DUP_CHK / 8];
151
152			static struct hostent *hostent;
153
154			static void sendping(int);
155			static void pingstats(int);
156			static void unpack(char , int, struct sockaddr_in );
157
158			#define A(bit) rcvd_tbl[(bit)>>3] /* identify byte in array */
159			#define B(bit) (1 << ((bit) & 0x07)) /* identify bit in byte */
160			#define SET(bit) (A(bit) \|= B(bit))
161			#define CLR(bit) (A(bit) &= (~B(bit)))
162			#define TST(bit) (A(bit) & B(bit))
163
164			/**************************************************************************/
165
166			static void pingstats(int junk)
167			{
168			int status;
169
170			signal(SIGINT, SIG_IGN);
171
172			printf("\n--- %s ping statistics ---\n", hostent->h_name);
173			printf("%lu packets transmitted, ", ntransmitted);
174			printf("%lu packets received, ", nreceived);
175			if (nrepeats)
176			printf("%lu duplicates, ", nrepeats);
177			if (ntransmitted)
178			printf("%lu%% packet loss\n",
179			(ntransmitted - nreceived) * 100 / ntransmitted);
180			if (nreceived)
181			printf("round-trip min/avg/max = %lu.%lu/%lu.%lu/%lu.%lu ms\n",
182			tmin / 10, tmin % 10,
183			(tsum / (nreceived + nrepeats)) / 10,
184			(tsum / (nreceived + nrepeats)) % 10, tmax / 10, tmax % 10);
185			if (nreceived != 0)
186			status = EXIT_SUCCESS;
187			else
188			status = EXIT_FAILURE;
189			exit(status);
190			}
191
192			static void sendping(int junk)
193			{
194			struct icmp *pkt;
195			int i;
196			char packet[datalen + ICMP_MINLEN];
197
198			pkt = (struct icmp *) packet;
199
200			pkt->icmp_type = ICMP_ECHO;
201			pkt->icmp_code = 0;
202			pkt->icmp_cksum = 0;
203			pkt->icmp_seq = htons(ntransmitted); /* don't ++ here, it can be a macro */
204			pkt->icmp_id = myid;
205			CLR(ntohs(pkt->icmp_seq) % MAX_DUP_CHK);
206			ntransmitted++;
207
208			gettimeofday((struct timeval *) &pkt->icmp_dun, NULL);
209			pkt->icmp_cksum = in_cksum((unsigned short *) pkt, sizeof(packet));
210
211			i = sendto(pingsock, packet, sizeof(packet), 0,
212			(struct sockaddr *) &pingaddr, sizeof(struct sockaddr_in));
213
214			if (i < 0)
215			bb_perror_msg_and_die("sendto");
216			if ((size_t)i != sizeof(packet))
217			bb_error_msg_and_die("ping wrote %d chars; %d expected", i,
218			(int)sizeof(packet));
219
220			signal(SIGALRM, sendping);
221			if (pingcount == 0 \|\| ntransmitted < pingcount) { /* schedule next in 1s */
222			alarm(PINGINTERVAL);
223			} else { /* done, wait for the last ping to come back */
224			/* todo, don't necessarily need to wait so long... */
225			signal(SIGALRM, pingstats);
226			alarm(MAXWAIT);
227			}
228			}
229
230			static char *icmp_type_name(int id)
231			{
232			switch (id) {
233			case ICMP_ECHOREPLY: return "Echo Reply";
234			case ICMP_DEST_UNREACH: return "Destination Unreachable";
235			case ICMP_SOURCE_QUENCH: return "Source Quench";
236			case ICMP_REDIRECT: return "Redirect (change route)";
237			case ICMP_ECHO: return "Echo Request";
238			case ICMP_TIME_EXCEEDED: return "Time Exceeded";
239			case ICMP_PARAMETERPROB: return "Parameter Problem";
240			case ICMP_TIMESTAMP: return "Timestamp Request";
241			case ICMP_TIMESTAMPREPLY: return "Timestamp Reply";
242			case ICMP_INFO_REQUEST: return "Information Request";
243			case ICMP_INFO_REPLY: return "Information Reply";
244			case ICMP_ADDRESS: return "Address Mask Request";
245			case ICMP_ADDRESSREPLY: return "Address Mask Reply";
246			default: return "unknown ICMP type";
247			}
248			}
249
250			static void unpack(char buf, int sz, struct sockaddr_in from)
251			{
252			struct icmp *icmppkt;
253			struct iphdr *iphdr;
254			struct timeval tv, *tp;
255			int hlen, dupflag;
256			unsigned long triptime;
257
258			gettimeofday(&tv, NULL);
259
260			/* discard if too short */
261			if (sz < (datalen + ICMP_MINLEN))
262			return;
263
264			/* check IP header */
265			iphdr = (struct iphdr *) buf;
266			hlen = iphdr->ihl << 2;
267			sz -= hlen;
268			icmppkt = (struct icmp *) (buf + hlen);
269			if (icmppkt->icmp_id != myid)
270			return; /* not our ping */
271
272			if (icmppkt->icmp_type == ICMP_ECHOREPLY) {
273			u_int16_t recv_seq = ntohs(icmppkt->icmp_seq);
274			++nreceived;
275			tp = (struct timeval *) icmppkt->icmp_data;
276
277			if ((tv.tv_usec -= tp->tv_usec) < 0) {
278			--tv.tv_sec;
279			tv.tv_usec += 1000000;
280			}
281			tv.tv_sec -= tp->tv_sec;
282
283			triptime = tv.tv_sec * 10000 + (tv.tv_usec / 100);
284			tsum += triptime;
285			if (triptime < tmin)
286			tmin = triptime;
287			if (triptime > tmax)
288			tmax = triptime;
289
290			if (TST(recv_seq % MAX_DUP_CHK)) {
291			++nrepeats;
292			--nreceived;
293			dupflag = 1;
294			} else {
295			SET(recv_seq % MAX_DUP_CHK);
296			dupflag = 0;
297			}
298
299			if (option_mask32 & OPT_QUIET)
300			return;
301
302			printf("%d bytes from %s: icmp_seq=%u", sz,
303			inet_ntoa((struct in_addr ) &from->sin_addr.s_addr),
304			recv_seq);
305			printf(" ttl=%d", iphdr->ttl);
306			printf(" time=%lu.%lu ms", triptime / 10, triptime % 10);
307			if (dupflag)
308			printf(" (DUP!)");
309			puts("");
310			} else
311			if (icmppkt->icmp_type != ICMP_ECHO)
312			bb_error_msg("warning: got ICMP %d (%s)",
313			icmppkt->icmp_type,
314			icmp_type_name(icmppkt->icmp_type));
315			fflush(stdout);
316			}
317
318			static void ping(const char *host)
319			{
320			char packet[datalen + MAXIPLEN + MAXICMPLEN];
321			int sockopt;
322
323			pingsock = create_icmp_socket();
324
325			if (sourceaddr.sin_addr.s_addr) {
326			xbind(pingsock, (struct sockaddr*)&sourceaddr, sizeof(sourceaddr));
327			}
328
329			memset(&pingaddr, 0, sizeof(struct sockaddr_in));
330
331			pingaddr.sin_family = AF_INET;
332			hostent = xgethostbyname(host);
333			if (hostent->h_addrtype != AF_INET)
334			bb_error_msg_and_die("unknown address type; only AF_INET is currently supported");
335
336			memcpy(&pingaddr.sin_addr, hostent->h_addr, sizeof(pingaddr.sin_addr));
337
338			/* enable broadcast pings */
339			setsockopt_broadcast(pingsock);
340
341			/* set recv buf for broadcast pings */
342			sockopt = 48 * 1024;
343			setsockopt(pingsock, SOL_SOCKET, SO_RCVBUF, (char *) &sockopt,
344			sizeof(sockopt));
345
346			printf("PING %s (%s)",
347			hostent->h_name,
348			inet_ntoa((struct in_addr ) &pingaddr.sin_addr.s_addr));
349			if (sourceaddr.sin_addr.s_addr) {
350			printf(" from %s",
351			inet_ntoa((struct in_addr ) &sourceaddr.sin_addr.s_addr));
352			}
353			printf(": %d data bytes\n", datalen);
354
355			signal(SIGINT, pingstats);
356
357			/* start the ping's going ... */
358			sendping(0);
359
360			/* listen for replies */
361			while (1) {
362			struct sockaddr_in from;
363			socklen_t fromlen = (socklen_t) sizeof(from);
364			int c;
365
366			c = recvfrom(pingsock, packet, sizeof(packet), 0,
367			(struct sockaddr *) &from, &fromlen);
368			if (c < 0) {
369			if (errno != EINTR)
370			bb_perror_msg("recvfrom");
371			continue;
372			}
373			unpack(packet, c, &from);
374			if (pingcount > 0 && nreceived >= pingcount)
375			break;
376			}
377			pingstats(0);
378			}
379
380			/* TODO: consolidate ether-wake.c, dnsd.c, ifupdown.c, nslookup.c
381			* versions of below thing. BTW we have far too many "%u.%u.%u.%u" too...
382			*/
383			static int parse_nipquad(const char str, struct sockaddr_in addr)
384			{
385			char dummy;
386			unsigned i1, i2, i3, i4;
387			if (sscanf(str, "%u.%u.%u.%u%c",
388			&i1, &i2, &i3, &i4, &dummy) == 4
389			&& ( (i1\|i2\|i3\|i4) <= 0xff )
390			) {
391			uint8_t* ptr = (uint8_t*)&addr->sin_addr;
392			ptr[0] = i1;
393			ptr[1] = i2;
394			ptr[2] = i3;
395			ptr[3] = i4;
396			return 0;
397			}
398			return 1; /* error */
399			}
400
401			int ping_main(int argc, char **argv)
402			{
403			char opt_c, opt_s, *opt_I;
404
405			datalen = DEFDATALEN; /* initialized here rather than in global scope to work around gcc bug */
406
407			/* exactly one argument needed */
408			opt_complementary = "=1";
409			getopt32(argc, argv, OPT_STRING, &opt_c, &opt_s, &opt_I);
410			if (option_mask32 & 2) pingcount = xatoul(opt_c); // -c
411			if (option_mask32 & 4) datalen = xatou16(opt_s); // -s
412			if (option_mask32 & 8) { // -I
413			/* TODO: ping6 accepts iface too:
414			if_index = if_nametoindex(*argv);
415			if (!if_index) ...
416			make it true for ping. */
417			if (parse_nipquad(opt_I, &sourceaddr))
418			bb_show_usage();
419			}
420
421			myid = (int16_t) getpid();
422			ping(argv[optind]);
423			return EXIT_SUCCESS;
424			}
425			#endif /* ! CONFIG_FEATURE_FANCY_PING */