/*

 * Copyright (c) 1989 The Regents of the University of California.

 * All rights reserved.

 *

 * This code is derived from software contributed to Berkeley by

 * Mike Muuss.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

/*

 *			P I N G . C

 *

 * Using the InterNet Control Message Protocol (ICMP) "ECHO" facility,

 * measure round-trip-delays and packet loss across network paths.

 *

 * Author -

 *	Mike Muuss

 *	U. S. Army Ballistic Research Laboratory

 *	December, 1983

 *

 * Status -

 *	Public Domain.  Distribution Unlimited.

 * Bugs -

 *	More statistics could always be gathered.

 *	If kernel does not support non-raw ICMP sockets,

 *	this program has to run SUID to ROOT or with

 *	net_cap_raw enabled.

 */

#include "ping.h"

#include <assert.h>

#include <netinet/ip.h>

#include <netinet/ip_icmp.h>

#ifndef WITHOUT_IFADDRS

#include <ifaddrs.h>

#endif

#ifndef ICMP_FILTER

#define ICMP_FILTER	1

struct icmp_filter {

	__u32	data;

};

#endif

ping_func_set_st ping4_func_set = {

	.send_probe = ping4_send_probe,

	.receive_error_msg = ping4_receive_error_msg,

	.parse_reply = ping4_parse_reply,

	.install_filter = ping4_install_filter

};

#define	MAXIPLEN	60

#define	MAXICMPLEN	76

#define	NROUTES		9		/* number of record route slots */

#define TOS_MAX		255		/* 8-bit TOS field */

static int ts_type;

static int nroute = 0;

static __u32 route[10];

static struct sockaddr_in whereto;	/* who to ping */

static int optlen = 0;

static int settos = 0;			/* Set TOS, Precendence or other QOS options */

static int broadcast_pings = 0;

static void pr_options(unsigned char * cp, int hlen);

static void pr_iph(struct iphdr *ip);

static void usage(void) __attribute__((noreturn));

static unsigned short in_cksum(const unsigned short *addr, int len, unsigned short salt);

static void pr_icmph(__u8 type, __u8 code, __u32 info, struct icmphdr *icp);

static int parsetos(char *str);

static int parseflow(char *str);

static struct {

	struct cmsghdr cm;

	struct in_pktinfo ipi;

} cmsg = { {sizeof(struct cmsghdr) + sizeof(struct in_pktinfo), SOL_IP, IP_PKTINFO},

	   {0, }};

int cmsg_len;

static struct sockaddr_in source = { .sin_family = AF_INET };

char *device;

int pmtudisc = -1;

static void create_socket(socket_st *sock, int family, int socktype, int protocol, int requisite)

{

	int do_fallback = 0;

	errno = 0;

	assert(sock->fd == -1);

	assert(socktype == SOCK_DGRAM || socktype == SOCK_RAW);

	/* Attempt to create a ping socket if requested. Attempt to create a raw

	 * socket otherwise or as a fallback. Well known errno values follow.

	 *

	 * 1) EACCES

	 *

	 * Kernel returns EACCES for all ping socket creation attempts when the

	 * user isn't allowed to use ping socket. A range of group ids is

	 * configured using the `net.ipv4.ping_group_range` sysctl. Fallback

	 * to raw socket is necessary.

	 *

	 * Kernel returns EACCES for all raw socket creation attempts when the

	 * proces doesn't have the `CAP_NET_RAW` capability.

	 *

	 * 2) EAFNOSUPPORT

	 *

	 * Kernel returns EAFNOSUPPORT for IPv6 ping or raw socket creation

	 * attempts when run with IPv6 support disabled (e.g. via `ipv6.disable=1`

	 * kernel command-line option.

	 *

	 * https://github.com/iputils/iputils/issues/32

	 *

	 * OpenVZ 2.6.32-042stab113.11 and possibly other older kernels return

	 * EAFNOSUPPORT for all IPv4 ping socket creation attempts due to lack

	 * of support in the kernel. Fallback to raw socket is necessary.

	 *

	 * https://github.com/iputils/iputils/issues/54

	 *

	 * 3) EPROTONOSUPPORT

	 *

	 * OpenVZ 2.6.32-042stab113.11 and possibly other older kernels return

	 * EPROTONOSUPPORT for all IPv6 ping socket creation attempts due to lack

	 * of support in the kernel. Fallback to raw socket is necessary.

	 *

	 * https://github.com/iputils/iputils/issues/54

	 *

	 */

	if (socktype == SOCK_DGRAM)

		sock->fd = socket(family, socktype, protocol);

	/* Kernel doesn't support ping sockets. */

	if (sock->fd == -1 && errno == EAFNOSUPPORT && family == AF_INET)

		do_fallback = 1;

	if (sock->fd == -1 && errno == EPROTONOSUPPORT && family == AF_INET6)

		do_fallback = 1;

	/* User is not allowed to use ping sockets. */

	if (sock->fd == -1 && errno == EACCES)

		do_fallback = 1;

	if (socktype == SOCK_RAW || do_fallback) {

		socktype = SOCK_RAW;

		sock->fd = socket(family, SOCK_RAW, protocol);

	}

	if (sock->fd == -1) {

		/* Report error related to disabled IPv6 only when IPv6 also failed or in

		 * verbose mode. Report other errors always.

		 */

		if ((errno == EAFNOSUPPORT && socktype == AF_INET6) || options & F_VERBOSE || requisite)

			fprintf(stderr, "ping: socket: %s\n", strerror(errno));

		if (requisite)

			exit(2);

	} else

		sock->socktype = socktype;

}

