Context Navigation

source: rtems/cpukit/libmisc/shell/main_ping.c @ 68e1ccc4

5

Last change on this file since 68e1ccc4 was 6cdaa85, checked in by Sebastian Huber <sebastian.huber@…>, on 10/04/18 at 18:16:45

shell: Use #include "..." for local header files

Update #3375.

Property mode set to 100644

File size: 51.1 KB

Line
1	#ifdef __rtems__
2	#define __need_getopt_newlib
3	#include <getopt.h>
4	#endif
5	/*
6	* Copyright (c) 1989, 1993
7	* The Regents of the University of California. All rights reserved.
8	*
9	* This code is derived from software contributed to Berkeley by
10	* Mike Muuss.
11	*
12	* Redistribution and use in source and binary forms, with or without
13	* modification, are permitted provided that the following conditions
14	* are met:
15	* 1. Redistributions of source code must retain the above copyright
16	* notice, this list of conditions and the following disclaimer.
17	* 2. Redistributions in binary form must reproduce the above copyright
18	* notice, this list of conditions and the following disclaimer in the
19	* documentation and/or other materials provided with the distribution.
20	* 4. Neither the name of the University nor the names of its contributors
21	* may be used to endorse or promote products derived from this software
22	* without specific prior written permission.
23	*
24	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34	* SUCH DAMAGE.
35	*/
36
37	#if !__rtems__
38	#ifndef lint
39	static const char copyright[] =
40	"@(#) Copyright (c) 1989, 1993\n\
41	The Regents of the University of California. All rights reserved.\n";
42	#endif /* not lint */
43
44	#ifndef lint
45	static char sccsid[] = "@(#)ping.c 8.1 (Berkeley) 6/5/93";
46	#endif /* not lint */
47	#endif
48	#include <sys/cdefs.h>
49	__FBSDID("$FreeBSD$");
50
51	/*
52	* P I N G . C
53	*
54	* Using the Internet Control Message Protocol (ICMP) "ECHO" facility,
55	* measure round-trip-delays and packet loss across network paths.
56	*
57	* Author -
58	* Mike Muuss
59	* U. S. Army Ballistic Research Laboratory
60	* December, 1983
61	*
62	* Status -
63	* Public Domain. Distribution Unlimited.
64	* Bugs -
65	* More statistics could always be gathered.
66	* This program has to run SUID to ROOT to access the ICMP socket.
67	*/
68
69	#include <sys/param.h> /* NB: we rely on this for <sys/types.h> */
70	#include <sys/socket.h>
71	#include <sys/sysctl.h>
72	#include <sys/time.h>
73	#include <sys/uio.h>
74
75	#include <netinet/in.h>
76	#include <netinet/in_systm.h>
77	#include <netinet/ip.h>
78	#include <netinet/ip_icmp.h>
79	#include <netinet/ip_var.h>
80	#include <arpa/inet.h>
81
82	#ifdef IPSEC
83	#include <netipsec/ipsec.h>
84	#endif /IPSEC/
85
86	#include <ctype.h>
87	//#include "err.h"
88	#include <errno.h>
89	#if !defined(__rtems__)
90	#include <math.h>
91	#endif
92	#include <netdb.h>
93	#include <signal.h>
94	#include <stdio.h>
95	#include <stdlib.h>
96	#include <string.h>
97	//#include <sysexits.h>
98	#include <unistd.h>
99
100	#include "err.h"
101	#include "sysexits.h"
102	#include <sys/select.h>
103	#ifdef __rtems__
104	#include <rtems/shell.h>
105	#endif /* __rtems__ */
106
107	#define INADDR_LEN ((int)sizeof(in_addr_t))
108	#define TIMEVAL_LEN ((int)sizeof(struct tv32))
109	#define MASK_LEN (ICMP_MASKLEN - ICMP_MINLEN)
110	#define TS_LEN (ICMP_TSLEN - ICMP_MINLEN)
111	#define DEFDATALEN 56 /* default data length */
112	#define FLOOD_BACKOFF 20000 /* usecs to back off if F_FLOOD mode */
113	/* runs out of buffer space */
114	#define MAXIPLEN (sizeof(struct ip) + MAX_IPOPTLEN)
115	#define MAXICMPLEN (ICMP_ADVLENMIN + MAX_IPOPTLEN)
116	#define MAXWAIT 10000 /* max ms to wait for response */
117	#define MAXALARM (60 * 60) /* max seconds for alarm timeout */
118	#define MAXTOS 255
119
120	#define A(bit) rcvd_tbl[(bit)>>3] /* identify byte in array */
121	#define B(bit) (1 << ((bit) & 0x07)) /* identify bit in byte */
122	#define SET(bit) (A(bit) \|= B(bit))
123	#define CLR(bit) (A(bit) &= (~B(bit)))
124	#define TST(bit) (A(bit) & B(bit))
125
126	struct tv32 {
127	int32_t tv32_sec;
128	int32_t tv32_usec;
129	};
130
131	/* various options */
132	#if !__rtems__
133	int options;
134	#endif
135	#define F_FLOOD 0x0001
136	#define F_INTERVAL 0x0002
137	#define F_NUMERIC 0x0004
138	#define F_PINGFILLED 0x0008
139	#define F_QUIET 0x0010
140	#define F_RROUTE 0x0020
141	#define F_SO_DEBUG 0x0040
142	#define F_SO_DONTROUTE 0x0080
143	#define F_VERBOSE 0x0100
144	#define F_QUIET2 0x0200
145	#define F_NOLOOP 0x0400
146	#define F_MTTL 0x0800
147	#define F_MIF 0x1000
148	#define F_AUDIBLE 0x2000
149	#ifdef IPSEC
150	#ifdef IPSEC_POLICY_IPSEC
151	#define F_POLICY 0x4000
152	#endif /IPSEC_POLICY_IPSEC/
153	#endif /IPSEC/
154	#define F_TTL 0x8000
155	#define F_MISSED 0x10000
156	#define F_ONCE 0x20000
157	#define F_HDRINCL 0x40000
158	#define F_MASK 0x80000
159	#define F_TIME 0x100000
160	#define F_SWEEP 0x200000
161	#define F_WAITTIME 0x400000
162
163	/*
164	* MAX_DUP_CHK is the number of bits in received table, i.e. the maximum
165	* number of received sequence numbers we can keep track of. Change 128
166	* to 8192 for complete accuracy...
167	*/
168	#define MAX_DUP_CHK (8 * 128)
169	#if !__rtems__
170	int mx_dup_ck = MAX_DUP_CHK;
171	char rcvd_tbl[MAX_DUP_CHK / 8];
172
173	struct sockaddr_in whereto; /* who to ping */
174	int datalen = DEFDATALEN;
175	int maxpayload;
176	int s; /* socket file descriptor */
177	u_char outpackhdr[IP_MAXPACKET], *outpack;
178	#endif
179	char BBELL = '\a'; /* characters written for MISSED and AUDIBLE */
180	char BSPACE = '\b'; /* characters written for flood */
181	char DOT = '.';
182	#if !__rtems__
183	char *hostname;
184	char *shostname;
185	int ident; /* process id to identify our packets */
186	int uid; /* cached uid for micro-optimization */
187	u_char icmp_type = ICMP_ECHO;
188	u_char icmp_type_rsp = ICMP_ECHOREPLY;
189	int phdr_len = 0;
190	int send_len;
191
192	/* counters */
193	long nmissedmax; /* max value of ntransmitted - nreceived - 1 */
194	long npackets; /* max packets to transmit */
195	long nreceived; /* # of packets we got back */
196	long nrepeats; /* number of duplicates */
197	long ntransmitted; /* sequence # for outbound packets = #sent */
198	long snpackets; /* max packets to transmit in one sweep */
199	long snreceived; /* # of packets we got back in this sweep */
200	long sntransmitted; /* # of packets we sent in this sweep */
201	int sweepmax; /* max value of payload in sweep */
202	int sweepmin = 0; /* start value of payload in sweep */
203	int sweepincr = 1; /* payload increment in sweep */
204	int interval = 1000; /* interval between packets, ms */
205	int waittime = MAXWAIT; /* timeout for each packet */
206	long nrcvtimeout = 0; /* # of packets we got back after waittime */
207
208	/* timing */
209	int timing; /* flag to do timing */
210	double tmin = 999999999.0; /* minimum round trip time */
211	double tmax = 0.0; /* maximum round trip time */
212	double tsum = 0.0; /* sum of all times, for doing average */
213	double tsumsq = 0.0; /* sum of all times squared, for std. dev. */
214
215	volatile sig_atomic_t finish_up; /* nonzero if we've been told to finish up */
216	volatile sig_atomic_t siginfo_p;
217
218	static void fill(char , char );
219	static u_short in_cksum(u_short *, int);
220	static void check_status(void);
221	static void finish(void) __dead2;
222	static void pinger(void);
223	static char *pr_addr(struct in_addr);
224	static char *pr_ntime(n_time);
225	static void pr_icmph(struct icmp *);
226	static void pr_iph(struct ip *);
227	static void pr_pack(char , int, struct sockaddr_in , struct timeval *);
228	static void pr_retip(struct ip *);
229	static void status(int);
230	static void stopit(int);
231	static void tvsub(struct timeval , struct timeval );
232	static void usage(void) __dead2;
233	#endif
234
235	#if __rtems__
236	#define CMSG_SPACE(l) (_ALIGN(sizeof(struct cmsghdr)) + _ALIGN(l))
237	#define CMSG_LEN(l) (_ALIGN(sizeof(struct cmsghdr)) + (l))
238	typedef struct
239	{
240	int options;
241	int mx_dup_ck;
242	char rcvd_tbl[MAX_DUP_CHK / 8];
243	struct sockaddr_in whereto;
244	int datalen;
245	int maxpayload;
246	int s;
247	u_char outpackhdr[IP_MAXPACKET];
248	u_char *outpack;
249	char *hostname;
250	char *shostname;
251	int ident;
252	int uid;
253	u_char icmp_type;
254	u_char icmp_type_rsp;
255	int phdr_len;
256	int send_len;
257	long nmissedmax;
258	long npackets;
259	long nreceived;
260	long nrepeats;
261	long ntransmitted;
262	long snpackets;
263	long snreceived;
264	long sntransmitted;
265	int sweepmax;
266	int sweepmin;
267	int sweepincr;
268	int interval;
269	int waittime;
270	long nrcvtimeout;
271	int timing;
272	double tmin;
273	double tmax;
274	double tsum;
275	double tsumsq;
276	volatile sig_atomic_t finish_up;
277	volatile sig_atomic_t siginfo_p;
278
279	/* main */
280	u_char packet[IP_MAXPACKET] __aligned(4);
281
282	/* pr_pack */
283	int old_rrlen;
284	char old_rr[MAX_IPOPTLEN];
285
286	int exit_code;
287	jmp_buf exit_jmp;
288	} rtems_shell_globals_t;
289
290	#define options_ globals->options
291	#define mx_dup_ck globals->mx_dup_ck
292	#define rcvd_tbl globals->rcvd_tbl
293	#define whereto globals->whereto
294	#define datalen globals->datalen
295	#define maxpayload globals->maxpayload
296	#define s globals->s
297	#define outpackhdr globals->outpackhdr
298	#define outpack globals->outpack
299	#define hostname globals->hostname
300	#define shostname globals->shostname
301	#define ident globals->ident
302	#define uid globals->uid
303	#define icmp_type_ globals->icmp_type
304	#define icmp_type_rsp globals->icmp_type_rsp
305	#define phdr_len globals->phdr_len
306	#define send_len globals->send_len
307	#define nmissedmax globals->nmissedmax
308	#define npackets globals->npackets
309	#define nreceived globals->nreceived
310	#define nrepeats globals->nrepeats
311	#define ntransmitted globals->ntransmitted
312	#define snpackets globals->snpackets
313	#define snreceived globals->snreceived
314	#define sntransmitted globals->sntransmitted
315	#define sweepmax globals->sweepmax
316	#define sweepmin globals->sweepmin
317	#define sweepincr globals->sweepincr
318	#define interval globals->interval
319	#define waittime globals->waittime
320	#define nrcvtimeout globals->nrcvtimeout
321	#define timing globals->timing
322	#define tmin globals->tmin
323	#define tmax globals->tmax
324	#define tsum globals->tsum
325	#define tsumsq globals->tsumsq
326	#define finish_up globals->finish_up
327	#define siginfo_p globals->siginfo_p
328
329	#define old_rrlen globals->old_rrlen
330	#define old_rr globals->old_rr
331
332	#define packet_ globals->packet
333
334	static u_short in_cksum(u_short *, int);
335	static char *pr_ntime(n_time);
336	static void pr_icmph(struct icmp *);
337	static void pr_iph(struct ip *);
338	static void pr_retip(struct ip *);
339	static void stopit(int);
340	static void tvsub(struct timeval , struct timeval );
341
342	#define fill(_a1, _a2) g_fill(_a1, _a2, globals)
343	static void g_fill(char _a1, char _a2, rtems_shell_globals_t* globals);
344
345	#define check_status() g_check_status(globals)
346	static void g_check_status(rtems_shell_globals_t* globals);
347
348	#define finish() g_finish(globals)
349	static void g_finish(rtems_shell_globals_t* globals) __dead2;
350
351	#define pinger() g_pinger(globals)
352	static void g_pinger(rtems_shell_globals_t* globals);
353
354	#define pr_addr(_a1) g_pr_addr(_a1, globals)
355	static char g_pr_addr(struct in_addr, rtems_shell_globals_t globals);
356
357	#define pr_pack(_a1, _a2, _a3, _a4) g_pr_pack(_a1, _a2, _a3, _a4, globals)
358	static void g_pr_pack(char , int, struct sockaddr_in , struct timeval , rtems_shell_globals_t globals);
359
360	#define usage() g_usage(globals)
361	static void g_usage(rtems_shell_globals_t* globals) __dead2;
362
363	static void
364	rtems_shell_ping_exit (rtems_shell_globals_t* globals, int code)
365	{
366	globals->exit_code = code;
367	longjmp (globals->exit_jmp, 1);
368	}
369
370	#define exit(_c) rtems_shell_ping_exit (globals, _c)
371	#define _exit(_c) exit(_c)
372
373	static int main_ping(int argc, char const argv, rtems_shell_globals_t* globals);
374	static int rtems_shell_main_ping(int argc, char *argv[])
375	{
376	rtems_shell_globals_t* globals = malloc(sizeof(rtems_shell_globals_t));
377	if (!globals)
378	{
379	printf("error: no memory\n");
380	return 1;
381	}
382	memset (globals, 0, sizeof (rtems_shell_globals_t));
383	npackets = 5;
384	datalen = DEFDATALEN;
385	icmp_type_ = ICMP_ECHO;
386	icmp_type_rsp = ICMP_ECHOREPLY;
387	phdr_len = 0;
388	sweepmin = 0;
389	sweepincr = 1;
390	interval = 1000;
391	waittime = MAXWAIT;
392	nrcvtimeout = 0;
393	tmin = 999999999.0;
394	tmax = 0.0;
395	tsum = 0.0;
396	tsumsq = 0.0;
397	globals->exit_code = 1;
398	if (setjmp (globals->exit_jmp) == 0)
399	return main_ping (argc, argv, globals);
400	return globals->exit_code;
401	}
402	#endif
403
404
405
406	int
407	#ifdef __rtems__
408	main_ping(argc, argv, globals)
409	#else
410	main(argc, argv)
411	#endif
412	int argc;
413	char const argv;
414	rtems_shell_globals_t* globals;
415	{
416	struct sockaddr_in from, sock_in;
417	struct in_addr ifaddr;
418	struct timeval last, intvl;
419	struct iovec iov;
420	struct ip *ip;
421	struct msghdr msg;
422	struct sigaction si_sa;
423	size_t sz;
424	#if !__rtems__
425	u_char *datap, packet[IP_MAXPACKET] __aligned(4);
426	#else
427	u_char *datap;
428	#endif
429	char ep, source, target, payload;
430	struct hostent *hp;
431	#ifdef IPSEC_POLICY_IPSEC
432	char policy_in, policy_out;
433	#endif
434	struct sockaddr_in *to;
435	double t;
436	u_long alarmtimeout, ultmp;
437	int almost_done, ch, df, hold, i, icmp_len, mib[4], preload, sockerrno,
438	tos, ttl;
439	char ctrl[CMSG_SPACE(sizeof(struct timeval))];
440	char hnamebuf[MAXHOSTNAMELEN], snamebuf[MAXHOSTNAMELEN];
441	#ifdef IP_OPTIONS
442	char rspace[MAX_IPOPTLEN]; /* record route space */
443	#endif
444	unsigned char loop, mttl;
445	#ifdef __rtems__
446	struct getopt_data getopt_reent;
447	#define optarg getopt_reent.optarg
448	#define optind getopt_reent.optind
449	#define opterr getopt.reent.opterr
450	#define optopt getopt.reent.optopt
451	#endif
452
453	payload = source = NULL;
454	#ifdef IPSEC_POLICY_IPSEC
455	policy_in = policy_out = NULL;
456	#endif
457
458	/*
459	* Do the stuff that we need root priv's for first, and
460	* then drop our setuid bit. Save error reporting for
461	* after arg parsing.
462	*/
463	s = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
464	sockerrno = errno;
465
466	setuid(getuid());
467	uid = getuid();
468
469	alarmtimeout = df = preload = tos = 0;
470
471	outpack = outpackhdr + sizeof(struct ip);
472	#ifdef __rtems__
473	memset(&getopt_reent, 0, sizeof(getopt_data));
474	while ((ch = getopt_r(argc, argv,
475	#else
476	while ((ch = getopt(argc, argv,
477	#endif
478	"Aac:DdfG:g:h:I:i:Ll:M:m:nop:QqRrS:s:T:t:vW:z:"
479	#ifdef IPSEC
480	#ifdef IPSEC_POLICY_IPSEC
481	"P:"
482	#endif /IPSEC_POLICY_IPSEC/
483	#endif /IPSEC/
484	#ifdef __rtems__
485	, &getopt_reent
486	#endif
487	)) != -1)
488	{
489	switch(ch) {
490	case 'A':
491	options_ \|= F_MISSED;
492	break;
493	case 'a':
494	options_ \|= F_AUDIBLE;
495	break;
496	case 'c':
497	ultmp = strtoul(optarg, &ep, 0);
498	if (*ep \|\| ep == optarg \|\| ultmp > LONG_MAX \|\| !ultmp)
499	errx(&globals->exit_jmp, EX_USAGE,
500	"invalid count of packets to transmit: `%s'",
501	optarg);
502	npackets = ultmp;
503	break;
504	case 'D':
505	options_ \|= F_HDRINCL;
506	df = 1;
507	break;
508	case 'd':
509	options_ \|= F_SO_DEBUG;
510	break;
511	case 'f':
512	if (uid) {
513	errno = EPERM;
514	err(&globals->exit_jmp, EX_NOPERM, "-f flag");
515	}
516	options_ \|= F_FLOOD;
517	setbuf(stdout, (char *)NULL);
518	break;
519	case 'G': /* Maximum packet size for ping sweep */
520	ultmp = strtoul(optarg, &ep, 0);
521	if (*ep \|\| ep == optarg)
522	errx(&globals->exit_jmp, EX_USAGE, "invalid packet size: `%s'",
523	optarg);
524	if (uid != 0 && ultmp > DEFDATALEN) {
525	errno = EPERM;
526	err(&globals->exit_jmp, EX_NOPERM,
527	"packet size too large: %lu > %u",
528	ultmp, DEFDATALEN);
529	}
530	options_ \|= F_SWEEP;
531	sweepmax = ultmp;
532	break;
533	case 'g': /* Minimum packet size for ping sweep */
534	ultmp = strtoul(optarg, &ep, 0);
535	if (*ep \|\| ep == optarg)
536	errx(&globals->exit_jmp, EX_USAGE, "invalid packet size: `%s'",
537	optarg);
538	if (uid != 0 && ultmp > DEFDATALEN) {
539	errno = EPERM;
540	err(&globals->exit_jmp, EX_NOPERM,
541	"packet size too large: %lu > %u",
542	ultmp, DEFDATALEN);
543	}
544	options_ \|= F_SWEEP;
545	sweepmin = ultmp;
546	break;
547	case 'h': /* Packet size increment for ping sweep */
548	ultmp = strtoul(optarg, &ep, 0);
549	if (*ep \|\| ep == optarg \|\| ultmp < 1)
550	errx(&globals->exit_jmp, EX_USAGE, "invalid increment size: `%s'",
551	optarg);
552	if (uid != 0 && ultmp > DEFDATALEN) {
553	errno = EPERM;
554	err(&globals->exit_jmp, EX_NOPERM,
555	"packet size too large: %lu > %u",
556	ultmp, DEFDATALEN);
557	}
558	options_ \|= F_SWEEP;
559	sweepincr = ultmp;
560	break;
561	case 'I': /* multicast interface */
562	if (inet_aton(optarg, &ifaddr) == 0)
563	errx(&globals->exit_jmp, EX_USAGE,
564	"invalid multicast interface: `%s'",
565	optarg);
566	options_ \|= F_MIF;
567	break;
568	case 'i': /* wait between sending packets */
569	t = strtod(optarg, &ep) * 1000.0;
570	if (*ep \|\| ep == optarg \|\| t > (double)INT_MAX)
571	errx(&globals->exit_jmp, EX_USAGE, "invalid timing interval: `%s'",
572	optarg);
573	options_ \|= F_INTERVAL;
574	interval = (int)t;
575	if (uid && interval < 1000) {
576	errno = EPERM;
577	err(&globals->exit_jmp, EX_NOPERM, "-i interval too short");
578	}
579	break;
580	case 'L':
581	options_ \|= F_NOLOOP;
582	loop = 0;
583	break;
584	case 'l':
585	ultmp = strtoul(optarg, &ep, 0);
586	if (*ep \|\| ep == optarg \|\| ultmp > INT_MAX)
587	errx(&globals->exit_jmp, EX_USAGE,
588	"invalid preload value: `%s'", optarg);
589	if (uid) {
590	errno = EPERM;
591	err(&globals->exit_jmp, EX_NOPERM, "-l flag");
592	}
593	preload = ultmp;
594	break;
595	case 'M':
596	switch(optarg[0]) {
597	case 'M':
598	case 'm':
599	options_ \|= F_MASK;
600	break;
601	case 'T':
602	case 't':
603	options_ \|= F_TIME;
604	break;
605	default:
606	errx(&globals->exit_jmp, EX_USAGE, "invalid message: `%c'", optarg[0]);
607	break;
608	}
609	break;
610	case 'm': /* TTL */
611	ultmp = strtoul(optarg, &ep, 0);
612	if (*ep \|\| ep == optarg \|\| ultmp > MAXTTL)
613	errx(&globals->exit_jmp, EX_USAGE, "invalid TTL: `%s'", optarg);
614	ttl = ultmp;
615	options_ \|= F_TTL;
616	break;
617	case 'n':
618	options_ \|= F_NUMERIC;
619	break;
620	case 'o':
621	options_ \|= F_ONCE;
622	break;
623	#ifdef IPSEC
624	#ifdef IPSEC_POLICY_IPSEC
625	case 'P':
626	options_ \|= F_POLICY;
627	if (!strncmp("in", optarg, 2))
628	policy_in = strdup(optarg);
629	else if (!strncmp("out", optarg, 3))
630	policy_out = strdup(optarg);
631	else
632	errx(&globals->exit_jmp, 1, "invalid security policy");
633	break;
634	#endif /IPSEC_POLICY_IPSEC/
635	#endif /IPSEC/
636	case 'p': /* fill buffer with user pattern */
637	options_ \|= F_PINGFILLED;
638	payload = optarg;
639	break;
640	case 'Q':
641	options_ \|= F_QUIET2;
642	break;
643	case 'q':
644	options_ \|= F_QUIET;
645	break;
646	case 'R':
647	options_ \|= F_RROUTE;
648	break;
649	case 'r':
650	options_ \|= F_SO_DONTROUTE;
651	break;
652	case 'S':
653	source = optarg;
654	break;
655	case 's': /* size of packet to send */
656	ultmp = strtoul(optarg, &ep, 0);
657	if (*ep \|\| ep == optarg)
658	errx(&globals->exit_jmp, EX_USAGE, "invalid packet size: `%s'",
659	optarg);
660	if (uid != 0 && ultmp > DEFDATALEN) {
661	errno = EPERM;
662	err(&globals->exit_jmp, EX_NOPERM,
663	"packet size too large: %lu > %u",
664	ultmp, DEFDATALEN);
665	}
666	datalen = ultmp;
667	break;
668	case 'T': /* multicast TTL */
669	ultmp = strtoul(optarg, &ep, 0);
670	if (*ep \|\| ep == optarg \|\| ultmp > MAXTTL)
671	errx(&globals->exit_jmp, EX_USAGE, "invalid multicast TTL: `%s'",
672	optarg);
673	mttl = ultmp;
674	options_ \|= F_MTTL;
675	break;
676	case 't':
677	alarmtimeout = strtoul(optarg, &ep, 0);
678	if ((alarmtimeout < 1) \|\| (alarmtimeout == ULONG_MAX))
679	errx(&globals->exit_jmp, EX_USAGE, "invalid timeout: `%s'",
680	optarg);
681	if (alarmtimeout > MAXALARM)
682	errx(&globals->exit_jmp, EX_USAGE, "invalid timeout: `%s' > %d",
683	optarg, MAXALARM);
684	alarm((int)alarmtimeout);
685	break;
686	case 'v':
687	options_ \|= F_VERBOSE;
688	break;
689	case 'W': /* wait ms for answer */
690	t = strtod(optarg, &ep);
691	if (*ep \|\| ep == optarg \|\| t > (double)INT_MAX)
692	errx(&globals->exit_jmp, EX_USAGE, "invalid timing interval: `%s'",
693	optarg);
694	options_ \|= F_WAITTIME;
695	waittime = (int)t;
696	break;
697	case 'z':
698	options_ \|= F_HDRINCL;
699	ultmp = strtoul(optarg, &ep, 0);
700	if (*ep \|\| ep == optarg \|\| ultmp > MAXTOS)
701	errx(&globals->exit_jmp, EX_USAGE, "invalid TOS: `%s'", optarg);
702	tos = ultmp;
703	break;
704	default:
705	usage();
706
707	}
708	}
709
710	if (argc - optind != 1)
711	usage();
712
713	target = argv[optind];
714
715	switch (options_ & (F_MASK\|F_TIME)) {
716	case 0: break;
717	case F_MASK:
718	icmp_type_ = ICMP_MASKREQ;
719	icmp_type_rsp = ICMP_MASKREPLY;
720	phdr_len = MASK_LEN;
721	if (!(options_ & F_QUIET))
722	(void)printf("ICMP_MASKREQ\n");
723	break;
724	case F_TIME:
725	icmp_type_ = ICMP_TSTAMP;
726	icmp_type_rsp = ICMP_TSTAMPREPLY;
727	phdr_len = TS_LEN;
728	if (!(options_ & F_QUIET))
729	(void)printf("ICMP_TSTAMP\n");
730	break;
731	default:
732	errx(&globals->exit_jmp, EX_USAGE, "ICMP_TSTAMP and ICMP_MASKREQ are exclusive.");
733	break;
734	}
735	icmp_len = sizeof(struct ip) + ICMP_MINLEN + phdr_len;
736	if (options_ & F_RROUTE)
737	icmp_len += MAX_IPOPTLEN;
738	maxpayload = IP_MAXPACKET - icmp_len;
739	if (datalen > maxpayload)
740	errx(&globals->exit_jmp, EX_USAGE, "packet size too large: %d > %d", datalen,
741	maxpayload);
742	send_len = icmp_len + datalen;
743	datap = &outpack[ICMP_MINLEN + phdr_len + TIMEVAL_LEN];
744	if (options_ & F_PINGFILLED) {
745	fill((char *)datap, payload);
746	}
747	if (source) {
748	bzero((char *)&sock_in, sizeof(sock_in));
749	sock_in.sin_family = AF_INET;
750	if (inet_aton(source, &sock_in.sin_addr) != 0) {
751	shostname = source;
752	} else {
753	hp = gethostbyname2(source, AF_INET);
754	if (!hp)
755	errx(&globals->exit_jmp, EX_NOHOST, "cannot resolve %s: %s",
756	source, hstrerror(h_errno));
757
758	sock_in.sin_len = sizeof sock_in;
759	if ((unsigned)hp->h_length > sizeof(sock_in.sin_addr) \|\|
760	hp->h_length < 0)
761	errx(&globals->exit_jmp, 1, "gethostbyname2: illegal address");
762	memcpy(&sock_in.sin_addr, hp->h_addr_list[0],
763	sizeof(sock_in.sin_addr));
764	(void)strncpy(snamebuf, hp->h_name,
765	sizeof(snamebuf) - 1);
766	snamebuf[sizeof(snamebuf) - 1] = '\0';
767	shostname = snamebuf;
768	}
769	if (bind(s, (struct sockaddr *)&sock_in, sizeof sock_in) == -1)
770	err(&globals->exit_jmp, 1, "bind");
771	}
772
773	bzero(&whereto, sizeof(whereto));
774	to = &whereto;
775	to->sin_family = AF_INET;
776	to->sin_len = sizeof *to;
777	if (inet_aton(target, &to->sin_addr) != 0) {
778	hostname = target;
779	} else {
780	hp = gethostbyname2(target, AF_INET);
781	if (!hp)
782	errx(&globals->exit_jmp, EX_NOHOST, "cannot resolve %s: %s",
783	target, hstrerror(h_errno));
784
785	if ((unsigned)hp->h_length > sizeof(to->sin_addr))
786	errx(&globals->exit_jmp, 1, "gethostbyname2 returned an illegal address");
787	memcpy(&to->sin_addr, hp->h_addr_list[0], sizeof to->sin_addr);
788	(void)strncpy(hnamebuf, hp->h_name, sizeof(hnamebuf) - 1);
789	hnamebuf[sizeof(hnamebuf) - 1] = '\0';
790	hostname = hnamebuf;
791	}
792
793	if (options_ & F_FLOOD && options_ & F_INTERVAL)
794	errx(&globals->exit_jmp, EX_USAGE, "-f and -i: incompatible options");
795
796	if (options_ & F_FLOOD && IN_MULTICAST(ntohl(to->sin_addr.s_addr)))
797	errx(&globals->exit_jmp, EX_USAGE,
798	"-f flag cannot be used with multicast destination");
799	if (options_ & (F_MIF \| F_NOLOOP \| F_MTTL)
800	&& !IN_MULTICAST(ntohl(to->sin_addr.s_addr)))
801	errx(&globals->exit_jmp, EX_USAGE,
802	"-I, -L, -T flags cannot be used with unicast destination");
803
804	if (datalen >= TIMEVAL_LEN) /* can we time transfer */
805	timing = 1;
806
807	if (!(options_ & F_PINGFILLED))
808	for (i = TIMEVAL_LEN; i < datalen; ++i)
809	*datap++ = i;
810
811	ident = getpid() & 0xFFFF;
812
813	if (s < 0) {
814	errno = sockerrno;
815	err(&globals->exit_jmp, EX_OSERR, "socket");
816	}
817	hold = 1;
818	if (options_ & F_SO_DEBUG)
819	(void)setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&hold,
820	sizeof(hold));
821	if (options_ & F_SO_DONTROUTE)
822	(void)setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)&hold,
823	sizeof(hold));
824	#ifdef IPSEC
825	#ifdef IPSEC_POLICY_IPSEC
826	if (options_ & F_POLICY) {
827	char *buf;
828	if (policy_in != NULL) {
829	buf = ipsec_set_policy(policy_in, strlen(policy_in));
830	if (buf == NULL)
831	errx(&globals->exit_jmp, EX_CONFIG, "%s", ipsec_strerror());
832	if (setsockopt(s, IPPROTO_IP, IP_IPSEC_POLICY,
833	buf, ipsec_get_policylen(buf)) < 0)
834	err(EX_CONFIG,
835	"ipsec policy cannot be configured");
836	free(buf);
837	}
838
839	if (policy_out != NULL) {
840	buf = ipsec_set_policy(policy_out, strlen(policy_out));
841	if (buf == NULL)
842	errx(&globals->exit_jmp, EX_CONFIG, "%s", ipsec_strerror());
843	if (setsockopt(s, IPPROTO_IP, IP_IPSEC_POLICY,
844	buf, ipsec_get_policylen(buf)) < 0)
845	err(EX_CONFIG,
846	"ipsec policy cannot be configured");
847	free(buf);
848	}
849	}
850	#endif /IPSEC_POLICY_IPSEC/
851	#endif /IPSEC/
852
853	if (options_ & F_HDRINCL) {
854	ip = (struct ip*)outpackhdr;
855	if (!(options_ & (F_TTL \| F_MTTL))) {
856	mib[0] = CTL_NET;
857	mib[1] = PF_INET;
858	mib[2] = IPPROTO_IP;
859	mib[3] = IPCTL_DEFTTL;
860	sz = sizeof(ttl);
861	if (sysctl(mib, 4, &ttl, &sz, NULL, 0) == -1)
862	err(&globals->exit_jmp, 1, "sysctl(net.inet.ip.ttl)");
863	}
864	setsockopt(s, IPPROTO_IP, IP_HDRINCL, &hold, sizeof(hold));
865	ip->ip_v = IPVERSION;
866	ip->ip_hl = sizeof(struct ip) >> 2;
867	ip->ip_tos = tos;
868	ip->ip_id = 0;
869	ip->ip_off = df ? IP_DF : 0;
870	ip->ip_ttl = ttl;
871	ip->ip_p = IPPROTO_ICMP;
872	ip->ip_src.s_addr = source ? sock_in.sin_addr.s_addr : INADDR_ANY;
873	ip->ip_dst = to->sin_addr;
874	}
875	/* record route option */
876	if (options_ & F_RROUTE) {
877	#ifdef IP_OPTIONS
878	bzero(rspace, sizeof(rspace));
879	rspace[IPOPT_OPTVAL] = IPOPT_RR;
880	rspace[IPOPT_OLEN] = sizeof(rspace) - 1;
881	rspace[IPOPT_OFFSET] = IPOPT_MINOFF;
882	rspace[sizeof(rspace) - 1] = IPOPT_EOL;
883	if (setsockopt(s, IPPROTO_IP, IP_OPTIONS, rspace,
884	sizeof(rspace)) < 0)
885	err(&globals->exit_jmp, EX_OSERR, "setsockopt IP_OPTIONS");
886	#else
887	errx(&globals->exit_jmp, EX_UNAVAILABLE,
888	"record route not available in this implementation");
889	#endif /* IP_OPTIONS */
890	}
891
892	if (options_ & F_TTL) {
893	if (setsockopt(s, IPPROTO_IP, IP_TTL, &ttl,
894	sizeof(ttl)) < 0) {
895	err(&globals->exit_jmp, EX_OSERR, "setsockopt IP_TTL");
896	}
897	}
898	if (options_ & F_NOLOOP) {
899	if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_LOOP, &loop,
900	sizeof(loop)) < 0) {
901	err(&globals->exit_jmp, EX_OSERR, "setsockopt IP_MULTICAST_LOOP");
902	}
903	}
904	if (options_ & F_MTTL) {
905	if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, &mttl,
906	sizeof(mttl)) < 0) {
907	err(&globals->exit_jmp, EX_OSERR, "setsockopt IP_MULTICAST_TTL");
908	}
909	}
910	if (options_ & F_MIF) {
911	if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_IF, &ifaddr,
912	sizeof(ifaddr)) < 0) {
913	err(&globals->exit_jmp, EX_OSERR, "setsockopt IP_MULTICAST_IF");
914	}
915	}
916	#ifdef SO_TIMESTAMP
917	{ int on = 1;
918	if (setsockopt(s, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on)) < 0)
919	err(&globals->exit_jmp, EX_OSERR, "setsockopt SO_TIMESTAMP");
920	}
921	#endif
922	if (sweepmax) {
923	if (sweepmin >= sweepmax)
924	errx(&globals->exit_jmp, EX_USAGE, "Maximum packet size must be greater than the minimum packet size");
925
926	if (datalen != DEFDATALEN)
927	errx(&globals->exit_jmp, EX_USAGE, "Packet size and ping sweep are mutually exclusive");
928
929	if (npackets > 0) {
930	snpackets = npackets;
931	npackets = 0;
932	} else
933	snpackets = 1;
934	datalen = sweepmin;
935	send_len = icmp_len + sweepmin;
936	}
937	if (options_ & F_SWEEP && !sweepmax)
938	errx(&globals->exit_jmp, EX_USAGE, "Maximum sweep size must be specified");
939
940	/*
941	* When pinging the broadcast address, you can get a lot of answers.
942	* Doing something so evil is useful if you are trying to stress the
943	* ethernet, or just want to fill the arp cache to get some stuff for
944	* /etc/ethers. But beware: RFC 1122 allows hosts to ignore broadcast
945	* or multicast pings if they wish.
946	*/
947
948	/*
949	* XXX receive buffer needs undetermined space for mbuf overhead
950	* as well.
951	*/
952	hold = IP_MAXPACKET + 128;
953	(void)setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&hold,
954	sizeof(hold));
955	if (uid == 0)
956	(void)setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&hold,
957	sizeof(hold));
958
959	if (to->sin_family == AF_INET) {
960	(void)printf("PING %s (%s)", hostname,
961	inet_ntoa(to->sin_addr));
962	if (source)
963	(void)printf(" from %s", shostname);
964	if (sweepmax)
965	(void)printf(": (%d ... %d) data bytes\n",
966	sweepmin, sweepmax);
967	else
968	(void)printf(": %d data bytes\n", datalen);
969
970	} else {
971	if (sweepmax)
972	(void)printf("PING %s: (%d ... %d) data bytes\n",
973	hostname, sweepmin, sweepmax);
974	else
975	(void)printf("PING %s: %d data bytes\n", hostname, datalen);
976	}
977
978	/*
979	* Use sigaction() instead of signal() to get unambiguous semantics,
980	* in particular with SA_RESTART not set.
981	*/
982
983	sigemptyset(&si_sa.sa_mask);
984	si_sa.sa_flags = 0;
985
986	si_sa.sa_handler = stopit;
987	if (sigaction(SIGINT, &si_sa, 0) == -1) {
988	err(&globals->exit_jmp, EX_OSERR, "sigaction SIGINT");
989	}
990
991	#ifdef SIGINFO
992	si_sa.sa_handler = status;
993	if (sigaction(SIGINFO, &si_sa, 0) == -1) {
994	err(EX_OSERR, "sigaction");
995	}
996	#endif
997
998	if (alarmtimeout > 0) {
999	si_sa.sa_handler = stopit;
1000	if (sigaction(SIGALRM, &si_sa, 0) == -1)
1001	err(&globals->exit_jmp, EX_OSERR, "sigaction SIGALRM");
1002	}
1003
1004	bzero(&msg, sizeof(msg));
1005	msg.msg_name = (caddr_t)&from;
1006	msg.msg_iov = &iov;
1007	msg.msg_iovlen = 1;
1008	#ifdef SO_TIMESTAMP
1009	msg.msg_control = (caddr_t)ctrl;
1010	#endif
1011	iov.iov_base = packet_;
1012	iov.iov_len = IP_MAXPACKET;
1013
1014	if (preload == 0)
1015	pinger(); /* send the first ping */
1016	else {
1017	if (npackets != 0 && preload > npackets)
1018	preload = npackets;
1019	while (preload--) /* fire off them quickies */
1020	pinger();
1021	}
1022	(void)gettimeofday(&last, NULL);
1023
1024	if (options_ & F_FLOOD) {
1025	intvl.tv_sec = 0;
1026	intvl.tv_usec = 10000;
1027	} else {
1028	intvl.tv_sec = interval / 1000;
1029	intvl.tv_usec = interval % 1000 * 1000;
1030	}
1031
1032	almost_done = 0;
1033	while (!finish_up) {
1034	struct timeval now, timeout;
1035	fd_set rfds;
1036	int cc, n;
1037
1038	check_status();
1039	if ((unsigned)s >= FD_SETSIZE)
1040	errx(&globals->exit_jmp, EX_OSERR, "descriptor too large");
1041	FD_ZERO(&rfds);
1042	FD_SET(s, &rfds);
1043	(void)gettimeofday(&now, NULL);
1044	timeout.tv_sec = last.tv_sec + intvl.tv_sec - now.tv_sec;
1045	timeout.tv_usec = last.tv_usec + intvl.tv_usec - now.tv_usec;
1046	while (timeout.tv_usec < 0) {
1047	timeout.tv_usec += 1000000;
1048	timeout.tv_sec--;
1049	}
1050	while (timeout.tv_usec >= 1000000) {
1051	timeout.tv_usec -= 1000000;
1052	timeout.tv_sec++;
1053	}
1054	if (timeout.tv_sec < 0)
1055	timeout.tv_sec = timeout.tv_usec = 0;
1056	n = select(s + 1, &rfds, NULL, NULL, &timeout);
1057	if (n < 0)
1058	continue; /* Must be EINTR. */
1059	if (n == 1) {
1060	struct timeval *tv = NULL;
1061	#ifdef SO_TIMESTAMP
1062	struct cmsghdr cmsg = (struct cmsghdr )&ctrl;
1063
1064	msg.msg_controllen = sizeof(ctrl);
1065	#endif
1066
1067	bzero(&msg, sizeof(msg));
1068	msg.msg_name = (caddr_t)&from;
1069	msg.msg_iov = &iov;
1070	msg.msg_iovlen = 1;
1071	#ifdef SO_TIMESTAMP
1072	msg.msg_control = (caddr_t)ctrl;
1073	#endif
1074	iov.iov_base = packet_;
1075	iov.iov_len = IP_MAXPACKET;
1076
1077	msg.msg_namelen = sizeof(from);
1078	if ((cc = recvmsg(s, &msg, 0)) < 0) {
1079	if (errno == EINTR)
1080	continue;
1081	warn("recvmsg");
1082	continue;
1083	}
1084	#ifdef SO_TIMESTAMP
1085	if (cmsg->cmsg_level == SOL_SOCKET &&
1086	cmsg->cmsg_type == SCM_TIMESTAMP &&
1087	cmsg->cmsg_len == CMSG_LEN(sizeof *tv)) {
1088	/* Copy to avoid alignment problems: */
1089	memcpy(&now, CMSG_DATA(cmsg), sizeof(now));
1090	tv = &now;
1091	}
1092	#endif
1093	if (tv == NULL) {
1094	(void)gettimeofday(&now, NULL);
1095	tv = &now;
1096	}
1097	pr_pack((char *)packet_, cc, &from, tv);
1098	if ((options_ & F_ONCE && nreceived) \|\|
1099	(npackets && nreceived >= npackets))
1100	break;
1101	}
1102	if (n == 0 \|\| options_ & F_FLOOD) {
1103	if (sweepmax && sntransmitted == snpackets) {
1104	for (i = 0; i < sweepincr ; ++i)
1105	*datap++ = i;
1106	datalen += sweepincr;
1107	if (datalen > sweepmax)
1108	break;
1109	send_len = icmp_len + datalen;
1110	sntransmitted = 0;
1111	}
1112	if (!npackets \|\| ntransmitted < npackets)
1113	pinger();
1114	else {
1115	if (almost_done)
1116	break;
1117	almost_done = 1;
1118	intvl.tv_usec = 0;
1119	if (nreceived) {
1120	intvl.tv_sec = 2 * tmax / 1000;
1121	if (!intvl.tv_sec)
1122	intvl.tv_sec = 1;
1123	} else {
1124	intvl.tv_sec = waittime / 1000;
1125	intvl.tv_usec = waittime % 1000 * 1000;
1126	}
1127	}
1128	(void)gettimeofday(&last, NULL);
1129	if (ntransmitted - nreceived - 1 > nmissedmax) {
1130	nmissedmax = ntransmitted - nreceived - 1;
1131	if (options_ & F_MISSED)
1132	(void)write(STDOUT_FILENO, &BBELL, 1);
1133	}
1134	}
1135	}
1136	finish();
1137	#ifdef __rtems__
1138	/* RTEMS shell programs return -- they do not exit */
1139	if (nreceived)
1140	return(0);
1141	else
1142	return(2);
1143	#endif
1144	/* NOTREACHED */
1145	exit(0); /* Make the compiler happy */
1146	}
1147
1148	/*
1149	* stopit --
1150	* Set the global bit that causes the main loop to quit.
1151	* Do NOT call finish() from here, since finish() does far too much
1152	* to be called from a signal handler.
1153	*/
1154	void
1155	stopit(sig)
1156	int sig __unused;
1157	{
1158	#if !__rtems__
1159	/*
1160	* When doing reverse DNS lookups, the finish_up flag might not
1161	* be noticed for a while. Just exit if we get a second SIGINT.
1162	*/
1163	if (!(options_ & F_NUMERIC) && finish_up)
1164	_exit(nreceived ? 0 : 2);
1165	finish_up = 1;
1166	#endif
1167	}
1168
1169	/*
1170	* pinger --
1171	* Compose and transmit an ICMP ECHO REQUEST packet. The IP packet
1172	* will be added on by the kernel. The ID field is our UNIX process ID,
1173	* and the sequence number is an ascending integer. The first TIMEVAL_LEN
1174	* bytes of the data portion are used to hold a UNIX "timeval" struct in
1175	* host byte-order, to compute the round-trip time.
1176	*/
1177	static void
1178	g_pinger(globals)
1179	rtems_shell_globals_t* globals;
1180	{
1181	struct timeval now;
1182	struct tv32 tv32;
1183	struct ip *ip;
1184	struct icmp *icp;
1185	int cc, i;
1186	u_char *packet;
1187
1188	packet = outpack;
1189	icp = (struct icmp *)outpack;
1190	icp->icmp_type = icmp_type_;
1191	icp->icmp_code = 0;
1192	icp->icmp_cksum = 0;
1193	icp->icmp_seq = htons(ntransmitted);
1194	icp->icmp_id = ident; /* ID */
1195
1196	CLR(ntransmitted % mx_dup_ck);
1197
1198	if ((options_ & F_TIME) \|\| timing) {
1199	(void)gettimeofday(&now, NULL);
1200
1201	tv32.tv32_sec = htonl(now.tv_sec);
1202	tv32.tv32_usec = htonl(now.tv_usec);
1203	if (options_ & F_TIME)
1204	icp->icmp_otime = htonl((now.tv_sec % (246060))
1205	* 1000 + now.tv_usec / 1000);
1206	if (timing)
1207	bcopy((void *)&tv32,
1208	(void *)&outpack[ICMP_MINLEN + phdr_len],
1209	sizeof(tv32));
1210	}
1211
1212	cc = ICMP_MINLEN + phdr_len + datalen;
1213
1214	/* compute ICMP checksum here */
1215	icp->icmp_cksum = in_cksum((u_short *)icp, cc);
1216
1217	if (options_ & F_HDRINCL) {
1218	cc += sizeof(struct ip);
1219	ip = (struct ip *)outpackhdr;
1220	ip->ip_len = cc;
1221	ip->ip_sum = in_cksum((u_short *)outpackhdr, cc);
1222	packet = outpackhdr;
1223	}
1224	i = sendto(s, (char )packet, cc, 0, (struct sockaddr )&whereto,
1225	sizeof(whereto));
1226
1227	if (i < 0 \|\| i != cc) {
1228	if (i < 0) {
1229	if (options_ & F_FLOOD && errno == ENOBUFS) {
1230	usleep(FLOOD_BACKOFF);
1231	return;
1232	}
1233	warn("sendto");
1234	} else {
1235	warn("%s: partial write: %d of %d bytes",
1236	hostname, i, cc);
1237	}
1238	}
1239	ntransmitted++;
1240	sntransmitted++;
1241	if (!(options_ & F_QUIET) && options_ & F_FLOOD)
1242	(void)write(STDOUT_FILENO, &DOT, 1);
1243	}
1244
1245	/*
1246	* pr_pack --
1247	* Print out the packet, if it came from us. This logic is necessary
1248	* because ALL readers of the ICMP socket get a copy of ALL ICMP packets
1249	* which arrive ('tis only fair). This permits multiple copies of this
1250	* program to be run without having intermingled output (or statistics!).
1251	*/
1252	static void
1253	g_pr_pack(buf, cc, from, tv, globals)
1254	char *buf;
1255	int cc;
1256	struct sockaddr_in *from;
1257	struct timeval *tv;
1258	rtems_shell_globals_t* globals;
1259	{
1260	struct in_addr ina;
1261	u_char cp, dp;
1262	struct icmp *icp;
1263	struct ip *ip;
1264	const void *tp;
1265	double triptime;
1266	int dupflag, hlen, i, j, recv_len, seq;
1267	#if !__rtems__
1268	static int old_rrlen;
1269	static char old_rr[MAX_IPOPTLEN];
1270	#endif
1271
1272	/* Check the IP header */
1273	ip = (struct ip *)buf;
1274	hlen = ip->ip_hl << 2;
1275	recv_len = cc;
1276	if (cc < hlen + ICMP_MINLEN) {
1277	if (options_ & F_VERBOSE)
1278	warn("packet too short (%d bytes) from %s", cc,
1279	inet_ntoa(from->sin_addr));
1280	return;
1281	}
1282
1283	/* Now the ICMP part */
1284	cc -= hlen;
1285	icp = (struct icmp *)(buf + hlen);
1286	if (icp->icmp_type == icmp_type_rsp) {
1287	if (icp->icmp_id != ident)
1288	return; /* 'Twas not our ECHO */
1289	++nreceived;
1290	triptime = 0.0;
1291	if (timing) {
1292	struct timeval tv1;
1293	struct tv32 tv32;
1294	#ifndef icmp_data
1295	tp = &icp->icmp_ip;
1296	#else
1297	tp = icp->icmp_data;
1298	#endif
1299	tp = (const char *)tp + phdr_len;
1300
1301	if (cc - ICMP_MINLEN - phdr_len >= (int) sizeof(tv1)) {
1302	/* Copy to avoid alignment problems: */
1303	memcpy(&tv32, tp, sizeof(tv32));
1304	tv1.tv_sec = ntohl(tv32.tv32_sec);
1305	tv1.tv_usec = ntohl(tv32.tv32_usec);
1306	tvsub(tv, &tv1);
1307	triptime = ((double)tv->tv_sec) * 1000.0 +
1308	((double)tv->tv_usec) / 1000.0;
1309	tsum += triptime;
1310	tsumsq += triptime * triptime;
1311	if (triptime < tmin)
1312	tmin = triptime;
1313	if (triptime > tmax)
1314	tmax = triptime;
1315	} else
1316	timing = 0;
1317	}
1318
1319	seq = ntohs(icp->icmp_seq);
1320
1321	if (TST(seq % mx_dup_ck)) {
1322	++nrepeats;
1323	--nreceived;
1324	dupflag = 1;
1325	} else {
1326	SET(seq % mx_dup_ck);
1327	dupflag = 0;
1328	}
1329
1330	if (options_ & F_QUIET)
1331	return;
1332
1333	if (options_ & F_WAITTIME && triptime > waittime) {
1334	++nrcvtimeout;
1335	return;
1336	}
1337
1338	if (options_ & F_FLOOD)
1339	(void)write(STDOUT_FILENO, &BSPACE, 1);
1340	else {
1341	(void)printf("%d bytes from %s: icmp_seq=%u", cc,
1342	inet_ntoa((struct in_addr )&from->sin_addr.s_addr),
1343	seq);
1344	(void)printf(" ttl=%d", ip->ip_ttl);
1345	if (timing)
1346	(void)printf(" time=%.3f ms", triptime);
1347	if (dupflag)
1348	(void)printf(" (DUP!)");
1349	if (options_ & F_AUDIBLE)
1350	(void)write(STDOUT_FILENO, &BBELL, 1);
1351	if (options_ & F_MASK) {
1352	/* Just prentend this cast isn't ugly */
1353	(void)printf(" mask=%s",
1354	pr_addr((struct in_addr )&(icp->icmp_mask)));
1355	}
1356	if (options_ & F_TIME) {
1357	(void)printf(" tso=%s", pr_ntime(icp->icmp_otime));
1358	(void)printf(" tsr=%s", pr_ntime(icp->icmp_rtime));
1359	(void)printf(" tst=%s", pr_ntime(icp->icmp_ttime));
1360	}
1361	if (recv_len != send_len) {
1362	(void)printf(
1363	"\nwrong total length %d instead of %d",
1364	recv_len, send_len);
1365	}
1366	/* check the data */
1367	cp = (u_char*)&icp->icmp_data[phdr_len];
1368	dp = &outpack[ICMP_MINLEN + phdr_len];
1369	cc -= ICMP_MINLEN + phdr_len;
1370	i = 0;
1371	if (timing) { /* don't check variable timestamp */
1372	cp += TIMEVAL_LEN;
1373	dp += TIMEVAL_LEN;
1374	cc -= TIMEVAL_LEN;
1375	i += TIMEVAL_LEN;
1376	}
1377	for (; i < datalen && cc > 0; ++i, ++cp, ++dp, --cc) {
1378	if (cp != dp) {
1379	(void)printf("\nwrong data byte #%d should be 0x%x but was 0x%x",
1380	i, dp, cp);
1381	(void)printf("\ncp:");
1382	cp = (u_char*)&icp->icmp_data[0];
1383	for (i = 0; i < datalen; ++i, ++cp) {
1384	if ((i % 16) == 8)
1385	(void)printf("\n\t");
1386	(void)printf("%2x ", *cp);
1387	}
1388	(void)printf("\ndp:");
1389	cp = &outpack[ICMP_MINLEN];
1390	for (i = 0; i < datalen; ++i, ++cp) {
1391	if ((i % 16) == 8)
1392	(void)printf("\n\t");
1393	(void)printf("%2x ", *cp);
1394	}
1395	break;
1396	}
1397	}
1398	}
1399	} else {
1400	/*
1401	* We've got something other than an ECHOREPLY.
1402	* See if it's a reply to something that we sent.
1403	* We can compare IP destination, protocol,
1404	* and ICMP type and ID.
1405	*
1406	* Only print all the error messages if we are running
1407	* as root to avoid leaking information not normally
1408	* available to those not running as root.
1409	*/
1410	#ifndef icmp_data
1411	struct ip *oip = &icp->icmp_ip;
1412	#else
1413	struct ip oip = (struct ip )icp->icmp_data;
1414	#endif
1415	struct icmp oicmp = (struct icmp )(oip + 1);
1416
1417	if (((options_ & F_VERBOSE) && uid == 0) \|\|
1418	(!(options_ & F_QUIET2) &&
1419	(oip->ip_dst.s_addr == whereto.sin_addr.s_addr) &&
1420	(oip->ip_p == IPPROTO_ICMP) &&
1421	(oicmp->icmp_type == ICMP_ECHO) &&
1422	(oicmp->icmp_id == ident))) {
1423	(void)printf("%d bytes from %s: ", cc,
1424	pr_addr(from->sin_addr));
1425	pr_icmph(icp);
1426	} else
1427	return;
1428	}
1429
1430	/* Display any IP options */
1431	cp = (u_char *)buf + sizeof(struct ip);
1432
1433	for (; hlen > (int)sizeof(struct ip); --hlen, ++cp)
1434	switch (*cp) {
1435	case IPOPT_EOL:
1436	hlen = 0;
1437	break;
1438	case IPOPT_LSRR:
1439	case IPOPT_SSRR:
1440	(void)printf(*cp == IPOPT_LSRR ?
1441	"\nLSRR: " : "\nSSRR: ");
1442	j = cp[IPOPT_OLEN] - IPOPT_MINOFF + 1;
1443	hlen -= 2;
1444	cp += 2;
1445	if (j >= INADDR_LEN &&
1446	j <= hlen - (int)sizeof(struct ip)) {
1447	for (;;) {
1448	bcopy(++cp, &ina.s_addr, INADDR_LEN);
1449	if (ina.s_addr == 0)
1450	(void)printf("\t0.0.0.0");
1451	else
1452	(void)printf("\t%s",
1453	pr_addr(ina));
1454	hlen -= INADDR_LEN;
1455	cp += INADDR_LEN - 1;
1456	j -= INADDR_LEN;
1457	if (j < INADDR_LEN)
1458	break;
1459	(void)putchar('\n');
1460	}
1461	} else
1462	(void)printf("\t(truncated route)\n");
1463	break;
1464	case IPOPT_RR:
1465	j = cp[IPOPT_OLEN]; /* get length */
1466	i = cp[IPOPT_OFFSET]; /* and pointer */
1467	hlen -= 2;
1468	cp += 2;
1469	if (i > j)
1470	i = j;
1471	i = i - IPOPT_MINOFF + 1;
1472	if (i < 0 \|\| i > (hlen - (int)sizeof(struct ip))) {
1473	old_rrlen = 0;
1474	continue;
1475	}
1476	if (i == old_rrlen
1477	&& !bcmp((char *)cp, old_rr, i)
1478	&& !(options_ & F_FLOOD)) {
1479	(void)printf("\t(same route)");
1480	hlen -= i;
1481	cp += i;
1482	break;
1483	}
1484	old_rrlen = i;
1485	bcopy((char *)cp, old_rr, i);
1486	(void)printf("\nRR: ");
1487	if (i >= INADDR_LEN &&
1488	i <= hlen - (int)sizeof(struct ip)) {
1489	for (;;) {
1490	bcopy(++cp, &ina.s_addr, INADDR_LEN);
1491	if (ina.s_addr == 0)
1492	(void)printf("\t0.0.0.0");
1493	else
1494	(void)printf("\t%s",
1495	pr_addr(ina));
1496	hlen -= INADDR_LEN;
1497	cp += INADDR_LEN - 1;
1498	i -= INADDR_LEN;
1499	if (i < INADDR_LEN)
1500	break;
1501	(void)putchar('\n');
1502	}
1503	} else
1504	(void)printf("\t(truncated route)");
1505	break;
1506	case IPOPT_NOP:
1507	(void)printf("\nNOP");
1508	break;
1509	default:
1510	(void)printf("\nunknown option %x", *cp);
1511	break;
1512	}
1513	if (!(options_ & F_FLOOD)) {
1514	(void)putchar('\n');
1515	(void)fflush(stdout);
1516	}
1517	}
1518
1519	/*
1520	* in_cksum --
1521	* Checksum routine for Internet Protocol family headers (C Version)
1522	*/
1523	u_short
1524	in_cksum(addr, len)
1525	u_short *addr;
1526	int len;
1527	{
1528	int nleft, sum;
1529	u_short *w;
1530	union {
1531	u_short us;
1532	u_char uc[2];
1533	} last;
1534	u_short answer;
1535
1536	nleft = len;
1537	sum = 0;
1538	w = addr;
1539
1540	/*
1541	* Our algorithm is simple, using a 32 bit accumulator (sum), we add
1542	* sequential 16 bit words to it, and at the end, fold back all the
1543	* carry bits from the top 16 bits into the lower 16 bits.
1544	*/
1545	while (nleft > 1) {
1546	sum += *w++;
1547	nleft -= 2;
1548	}
1549
1550	/* mop up an odd byte, if necessary */
1551	if (nleft == 1) {
1552	last.uc[0] = (u_char )w;
1553	last.uc[1] = 0;
1554	sum += last.us;
1555	}
1556
1557	/* add back carry outs from top 16 bits to low 16 bits */
1558	sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
1559	sum += (sum >> 16); /* add carry */
1560	answer = ~sum; /* truncate to 16 bits */
1561	return(answer);
1562	}
1563
1564	/*
1565	* tvsub --
1566	* Subtract 2 timeval structs: out = out - in. Out is assumed to
1567	* be >= in.
1568	*/
1569	static void
1570	tvsub(out, in)
1571	struct timeval out, in;
1572	{
1573
1574	if ((out->tv_usec -= in->tv_usec) < 0) {
1575	--out->tv_sec;
1576	out->tv_usec += 1000000;
1577	}
1578	out->tv_sec -= in->tv_sec;
1579	}
1580
1581	/*
1582	* status --
1583	* Print out statistics when SIGINFO is received.
1584	*/
1585
1586	#if !defined(__rtems__)
1587	static void
1588	status(sig)
1589	int sig __unused;
1590	{
1591	siginfo_p = 1;
1592	}
1593	#endif
1594
1595	static void
1596	g_check_status(globals)
1597	rtems_shell_globals_t* globals;
1598	{
1599	if (siginfo_p) {
1600	siginfo_p = 0;
1601	(void)fprintf(stderr, "\r%ld/%ld packets received (%.1f%%)",
1602	nreceived, ntransmitted,
1603	ntransmitted ? nreceived * 100.0 / ntransmitted : 0.0);
1604	if (nreceived && timing)
1605	(void)fprintf(stderr, " %.3f min / %.3f avg / %.3f max",
1606	tmin, tsum / (nreceived + nrepeats), tmax);
1607	(void)fprintf(stderr, "\n");
1608	}
1609	}
1610
1611	/*
1612	* finish --
1613	* Print out statistics, and give up.
1614	*/
1615	static void
1616	g_finish(globals)
1617	rtems_shell_globals_t* globals;
1618	{
1619
1620	(void)signal(SIGINT, SIG_IGN);
1621	(void)signal(SIGALRM, SIG_IGN);
1622	(void)putchar('\n');
1623	(void)fflush(stdout);
1624	(void)printf("--- %s ping statistics ---\n", hostname);
1625	(void)printf("%ld packets transmitted, ", ntransmitted);
1626	(void)printf("%ld packets received, ", nreceived);
1627	if (nrepeats)
1628	(void)printf("+%ld duplicates, ", nrepeats);
1629	if (ntransmitted) {
1630	if (nreceived > ntransmitted)
1631	(void)printf("-- somebody's printing up packets!");
1632	else
1633	(void)printf("%.1f%% packet loss",
1634	((ntransmitted - nreceived) * 100.0) /
1635	ntransmitted);
1636	}
1637	if (nrcvtimeout)
1638	(void)printf(", %ld packets out of wait time", nrcvtimeout);
1639	(void)putchar('\n');
1640	if (nreceived && timing) {
1641	double n = nreceived + nrepeats;
1642	double avg = tsum / n;
1643	#if defined(__rtems__)
1644	(void) printf(
1645	"round-trip min/avg/max/stddev = %.3f/%.3f/%.3f ms\n",
1646	tmin, avg, tmax);
1647	#else
1648	double vari = tsumsq / n - avg * avg;
1649	(void)printf(
1650	"round-trip min/avg/max/stddev = %.3f/%.3f/%.3f/%.3f ms\n",
1651	tmin, avg, tmax, sqrt(vari));
1652	#endif
1653	}
1654	if (nreceived)
1655	exit(0);
1656	else
1657	exit(2);
1658	while (1);
1659	}
1660
1661	#ifdef notdef
1662	static char *ttab[] = {
1663	"Echo Reply", /* ip + seq + udata */
1664	"Dest Unreachable", /* net, host, proto, port, frag, sr + IP */
1665	"Source Quench", /* IP */
1666	"Redirect", /* redirect type, gateway, + IP */
1667	"Echo",
1668	"Time Exceeded", /* transit, frag reassem + IP */
1669	"Parameter Problem", /* pointer + IP */
1670	"Timestamp", /* id + seq + three timestamps */
1671	"Timestamp Reply", /* " */
1672	"Info Request", /* id + sq */
1673	"Info Reply" /* " */
1674	};
1675	#endif
1676
1677	/*
1678	* pr_icmph --
1679	* Print a descriptive string about an ICMP header.
1680	*/
1681	static void
1682	pr_icmph(icp)
1683	struct icmp *icp;
1684	{
1685
1686	switch(icp->icmp_type) {
1687	case ICMP_ECHOREPLY:
1688	(void)printf("Echo Reply\n");
1689	/* XXX ID + Seq + Data */
1690	break;
1691	case ICMP_UNREACH:
1692	switch(icp->icmp_code) {
1693	case ICMP_UNREACH_NET:
1694	(void)printf("Destination Net Unreachable\n");
1695	break;
1696	case ICMP_UNREACH_HOST:
1697	(void)printf("Destination Host Unreachable\n");
1698	break;
1699	case ICMP_UNREACH_PROTOCOL:
1700	(void)printf("Destination Protocol Unreachable\n");
1701	break;
1702	case ICMP_UNREACH_PORT:
1703	(void)printf("Destination Port Unreachable\n");
1704	break;
1705	case ICMP_UNREACH_NEEDFRAG:
1706	(void)printf("frag needed and DF set (MTU %d)\n",
1707	ntohs(icp->icmp_nextmtu));
1708	break;
1709	case ICMP_UNREACH_SRCFAIL:
1710	(void)printf("Source Route Failed\n");
1711	break;
1712	case ICMP_UNREACH_FILTER_PROHIB:
1713	(void)printf("Communication prohibited by filter\n");
1714	break;
1715	default:
1716	(void)printf("Dest Unreachable, Bad Code: %d\n",
1717	icp->icmp_code);
1718	break;
1719	}
1720	/* Print returned IP header information */
1721	#ifndef icmp_data
1722	pr_retip(&icp->icmp_ip);
1723	#else
1724	pr_retip((struct ip *)icp->icmp_data);
1725	#endif
1726	break;
1727	case ICMP_SOURCEQUENCH:
1728	(void)printf("Source Quench\n");
1729	#ifndef icmp_data
1730	pr_retip(&icp->icmp_ip);
1731	#else
1732	pr_retip((struct ip *)icp->icmp_data);
1733	#endif
1734	break;
1735	case ICMP_REDIRECT:
1736	switch(icp->icmp_code) {
1737	case ICMP_REDIRECT_NET:
1738	(void)printf("Redirect Network");
1739	break;
1740	case ICMP_REDIRECT_HOST:
1741	(void)printf("Redirect Host");
1742	break;
1743	case ICMP_REDIRECT_TOSNET:
1744	(void)printf("Redirect Type of Service and Network");
1745	break;
1746	case ICMP_REDIRECT_TOSHOST:
1747	(void)printf("Redirect Type of Service and Host");
1748	break;
1749	default:
1750	(void)printf("Redirect, Bad Code: %d", icp->icmp_code);
1751	break;
1752	}
1753	(void)printf("(New addr: %s)\n", inet_ntoa(icp->icmp_gwaddr));
1754	#ifndef icmp_data
1755	pr_retip(&icp->icmp_ip);
1756	#else
1757	pr_retip((struct ip *)icp->icmp_data);
1758	#endif
1759	break;
1760	case ICMP_ECHO:
1761	(void)printf("Echo Request\n");
1762	/* XXX ID + Seq + Data */
1763	break;
1764	case ICMP_TIMXCEED:
1765	switch(icp->icmp_code) {
1766	case ICMP_TIMXCEED_INTRANS:
1767	(void)printf("Time to live exceeded\n");
1768	break;
1769	case ICMP_TIMXCEED_REASS:
1770	(void)printf("Frag reassembly time exceeded\n");
1771	break;
1772	default:
1773	(void)printf("Time exceeded, Bad Code: %d\n",
1774	icp->icmp_code);
1775	break;
1776	}
1777	#ifndef icmp_data
1778	pr_retip(&icp->icmp_ip);
1779	#else
1780	pr_retip((struct ip *)icp->icmp_data);
1781	#endif
1782	break;
1783	case ICMP_PARAMPROB:
1784	(void)printf("Parameter problem: pointer = 0x%02x\n",
1785	icp->icmp_hun.ih_pptr);
1786	#ifndef icmp_data
1787	pr_retip(&icp->icmp_ip);
1788	#else
1789	pr_retip((struct ip *)icp->icmp_data);
1790	#endif
1791	break;
1792	case ICMP_TSTAMP:
1793	(void)printf("Timestamp\n");
1794	/* XXX ID + Seq + 3 timestamps */
1795	break;
1796	case ICMP_TSTAMPREPLY:
1797	(void)printf("Timestamp Reply\n");
1798	/* XXX ID + Seq + 3 timestamps */
1799	break;
1800	case ICMP_IREQ:
1801	(void)printf("Information Request\n");
1802	/* XXX ID + Seq */
1803	break;
1804	case ICMP_IREQREPLY:
1805	(void)printf("Information Reply\n");
1806	/* XXX ID + Seq */
1807	break;
1808	case ICMP_MASKREQ:
1809	(void)printf("Address Mask Request\n");
1810	break;
1811	case ICMP_MASKREPLY:
1812	(void)printf("Address Mask Reply\n");
1813	break;
1814	case ICMP_ROUTERADVERT:
1815	(void)printf("Router Advertisement\n");
1816	break;
1817	case ICMP_ROUTERSOLICIT:
1818	(void)printf("Router Solicitation\n");
1819	break;
1820	default:
1821	(void)printf("Bad ICMP type: %d\n", icp->icmp_type);
1822	}
1823	}
1824
1825	/*
1826	* pr_iph --
1827	* Print an IP header with options.
1828	*/
1829	static void
1830	pr_iph(ip)
1831	struct ip *ip;
1832	{
1833	u_char *cp;
1834	int hlen;
1835
1836	hlen = ip->ip_hl << 2;
1837	cp = (u_char )ip + 20; / point to options */
1838
1839	(void)printf("Vr HL TOS Len ID Flg off TTL Pro cks Src Dst\n");
1840	(void)printf(" %1x %1x %02x %04x %04x",
1841	ip->ip_v, ip->ip_hl, ip->ip_tos, ntohs(ip->ip_len),
1842	ntohs(ip->ip_id));
1843	(void)printf(" %1lx %04lx",
1844	(u_long) (ntohl(ip->ip_off) & 0xe000) >> 13,
1845	(u_long) ntohl(ip->ip_off) & 0x1fff);
1846	(void)printf(" %02x %02x %04x", ip->ip_ttl, ip->ip_p,
1847	ntohs(ip->ip_sum));
1848	(void)printf(" %s ", inet_ntoa((struct in_addr )&ip->ip_src.s_addr));
1849	(void)printf(" %s ", inet_ntoa((struct in_addr )&ip->ip_dst.s_addr));
1850	/* dump any option bytes */
1851	while (hlen-- > 20) {
1852	(void)printf("%02x", *cp++);
1853	}
1854	(void)putchar('\n');
1855	}
1856
1857	/*
1858	* pr_addr --
1859	* Return an ascii host address as a dotted quad and optionally with
1860	* a hostname.
1861	*/
1862	static char *
1863	g_pr_addr(ina, globals)
1864	struct in_addr ina;
1865	rtems_shell_globals_t* globals;
1866	{
1867	struct hostent *hp;
1868	static char buf[16 + 3 + MAXHOSTNAMELEN];
1869
1870	if ((options_ & F_NUMERIC) \|\|
1871	!(hp = gethostbyaddr((char *)&ina, 4, AF_INET)))
1872	return inet_ntoa(ina);
1873	else
1874	(void)snprintf(buf, sizeof(buf), "%s (%s)", hp->h_name,
1875	inet_ntoa(ina));
1876	return(buf);
1877	}
1878
1879	/*
1880	* pr_retip --
1881	* Dump some info on a returned (via ICMP) IP packet.
1882	*/
1883	static void
1884	pr_retip(ip)
1885	struct ip *ip;
1886	{
1887	u_char *cp;
1888	int hlen;
1889
1890	pr_iph(ip);
1891	hlen = ip->ip_hl << 2;
1892	cp = (u_char *)ip + hlen;
1893
1894	if (ip->ip_p == 6)
1895	(void)printf("TCP: from port %u, to port %u (decimal)\n",
1896	(cp 256 + (cp + 1)), ((cp + 2) * 256 + *(cp + 3)));
1897	else if (ip->ip_p == 17)
1898	(void)printf("UDP: from port %u, to port %u (decimal)\n",
1899	(cp 256 + (cp + 1)), ((cp + 2) * 256 + *(cp + 3)));
1900	}
1901
1902	static char *
1903	pr_ntime (n_time timestamp)
1904	{
1905	static char buf[10];
1906	int hour, min, sec;
1907
1908	sec = ntohl(timestamp) / 1000;
1909	hour = sec / 60 / 60;
1910	min = (sec % (60 * 60)) / 60;
1911	sec = (sec % (60 * 60)) % 60;
1912
1913	(void)snprintf(buf, sizeof(buf), "%02d:%02d:%02d", hour, min, sec);
1914
1915	return (buf);
1916	}
1917
1918	static void
1919	g_fill(bp, patp, globals)
1920	char bp, patp;
1921	rtems_shell_globals_t* globals;
1922	{
1923	char *cp;
1924	int pat[16];
1925	u_int ii, jj, kk;
1926
1927	for (cp = patp; *cp; cp++) {
1928	if (!isxdigit((int)*cp))
1929	errx(&globals->exit_jmp, EX_USAGE,
1930	"patterns must be specified as hex digits");
1931
1932	}
1933	ii = sscanf(patp,
1934	"%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
1935	&pat[0], &pat[1], &pat[2], &pat[3], &pat[4], &pat[5], &pat[6],
1936	&pat[7], &pat[8], &pat[9], &pat[10], &pat[11], &pat[12],
1937	&pat[13], &pat[14], &pat[15]);
1938
1939	if (ii > 0)
1940	for (kk = 0; kk <= maxpayload - (TIMEVAL_LEN + ii); kk += ii)
1941	for (jj = 0; jj < ii; ++jj)
1942	bp[jj + kk] = pat[jj];
1943	if (!(options_ & F_QUIET)) {
1944	(void)printf("PATTERN: 0x");
1945	for (jj = 0; jj < ii; ++jj)
1946	(void)printf("%02x", bp[jj] & 0xFF);
1947	(void)printf("\n");
1948	}
1949	}
1950
1951	#if defined(IPSEC) && defined(IPSEC_POLICY_IPSEC)
1952	#define SECOPT " [-P policy]"
1953	#else
1954	#define SECOPT ""
1955	#endif
1956	static void
1957	g_usage(globals)
1958	rtems_shell_globals_t* globals;
1959	{
1960	(void)fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n",
1961	"usage: ping [-AaDdfnoQqRrv] [-c count] [-G sweepmaxsize] [-g sweepminsize]",
1962	" [-h sweepincrsize] [-i wait] [-l preload] [-M mask \| time] [-m ttl]",
1963	" " SECOPT " [-p pattern] [-S src_addr] [-s packetsize] [-t timeout]",
1964	" [-W waittime] [-z tos] host",
1965	" ping [-AaDdfLnoQqRrv] [-c count] [-I iface] [-i wait] [-l preload]",
1966	" [-M mask \| time] [-m ttl]" SECOPT " [-p pattern] [-S src_addr]",
1967	" [-s packetsize] [-T ttl] [-t timeout] [-W waittime]",
1968	" [-z tos] mcast-group");
1969	exit(EX_USAGE);
1970	while (1);
1971	}
1972
1973	#if __rtems__
1974	rtems_shell_cmd_t rtems_shell_PING_Command = {
1975	"ping", /* name */
1976	"ping [args]", /* usage */
1977	"network", /* topic */
1978	rtems_shell_main_ping, /* command */
1979	NULL, /* alias */
1980	NULL /* next */
1981	};
1982	#endif

Note: See TracBrowser for help on using the repository browser.

Download in other formats: