Home | History | Annotate | Download | only in iputils
      1 #include "ping_common.h"
      2 #include <ctype.h>
      3 #include <sched.h>
      4 #include <math.h>
      5 
      6 int options;
      7 
      8 int mark;
      9 int sndbuf;
     10 int ttl;
     11 int rtt;
     12 int rtt_addend;
     13 __u16 acked;
     14 
     15 struct rcvd_table rcvd_tbl;
     16 int using_ping_socket = 1;
     17 
     18 
     19 /* counters */
     20 long npackets;			/* max packets to transmit */
     21 long nreceived;			/* # of packets we got back */
     22 long nrepeats;			/* number of duplicates */
     23 long ntransmitted;		/* sequence # for outbound packets = #sent */
     24 long nchecksum;			/* replies with bad checksum */
     25 long nerrors;			/* icmp errors */
     26 int interval = 1000;		/* interval between packets (msec) */
     27 int preload;
     28 int deadline = 0;		/* time to die */
     29 int lingertime = MAXWAIT*1000;
     30 struct timeval start_time, cur_time;
     31 volatile int exiting;
     32 volatile int status_snapshot;
     33 int confirm = 0;
     34 volatile int in_pr_addr = 0;	/* pr_addr() is executing */
     35 jmp_buf pr_addr_jmp;
     36 
     37 /* Stupid workarounds for bugs/missing functionality in older linuces.
     38  * confirm_flag fixes refusing service of kernels without MSG_CONFIRM.
     39  * i.e. for linux-2.2 */
     40 int confirm_flag = MSG_CONFIRM;
     41 /* And this is workaround for bug in IP_RECVERR on raw sockets which is present
     42  * in linux-2.2.[0-19], linux-2.4.[0-7] */
     43 int working_recverr;
     44 
     45 /* timing */
     46 int timing;			/* flag to do timing */
     47 long tmin = LONG_MAX;		/* minimum round trip time */
     48 long tmax;			/* maximum round trip time */
     49 /* Message for rpm maintainers: have _shame_. If you want
     50  * to fix something send the patch to me for sanity checking.
     51  * "sparcfix" patch is a complete non-sense, apparenly the person
     52  * prepared it was stoned.
     53  */
     54 long long tsum;			/* sum of all times, for doing average */
     55 long long tsum2;
     56 int  pipesize = -1;
     57 
     58 int datalen = DEFDATALEN;
     59 
     60 char *hostname;
     61 int uid;
     62 uid_t euid;
     63 int ident = 0;			/* process id to identify our packets */
     64 
     65 static int screen_width = INT_MAX;
     66 
     67 #define ARRAY_SIZE(a)	(sizeof(a) / sizeof(a[0]))
     68 
     69 #ifdef CAPABILITIES
     70 static cap_value_t cap_raw = CAP_NET_RAW;
     71 static cap_value_t cap_admin = CAP_NET_ADMIN;
     72 #endif
     73 
     74 void limit_capabilities(void)
     75 {
     76 #ifdef CAPABILITIES
     77 	cap_t cap_cur_p;
     78 	cap_t cap_p;
     79 	cap_flag_value_t cap_ok;
     80 
     81 	cap_cur_p = cap_get_proc();
     82 	if (!cap_cur_p) {
     83 		perror("ping: cap_get_proc");
     84 		exit(-1);
     85 	}
     86 
     87 	cap_p = cap_init();
     88 	if (!cap_p) {
     89 		perror("ping: cap_init");
     90 		exit(-1);
     91 	}
     92 
     93 	cap_ok = CAP_CLEAR;
     94 	cap_get_flag(cap_cur_p, CAP_NET_ADMIN, CAP_PERMITTED, &cap_ok);
     95 
     96 	if (cap_ok != CAP_CLEAR)
     97 		cap_set_flag(cap_p, CAP_PERMITTED, 1, &cap_admin, CAP_SET);
     98 
     99 	cap_ok = CAP_CLEAR;
    100 	cap_get_flag(cap_cur_p, CAP_NET_RAW, CAP_PERMITTED, &cap_ok);
    101 
    102 	if (cap_ok != CAP_CLEAR)
    103 		cap_set_flag(cap_p, CAP_PERMITTED, 1, &cap_raw, CAP_SET);
    104 
    105 	if (cap_set_proc(cap_p) < 0) {
    106 		perror("ping: cap_set_proc");
    107 		exit(-1);
    108 	}
    109 
    110 	if (prctl(PR_SET_KEEPCAPS, 1) < 0) {
    111 		perror("ping: prctl");
    112 		exit(-1);
    113 	}
    114 
    115 	if (setuid(getuid()) < 0) {
    116 		perror("setuid");
    117 		exit(-1);
    118 	}
    119 
    120 	if (prctl(PR_SET_KEEPCAPS, 0) < 0) {
    121 		perror("ping: prctl");
    122 		exit(-1);
    123 	}
    124 
    125 	cap_free(cap_p);
    126 	cap_free(cap_cur_p);
    127 #endif
    128 	uid = getuid();
    129 	euid = geteuid();
    130 #ifndef CAPABILITIES
    131 	if (seteuid(uid)) {
    132 		perror("ping: setuid");
    133 		exit(-1);
    134 	}
    135 #endif
    136 }
    137 
    138 #ifdef CAPABILITIES
    139 int modify_capability(cap_value_t cap, cap_flag_value_t on)
    140 {
    141 	cap_t cap_p = cap_get_proc();
    142 	cap_flag_value_t cap_ok;
    143 	int rc = -1;
    144 
    145 	if (!cap_p) {
    146 		perror("ping: cap_get_proc");
    147 		goto out;
    148 	}
    149 
    150 	cap_ok = CAP_CLEAR;
    151 	cap_get_flag(cap_p, cap, CAP_PERMITTED, &cap_ok);
    152 	if (cap_ok == CAP_CLEAR) {
    153 		rc = on ? -1 : 0;
    154 		goto out;
    155 	}
    156 
    157 	cap_set_flag(cap_p, CAP_EFFECTIVE, 1, &cap, on);
    158 
    159 	if (cap_set_proc(cap_p) < 0) {
    160 		perror("ping: cap_set_proc");
    161 		goto out;
    162 	}
    163 
    164 	cap_free(cap_p);
    165 
    166 	rc = 0;
    167 out:
    168 	if (cap_p)
    169 		cap_free(cap_p);
    170 	return rc;
    171 }
    172 #else
    173 int modify_capability(int on)
    174 {
    175 	if (seteuid(on ? euid : getuid())) {
    176 		perror("seteuid");
    177 		return -1;
    178 	}
    179 
    180 	return 0;
    181 }
    182 #endif
    183 
    184 void drop_capabilities(void)
    185 {
    186 #ifdef CAPABILITIES
    187 	cap_t cap = cap_init();
    188 	if (cap_set_proc(cap) < 0) {
    189 		perror("ping: cap_set_proc");
    190 		exit(-1);
    191 	}
    192 	cap_free(cap);
    193 #else
    194 	if (setuid(getuid())) {
    195 		perror("ping: setuid");
    196 		exit(-1);
    197 	}
    198 #endif
    199 }
    200 
    201 void android_check_security(void)
    202 {
    203 	if (getauxval(AT_SECURE) != 0) {
    204 		fprintf(stderr, "This version of ping should NOT run with privileges. Aborting\n");
    205 		exit(1);
    206 	}
    207 }
    208 
    209 /* Fills all the outpack, excluding ICMP header, but _including_
    210  * timestamp area with supplied pattern.
    211  */
    212 static void fill(char *patp)
    213 {
    214 	int ii, jj, kk;
    215 	int pat[16];
    216 	char *cp;
    217 	u_char *bp = outpack+8;
    218 
    219 #ifdef USE_IDN
    220 	setlocale(LC_ALL, "C");
    221 #endif
    222 
    223 	for (cp = patp; *cp; cp++) {
    224 		if (!isxdigit(*cp)) {
    225 			fprintf(stderr,
    226 				"ping: patterns must be specified as hex digits.\n");
    227 			exit(2);
    228 		}
    229 	}
    230 	ii = sscanf(patp,
    231 	    "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
    232 	    &pat[0], &pat[1], &pat[2], &pat[3], &pat[4], &pat[5], &pat[6],
    233 	    &pat[7], &pat[8], &pat[9], &pat[10], &pat[11], &pat[12],
    234 	    &pat[13], &pat[14], &pat[15]);
    235 
    236 	if (ii > 0) {
    237 		for (kk = 0; kk <= maxpacket - (8 + ii); kk += ii)
    238 			for (jj = 0; jj < ii; ++jj)
    239 				bp[jj + kk] = pat[jj];
    240 	}
    241 	if (!(options & F_QUIET)) {
    242 		printf("PATTERN: 0x");
    243 		for (jj = 0; jj < ii; ++jj)
    244 			printf("%02x", bp[jj] & 0xFF);
    245 		printf("\n");
    246 	}
    247 
    248 #ifdef USE_IDN
    249 	setlocale(LC_ALL, "");
    250 #endif
    251 }
    252 
    253 void common_options(int ch)
    254 {
    255 	switch(ch) {
    256 	case 'a':
    257 		options |= F_AUDIBLE;
    258 		break;
    259 	case 'A':
    260 		options |= F_ADAPTIVE;
    261 		break;
    262 	case 'c':
    263 		npackets = atoi(optarg);
    264 		if (npackets <= 0) {
    265 			fprintf(stderr, "ping: bad number of packets to transmit.\n");
    266 			exit(2);
    267 		}
    268 		break;
    269 	case 'd':
    270 		options |= F_SO_DEBUG;
    271 		break;
    272 	case 'D':
    273 		options |= F_PTIMEOFDAY;
    274 		break;
    275 	case 'i':		/* wait between sending packets */
    276 	{
    277 		double dbl;
    278 		char *ep;
    279 
    280 		errno = 0;
    281 		dbl = strtod(optarg, &ep);
    282 
    283 		if (errno || *ep != '\0' ||
    284 		    !finite(dbl) || dbl < 0.0 || dbl >= (double)INT_MAX / 1000 - 1.0) {
    285 			fprintf(stderr, "ping: bad timing interval\n");
    286 			exit(2);
    287 		}
    288 
    289 		interval = (int)(dbl * 1000);
    290 
    291 		options |= F_INTERVAL;
    292 		break;
    293 	}
    294 	case 'm':
    295 	{
    296 		char *endp;
    297 		mark = (int)strtoul(optarg, &endp, 10);
    298 		if (mark < 0 || *endp != '\0') {
    299 			fprintf(stderr, "mark cannot be negative\n");
    300 			exit(2);
    301 		}
    302 		options |= F_MARK;
    303 		break;
    304 	}
    305 	case 'w':
    306 		deadline = atoi(optarg);
    307 		if (deadline < 0) {
    308 			fprintf(stderr, "ping: bad wait time.\n");
    309 			exit(2);
    310 		}
    311 		break;
    312 	case 'l':
    313 		preload = atoi(optarg);
    314 		if (preload <= 0) {
    315 			fprintf(stderr, "ping: bad preload value, should be 1..%d\n", MAX_DUP_CHK);
    316 			exit(2);
    317 		}
    318 		if (preload > MAX_DUP_CHK)
    319 			preload = MAX_DUP_CHK;
    320 		if (uid && preload > 3) {
    321 			fprintf(stderr, "ping: cannot set preload to value > 3\n");
    322 			exit(2);
    323 		}
    324 		break;
    325 	case 'O':
    326 		options |= F_OUTSTANDING;
    327 		break;
    328 	case 'S':
    329 		sndbuf = atoi(optarg);
    330 		if (sndbuf <= 0) {
    331 			fprintf(stderr, "ping: bad sndbuf value.\n");
    332 			exit(2);
    333 		}
    334 		break;
    335 	case 'f':
    336 		options |= F_FLOOD;
    337 		setbuf(stdout, (char *)NULL);
    338 		/* fallthrough to numeric - avoid gethostbyaddr during flood */
    339 	case 'n':
    340 		options |= F_NUMERIC;
    341 		break;
    342 	case 'p':		/* fill buffer with user pattern */
    343 		options |= F_PINGFILLED;
    344 		fill(optarg);
    345 		break;
    346 	case 'q':
    347 		options |= F_QUIET;
    348 		break;
    349 	case 'r':
    350 		options |= F_SO_DONTROUTE;
    351 		break;
    352 	case 's':		/* size of packet to send */
    353 		datalen = atoi(optarg);
    354 		if (datalen < 0) {
    355 			fprintf(stderr, "ping: illegal negative packet size %d.\n", datalen);
    356 			exit(2);
    357 		}
    358 		if (datalen > maxpacket - 8) {
    359 			fprintf(stderr, "ping: packet size too large: %d\n",
    360 				datalen);
    361 			exit(2);
    362 		}
    363 		break;
    364 	case 'v':
    365 		options |= F_VERBOSE;
    366 		break;
    367 	case 'L':
    368 		options |= F_NOLOOP;
    369 		break;
    370 	case 't':
    371 		options |= F_TTL;
    372 		ttl = atoi(optarg);
    373 		if (ttl < 0 || ttl > 255) {
    374 			fprintf(stderr, "ping: ttl %u out of range\n", ttl);
    375 			exit(2);
    376 		}
    377 		break;
    378 	case 'U':
    379 		options |= F_LATENCY;
    380 		break;
    381 	case 'B':
    382 		options |= F_STRICTSOURCE;
    383 		break;
    384 	case 'W':
    385 		lingertime = atoi(optarg);
    386 		if (lingertime < 0 || lingertime > INT_MAX/1000000) {
    387 			fprintf(stderr, "ping: bad linger time.\n");
    388 			exit(2);
    389 		}
    390 		lingertime *= 1000;
    391 		break;
    392 	case 'V':
    393 		printf("ping utility, iputils-%s\n", SNAPSHOT);
    394 		exit(0);
    395 	default:
    396 		abort();
    397 	}
    398 }
    399 
    400 
    401 static void sigexit(int signo)
    402 {
    403 	exiting = 1;
    404 	if (in_pr_addr)
    405 		longjmp(pr_addr_jmp, 0);
    406 }
    407 
    408 static void sigstatus(int signo)
    409 {
    410 	status_snapshot = 1;
    411 }
    412 
    413 
    414 int __schedule_exit(int next)
    415 {
    416 	static unsigned long waittime;
    417 	struct itimerval it;
    418 
    419 	if (waittime)
    420 		return next;
    421 
    422 	if (nreceived) {
    423 		waittime = 2 * tmax;
    424 		if (waittime < 1000*interval)
    425 			waittime = 1000*interval;
    426 	} else
    427 		waittime = lingertime*1000;
    428 
    429 	if (next < 0 || next < waittime/1000)
    430 		next = waittime/1000;
    431 
    432 	it.it_interval.tv_sec = 0;
    433 	it.it_interval.tv_usec = 0;
    434 	it.it_value.tv_sec = waittime/1000000;
    435 	it.it_value.tv_usec = waittime%1000000;
    436 	setitimer(ITIMER_REAL, &it, NULL);
    437 	return next;
    438 }
    439 
    440 static inline void update_interval(void)
    441 {
    442 	int est = rtt ? rtt/8 : interval*1000;
    443 
    444 	interval = (est+rtt_addend+500)/1000;
    445 	if (uid && interval < MINUSERINTERVAL)
    446 		interval = MINUSERINTERVAL;
    447 }
    448 
    449 /*
    450  * Print timestamp
    451  */
    452 void print_timestamp(void)
    453 {
    454 	if (options & F_PTIMEOFDAY) {
    455 		struct timeval tv;
    456 		gettimeofday(&tv, NULL);
    457 		printf("[%lu.%06lu] ",
    458 		       (unsigned long)tv.tv_sec, (unsigned long)tv.tv_usec);
    459 	}
    460 }
    461 
    462 /*
    463  * pinger --
    464  * 	Compose and transmit an ICMP ECHO REQUEST packet.  The IP packet
    465  * will be added on by the kernel.  The ID field is our UNIX process ID,
    466  * and the sequence number is an ascending integer.  The first 8 bytes
    467  * of the data portion are used to hold a UNIX "timeval" struct in VAX
    468  * byte-order, to compute the round-trip time.
    469  */
    470 int pinger(void)
    471 {
    472 	static int oom_count;
    473 	static int tokens;
    474 	int i;
    475 
    476 	/* Have we already sent enough? If we have, return an arbitrary positive value. */
    477 	if (exiting || (npackets && ntransmitted >= npackets && !deadline))
    478 		return 1000;
    479 
    480 	/* Check that packets < rate*time + preload */
    481 	if (cur_time.tv_sec == 0) {
    482 		gettimeofday(&cur_time, NULL);
    483 		tokens = interval*(preload-1);
    484 	} else {
    485 		long ntokens;
    486 		struct timeval tv;
    487 
    488 		gettimeofday(&tv, NULL);
    489 		ntokens = (tv.tv_sec - cur_time.tv_sec)*1000 +
    490 			(tv.tv_usec-cur_time.tv_usec)/1000;
    491 		if (!interval) {
    492 			/* Case of unlimited flood is special;
    493 			 * if we see no reply, they are limited to 100pps */
    494 			if (ntokens < MININTERVAL && in_flight() >= preload)
    495 				return MININTERVAL-ntokens;
    496 		}
    497 		ntokens += tokens;
    498 		if (ntokens > interval*preload)
    499 			ntokens = interval*preload;
    500 		if (ntokens < interval)
    501 			return interval - ntokens;
    502 
    503 		cur_time = tv;
    504 		tokens = ntokens - interval;
    505 	}
    506 
    507 	if (options & F_OUTSTANDING) {
    508 		if (ntransmitted > 0 && !rcvd_test(ntransmitted)) {
    509 			print_timestamp();
    510 			printf("no answer yet for icmp_seq=%lu\n", (ntransmitted % MAX_DUP_CHK));
    511 			fflush(stdout);
    512 		}
    513 	}
    514 
    515 resend:
    516 	i = send_probe();
    517 
    518 	if (i == 0) {
    519 		oom_count = 0;
    520 		advance_ntransmitted();
    521 		if (!(options & F_QUIET) && (options & F_FLOOD)) {
    522 			/* Very silly, but without this output with
    523 			 * high preload or pipe size is very confusing. */
    524 			if ((preload < screen_width && pipesize < screen_width) ||
    525 			    in_flight() < screen_width)
    526 				write_stdout(".", 1);
    527 		}
    528 		return interval - tokens;
    529 	}
    530 
    531 	/* And handle various errors... */
    532 	if (i > 0) {
    533 		/* Apparently, it is some fatal bug. */
    534 		abort();
    535 	} else if (errno == ENOBUFS || errno == ENOMEM) {
    536 		int nores_interval;
    537 
    538 		/* Device queue overflow or OOM. Packet is not sent. */
    539 		tokens = 0;
    540 		/* Slowdown. This works only in adaptive mode (option -A) */
    541 		rtt_addend += (rtt < 8*50000 ? rtt/8 : 50000);
    542 		if (options&F_ADAPTIVE)
    543 			update_interval();
    544 		nores_interval = SCHINT(interval/2);
    545 		if (nores_interval > 500)
    546 			nores_interval = 500;
    547 		oom_count++;
    548 		if (oom_count*nores_interval < lingertime)
    549 			return nores_interval;
    550 		i = 0;
    551 		/* Fall to hard error. It is to avoid complete deadlock
    552 		 * on stuck output device even when dealine was not requested.
    553 		 * Expected timings are screwed up in any case, but we will
    554 		 * exit some day. :-) */
    555 	} else if (errno == EAGAIN) {
    556 		/* Socket buffer is full. */
    557 		tokens += interval;
    558 		return MININTERVAL;
    559 	} else {
    560 		if ((i=receive_error_msg()) > 0) {
    561 			/* An ICMP error arrived. */
    562 			tokens += interval;
    563 			return MININTERVAL;
    564 		}
    565 		/* Compatibility with old linuces. */
    566 		if (i == 0 && confirm_flag && errno == EINVAL) {
    567 			confirm_flag = 0;
    568 			errno = 0;
    569 		}
    570 		if (!errno)
    571 			goto resend;
    572 	}
    573 
    574 	/* Hard local error. Pretend we sent packet. */
    575 	advance_ntransmitted();
    576 
    577 	if (i == 0 && !(options & F_QUIET)) {
    578 		if (options & F_FLOOD)
    579 			write_stdout("E", 1);
    580 		else
    581 			perror("ping: sendmsg");
    582 	}
    583 	tokens = 0;
    584 	return SCHINT(interval);
    585 }
    586 
    587 /* Set socket buffers, "alloc" is an estimate of memory taken by single packet. */
    588 
    589 void sock_setbufs(int icmp_sock, int alloc)
    590 {
    591 	int rcvbuf, hold;
    592 	socklen_t tmplen = sizeof(hold);
    593 
    594 	if (!sndbuf)
    595 		sndbuf = alloc;
    596 	setsockopt(icmp_sock, SOL_SOCKET, SO_SNDBUF, (char *)&sndbuf, sizeof(sndbuf));
    597 
    598 	rcvbuf = hold = alloc * preload;
    599 	if (hold < 65536)
    600 		hold = 65536;
    601 	setsockopt(icmp_sock, SOL_SOCKET, SO_RCVBUF, (char *)&hold, sizeof(hold));
    602 	if (getsockopt(icmp_sock, SOL_SOCKET, SO_RCVBUF, (char *)&hold, &tmplen) == 0) {
    603 		if (hold < rcvbuf)
    604 			fprintf(stderr, "WARNING: probably, rcvbuf is not enough to hold preload.\n");
    605 	}
    606 }
    607 
    608 void sock_setmark(int icmp_sock) {
    609 #ifdef SO_MARK
    610 	if (options & F_MARK) {
    611 		int ret;
    612 
    613 		enable_capability_admin();
    614 		ret = setsockopt(icmp_sock, SOL_SOCKET, SO_MARK, &mark, sizeof(mark));
    615 		disable_capability_admin();
    616 
    617 		if (ret == -1) {
    618 			/* we probably dont wanna exit since old kernels
    619 			 * dont support mark ..
    620 			*/
    621 			fprintf(stderr, "Warning: Failed to set mark %d\n", mark);
    622 		}
    623 	}
    624 #endif
    625 }
    626 
    627 /* Protocol independent setup and parameter checks. */
    628 
    629 void setup(int icmp_sock)
    630 {
    631 	int hold;
    632 	struct timeval tv;
    633 	sigset_t sset;
    634 
    635 	if ((options & F_FLOOD) && !(options & F_INTERVAL))
    636 		interval = 0;
    637 
    638 	if (uid && interval < MINUSERINTERVAL) {
    639 		fprintf(stderr, "ping: cannot flood; minimal interval, allowed for user, is %dms\n", MINUSERINTERVAL);
    640 		exit(2);
    641 	}
    642 
    643 	if (interval >= INT_MAX/preload) {
    644 		fprintf(stderr, "ping: illegal preload and/or interval\n");
    645 		exit(2);
    646 	}
    647 
    648 	hold = 1;
    649 	if (options & F_SO_DEBUG)
    650 		setsockopt(icmp_sock, SOL_SOCKET, SO_DEBUG, (char *)&hold, sizeof(hold));
    651 	if (options & F_SO_DONTROUTE)
    652 		setsockopt(icmp_sock, SOL_SOCKET, SO_DONTROUTE, (char *)&hold, sizeof(hold));
    653 
    654 #ifdef SO_TIMESTAMP
    655 	if (!(options&F_LATENCY)) {
    656 		int on = 1;
    657 		if (setsockopt(icmp_sock, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on)))
    658 			fprintf(stderr, "Warning: no SO_TIMESTAMP support, falling back to SIOCGSTAMP\n");
    659 	}
    660 #endif
    661 
    662 	sock_setmark(icmp_sock);
    663 
    664 	/* Set some SNDTIMEO to prevent blocking forever
    665 	 * on sends, when device is too slow or stalls. Just put limit
    666 	 * of one second, or "interval", if it is less.
    667 	 */
    668 	tv.tv_sec = 1;
    669 	tv.tv_usec = 0;
    670 	if (interval < 1000) {
    671 		tv.tv_sec = 0;
    672 		tv.tv_usec = 1000 * SCHINT(interval);
    673 	}
    674 	setsockopt(icmp_sock, SOL_SOCKET, SO_SNDTIMEO, (char*)&tv, sizeof(tv));
    675 
    676 	/* Set RCVTIMEO to "interval". Note, it is just an optimization
    677 	 * allowing to avoid redundant poll(). */
    678 	tv.tv_sec = SCHINT(interval)/1000;
    679 	tv.tv_usec = 1000*(SCHINT(interval)%1000);
    680 	if (setsockopt(icmp_sock, SOL_SOCKET, SO_RCVTIMEO, (char*)&tv, sizeof(tv)))
    681 		options |= F_FLOOD_POLL;
    682 
    683 	if (!(options & F_PINGFILLED)) {
    684 		int i;
    685 		u_char *p = outpack+8;
    686 
    687 		/* Do not forget about case of small datalen,
    688 		 * fill timestamp area too!
    689 		 */
    690 		for (i = 0; i < datalen; ++i)
    691 			*p++ = i;
    692 	}
    693 
    694 	if (!using_ping_socket)
    695 		ident = htons(getpid() & 0xFFFF);
    696 
    697 	set_signal(SIGINT, sigexit);
    698 	set_signal(SIGALRM, sigexit);
    699 	set_signal(SIGQUIT, sigstatus);
    700 
    701 	sigemptyset(&sset);
    702 	sigprocmask(SIG_SETMASK, &sset, NULL);
    703 
    704 	gettimeofday(&start_time, NULL);
    705 
    706 	if (deadline) {
    707 		struct itimerval it;
    708 
    709 		it.it_interval.tv_sec = 0;
    710 		it.it_interval.tv_usec = 0;
    711 		it.it_value.tv_sec = deadline;
    712 		it.it_value.tv_usec = 0;
    713 		setitimer(ITIMER_REAL, &it, NULL);
    714 	}
    715 
    716 	if (isatty(STDOUT_FILENO)) {
    717 		struct winsize w;
    718 
    719 		if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &w) != -1) {
    720 			if (w.ws_col > 0)
    721 				screen_width = w.ws_col;
    722 		}
    723 	}
    724 }
    725 
    726 void main_loop(int icmp_sock, __u8 *packet, int packlen)
    727 {
    728 	char addrbuf[128];
    729 	char ans_data[4096];
    730 	struct iovec iov;
    731 	struct msghdr msg;
    732 	struct cmsghdr *c;
    733 	int cc;
    734 	int next;
    735 	int polling;
    736 
    737 	iov.iov_base = (char *)packet;
    738 
    739 	for (;;) {
    740 		/* Check exit conditions. */
    741 		if (exiting)
    742 			break;
    743 		if (npackets && nreceived + nerrors >= npackets)
    744 			break;
    745 		if (deadline && nerrors)
    746 			break;
    747 		/* Check for and do special actions. */
    748 		if (status_snapshot)
    749 			status();
    750 
    751 		/* Send probes scheduled to this time. */
    752 		do {
    753 			next = pinger();
    754 			next = schedule_exit(next);
    755 		} while (next <= 0);
    756 
    757 		/* "next" is time to send next probe, if positive.
    758 		 * If next<=0 send now or as soon as possible. */
    759 
    760 		/* Technical part. Looks wicked. Could be dropped,
    761 		 * if everyone used the newest kernel. :-)
    762 		 * Its purpose is:
    763 		 * 1. Provide intervals less than resolution of scheduler.
    764 		 *    Solution: spinning.
    765 		 * 2. Avoid use of poll(), when recvmsg() can provide
    766 		 *    timed waiting (SO_RCVTIMEO). */
    767 		polling = 0;
    768 		if ((options & (F_ADAPTIVE|F_FLOOD_POLL)) || next<SCHINT(interval)) {
    769 			int recv_expected = in_flight();
    770 
    771 			/* If we are here, recvmsg() is unable to wait for
    772 			 * required timeout. */
    773 			if (1000 % HZ == 0 ? next <= 1000 / HZ : (next < INT_MAX / HZ && next * HZ <= 1000)) {
    774 				/* Very short timeout... So, if we wait for
    775 				 * something, we sleep for MININTERVAL.
    776 				 * Otherwise, spin! */
    777 				if (recv_expected) {
    778 					next = MININTERVAL;
    779 				} else {
    780 					next = 0;
    781 					/* When spinning, no reasons to poll.
    782 					 * Use nonblocking recvmsg() instead. */
    783 					polling = MSG_DONTWAIT;
    784 					/* But yield yet. */
    785 					sched_yield();
    786 				}
    787 			}
    788 
    789 			if (!polling &&
    790 			    ((options & (F_ADAPTIVE|F_FLOOD_POLL)) || interval)) {
    791 				struct pollfd pset;
    792 				pset.fd = icmp_sock;
    793 				pset.events = POLLIN|POLLERR;
    794 				pset.revents = 0;
    795 				if (poll(&pset, 1, next) < 1 ||
    796 				    !(pset.revents&(POLLIN|POLLERR)))
    797 					continue;
    798 				polling = MSG_DONTWAIT;
    799 			}
    800 		}
    801 
    802 		for (;;) {
    803 			struct timeval *recv_timep = NULL;
    804 			struct timeval recv_time;
    805 			int not_ours = 0; /* Raw socket can receive messages
    806 					   * destined to other running pings. */
    807 
    808 			iov.iov_len = packlen;
    809 			memset(&msg, 0, sizeof(msg));
    810 			msg.msg_name = addrbuf;
    811 			msg.msg_namelen = sizeof(addrbuf);
    812 			msg.msg_iov = &iov;
    813 			msg.msg_iovlen = 1;
    814 			msg.msg_control = ans_data;
    815 			msg.msg_controllen = sizeof(ans_data);
    816 
    817 			cc = recvmsg(icmp_sock, &msg, polling);
    818 			polling = MSG_DONTWAIT;
    819 
    820 			if (cc < 0) {
    821 				if (errno == EAGAIN || errno == EINTR)
    822 					break;
    823 				if (!receive_error_msg()) {
    824 					if (errno) {
    825 						perror("ping: recvmsg");
    826 						break;
    827 					}
    828 					not_ours = 1;
    829 				}
    830 			} else {
    831 
    832 #ifdef SO_TIMESTAMP
    833 				for (c = CMSG_FIRSTHDR(&msg); c; c = CMSG_NXTHDR(&msg, c)) {
    834 					if (c->cmsg_level != SOL_SOCKET ||
    835 					    c->cmsg_type != SO_TIMESTAMP)
    836 						continue;
    837 					if (c->cmsg_len < CMSG_LEN(sizeof(struct timeval)))
    838 						continue;
    839 					recv_timep = (struct timeval*)CMSG_DATA(c);
    840 				}
    841 #endif
    842 
    843 				if ((options&F_LATENCY) || recv_timep == NULL) {
    844 					if ((options&F_LATENCY) ||
    845 					    ioctl(icmp_sock, SIOCGSTAMP, &recv_time))
    846 						gettimeofday(&recv_time, NULL);
    847 					recv_timep = &recv_time;
    848 				}
    849 
    850 				not_ours = parse_reply(&msg, cc, addrbuf, recv_timep);
    851 			}
    852 
    853 			/* See? ... someone runs another ping on this host. */
    854 			if (not_ours && !using_ping_socket)
    855 				install_filter();
    856 
    857 			/* If nothing is in flight, "break" returns us to pinger. */
    858 			if (in_flight() == 0)
    859 				break;
    860 
    861 			/* Otherwise, try to recvmsg() again. recvmsg()
    862 			 * is nonblocking after the first iteration, so that
    863 			 * if nothing is queued, it will receive EAGAIN
    864 			 * and return to pinger. */
    865 		}
    866 	}
    867 	finish();
    868 }
    869 
    870 int gather_statistics(__u8 *icmph, int icmplen,
    871 		      int cc, __u16 seq, int hops,
    872 		      int csfailed, struct timeval *tv, char *from,
    873 		      void (*pr_reply)(__u8 *icmph, int cc))
    874 {
    875 	int dupflag = 0;
    876 	long triptime = 0;
    877 	__u8 *ptr = icmph + icmplen;
    878 
    879 	++nreceived;
    880 	if (!csfailed)
    881 		acknowledge(seq);
    882 
    883 	if (timing && cc >= 8+sizeof(struct timeval)) {
    884 		struct timeval tmp_tv;
    885 		memcpy(&tmp_tv, ptr, sizeof(tmp_tv));
    886 
    887 restamp:
    888 		tvsub(tv, &tmp_tv);
    889 		triptime = tv->tv_sec * 1000000 + tv->tv_usec;
    890 		if (triptime < 0) {
    891 			fprintf(stderr, "Warning: time of day goes back (%ldus), taking countermeasures.\n", triptime);
    892 			triptime = 0;
    893 			if (!(options & F_LATENCY)) {
    894 				gettimeofday(tv, NULL);
    895 				options |= F_LATENCY;
    896 				goto restamp;
    897 			}
    898 		}
    899 		if (!csfailed) {
    900 			tsum += triptime;
    901 			tsum2 += (long long)triptime * (long long)triptime;
    902 			if (triptime < tmin)
    903 				tmin = triptime;
    904 			if (triptime > tmax)
    905 				tmax = triptime;
    906 			if (!rtt)
    907 				rtt = triptime*8;
    908 			else
    909 				rtt += triptime-rtt/8;
    910 			if (options&F_ADAPTIVE)
    911 				update_interval();
    912 		}
    913 	}
    914 
    915 	if (csfailed) {
    916 		++nchecksum;
    917 		--nreceived;
    918 	} else if (rcvd_test(seq)) {
    919 		++nrepeats;
    920 		--nreceived;
    921 		dupflag = 1;
    922 	} else {
    923 		rcvd_set(seq);
    924 		dupflag = 0;
    925 	}
    926 	confirm = confirm_flag;
    927 
    928 	if (options & F_QUIET)
    929 		return 1;
    930 
    931 	if (options & F_FLOOD) {
    932 		if (!csfailed)
    933 			write_stdout("\b \b", 3);
    934 		else
    935 			write_stdout("\bC", 2);
    936 	} else {
    937 		int i;
    938 		__u8 *cp, *dp;
    939 
    940 		print_timestamp();
    941 		printf("%d bytes from %s:", cc, from);
    942 
    943 		if (pr_reply)
    944 			pr_reply(icmph, cc);
    945 
    946 		if (hops >= 0)
    947 			printf(" ttl=%d", hops);
    948 
    949 		if (cc < datalen+8) {
    950 			printf(" (truncated)\n");
    951 			return 1;
    952 		}
    953 		if (timing) {
    954 			if (triptime >= 100000)
    955 				printf(" time=%ld ms", triptime/1000);
    956 			else if (triptime >= 10000)
    957 				printf(" time=%ld.%01ld ms", triptime/1000,
    958 				       (triptime%1000)/100);
    959 			else if (triptime >= 1000)
    960 				printf(" time=%ld.%02ld ms", triptime/1000,
    961 				       (triptime%1000)/10);
    962 			else
    963 				printf(" time=%ld.%03ld ms", triptime/1000,
    964 				       triptime%1000);
    965 		}
    966 		if (dupflag)
    967 			printf(" (DUP!)");
    968 		if (csfailed)
    969 			printf(" (BAD CHECKSUM!)");
    970 
    971 		/* check the data */
    972 		cp = ((u_char*)ptr) + sizeof(struct timeval);
    973 		dp = &outpack[8 + sizeof(struct timeval)];
    974 		for (i = sizeof(struct timeval); i < datalen; ++i, ++cp, ++dp) {
    975 			if (*cp != *dp) {
    976 				printf("\nwrong data byte #%d should be 0x%x but was 0x%x",
    977 				       i, *dp, *cp);
    978 				cp = (u_char*)ptr + sizeof(struct timeval);
    979 				for (i = sizeof(struct timeval); i < datalen; ++i, ++cp) {
    980 					if ((i % 32) == sizeof(struct timeval))
    981 						printf("\n#%d\t", i);
    982 					printf("%x ", *cp);
    983 				}
    984 				break;
    985 			}
    986 		}
    987 	}
    988 	return 0;
    989 }
    990 
    991 static long llsqrt(long long a)
    992 {
    993 	long long prev = ~((long long)1 << 63);
    994 	long long x = a;
    995 
    996 	if (x > 0) {
    997 		while (x < prev) {
    998 			prev = x;
    999 			x = (x+(a/x))/2;
   1000 		}
   1001 	}
   1002 
   1003 	return (long)x;
   1004 }
   1005 
   1006 /*
   1007  * finish --
   1008  *	Print out statistics, and give up.
   1009  */
   1010 void finish(void)
   1011 {
   1012 	struct timeval tv = cur_time;
   1013 	char *comma = "";
   1014 
   1015 	tvsub(&tv, &start_time);
   1016 
   1017 	putchar('\n');
   1018 	fflush(stdout);
   1019 	printf("--- %s ping statistics ---\n", hostname);
   1020 	printf("%ld packets transmitted, ", ntransmitted);
   1021 	printf("%ld received", nreceived);
   1022 	if (nrepeats)
   1023 		printf(", +%ld duplicates", nrepeats);
   1024 	if (nchecksum)
   1025 		printf(", +%ld corrupted", nchecksum);
   1026 	if (nerrors)
   1027 		printf(", +%ld errors", nerrors);
   1028 	if (ntransmitted) {
   1029 		printf(", %d%% packet loss",
   1030 		       (int) ((((long long)(ntransmitted - nreceived)) * 100) /
   1031 			      ntransmitted));
   1032 		printf(", time %ldms", 1000*tv.tv_sec+tv.tv_usec/1000);
   1033 	}
   1034 	putchar('\n');
   1035 
   1036 	if (nreceived && timing) {
   1037 		long tmdev;
   1038 
   1039 		tsum /= nreceived + nrepeats;
   1040 		tsum2 /= nreceived + nrepeats;
   1041 		tmdev = llsqrt(tsum2 - tsum * tsum);
   1042 
   1043 		printf("rtt min/avg/max/mdev = %ld.%03ld/%lu.%03ld/%ld.%03ld/%ld.%03ld ms",
   1044 		       (long)tmin/1000, (long)tmin%1000,
   1045 		       (unsigned long)(tsum/1000), (long)(tsum%1000),
   1046 		       (long)tmax/1000, (long)tmax%1000,
   1047 		       (long)tmdev/1000, (long)tmdev%1000
   1048 		       );
   1049 		comma = ", ";
   1050 	}
   1051 	if (pipesize > 1) {
   1052 		printf("%spipe %d", comma, pipesize);
   1053 		comma = ", ";
   1054 	}
   1055 	if (nreceived && (!interval || (options&(F_FLOOD|F_ADAPTIVE))) && ntransmitted > 1) {
   1056 		int ipg = (1000000*(long long)tv.tv_sec+tv.tv_usec)/(ntransmitted-1);
   1057 		printf("%sipg/ewma %d.%03d/%d.%03d ms",
   1058 		       comma, ipg/1000, ipg%1000, rtt/8000, (rtt/8)%1000);
   1059 	}
   1060 	putchar('\n');
   1061 	exit(!nreceived || (deadline && nreceived < npackets));
   1062 }
   1063 
   1064 
   1065 void status(void)
   1066 {
   1067 	int loss = 0;
   1068 	long tavg = 0;
   1069 
   1070 	status_snapshot = 0;
   1071 
   1072 	if (ntransmitted)
   1073 		loss = (((long long)(ntransmitted - nreceived)) * 100) / ntransmitted;
   1074 
   1075 	fprintf(stderr, "\r%ld/%ld packets, %d%% loss", ntransmitted, nreceived, loss);
   1076 
   1077 	if (nreceived && timing) {
   1078 		tavg = tsum / (nreceived + nrepeats);
   1079 
   1080 		fprintf(stderr, ", min/avg/ewma/max = %ld.%03ld/%lu.%03ld/%d.%03d/%ld.%03ld ms",
   1081 		       (long)tmin/1000, (long)tmin%1000,
   1082 		       tavg/1000, tavg%1000,
   1083 		       rtt/8000, (rtt/8)%1000,
   1084 		       (long)tmax/1000, (long)tmax%1000
   1085 		       );
   1086 	}
   1087 	fprintf(stderr, "\n");
   1088 }
   1089 
   1090 inline int is_ours(uint16_t id) {
   1091 	return using_ping_socket || id == ident;
   1092 }
   1093 
   1094