static void set_socket_option(socket_st *sock, int level, int optname, const void *optval, socklen_t optlen)

{

	if (sock->fd == -1)

		return;

	if (setsockopt(sock->fd, level, optname, optval, optlen) == -1) {

		fprintf(stderr, "ping: setsockopt: %s\n", strerror(errno));

		exit(2);

	}

}

int

main(int argc, char **argv)

{

	struct addrinfo hints = { .ai_family = AF_UNSPEC, .ai_protocol = IPPROTO_UDP, .ai_socktype = SOCK_DGRAM, .ai_flags = getaddrinfo_flags };

	struct addrinfo *result, *ai;

	int status;

	int ch;

	socket_st sock4 = { .fd = -1 };

	socket_st sock6 = { .fd = -1 };

	char *target;

	limit_capabilities();

#ifdef USE_IDN

	setlocale(LC_ALL, "");

#endif

	if (!strcmp(setlocale(LC_ALL, NULL), "C"))

		hints.ai_flags &= ~ AI_CANONIDN;

	/* Support being called using `ping4` or `ping6` symlinks */

	if (argv[0][strlen(argv[0])-1] == '4')

		hints.ai_family = AF_INET;

	else if (argv[0][strlen(argv[0])-1] == '6')

		hints.ai_family = AF_INET6;

	/* Parse command line options */

	while ((ch = getopt(argc, argv, "h?" "4bRT:" "6F:N:" "aABc:dDfi:I:l:Lm:M:nOp:qQ:rs:S:t:UvVw:W:")) != EOF) {

		switch(ch) {

		/* IPv4 specific options */

		case '4':

			if (hints.ai_family != AF_UNSPEC) {

				fprintf(stderr, "ping: Only one -4 or -6 option may be specified\n");

				exit(2);

			}

			hints.ai_family = AF_INET;

			break;

		case 'b':

			broadcast_pings = 1;

			break;

		case 'R':

			if (options & F_TIMESTAMP) {

				fprintf(stderr, "Only one of -T or -R may be used\n");

				exit(2);

			}

			options |= F_RROUTE;

			break;

		case 'T':

			if (options & F_RROUTE) {

				fprintf(stderr, "Only one of -T or -R may be used\n");

				exit(2);

			}

			options |= F_TIMESTAMP;

			if (strcmp(optarg, "tsonly") == 0)

				ts_type = IPOPT_TS_TSONLY;

			else if (strcmp(optarg, "tsandaddr") == 0)

				ts_type = IPOPT_TS_TSANDADDR;

			else if (strcmp(optarg, "tsprespec") == 0)

				ts_type = IPOPT_TS_PRESPEC;

			else {

				fprintf(stderr, "Invalid timestamp type\n");

				exit(2);

			}

			break;

		/* IPv6 specific options */

		case '6':

			if (hints.ai_family != AF_UNSPEC) {

				fprintf(stderr, "ping: Only one -4 or -6 option may be specified\n");

				exit(2);

			}

			hints.ai_family = AF_INET6;

			break;

		case 'F':

			flowlabel = parseflow(optarg);

			options |= F_FLOWINFO;

			break;

		case 'N':

			if (niquery_option_handler(optarg) < 0) {

				ping6_usage(0);

				exit(2);

			}

			hints.ai_socktype = SOCK_RAW;

			break;

		/* Common options */

		case 'a':

			options |= F_AUDIBLE;

			break;

		case 'A':

			options |= F_ADAPTIVE;

			break;

		case 'B':

			options |= F_STRICTSOURCE;

			break;

		case 'c':

			npackets = atoi(optarg);

			if (npackets <= 0) {

				fprintf(stderr, "ping: bad number of packets to transmit.\n");

				exit(2);

			}

			break;

		case 'd':

			options |= F_SO_DEBUG;

			break;

		case 'D':

			options |= F_PTIMEOFDAY;

			break;

		case 'i':

		{

			double dbl;

			char *ep;

			errno = 0;

#ifdef USE_IDN

			setlocale(LC_ALL, "C");

#endif

			dbl = strtod(optarg, &ep);

#ifdef USE_IDN

			setlocale(LC_ALL, "");

#endif

			if (errno || *ep != '\0' ||

				!finite(dbl) || dbl < 0.0 || dbl >= (double)INT_MAX / 1000 - 1.0) {

				fprintf(stderr, "ping: bad timing interval\n");

				exit(2);

			}

			interval = (int)(dbl * 1000);

			options |= F_INTERVAL;

			break;

		}

		case 'I':

			/* IPv6 */

			if (strchr(optarg, ':')) {

				char *p, *addr = strdup(optarg);

				if (!addr) {

					fprintf(stderr, "ping: out of memory\n");

					exit(2);

				}

				p = strchr(addr, SCOPE_DELIMITER);

				if (p) {

					*p = '\0';

					device = optarg + (p - addr) + 1;

				}

				if (inet_pton(AF_INET6, addr, (char*)&source6.sin6_addr) <= 0) {

					fprintf(stderr, "ping: invalid source address %s\n", optarg);

					exit(2);

				}

				options |= F_STRICTSOURCE;

				free(addr);

			} else if (inet_pton(AF_INET, optarg, &source.sin_addr) > 0) {

				options |= F_STRICTSOURCE;

			} else {

				device = optarg;

			}

			break;

		case 'l':

			preload = atoi(optarg);

			if (preload <= 0) {

				fprintf(stderr, "ping: bad preload value, should be 1..%d\n", MAX_DUP_CHK);

				exit(2);

			}

			if (preload > MAX_DUP_CHK)

				preload = MAX_DUP_CHK;

			if (uid && preload > 3) {

				fprintf(stderr, "ping: cannot set preload to value > 3\n");

				exit(2);

			}

			break;

		case 'L':

			options |= F_NOLOOP;

			break;

		case 'm':

		{

			char *endp;

			mark = (int)strtoul(optarg, &endp, 10);

			if (mark < 0 || *endp != '\0') {

				fprintf(stderr, "mark cannot be negative\n");

				exit(2);

			}

			options |= F_MARK;

			break;

		}

		case 'M':

			if (strcmp(optarg, "do") == 0)

				pmtudisc = IP_PMTUDISC_DO;

			else if (strcmp(optarg, "dont") == 0)

				pmtudisc = IP_PMTUDISC_DONT;

			else if (strcmp(optarg, "want") == 0)

				pmtudisc = IP_PMTUDISC_WANT;

			else {

				fprintf(stderr, "ping: wrong value for -M: do, dont, want are valid ones.\n");

				exit(2);

			}

			break;

		case 'n':

			options |= F_NUMERIC;

			break;

		case 'O':

			options |= F_OUTSTANDING;

			break;

		case 'f':

			/* avoid `getaddrinfo()` during flood */

			options |= F_FLOOD | F_NUMERIC;

			setbuf(stdout, (char *)NULL);

			break;

		case 'p':

			options |= F_PINGFILLED;

			fill(optarg, outpack, sizeof(outpack));

			break;

		case 'q':

			options |= F_QUIET;

			break;

		case 'Q':

			settos = parsetos(optarg); /* IPv4 */

			tclass = settos; /* IPv6 */

			break;

		case 'r':

			options |= F_SO_DONTROUTE;

			break;

		case 's':

			datalen = atoi(optarg);

			if (datalen < 0) {

				fprintf(stderr, "ping: illegal negative packet size %d.\n", datalen);

				exit(2);

			}

			if (datalen > MAXPACKET - 8) {

				fprintf(stderr, "ping: packet size too large: %d\n",

					datalen);

				exit(2);

			}

			break;

		case 'S':

			sndbuf = atoi(optarg);

			if (sndbuf <= 0) {

				fprintf(stderr, "ping: bad sndbuf value.\n");

				exit(2);

			}

			break;

		case 't':

			options |= F_TTL;

			ttl = atoi(optarg);

			if (ttl < 0 || ttl > 255) {

				fprintf(stderr, "ping: ttl %u out of range\n", ttl);

				exit(2);

			}

			break;

		case 'U':

			options |= F_LATENCY;

			break;

		case 'v':

			options |= F_VERBOSE;

			break;

		case 'V':

			printf("ping utility, iputils-%s\n", SNAPSHOT);

			exit(0);

		case 'w':

			deadline = atoi(optarg);

			if (deadline < 0) {

				fprintf(stderr, "ping: bad wait time.\n");

				exit(2);

			}

			break;

		case 'W':

			lingertime = atoi(optarg);

			if (lingertime < 0 || lingertime > INT_MAX/1000000) {

				fprintf(stderr, "ping: bad linger time.\n");

				exit(2);

			}

			lingertime *= 1000;

			break;

		default:

			usage();

			break;

		}

	}

	argc -= optind;

	argv += optind;

	if (!argc)

		usage();

	target = argv[argc-1];

	/* Create sockets */

	enable_capability_raw();

	if (hints.ai_family != AF_INET6)

		create_socket(&sock4, AF_INET, hints.ai_socktype, IPPROTO_ICMP, hints.ai_family == AF_INET);

	if (hints.ai_family != AF_INET) {

		create_socket(&sock6, AF_INET6, hints.ai_socktype, IPPROTO_ICMPV6, sock4.fd == -1);

		/* This may not be needed if both protocol versions always had the same value, but

		 * since I don't know that, it's better to be safe than sorry. */

		pmtudisc = pmtudisc == IP_PMTUDISC_DO   ? IPV6_PMTUDISC_DO :

			   pmtudisc == IP_PMTUDISC_DONT ? IPV6_PMTUDISC_DONT :

			   pmtudisc == IP_PMTUDISC_WANT ? IPV6_PMTUDISC_WANT : pmtudisc;

	}

	disable_capability_raw();

	/* Limit address family on single-protocol systems */

	if (hints.ai_family == AF_UNSPEC) {

		if (sock4.fd == -1)

			hints.ai_family = AF_INET6;

		else if (sock6.fd == -1)

			hints.ai_family = AF_INET;

	}

	/* Set socket options */

	if (settos)

		set_socket_option(&sock4, IPPROTO_IP, IP_TOS, &settos, sizeof settos);

	if (tclass)

		set_socket_option(&sock6, IPPROTO_IPV6, IPV6_TCLASS, &tclass, sizeof tclass);

	status = getaddrinfo(target, NULL, &hints, &result);

	if (status) {

		fprintf(stderr, "ping: %s: %s\n", target, gai_strerror(status));

		exit(2);

	}

	for (ai = result; ai; ai = ai->ai_next) {

		switch (ai->ai_family) {

		case AF_INET:

			status = ping4_run(argc, argv, ai, &sock4);

			break;

		case AF_INET6:

			status = ping6_run(argc, argv, ai, &sock6);

			break;

		default:

			fprintf(stderr, "ping: unknown protocol family: %d\n", ai->ai_family);

			exit(2);

		}

		if (status == 0)

			break;

	}

	freeaddrinfo(result);

	return status;

}

int ping4_run(int argc, char **argv, struct addrinfo *ai, socket_st *sock)

{

	static const struct addrinfo hints = { .ai_family = AF_INET, .ai_protocol = IPPROTO_UDP, .ai_flags = getaddrinfo_flags };

	int hold, packlen;

	unsigned char *packet;

	char *target;

	char hnamebuf[NI_MAXHOST];

	unsigned char rspace[3 + 4 * NROUTES + 1];	/* record route space */

	__u32 *tmp_rspace;

	if (argc > 1) {

		if (options & F_RROUTE)

			usage();

		else if (options & F_TIMESTAMP) {

			if (ts_type != IPOPT_TS_PRESPEC)

				usage();

			if (argc > 5)

				usage();

		} else {

			if (argc > 10)

				usage();

			options |= F_SOURCEROUTE;

		}

	}

	while (argc > 0) {

		target = *argv;

		memset((char *)&whereto, 0, sizeof(whereto));

		whereto.sin_family = AF_INET;

		if (inet_aton(target, &whereto.sin_addr) == 1) {

			hostname = target;

			if (argc == 1)

				options |= F_NUMERIC;

		} else {

			struct addrinfo *result = NULL;

			int status;

			if (argc > 1 || !ai) {

				status = getaddrinfo(target, NULL, &hints, &result);

				if (status) {

					fprintf(stderr, "ping: %s: %s\n", target, gai_strerror(status));

					exit(2);

				}

				ai = result;

			}

			memcpy(&whereto, ai->ai_addr, sizeof whereto);

			memset(hnamebuf, 0, sizeof hnamebuf);

			if (ai->ai_canonname)

				strncpy(hnamebuf, ai->ai_canonname, sizeof hnamebuf - 1);

			hostname = hnamebuf;

			if (result) {

				freeaddrinfo(result);

				ai = NULL;

			}

		}

		if (argc > 1)

			route[nroute++] = whereto.sin_addr.s_addr;

		argc--;

		argv++;

	}

	if (source.sin_addr.s_addr == 0) {

		socklen_t alen;

		struct sockaddr_in dst = whereto;

		int probe_fd = socket(AF_INET, SOCK_DGRAM, 0);

		if (probe_fd < 0) {

			perror("socket");

			exit(2);

		}

		if (device) {

			struct ifreq ifr;

			int i;

			int fds[2] = {probe_fd, sock->fd};

			memset(&ifr, 0, sizeof(ifr));

			strncpy(ifr.ifr_name, device, IFNAMSIZ-1);

			for (i = 0; i < 2; i++) {

				int fd = fds[i];

				int rc;

				enable_capability_raw();

				rc = setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, device, strlen(device)+1);

				disable_capability_raw();

				if (rc == -1) {

					if (IN_MULTICAST(ntohl(dst.sin_addr.s_addr))) {

						struct ip_mreqn imr;

						if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0) {

							fprintf(stderr, "ping: unknown iface %s\n", device);

							exit(2);

						}

						memset(&imr, 0, sizeof(imr));

						imr.imr_ifindex = ifr.ifr_ifindex;

						if (setsockopt(fd, SOL_IP, IP_MULTICAST_IF, &imr, sizeof(imr)) == -1) {

							perror("ping: IP_MULTICAST_IF");

							exit(2);

						}

					} else {

						perror("ping: SO_BINDTODEVICE");

						exit(2);

					}

				}

			}

		}

		if (settos &&

		    setsockopt(probe_fd, IPPROTO_IP, IP_TOS, (char *)&settos, sizeof(int)) < 0)

			perror("Warning: error setting QOS sockopts");

		dst.sin_port = htons(1025);

		if (nroute)

			dst.sin_addr.s_addr = route[0];

		if (connect(probe_fd, (struct sockaddr*)&dst, sizeof(dst)) == -1) {

			if (errno == EACCES) {

				if (broadcast_pings == 0) {

					fprintf(stderr,

						"Do you want to ping broadcast? Then -b. If not, check your local firewall rules.\n");

					exit(2);

				}

				fprintf(stderr, "WARNING: pinging broadcast address\n");

				if (setsockopt(probe_fd, SOL_SOCKET, SO_BROADCAST,

					       &broadcast_pings, sizeof(broadcast_pings)) < 0) {

					perror ("can't set broadcasting");

					exit(2);

				}

				if (connect(probe_fd, (struct sockaddr*)&dst, sizeof(dst)) == -1) {

					perror("connect");

					exit(2);

				}

			} else {

				perror("connect");

				exit(2);

			}

		}

		alen = sizeof(source);

		if (getsockname(probe_fd, (struct sockaddr*)&source, &alen) == -1) {

			perror("getsockname");

			exit(2);

		}

		source.sin_port = 0;

#ifndef WITHOUT_IFADDRS

		if (device) {

			struct ifaddrs *ifa0, *ifa;

			int ret;

			ret = getifaddrs(&ifa0);

			if (ret) {

				fprintf(stderr, "gatifaddrs() failed.\n");

				exit(2);

			}

			for (ifa = ifa0; ifa; ifa = ifa->ifa_next) {

				if (!ifa->ifa_addr || ifa->ifa_addr->sa_family != AF_INET)

					continue;

				if (!strncmp(ifa->ifa_name, device, sizeof(device) - 1) &&

				    !memcmp(&((struct sockaddr_in *)ifa->ifa_addr)->sin_addr,

					    &source.sin_addr, sizeof(source.sin_addr)))

					break;

			}

			freeifaddrs(ifa0);

			if (!ifa)

				fprintf(stderr, "ping: Warning: source address might be selected on device other than %s.\n", device);

		}

#endif

		close(probe_fd);

	} while (0);

	if (whereto.sin_addr.s_addr == 0)

		whereto.sin_addr.s_addr = source.sin_addr.s_addr;

	if (device) {

		struct ifreq ifr;

		memset(&ifr, 0, sizeof(ifr));

		strncpy(ifr.ifr_name, device, IFNAMSIZ-1);

		if (ioctl(sock->fd, SIOCGIFINDEX, &ifr) < 0) {

			fprintf(stderr, "ping: unknown iface %s\n", device);

			exit(2);

		}

		cmsg.ipi.ipi_ifindex = ifr.ifr_ifindex;

		cmsg_len = sizeof(cmsg);

	}

	if (broadcast_pings || IN_MULTICAST(ntohl(whereto.sin_addr.s_addr))) {

		if (uid) {

			if (interval < 1000) {

				fprintf(stderr, "ping: broadcast ping with too short interval.\n");

				exit(2);

			}

			if (pmtudisc >= 0 && pmtudisc != IP_PMTUDISC_DO) {

				fprintf(stderr, "ping: broadcast ping does not fragment.\n");

				exit(2);

			}

		}

		if (pmtudisc < 0)

			pmtudisc = IP_PMTUDISC_DO;

	}

	if (pmtudisc >= 0) {

		if (setsockopt(sock->fd, SOL_IP, IP_MTU_DISCOVER, &pmtudisc, sizeof pmtudisc) == -1) {

			perror("ping: IP_MTU_DISCOVER");

			exit(2);

		}

	}

	if ((options&F_STRICTSOURCE) &&

	    bind(sock->fd, (struct sockaddr *) &source, sizeof source) == -1) {

		perror("bind");

		exit(2);

	}

	if (sock->socktype == SOCK_RAW) {

		struct icmp_filter filt;

		filt.data = ~((1<

			      (1<

			      (1<

			      (1<

			      (1<

			      (1<

		if (setsockopt(sock->fd, SOL_RAW, ICMP_FILTER, &filt, sizeof filt) == -1)

			perror("WARNING: setsockopt(ICMP_FILTER)");

	}

	hold = 1;

	if (setsockopt(sock->fd, SOL_IP, IP_RECVERR, &hold, sizeof hold))

		fprintf(stderr, "WARNING: your kernel is veeery old. No problems.\n");

	if (sock->socktype == SOCK_DGRAM) {

		if (setsockopt(sock->fd, SOL_IP, IP_RECVTTL, &hold, sizeof hold))

			perror("WARNING: setsockopt(IP_RECVTTL)");

		if (setsockopt(sock->fd, SOL_IP, IP_RETOPTS, &hold, sizeof hold))

			perror("WARNING: setsockopt(IP_RETOPTS)");

	}

	/* record route option */

	if (options & F_RROUTE) {

		memset(rspace, 0, sizeof(rspace));

		rspace[0] = IPOPT_NOP;

		rspace[1+IPOPT_OPTVAL] = IPOPT_RR;

		rspace[1+IPOPT_OLEN] = sizeof(rspace)-1;

		rspace[1+IPOPT_OFFSET] = IPOPT_MINOFF;

		optlen = 40;

		if (setsockopt(sock->fd, IPPROTO_IP, IP_OPTIONS, rspace, sizeof rspace) < 0) {

			perror("ping: record route");

			exit(2);

		}

	}

	if (options & F_TIMESTAMP) {

		memset(rspace, 0, sizeof(rspace));

		rspace[0] = IPOPT_TIMESTAMP;

		rspace[1] = (ts_type==IPOPT_TS_TSONLY ? 40 : 36);

		rspace[2] = 5;

		rspace[3] = ts_type;

		if (ts_type == IPOPT_TS_PRESPEC) {

			int i;

			rspace[1] = 4+nroute*8;

			for (i = 0; i < nroute; i++) {

				tmp_rspace = (__u32*)&rspace[4+i*8];

				*tmp_rspace = route[i];

			}

		}

		if (setsockopt(sock->fd, IPPROTO_IP, IP_OPTIONS, rspace, rspace[1]) < 0) {

			rspace[3] = 2;

			if (setsockopt(sock->fd, IPPROTO_IP, IP_OPTIONS, rspace, rspace[1]) < 0) {

				perror("ping: ts option");

				exit(2);

			}

		}

		optlen = 40;

	}

	if (options & F_SOURCEROUTE) {

		int i;

		memset(rspace, 0, sizeof(rspace));

		rspace[0] = IPOPT_NOOP;

		rspace[1+IPOPT_OPTVAL] = (options & F_SO_DONTROUTE) ? IPOPT_SSRR

			: IPOPT_LSRR;

		rspace[1+IPOPT_OLEN] = 3 + nroute*4;

		rspace[1+IPOPT_OFFSET] = IPOPT_MINOFF;

		for (i = 0; i < nroute; i++) {

			tmp_rspace = (__u32*)&rspace[4+i*4];

			*tmp_rspace = route[i];

		}

		if (setsockopt(sock->fd, IPPROTO_IP, IP_OPTIONS, rspace, 4 + nroute*4) < 0) {

			perror("ping: record route");

			exit(2);

		}

		optlen = 40;

	}

	/* Estimate memory eaten by single packet. It is rough estimate.

	 * Actually, for small datalen's it depends on kernel side a lot. */

	hold = datalen + 8;

	hold += ((hold+511)/512)*(optlen + 20 + 16 + 64 + 160);

	sock_setbufs(sock, hold);

	if (broadcast_pings) {

		if (setsockopt(sock->fd, SOL_SOCKET, SO_BROADCAST, &broadcast_pings, sizeof broadcast_pings) < 0) {

			perror ("ping: can't set broadcasting");

			exit(2);

		}

	}

	if (options & F_NOLOOP) {

		int loop = 0;

		if (setsockopt(sock->fd, IPPROTO_IP, IP_MULTICAST_LOOP, &loop, sizeof loop) == -1) {

			perror ("ping: can't disable multicast loopback");

			exit(2);

		}

	}

	if (options & F_TTL) {

		int ittl = ttl;

		if (setsockopt(sock->fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof ttl) == -1) {

			perror ("ping: can't set multicast time-to-live");

			exit(2);

		}

		if (setsockopt(sock->fd, IPPROTO_IP, IP_TTL, &ittl, sizeof ittl) == -1) {

			perror ("ping: can't set unicast time-to-live");

			exit(2);

		}

	}

	if (datalen > 0xFFFF - 8 - optlen - 20) {

		fprintf(stderr, "Error: packet size %d is too large. Maximum is %d\n", datalen, 0xFFFF-8-20-optlen);

		exit(2);

	}

	if (datalen >= sizeof(struct timeval))	/* can we time transfer */

		timing = 1;

	packlen = datalen + MAXIPLEN + MAXICMPLEN;

	if (!(packet = (unsigned char *)malloc((unsigned int)packlen))) {

		fprintf(stderr, "ping: out of memory.\n");

		exit(2);

	}

	printf("PING %s (%s) ", hostname, inet_ntoa(whereto.sin_addr));

	if (device || (options&F_STRICTSOURCE))

		printf("from %s %s: ", inet_ntoa(source.sin_addr), device ?: "");