/usr/src/sbin/ping/ping.c

Bug Summary

File:	src/sbin/ping/ping.c
Warning:	line 783, column 21 2nd function call argument is an uninitialized value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ping.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sbin/ping/obj -resource-dir /usr/local/llvm16/lib/clang/16 -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/sbin/ping/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/scan/2024-01-11-140451-98009-1 -x c /usr/src/sbin/ping/ping.c
1/*	$OpenBSD: ping.c,v 1.248 2022/12/01 07:34:06 florian Exp $	*/

3/*
* Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
* All rights reserved.
*
* 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 project 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 PROJECT 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 PROJECT 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.
*/

32/*
* Copyright (c) 1989, 1993
*	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.
*/

64/*
* 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.
*	This program has to run SUID to ROOT to access the ICMP socket.
*/

80#include <sys/types.h>
81#include <sys/socket.h>
82#include <sys/time.h>
83#include <sys/uio.h>

85#include <netinet/in.h>
86#include <netinet/ip.h>
87#include <netinet/ip_icmp.h>
88#include <netinet/ip_var.h>
89#include <netinet/ip6.h>
90#include <netinet/icmp6.h>
91#include <netinet/ip_ah.h>
92#include <arpa/inet.h>
93#include <netdb.h>

95#include <ctype.h>
96#include <err.h>
97#include <errno(*__errno()).h>
98#include <limits.h>
99#include <math.h>
100#include <poll.h>
101#include <pwd.h>
102#include <signal.h>
103#include <siphash.h>
104#include <stdint.h>
105#include <stdio.h>
106#include <stdlib.h>
107#include <string.h>
108#include <time.h>
109#include <unistd.h>

111struct tv64 {
u_int64_t	tv64_sec;
u_int64_t	tv64_nsec;
114};

116struct payload {
struct tv64	tv64;
u_int8_t	mac[SIPHASH_DIGEST_LENGTH8];
119};

121#define	ECHOLEN8		8	/* icmp echo header len excluding time */
122#define	ECHOTMLENsizeof(struct payload)	sizeof(struct payload)
123#define	DEFDATALEN(64 - 8)	(64 - ECHOLEN8)		/* default data length */
124#define	MAXIPLEN60	60
125#define	MAXICMPLEN76	76
126#define	MAXPAYLOAD(65535 - 60 - 8)	(IP_MAXPACKET65535 - MAXIPLEN60 - ECHOLEN8)
127#define	IP6LEN40		40
128#define	EXTRA256		256	/* for AH and various other headers. weird. */
129#define	MAXPAYLOAD665535 - 40 - 8	IPV6_MAXPACKET65535 - IP6LEN40 - ECHOLEN8
130#define	MAXWAIT_DEFAULT10	10			/* secs to wait for response */
131#define	NROUTES9		9			/* number of record route slots */

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

139/* various options */
140int options;
141#define	F_FLOOD0x0001		0x0001
142#define	F_INTERVAL0x0002	0x0002
143#define	F_HOSTNAME0x0004	0x0004
144#define	F_PINGFILLED0x0008	0x0008
145#define	F_QUIET0x0010		0x0010
146#define	F_RROUTE0x0020	0x0020
147#define	F_SO_DEBUG0x0040	0x0040
148#define	F_SHOWCHAR0x0080	0x0080
149#define	F_VERBOSE0x0100	0x0100
150/*			0x0200 */
151#define	F_HDRINCL0x0400	0x0400
152#define	F_TTL0x0800		0x0800
153#define	F_TOS0x1000		0x1000
154#define	F_AUD_RECV0x2000	0x2000
155#define	F_AUD_MISS0x4000	0x4000

157/* multicast options */
158int moptions;
159#define	MULTICAST_NOLOOP0x001	0x001
160#define	MULTICAST_TTL0x002		0x002

162#define	DUMMY_PORT10101	10101
163#define	PING_USER"_ping"	"_ping"

165/*
* MAX_DUP_CHK is the number of bits in received table, i.e. the maximum
* number of received sequence numbers we can keep track of.  Change 128
* to 8192 for complete accuracy...
*/
170#define	MAX_DUP_CHK(8 * 8192)	(8 * 8192)
171int mx_dup_ck = MAX_DUP_CHK(8 * 8192);
172char rcvd_tbl[MAX_DUP_CHK(8 * 8192) / 8];

174int datalen = DEFDATALEN(64 - 8);
175int maxpayload = MAXPAYLOAD(65535 - 60 - 8);
176u_char outpackhdr[IP_MAXPACKET65535+sizeof(struct ip)];
177u_char *outpack = outpackhdr+sizeof(struct ip);
178char BSPACE = '\b';		/* characters written for flood */
179char DOT = '.';
180char *hostname;
181int ident;			/* random number to identify our packets */
182int v6flag;			/* are we ping6? */

184/* counters */
185int64_t npackets;		/* max packets to transmit */
186int64_t nreceived;		/* # of packets we got back */
187int64_t nrepeats;		/* number of duplicates */
188int64_t ntransmitted;		/* sequence # for outbound packets = #sent */
189int64_t nmissedmax = 1;		/* max value of ntransmitted - nreceived - 1 */
190struct timeval interval = {1, 0}; /* interval between packets */

192/* timing */
193int timing;			/* flag to do timing */
194int timinginfo;
195unsigned int maxwait = MAXWAIT_DEFAULT10;	/* max seconds to wait for response */
196double tmin = 999999999.0;	/* minimum round trip time */
197double tmax;			/* maximum round trip time */
198double tsum;			/* sum of all times, for doing average */
199double tsumsq;			/* sum of all times squared, for std. dev. */

201struct tv64 tv64_offset;
202SIPHASH_KEY mac_key;

204struct msghdr smsghdr;
205struct iovec smsgiov;

207volatile sig_atomic_t seenalrm;
208volatile sig_atomic_t seenint;
209volatile sig_atomic_t seeninfo;

211void			 fill(char *, char *);
212void			 summary(void);
213void			 onsignal(int);
214void			 retransmit(int);
215int			 pinger(int);
216const char		*pr_addr(struct sockaddr *, socklen_t);
217void			 pr_pack(u_char *, int, struct msghdr *);
218__dead__attribute__((__noreturn__)) void		 usage(void);

220/* IPv4 specific functions */
221void			 pr_ipopt(int, u_char *);
222int			 in_cksum(u_short *, int);
223void			 pr_icmph(struct icmp *);
224void			 pr_retip(struct ip *);
225void			 pr_iph(struct ip *);
226#ifndef SMALL
227int			 map_tos(char *, int *);
228#endif	/* SMALL */

230/* IPv6 specific functions */
231int			 get_hoplim(struct msghdr *);
232int			 get_pathmtu(struct msghdr *, struct sockaddr_in6 *);
233void			 pr_icmph6(struct icmp6_hdr *, u_char *);
234void			 pr_iph6(struct ip6_hdr *);
235void			 pr_exthdrs(struct msghdr *);
236void			 pr_ip6opt(void *);
237void			 pr_rthdr(void *);
238void			 pr_retip6(struct ip6_hdr *, u_char *);

240int
241main(int argc, char *argv[])
242{
struct addrinfo hints, *res;
struct itimerval itimer;
struct sockaddr *from, *dst;
struct sockaddr_in from4, dst4;
struct sockaddr_in6 from6, dst6;
struct cmsghdr *scmsg = NULL((void *)0);
struct in6_pktinfo *pktinfo = NULL((void *)0);
struct icmp6_filter filt;
struct passwd *pw;
socklen_t maxsizelen;
int64_t preload;
int ch, i, optval = 1, packlen, maxsize, error, s, flooddone = 0;
int df = 0, tos = 0, bufspace = IP_MAXPACKET65535, hoplimit = -1, mflag = 0;
u_char *datap, *packet;
u_char ttl = MAXTTL255;
char *e, *target, hbuf[NI_MAXHOST256], *source = NULL((void *)0);
char rspace[3 + 4 * NROUTES9 + 1];	/* record route space */
const char *errstr;
double fraction, integral, seconds;
uid_t ouid, uid;
gid_t gid;
u_int rtableid = 0;
extern char *__progname;

/* Cannot pledge due to special setsockopt()s below */
if (unveil("/", "r") == -1)
1
Assuming the condition is false→
2
←
Taking false branch→
err(1, "unveil /");
if (unveil(NULL((void *)0), NULL((void *)0)) == -1)
3
←
Assuming the condition is false→
4
←
Taking false branch→
err(1, "unveil");

if (strcmp("ping6", __progname) == 0) {
5
←
Assuming the condition is false→
6
←
Taking false branch→
v6flag = 1;
maxpayload = MAXPAYLOAD665535 - 40 - 8;
if ((s = socket(AF_INET624, SOCK_RAW3, IPPROTO_ICMPV658)) == -1)
	err(1, "socket");
} else {
if ((s = socket(AF_INET2, SOCK_RAW3, IPPROTO_ICMP1)) == -1)
7
←
Assuming the condition is false→
8
←
Taking false branch→
	err(1, "socket");
}

/* revoke privs */
ouid = getuid();
if (ouid == 0 && (pw = getpwnam(PING_USER"_ping")) != NULL((void *)0)) {
9
←
Assuming 'ouid' is not equal to 0→
uid = pw->pw_uid;
gid = pw->pw_gid;
} else {
uid = getuid();
gid = getgid();
}
if (ouid9.1
'ouid' is not equal to 0
 && (setgroups(1, &gid) ||
10
←
Assuming the condition is false→
13
←
Taking false branch→
   setresgid(gid, gid, gid) ||
11
←
Assuming the condition is false→
   setresuid(uid, uid, uid)))
12
←
Assuming the condition is false→
err(1, "unable to revoke privs");

preload = 0;
datap = &outpack[ECHOLEN8 + ECHOTMLENsizeof(struct payload)];
while ((ch = getopt(argc, argv, v6flag ?
14
←
Assuming 'v6flag' is 0→
15
←
'?' condition is false→
16
←
Assuming the condition is false→
   "c:DdEefgHh:I:i:Ll:mNnp:qS:s:T:V:vw:" :
   "DEI:LRS:c:defgHi:l:np:qs:T:t:V:vw:")) != -1) {
switch(ch) {
case 'c':
	npackets = strtonum(optarg, 0, INT64_MAX0x7fffffffffffffffLL, &errstr);
	if (errstr)
		errx(1,
		    "number of packets to transmit is %s: %s",
		    errstr, optarg);
	break;
case 'D':
	options |= F_HDRINCL0x0400;
	df = 1;
	break;
case 'd':
	options |= F_SO_DEBUG0x0040;
	break;
case 'E':
	options |= F_AUD_MISS0x4000;
	break;
case 'e':
	options |= F_AUD_RECV0x2000;
	break;
case 'f':
	if (ouid)
		errc(1, EPERM1, NULL((void *)0));
	options |= F_FLOOD0x0001;
	setvbuf(stdout(&__sF[1]), NULL((void *)0), _IONBF2, 0);
	break;
case 'g':
	options |= F_SHOWCHAR0x0080;
	break;
case 'H':
	options |= F_HOSTNAME0x0004;
	break;
case 'h':		/* hoplimit */
	hoplimit = strtonum(optarg, 0, IPV6_MAXHLIM255, &errstr);
	if (errstr)
		errx(1, "hoplimit is %s: %s", errstr, optarg);
	break;
case 'I':
case 'S':	/* deprecated */
	source = optarg;
	break;
case 'i':		/* interval between packets */
	seconds = strtod(optarg, &e);
	if (*optarg == '\0' || *e != '\0' || seconds < 0.0)
		errx(1, "interval is invalid: %s", optarg);
	fraction = modf(seconds, &integral);
	if (integral > UINT_MAX0xffffffffU)
		errx(1, "interval is too large: %s", optarg);
	interval.tv_sec = integral;
	interval.tv_usec = fraction * 1000000.0;
	if (!timerisset(&interval)((&interval)->tv_sec || (&interval)->tv_usec))
		errx(1, "interval is too small: %s", optarg);
	if (interval.tv_sec < 1 && ouid != 0) {
		errx(1, "only root may use an interval smaller"
		    " than one second");
	}
	options |= F_INTERVAL0x0002;
	break;
case 'L':
	moptions |= MULTICAST_NOLOOP0x001;
	break;
case 'l':
	if (ouid)
		errc(1, EPERM1, NULL((void *)0));
	preload = strtonum(optarg, 1, INT64_MAX0x7fffffffffffffffLL, &errstr);
	if (errstr)
		errx(1, "preload value is %s: %s", errstr,
		    optarg);
	break;
case 'm':
	mflag++;
	break;
case 'n':
	options &= ~F_HOSTNAME0x0004;
	break;
case 'p':		/* fill buffer with user pattern */
	options |= F_PINGFILLED0x0008;
	fill((char *)datap, optarg);
		break;
case 'q':
	options |= F_QUIET0x0010;
	break;
case 'R':
	options |= F_RROUTE0x0020;
	break;
case 's':		/* size of packet to send */
	datalen = strtonum(optarg, 0, maxpayload, &errstr);
	if (errstr)
		errx(1, "packet size is %s: %s", errstr,
		    optarg);
	break;
394#ifndef SMALL
case 'T':
	options |= F_HDRINCL0x0400;
	options |= F_TOS0x1000;
	errno(*__errno()) = 0;
	errstr = NULL((void *)0);
	if (map_tos(optarg, &tos))
		break;
	if (strlen(optarg) > 1 && optarg[0] == '0' &&
	    optarg[1] == 'x')
		tos = (int)strtol(optarg, NULL((void *)0), 16);
	else
		tos = strtonum(optarg, 0, 255, &errstr);
	if (tos < 0 || tos > 255 || errstr || errno(*__errno()))
		errx(1, "illegal tos value %s", optarg);
	break;
410#endif	/* SMALL */
case 't':
	options |= F_TTL0x0800;
	ttl = strtonum(optarg, 0, MAXTTL255, &errstr);
	if (errstr)
		errx(1, "ttl value is %s: %s", errstr, optarg);
	break;
case 'V':
	rtableid = strtonum(optarg, 0, RT_TABLEID_MAX255, &errstr);
	if (errstr)
		errx(1, "rtable value is %s: %s", errstr,
		    optarg);
	if (setsockopt(s, SOL_SOCKET0xffff, SO_RTABLE0x1021, &rtableid,
	    sizeof(rtableid)) == -1)
		err(1, "setsockopt SO_RTABLE");
	break;
case 'v':
	options |= F_VERBOSE0x0100;
	break;
case 'w':
	maxwait = strtonum(optarg, 1, INT_MAX0x7fffffff, &errstr);
	if (errstr)
		errx(1, "maxwait value is %s: %s",
		    errstr, optarg);
	break;
default:
	usage();
}
}

if (ouid16.1
'ouid' is not equal to 0
 == 0 && (setgroups(1, &gid) ||
   setresgid(gid, gid, gid) ||
   setresuid(uid, uid, uid)))
err(1, "unable to revoke privs");

argc -= optind;
argv += optind;

if (argc != 1)
17
←
Assuming 'argc' is equal to 1→
18
←
Taking false branch→
usage();

memset(&dst4, 0, sizeof(dst4));
memset(&dst6, 0, sizeof(dst6));

target = *argv;

memset(&hints, 0, sizeof(hints));
hints.ai_family = v6flag18.1
'v6flag' is 0
 ? AF_INET624 : AF_INET2;
19
←
'?' condition is false→
hints.ai_socktype = SOCK_RAW3;
hints.ai_protocol = 0;
hints.ai_flags = AI_CANONNAME2;
if ((error = getaddrinfo(target, NULL((void *)0), &hints, &res)))
20
←
Assuming 'error' is 0→
21
←
Taking false branch→
errx(1, "%s", gai_strerror(error));

switch (res->ai_family) {
22
←
Control jumps to 'case 24:'  at line 469→
case AF_INET2:
dst = (struct sockaddr *)&dst4;
from = (struct sockaddr *)&from4;
break;
case AF_INET624:
dst = (struct sockaddr *)&dst6;
from = (struct sockaddr *)&from6;
break;
default:
errx(1, "unsupported AF: %d", res->ai_family);
break;
}

memcpy(dst, res->ai_addr, res->ai_addrlen);

if (!hostname) {
23
←
Assuming 'hostname' is non-null→
24
←
Taking false branch→
hostname = res->ai_canonname ? strdup(res->ai_canonname) :
    target;
if (!hostname)
	err(1, "malloc");
}

if (res->ai_next) {
25
←
Assuming field 'ai_next' is null→
26
←
Taking false branch→
if (getnameinfo(res->ai_addr, res->ai_addrlen, hbuf,
    sizeof(hbuf), NULL((void *)0), 0, NI_NUMERICHOST1) != 0)
	strlcpy(hbuf, "?", sizeof(hbuf));
warnx("Warning: %s has multiple "
    "addresses; using %s", hostname, hbuf);
}
freeaddrinfo(res);

if (source26.1
'source' is null
) {
27
←
Taking false branch→
memset(&hints, 0, sizeof(hints));
hints.ai_family = dst->sa_family;
if ((error = getaddrinfo(source, NULL((void *)0), &hints, &res)))
	errx(1, "%s: %s", source, gai_strerror(error));
memcpy(from, res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);

if (!v6flag && IN_MULTICAST(ntohl(dst4.sin_addr.s_addr))(((u_int32_t)((__uint32_t)(__builtin_constant_p(dst4.sin_addr
.s_addr) ? (__uint32_t)(((__uint32_t)(dst4.sin_addr.s_addr) &
 0xff) << 24 | ((__uint32_t)(dst4.sin_addr.s_addr) &
 0xff00) << 8 | ((__uint32_t)(dst4.sin_addr.s_addr) &
 0xff0000) >> 8 | ((__uint32_t)(dst4.sin_addr.s_addr) &
 0xff000000) >> 24) : __swap32md(dst4.sin_addr.s_addr))
) & ((u_int32_t)(0xf0000000))) == ((u_int32_t)(0xe0000000
)))) {
	if (setsockopt(s, IPPROTO_IP0, IP_MULTICAST_IF9,
	    &from4.sin_addr, sizeof(from4.sin_addr)) == -1)
		err(1, "setsockopt IP_MULTICAST_IF");
} else {
	if (bind(s, from, from->sa_len) == -1)
		err(1, "bind");
}
} else if (options & F_VERBOSE0x0100) {
28
←
Assuming the condition is false→
29
←
Taking false branch→
/*
 * get the source address. XXX since we revoked the root
 * privilege, we cannot use a raw socket for this.
 */
int dummy;
socklen_t len = dst->sa_len;

if ((dummy = socket(dst->sa_family, SOCK_DGRAM2, 0)) == -1)
	err(1, "UDP socket");

memcpy(from, dst, dst->sa_len);
if (v6flag) {
	from6.sin6_port = ntohs(DUMMY_PORT)(__uint16_t)(__builtin_constant_p(10101) ? (__uint16_t)(((__uint16_t
)(10101) & 0xffU) << 8 | ((__uint16_t)(10101) &
 0xff00U) >> 8) : __swap16md(10101));
	if (pktinfo &&
	    setsockopt(dummy, IPPROTO_IPV641, IPV6_PKTINFO46,
	    pktinfo, sizeof(*pktinfo)))
		err(1, "UDP setsockopt(IPV6_PKTINFO)");

	if (hoplimit != -1 &&
	    setsockopt(dummy, IPPROTO_IPV641, IPV6_UNICAST_HOPS4,
	    &hoplimit, sizeof(hoplimit)))
		err(1, "UDP setsockopt(IPV6_UNICAST_HOPS)");

	if (hoplimit != -1 &&
	    setsockopt(dummy, IPPROTO_IPV641, IPV6_MULTICAST_HOPS10,
	    &hoplimit, sizeof(hoplimit)))
		err(1, "UDP setsockopt(IPV6_MULTICAST_HOPS)");
} else {
	u_char loop = 0;

	from4.sin_port = ntohs(DUMMY_PORT)(__uint16_t)(__builtin_constant_p(10101) ? (__uint16_t)(((__uint16_t
)(10101) & 0xffU) << 8 | ((__uint16_t)(10101) &
 0xff00U) >> 8) : __swap16md(10101));

	if ((moptions & MULTICAST_NOLOOP0x001) && setsockopt(dummy,
	    IPPROTO_IP0, IP_MULTICAST_LOOP11, &loop,
	    sizeof(loop)) == -1)
		err(1, "setsockopt IP_MULTICAST_LOOP");
	if ((moptions & MULTICAST_TTL0x002) && setsockopt(dummy,
	    IPPROTO_IP0, IP_MULTICAST_TTL10, &ttl,
	    sizeof(ttl)) == -1)
		err(1, "setsockopt IP_MULTICAST_TTL");
}

if (rtableid > 0 &&
    setsockopt(dummy, SOL_SOCKET0xffff, SO_RTABLE0x1021, &rtableid,
    sizeof(rtableid)) == -1)
	err(1, "setsockopt(SO_RTABLE)");

if (connect(dummy, from, len) == -1)
	err(1, "UDP connect");

if (getsockname(dummy, from, &len) == -1)
	err(1, "getsockname");

close(dummy);
}

if (options & F_SO_DEBUG0x0040)
30
←
Assuming the condition is false→
(void)setsockopt(s, SOL_SOCKET0xffff, SO_DEBUG0x0001, &optval,
    sizeof(optval));

if ((options & F_FLOOD0x0001) && (options & F_INTERVAL0x0002))
31
←
Assuming the condition is false→
errx(1, "-f and -i options are incompatible");

if ((options & F_FLOOD0x0001) && (options & (F_AUD_RECV0x2000 | F_AUD_MISS0x4000)))
warnx("No audible output for flood pings");

if (datalen >= sizeof(struct payload))	/* can we time transfer */
32
←
Assuming the condition is false→
33
←
Taking false branch→
timing = 1;

if (v6flag33.1
'v6flag' is 0
) {
34
←
Taking false branch→
/* in F_VERBOSE case, we may get non-echoreply packets*/
if ((options & F_VERBOSE0x0100) && datalen < 2048) /* XXX 2048? */
	packlen = 2048 + IP6LEN40 + ECHOLEN8 + EXTRA256;
else
	packlen = datalen + IP6LEN40 + ECHOLEN8 + EXTRA256;
} else
packlen = datalen + MAXIPLEN60 + MAXICMPLEN76;
if (!(packet = malloc(packlen)))
35
←
Assuming 'packet' is non-null→
36
←
Taking false branch→
err(1, "malloc");

if (!(options & F_PINGFILLED0x0008))
37
←
Assuming the condition is false→
38
←
Taking false branch→
for (i = ECHOTMLENsizeof(struct payload); i < datalen; ++i)
	*datap++ = i;

ident = arc4random() & 0xFFFF;

/*
* When trying to send large packets, you must increase the
* size of both the send and receive buffers...
*/
maxsizelen = sizeof maxsize;
if (getsockopt(s, SOL_SOCKET0xffff, SO_SNDBUF0x1001, &maxsize, &maxsizelen) == -1)
39
←
Assuming the condition is false→
err(1, "getsockopt");
if (maxsize < packlen &&
40
←
Assuming 'maxsize' is >= 'packlen'→
   setsockopt(s, SOL_SOCKET0xffff, SO_SNDBUF0x1001, &packlen, sizeof(maxsize)) == -1)
err(1, "setsockopt");

/*
* When pinging the broadcast address, you can get a lot of answers.
* Doing something so evil is useful if you are trying to stress the
* ethernet, or just want to fill the arp cache to get some stuff for
* /etc/ethers.
*/
while (setsockopt(s, SOL_SOCKET0xffff, SO_RCVBUF0x1002,
41
←
Assuming the condition is false→
42
←
Loop condition is false. Execution continues on line 621→
   &bufspace, sizeof(bufspace)) == -1) {
if ((bufspace -= 1024) <= 0)
	err(1, "Cannot set the receive buffer size");
}
if (bufspace42.1
'bufspace' is >= IP_MAXPACKET
 < IP_MAXPACKET65535)
43
←
Taking false branch→
warnx("Could only allocate a receive buffer of %d bytes "
    "(default %d)", bufspace, IP_MAXPACKET65535);

if (v6flag43.1
'v6flag' is 0
) {
44
←
Taking false branch→
unsigned int loop = 0;

/*
 * let the kernel pass extension headers of incoming packets,
 * for privileged socket options
 */
if (options & F_VERBOSE0x0100) {
	int opton = 1;

	if (setsockopt(s, IPPROTO_IPV641, IPV6_RECVHOPOPTS39,
	    &opton, sizeof(opton)))
		err(1, "setsockopt(IPV6_RECVHOPOPTS)");
	if (setsockopt(s, IPPROTO_IPV641, IPV6_RECVDSTOPTS40,
	    &opton, sizeof(opton)))
		err(1, "setsockopt(IPV6_RECVDSTOPTS)");
	if (setsockopt(s, IPPROTO_IPV641, IPV6_RECVRTHDR38,
	    &opton, sizeof(opton)))
		err(1, "setsockopt(IPV6_RECVRTHDR)");
	ICMP6_FILTER_SETPASSALL(&filt)memset(&filt, 0xff, sizeof(struct icmp6_filter));
} else {
	ICMP6_FILTER_SETBLOCKALL(&filt)memset(&filt, 0x00, sizeof(struct icmp6_filter));
	ICMP6_FILTER_SETPASS(ICMP6_ECHO_REPLY, &filt)(((&filt)->icmp6_filt[(129) >> 5]) |= (1 <<
 ((129) & 31)));
}

if ((moptions & MULTICAST_NOLOOP0x001) &&
    setsockopt(s, IPPROTO_IPV641, IPV6_MULTICAST_LOOP11,
    &loop, sizeof(loop)) == -1)
	err(1, "setsockopt IPV6_MULTICAST_LOOP");

optval = IPV6_DEFHLIM64;
if (IN6_IS_ADDR_MULTICAST(&dst6.sin6_addr)((&dst6.sin6_addr)->__u6_addr.__u6_addr8[0] == 0xff)) {
	if (setsockopt(s, IPPROTO_IPV641, IPV6_MULTICAST_HOPS10,
	    &optval, sizeof(optval)) == -1)
		err(1, "IPV6_MULTICAST_HOPS");
}
if (mflag != 1) {
	optval = mflag > 1 ? 0 : 1;

	if (setsockopt(s, IPPROTO_IPV641, IPV6_USE_MIN_MTU42,
	    &optval, sizeof(optval)) == -1)
		err(1, "setsockopt(IPV6_USE_MIN_MTU)");
} else {
	optval = 1;
	if (setsockopt(s, IPPROTO_IPV641, IPV6_RECVPATHMTU43,
	    &optval, sizeof(optval)) == -1)
		err(1, "setsockopt(IPV6_RECVPATHMTU)");
}

if (setsockopt(s, IPPROTO_ICMPV658, ICMP6_FILTER18,
    &filt, sizeof(filt)) == -1)
	err(1, "setsockopt(ICMP6_FILTER)");

if (hoplimit != -1) {
	/* set IP6 packet options */
	if ((scmsg = malloc( CMSG_SPACE(sizeof(int))((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (((unsigned long)(sizeof(int))
 + (sizeof(long) - 1)) &~(sizeof(long) - 1))))) == NULL((void *)0))
		err(1, "malloc");
	smsghdr.msg_control = (caddr_t)scmsg;
	smsghdr.msg_controllen = CMSG_SPACE(sizeof(int))((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (((unsigned long)(sizeof(int))
 + (sizeof(long) - 1)) &~(sizeof(long) - 1)));

	scmsg->cmsg_len = CMSG_LEN(sizeof(int))((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (sizeof(int)));
	scmsg->cmsg_level = IPPROTO_IPV641;
	scmsg->cmsg_type = IPV6_HOPLIMIT47;
	*(int *)(CMSG_DATA(scmsg)((unsigned char *)(scmsg) + (((unsigned long)(sizeof(struct cmsghdr
)) + (sizeof(long) - 1)) &~(sizeof(long) - 1)))) = hoplimit;
}

if (options & F_TOS0x1000) {
	optval = tos;
	if (setsockopt(s, IPPROTO_IPV641, IPV6_TCLASS61,
	    &optval, sizeof(optval)) == -1)
		err(1, "setsockopt(IPV6_TCLASS)");
}

if (df) {
	optval = 1;
	if (setsockopt(s, IPPROTO_IPV641, IPV6_DONTFRAG62,
	    &optval, sizeof(optval)) == -1)
		err(1, "setsockopt(IPV6_DONTFRAG)");
}

optval = 1;
if (setsockopt(s, IPPROTO_IPV641, IPV6_RECVPKTINFO36,
    &optval, sizeof(optval)) == -1)
	err(1, "setsockopt(IPV6_RECVPKTINFO)");
if (setsockopt(s, IPPROTO_IPV641, IPV6_RECVHOPLIMIT37,
    &optval, sizeof(optval)) == -1)
	err(1, "setsockopt(IPV6_RECVHOPLIMIT)");
} else {
u_char loop = 0;

if (options & F_TTL0x0800) {
45
←
Assuming the condition is true→
	if (IN_MULTICAST(ntohl(dst4.sin_addr.s_addr))(((u_int32_t)((__uint32_t)(__builtin_constant_p(dst4.sin_addr
.s_addr) ? (__uint32_t)(((__uint32_t)(dst4.sin_addr.s_addr) &
 0xff) << 24 | ((__uint32_t)(dst4.sin_addr.s_addr) &
 0xff00) << 8 | ((__uint32_t)(dst4.sin_addr.s_addr) &
 0xff0000) >> 8 | ((__uint32_t)(dst4.sin_addr.s_addr) &
 0xff000000) >> 24) : __swap32md(dst4.sin_addr.s_addr))
) & ((u_int32_t)(0xf0000000))) == ((u_int32_t)(0xe0000000
))))
46
←
Taking true branch→
47
←
'?' condition is false→
48
←
Assuming the condition is false→
49
←
Taking false branch→
		moptions |= MULTICAST_TTL0x002;
	else
		options |= F_HDRINCL0x0400;
}

if ((options & F_RROUTE0x0020) && (options & F_HDRINCL0x0400))
50
←
Assuming the condition is false→
	errx(1, "-R option and -D or -T, or -t to unicast"
	    " destinations are incompatible");

if (options & F_HDRINCL0x0400) {
51
←
Assuming the condition is false→
52
←
Taking false branch→
	struct ip *ip = (struct ip *)outpackhdr;

	if (setsockopt(s, IPPROTO_IP0, IP_HDRINCL2,
	    &optval, sizeof(optval)) == -1)
		err(1, "setsockopt(IP_HDRINCL)");
	ip->ip_v = IPVERSION4;
	ip->ip_hl = sizeof(struct ip) >> 2;
	ip->ip_tos = tos;
	ip->ip_id = 0;
	ip->ip_off = htons(df ? IP_DF : 0)(__uint16_t)(__builtin_constant_p(df ? 0x4000 : 0) ? (__uint16_t
)(((__uint16_t)(df ? 0x4000 : 0) & 0xffU) << 8 | ((
__uint16_t)(df ? 0x4000 : 0) & 0xff00U) >> 8) : __swap16md
(df ? 0x4000 : 0));
	ip->ip_ttl = ttl;
	ip->ip_p = IPPROTO_ICMP1;
	if (source)
		ip->ip_src = from4.sin_addr;
	else
		ip->ip_src.s_addr = INADDR_ANY((u_int32_t)(0x00000000));
	ip->ip_dst = dst4.sin_addr;
}

/* record route option */
if (options & F_RROUTE0x0020) {
	if (IN_MULTICAST(ntohl(dst4.sin_addr.s_addr))(((u_int32_t)((__uint32_t)(__builtin_constant_p(dst4.sin_addr
.s_addr) ? (__uint32_t)(((__uint32_t)(dst4.sin_addr.s_addr) &
 0xff) << 24 | ((__uint32_t)(dst4.sin_addr.s_addr) &
 0xff00) << 8 | ((__uint32_t)(dst4.sin_addr.s_addr) &
 0xff0000) >> 8 | ((__uint32_t)(dst4.sin_addr.s_addr) &
 0xff000000) >> 24) : __swap32md(dst4.sin_addr.s_addr))
) & ((u_int32_t)(0xf0000000))) == ((u_int32_t)(0xe0000000
))))
		errx(1, "record route not valid to multicast"
		    " destinations");
	memset(rspace, 0, sizeof(rspace));
	rspace[IPOPT_OPTVAL0] = IPOPT_RR7;
	rspace[IPOPT_OLEN1] = sizeof(rspace)-1;
	rspace[IPOPT_OFFSET2] = IPOPT_MINOFF4;
	if (setsockopt(s, IPPROTO_IP0, IP_OPTIONS1,
	    rspace, sizeof(rspace)) == -1)
		err(1, "record route");
}

if ((moptions & MULTICAST_NOLOOP0x001) &&
53
←
Assuming the condition is false→
    setsockopt(s, IPPROTO_IP0, IP_MULTICAST_LOOP11,
    &loop, sizeof(loop)) == -1)
	err(1, "setsockopt IP_MULTICAST_LOOP");
if ((moptions & MULTICAST_TTL0x002) &&
54
←
Assuming the condition is false→
    setsockopt(s, IPPROTO_IP0, IP_MULTICAST_TTL10,
    &ttl, sizeof(ttl)) == -1)
	err(1, "setsockopt IP_MULTICAST_TTL");
}

if (options & F_HOSTNAME0x0004) {
55
←
Assuming the condition is false→
56
←
Taking false branch→
if (pledge("stdio inet dns", NULL((void *)0)) == -1)
	err(1, "pledge");
} else {
if (pledge("stdio inet", NULL((void *)0)) == -1)
57
←
Assuming the condition is false→
58
←
Taking false branch→
	err(1, "pledge");
}

arc4random_buf(&tv64_offset, sizeof(tv64_offset));
arc4random_buf(&mac_key, sizeof(mac_key));

printf("PING %s (", hostname);
if (options & F_VERBOSE0x0100)
59
←
Assuming the condition is true→
60
←
Taking true branch→
printf("%s --> ", pr_addr(from, from->sa_len));
61
←
2nd function call argument is an uninitialized value
printf("%s): %d data bytes\n", pr_addr(dst, dst->sa_len), datalen);

smsghdr.msg_name = dst;
smsghdr.msg_namelen = dst->sa_len;
smsgiov.iov_base = (caddr_t)outpack;
smsghdr.msg_iov = &smsgiov;
smsghdr.msg_iovlen = 1;

/* Drain our socket. */
(void)signal(SIGALRM14, onsignal);
memset(&itimer, 0, sizeof(itimer));
itimer.it_value.tv_sec = 1; /* make sure we don't get stuck */
(void)setitimer(ITIMER_REAL0, &itimer, NULL((void *)0));
for (;;) {
struct msghdr		m;
union {
	struct cmsghdr hdr;
	u_char buf[CMSG_SPACE(1024)((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (((unsigned long)(1024) + (sizeof
(long) - 1)) &~(sizeof(long) - 1)))];
}			cmsgbuf;
struct iovec		iov[1];
struct pollfd		pfd;
struct sockaddr_in	peer4;
struct sockaddr_in6	peer6;
ssize_t			cc;

if (seenalrm)
	break;

pfd.fd = s;
pfd.events = POLLIN0x0001;

if (poll(&pfd, 1, 0) <= 0)
	break;

if (v6flag) {
	m.msg_name = &peer6;
	m.msg_namelen = sizeof(peer6);
} else {
	m.msg_name = &peer4;
	m.msg_namelen = sizeof(peer4);
}
memset(&iov, 0, sizeof(iov));
iov[0].iov_base = (caddr_t)packet;
iov[0].iov_len = packlen;

m.msg_iov = iov;
m.msg_iovlen = 1;
m.msg_control = (caddr_t)&cmsgbuf.buf;
m.msg_controllen = sizeof(cmsgbuf.buf);

cc = recvmsg(s, &m, 0);
if (cc == -1 && errno(*__errno()) != EINTR4)
	break;
}
memset(&itimer, 0, sizeof(itimer));
(void)setitimer(ITIMER_REAL0, &itimer, NULL((void *)0));

while (preload--)		/* Fire off them quickies. */
pinger(s);

(void)signal(SIGINT2, onsignal);
(void)signal(SIGINFO29, onsignal);

if (!(options & F_FLOOD0x0001)) {
(void)signal(SIGALRM14, onsignal);
itimer.it_interval = interval;
itimer.it_value = interval;
(void)setitimer(ITIMER_REAL0, &itimer, NULL((void *)0));
if (ntransmitted == 0)
	retransmit(s);
}

seenalrm = seenint = 0;
seeninfo = 0;

for (;;) {
struct msghdr		m;
union {
	struct cmsghdr hdr;
	u_char buf[CMSG_SPACE(1024)((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (((unsigned long)(1024) + (sizeof
(long) - 1)) &~(sizeof(long) - 1)))];
}			cmsgbuf;
struct iovec		iov[1];
struct pollfd		pfd;
struct sockaddr_in	peer4;
struct sockaddr_in6	peer6;
ssize_t			cc;
int			timeout;

/* signal handling */
if (seenint)
	break;
if (seenalrm) {
	if (flooddone)
		break;
	retransmit(s);
	seenalrm = 0;
	if (ntransmitted - nreceived - 1 > nmissedmax) {
		nmissedmax = ntransmitted - nreceived - 1;
		if (!(options & F_FLOOD0x0001) &&
		    (options & F_AUD_MISS0x4000))
			fputc('\a', stderr(&__sF[2]));
		if ((options & F_SHOWCHAR0x0080) &&
		    !(options & F_FLOOD0x0001)) {
			putchar('.')(!__isthreaded ? __sputc('.', (&__sF[1])) : (putc)('.', (
&__sF[1])));
			fflush(stdout(&__sF[1]));
		}
	}
	continue;
}
if (seeninfo) {
	summary();
	seeninfo = 0;
	continue;
}

if ((options & F_FLOOD0x0001 && !flooddone)) {
	if (pinger(s) != 0) {
		(void)signal(SIGALRM14, onsignal);
		timeout = INFTIM(-1);
		memset(&itimer, 0, sizeof(itimer));
		if (nreceived) {
			itimer.it_value.tv_sec = 2 * tmax /
			    1000;
			if (itimer.it_value.tv_sec == 0)
				itimer.it_value.tv_sec = 1;
		} else
			itimer.it_value.tv_sec = maxwait;
		(void)setitimer(ITIMER_REAL0, &itimer, NULL((void *)0));

		/* When the alarm goes off we are done. */
		flooddone = 1;
	} else
		timeout = 10;
} else
	timeout = INFTIM(-1);

pfd.fd = s;
pfd.events = POLLIN0x0001;

if (poll(&pfd, 1, timeout) <= 0)
	continue;

if (v6flag) {
	m.msg_name = &peer6;
	m.msg_namelen = sizeof(peer6);
} else {
	m.msg_name = &peer4;
	m.msg_namelen = sizeof(peer4);
}
memset(&iov, 0, sizeof(iov));
iov[0].iov_base = (caddr_t)packet;
iov[0].iov_len = packlen;
m.msg_iov = iov;
m.msg_iovlen = 1;
m.msg_control = (caddr_t)&cmsgbuf.buf;
m.msg_controllen = sizeof(cmsgbuf.buf);

cc = recvmsg(s, &m, 0);
if (cc == -1) {
	if (errno(*__errno()) != EINTR4) {
		warn("recvmsg");
		sleep(1);
	}
	continue;
} else if (cc == 0) {
	int mtu;

	/*
	 * receive control messages only. Process the
	 * exceptions (currently the only possibility is
	 * a path MTU notification.)
	 */
	if ((mtu = get_pathmtu(&m, &dst6)) > 0) {
		if (options & F_VERBOSE0x0100) {
			printf("new path MTU (%d) is "
			    "notified\n", mtu);
		}
	}
	continue;
} else
	pr_pack(packet, cc, &m);

if (npackets && nreceived >= npackets)
	break;
}
summary();
exit(nreceived == 0);
971}

973void
974onsignal(int sig)
975{
switch (sig) {
case SIGALRM14:
seenalrm++;
break;
case SIGINT2:
seenint++;
break;
case SIGINFO29:
seeninfo++;
break;
}
987}

989void
990fill(char *bp, char *patp)
991{
int ii, jj, kk;
int pat[16];
char *cp;

for (cp = patp; *cp; cp++)
if (!isxdigit((unsigned char)*cp))
	errx(1, "patterns must be specified as hex digits");
ii = sscanf(patp,
   "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
   &pat[0], &pat[1], &pat[2], &pat[3], &pat[4], &pat[5], &pat[6],
   &pat[7], &pat[8], &pat[9], &pat[10], &pat[11], &pat[12],
   &pat[13], &pat[14], &pat[15]);

if (ii > 0)
for (kk = 0;
    kk <= maxpayload - (ECHOLEN8 + ECHOTMLENsizeof(struct payload) + ii);
    kk += ii)
	for (jj = 0; jj < ii; ++jj)
		bp[jj + kk] = pat[jj];
if (!(options & F_QUIET0x0010)) {
printf("PATTERN: 0x");
for (jj = 0; jj < ii; ++jj)
	printf("%02x", bp[jj] & 0xFF);
printf("\n");
}
1017}

1019void
1020summary(void)
1021{
printf("\n--- %s ping statistics ---\n", hostname);
printf("%lld packets transmitted, ", ntransmitted);
printf("%lld packets received, ", nreceived);

if (nrepeats)
printf("%lld duplicates, ", nrepeats);
if (ntransmitted) {
if (nreceived > ntransmitted)
	printf("-- somebody's duplicating packets!");
else
	printf("%.1f%% packet loss",
	    ((((double)ntransmitted - nreceived) * 100) /
	    ntransmitted));
}
printf("\n");
if (timinginfo) {
/* Only display average to microseconds */
double num = nreceived + nrepeats;
double avg = tsum / num;
double dev = sqrt(fmax(0, tsumsq / num - avg * avg));
printf("round-trip min/avg/max/std-dev = %.3f/%.3f/%.3f/%.3f ms\n",
    tmin, avg, tmax, dev);
}
1045}

1047/*
* pr_addr --
*	Return address in numeric form or a host name
*/
1051const char *
1052pr_addr(struct sockaddr *addr, socklen_t addrlen)
1053{
static char buf[NI_MAXHOST256];
int flag = 0;

if (!(options & F_HOSTNAME0x0004))
flag |= NI_NUMERICHOST1;

if (getnameinfo(addr, addrlen, buf, sizeof(buf), NULL((void *)0), 0, flag) == 0)
return (buf);
else
return "?";
1064}

1066/*
* retransmit --
*	This routine transmits another ping.
*/
1070void
1071retransmit(int s)
1072{
struct itimerval itimer;
static int last_time;

if (last_time) {
seenint = 1;	/* break out of ping event loop */
return;
}

if (pinger(s) == 0)
return;

/*
* If we're not transmitting any more packets, change the timer
* to wait two round-trip times if we've received any packets or
* maxwait seconds if we haven't.
*/
memset(&itimer, 0, sizeof(itimer));
if (nreceived) {
itimer.it_value.tv_sec = 2 * tmax / 1000;
if (itimer.it_value.tv_sec == 0)
	itimer.it_value.tv_sec = 1;
} else
itimer.it_value.tv_sec = maxwait;
(void)setitimer(ITIMER_REAL0, &itimer, NULL((void *)0));

/* When the alarm goes off we are done. */
last_time = 1;
1100}

1102/*
* pinger --
*	Compose and transmit an ICMP ECHO REQUEST packet.  The IP packet
* will be added on by the kernel.  The ID field is a random number,
* and the sequence number is an ascending integer.  The first 8 bytes
* of the data portion are used to hold a UNIX "timeval" struct in VAX
* byte-order, to compute the round-trip time.
*/
1110int
1111pinger(int s)
1112{
struct icmp *icp = NULL((void *)0);
struct icmp6_hdr *icp6 = NULL((void *)0);
int cc, i;
u_int16_t seq;

if (npackets && ntransmitted >= npackets)
return(-1);	/* no more transmission */

seq = htons(ntransmitted++)(__uint16_t)(__builtin_constant_p(ntransmitted++) ? (__uint16_t
)(((__uint16_t)(ntransmitted++) & 0xffU) << 8 | ((__uint16_t
)(ntransmitted++) & 0xff00U) >> 8) : __swap16md(ntransmitted
++));

if (v6flag) {
icp6 = (struct icmp6_hdr *)outpack;
memset(icp6, 0, sizeof(*icp6));
icp6->icmp6_cksum = 0;
icp6->icmp6_type = ICMP6_ECHO_REQUEST128;
icp6->icmp6_code = 0;
icp6->icmp6_idicmp6_dataun.icmp6_un_data16[0] = ident;
icp6->icmp6_seqicmp6_dataun.icmp6_un_data16[1] = seq;
} else {
icp = (struct icmp *)outpack;
icp->icmp_type = ICMP_ECHO8;
icp->icmp_code = 0;
icp->icmp_cksum = 0;
icp->icmp_seqicmp_hun.ih_idseq.icd_seq = seq;
icp->icmp_idicmp_hun.ih_idseq.icd_id = ident;
}
CLR(ntohs(seq) % mx_dup_ck)(rcvd_tbl[((__uint16_t)(__builtin_constant_p(seq) ? (__uint16_t
)(((__uint16_t)(seq) & 0xffU) << 8 | ((__uint16_t)(
seq) & 0xff00U) >> 8) : __swap16md(seq)) % mx_dup_ck
)>>3] &= (~(1 << (((__uint16_t)(__builtin_constant_p
(seq) ? (__uint16_t)(((__uint16_t)(seq) & 0xffU) <<
| ((__uint16_t)(seq) & 0xff00U) >> 8) : __swap16md
(seq)) % mx_dup_ck) & 0x07))));

if (timing) {
SIPHASH_CTX ctx;
struct timespec ts;
struct payload payload;
struct tv64 *tv64 = &payload.tv64;

if (clock_gettime(CLOCK_MONOTONIC3, &ts) == -1)
	err(1, "clock_gettime(CLOCK_MONOTONIC)");
tv64->tv64_sec = htobe64((u_int64_t)ts.tv_sec +(__uint64_t)(__builtin_constant_p((u_int64_t)ts.tv_sec + tv64_offset
.tv64_sec) ? (__uint64_t)((((__uint64_t)((u_int64_t)ts.tv_sec
 + tv64_offset.tv64_sec) & 0xff) << 56) | ((__uint64_t
)((u_int64_t)ts.tv_sec + tv64_offset.tv64_sec) & 0xff00ULL
) << 40 | ((__uint64_t)((u_int64_t)ts.tv_sec + tv64_offset
.tv64_sec) & 0xff0000ULL) << 24 | ((__uint64_t)((u_int64_t
)ts.tv_sec + tv64_offset.tv64_sec) & 0xff000000ULL) <<
| ((__uint64_t)((u_int64_t)ts.tv_sec + tv64_offset.tv64_sec
) & 0xff00000000ULL) >> 8 | ((__uint64_t)((u_int64_t
)ts.tv_sec + tv64_offset.tv64_sec) & 0xff0000000000ULL) >>
| ((__uint64_t)((u_int64_t)ts.tv_sec + tv64_offset.tv64_sec
) & 0xff000000000000ULL) >> 40 | ((__uint64_t)((u_int64_t
)ts.tv_sec + tv64_offset.tv64_sec) & 0xff00000000000000ULL
) >> 56) : __swap64md((u_int64_t)ts.tv_sec + tv64_offset
.tv64_sec))
    tv64_offset.tv64_sec)(__uint64_t)(__builtin_constant_p((u_int64_t)ts.tv_sec + tv64_offset
.tv64_sec) ? (__uint64_t)((((__uint64_t)((u_int64_t)ts.tv_sec
 + tv64_offset.tv64_sec) & 0xff) << 56) | ((__uint64_t
)((u_int64_t)ts.tv_sec + tv64_offset.tv64_sec) & 0xff00ULL
) << 40 | ((__uint64_t)((u_int64_t)ts.tv_sec + tv64_offset
.tv64_sec) & 0xff0000ULL) << 24 | ((__uint64_t)((u_int64_t
)ts.tv_sec + tv64_offset.tv64_sec) & 0xff000000ULL) <<
| ((__uint64_t)((u_int64_t)ts.tv_sec + tv64_offset.tv64_sec
) & 0xff00000000ULL) >> 8 | ((__uint64_t)((u_int64_t
)ts.tv_sec + tv64_offset.tv64_sec) & 0xff0000000000ULL) >>
| ((__uint64_t)((u_int64_t)ts.tv_sec + tv64_offset.tv64_sec
) & 0xff000000000000ULL) >> 40 | ((__uint64_t)((u_int64_t
)ts.tv_sec + tv64_offset.tv64_sec) & 0xff00000000000000ULL
) >> 56) : __swap64md((u_int64_t)ts.tv_sec + tv64_offset
.tv64_sec));
tv64->tv64_nsec = htobe64((u_int64_t)ts.tv_nsec +(__uint64_t)(__builtin_constant_p((u_int64_t)ts.tv_nsec + tv64_offset
.tv64_nsec) ? (__uint64_t)((((__uint64_t)((u_int64_t)ts.tv_nsec
 + tv64_offset.tv64_nsec) & 0xff) << 56) | ((__uint64_t
)((u_int64_t)ts.tv_nsec + tv64_offset.tv64_nsec) & 0xff00ULL
) << 40 | ((__uint64_t)((u_int64_t)ts.tv_nsec + tv64_offset
.tv64_nsec) & 0xff0000ULL) << 24 | ((__uint64_t)((u_int64_t
)ts.tv_nsec + tv64_offset.tv64_nsec) & 0xff000000ULL) <<
| ((__uint64_t)((u_int64_t)ts.tv_nsec + tv64_offset.tv64_nsec
) & 0xff00000000ULL) >> 8 | ((__uint64_t)((u_int64_t
)ts.tv_nsec + tv64_offset.tv64_nsec) & 0xff0000000000ULL)
 >> 24 | ((__uint64_t)((u_int64_t)ts.tv_nsec + tv64_offset
.tv64_nsec) & 0xff000000000000ULL) >> 40 | ((__uint64_t
)((u_int64_t)ts.tv_nsec + tv64_offset.tv64_nsec) & 0xff00000000000000ULL
) >> 56) : __swap64md((u_int64_t)ts.tv_nsec + tv64_offset
.tv64_nsec))
    tv64_offset.tv64_nsec)(__uint64_t)(__builtin_constant_p((u_int64_t)ts.tv_nsec + tv64_offset
.tv64_nsec) ? (__uint64_t)((((__uint64_t)((u_int64_t)ts.tv_nsec
 + tv64_offset.tv64_nsec) & 0xff) << 56) | ((__uint64_t
)((u_int64_t)ts.tv_nsec + tv64_offset.tv64_nsec) & 0xff00ULL
) << 40 | ((__uint64_t)((u_int64_t)ts.tv_nsec + tv64_offset
.tv64_nsec) & 0xff0000ULL) << 24 | ((__uint64_t)((u_int64_t
)ts.tv_nsec + tv64_offset.tv64_nsec) & 0xff000000ULL) <<
| ((__uint64_t)((u_int64_t)ts.tv_nsec + tv64_offset.tv64_nsec
) & 0xff00000000ULL) >> 8 | ((__uint64_t)((u_int64_t
)ts.tv_nsec + tv64_offset.tv64_nsec) & 0xff0000000000ULL)
 >> 24 | ((__uint64_t)((u_int64_t)ts.tv_nsec + tv64_offset
.tv64_nsec) & 0xff000000000000ULL) >> 40 | ((__uint64_t
)((u_int64_t)ts.tv_nsec + tv64_offset.tv64_nsec) & 0xff00000000000000ULL
) >> 56) : __swap64md((u_int64_t)ts.tv_nsec + tv64_offset
.tv64_nsec));

SipHash24_Init(&ctx, &mac_key)SipHash_Init((&ctx), (&mac_key));
SipHash24_Update(&ctx, tv64, sizeof(*tv64))SipHash_Update((&ctx), 2, 4, (tv64), (sizeof(*tv64)));
SipHash24_Update(&ctx, &ident, sizeof(ident))SipHash_Update((&ctx), 2, 4, (&ident), (sizeof(ident)
));
SipHash24_Update(&ctx, &seq, sizeof(seq))SipHash_Update((&ctx), 2, 4, (&seq), (sizeof(seq)));
SipHash24_Final(&payload.mac, &ctx)SipHash_Final((&payload.mac), (&ctx), 2, 4);

memcpy(&outpack[ECHOLEN8], &payload, sizeof(payload));
}

cc = ECHOLEN8 + datalen;

if (!v6flag) {
/* compute ICMP checksum here */
icp->icmp_cksum = in_cksum((u_short *)icp, cc);

if (options & F_HDRINCL0x0400) {
	struct ip *ip = (struct ip *)outpackhdr;

	smsgiov.iov_base = (caddr_t)outpackhdr;
	cc += sizeof(struct ip);
	ip->ip_len = htons(cc)(__uint16_t)(__builtin_constant_p(cc) ? (__uint16_t)(((__uint16_t
)(cc) & 0xffU) << 8 | ((__uint16_t)(cc) & 0xff00U
) >> 8) : __swap16md(cc));
	ip->ip_sum = in_cksum((u_short *)outpackhdr, cc);
}
}

smsgiov.iov_len = cc;

i = sendmsg(s, &smsghdr, 0);

if (i == -1 || i != cc) {
if (i == -1)
	warn("sendmsg");
printf("ping: wrote %s %d chars, ret=%d\n", hostname, cc, i);
}
if (!(options & F_QUIET0x0010) && (options & F_FLOOD0x0001))
write(STDOUT_FILENO1, &DOT, 1);

return (0);
1192}

1194/*
* pr_pack --
*	Print out the packet, if it came from us.  This logic is necessary
* because ALL readers of the ICMP socket get a copy of ALL ICMP packets
* which arrive ('tis only fair).  This permits multiple copies of this
* program to be run without having intermingled output (or statistics!).
*/
1201void
1202pr_pack(u_char *buf, int cc, struct msghdr *mhdr)
1203{
struct ip *ip = NULL((void *)0);
struct icmp *icp = NULL((void *)0);
struct icmp6_hdr *icp6 = NULL((void *)0);
struct timespec ts, tp;
struct payload payload;
struct sockaddr *from;
socklen_t fromlen;
double triptime = 0;
int i, dupflag;
int hlen = -1, hoplim = -1, echo_reply = 0;
u_int16_t seq;
u_char *cp, *dp;
char* pkttime;

if (clock_gettime(CLOCK_MONOTONIC3, &ts) == -1)
err(1, "clock_gettime(CLOCK_MONOTONIC)");

if (v6flag) {
if (!mhdr || !mhdr->msg_name ||
    mhdr->msg_namelen != sizeof(struct sockaddr_in6) ||
    ((struct sockaddr *)mhdr->msg_name)->sa_family !=
    AF_INET624) {
	if (options & F_VERBOSE0x0100)
		warnx("invalid peername");
	return;
}
from = (struct sockaddr *)mhdr->msg_name;
fromlen = mhdr->msg_namelen;

if (cc < sizeof(struct icmp6_hdr)) {
	if (options & F_VERBOSE0x0100)
		warnx("packet too short (%d bytes) from %s", cc,
		    pr_addr(from, fromlen));
	return;
}
icp6 = (struct icmp6_hdr *)buf;

if ((hoplim = get_hoplim(mhdr)) == -1) {
	warnx("failed to get receiving hop limit");
	return;
}

if (icp6->icmp6_type == ICMP6_ECHO_REPLY129) {
	if (icp6->icmp6_idicmp6_dataun.icmp6_un_data16[0] != ident)
		return;			/* 'Twas not our ECHO */
	seq = icp6->icmp6_seqicmp6_dataun.icmp6_un_data16[1];
	echo_reply = 1;
	pkttime = (char *)(icp6 + 1);
}
} else {
if (!mhdr || !mhdr->msg_name ||
    mhdr->msg_namelen != sizeof(struct sockaddr_in) ||
    ((struct sockaddr *)mhdr->msg_name)->sa_family != AF_INET2) {
	if (options & F_VERBOSE0x0100)
		warnx("invalid peername");
	return;
}

from = (struct sockaddr *)mhdr->msg_name;
fromlen = mhdr->msg_namelen;

/* Check the IP header */
ip = (struct ip *)buf;
hlen = ip->ip_hl << 2;
if (cc < hlen + ICMP_MINLEN8) {
	if (options & F_VERBOSE0x0100)
		warnx("packet too short (%d bytes) from %s", cc,
		    pr_addr(from, fromlen));
	return;
}

/* Now the ICMP part */
cc -= hlen;
icp = (struct icmp *)(buf + hlen);
if (icp->icmp_type == ICMP_ECHOREPLY0) {
	if (icp->icmp_idicmp_hun.ih_idseq.icd_id != ident)
		return;			/* 'Twas not our ECHO */
	seq = icp->icmp_seqicmp_hun.ih_idseq.icd_seq;
	echo_reply = 1;
	pkttime = (char *)icp->icmp_dataicmp_dun.id_data;
}
}

if (echo_reply) {
++nreceived;
if (cc >= ECHOLEN8 + ECHOTMLENsizeof(struct payload)) {
	SIPHASH_CTX ctx;
	struct tv64 *tv64;
	u_int8_t mac[SIPHASH_DIGEST_LENGTH8];

	memcpy(&payload, pkttime, sizeof(payload));
	tv64 = &payload.tv64;

	SipHash24_Init(&ctx, &mac_key)SipHash_Init((&ctx), (&mac_key));
	SipHash24_Update(&ctx, tv64, sizeof(*tv64))SipHash_Update((&ctx), 2, 4, (tv64), (sizeof(*tv64)));
	SipHash24_Update(&ctx, &ident, sizeof(ident))SipHash_Update((&ctx), 2, 4, (&ident), (sizeof(ident)
));
	SipHash24_Update(&ctx, &seq, sizeof(seq))SipHash_Update((&ctx), 2, 4, (&seq), (sizeof(seq)));
	SipHash24_Final(mac, &ctx)SipHash_Final((mac), (&ctx), 2, 4);

	if (timingsafe_memcmp(mac, &payload.mac,
	    sizeof(mac)) != 0) {
		printf("signature mismatch from %s: "
		    "icmp_seq=%u\n", pr_addr(from, fromlen),
		    ntohs(seq)(__uint16_t)(__builtin_constant_p(seq) ? (__uint16_t)(((__uint16_t
)(seq) & 0xffU) << 8 | ((__uint16_t)(seq) & 0xff00U
) >> 8) : __swap16md(seq)));
		--nreceived;
		return;
	}
	timinginfo=1;

	tp.tv_sec = betoh64(tv64->tv64_sec)(__uint64_t)(__builtin_constant_p(tv64->tv64_sec) ? (__uint64_t
)((((__uint64_t)(tv64->tv64_sec) & 0xff) << 56) |
 ((__uint64_t)(tv64->tv64_sec) & 0xff00ULL) << 40
 | ((__uint64_t)(tv64->tv64_sec) & 0xff0000ULL) <<
| ((__uint64_t)(tv64->tv64_sec) & 0xff000000ULL) <<
| ((__uint64_t)(tv64->tv64_sec) & 0xff00000000ULL) >>
| ((__uint64_t)(tv64->tv64_sec) & 0xff0000000000ULL
) >> 24 | ((__uint64_t)(tv64->tv64_sec) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(tv64->tv64_sec) & 0xff00000000000000ULL
) >> 56) : __swap64md(tv64->tv64_sec)) -
	    tv64_offset.tv64_sec;
	tp.tv_nsec = betoh64(tv64->tv64_nsec)(__uint64_t)(__builtin_constant_p(tv64->tv64_nsec) ? (__uint64_t
)((((__uint64_t)(tv64->tv64_nsec) & 0xff) << 56)
 | ((__uint64_t)(tv64->tv64_nsec) & 0xff00ULL) <<
| ((__uint64_t)(tv64->tv64_nsec) & 0xff0000ULL) <<
| ((__uint64_t)(tv64->tv64_nsec) & 0xff000000ULL) <<
| ((__uint64_t)(tv64->tv64_nsec) & 0xff00000000ULL)
 >> 8 | ((__uint64_t)(tv64->tv64_nsec) & 0xff0000000000ULL
) >> 24 | ((__uint64_t)(tv64->tv64_nsec) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(tv64->tv64_nsec) & 0xff00000000000000ULL
) >> 56) : __swap64md(tv64->tv64_nsec)) -
	    tv64_offset.tv64_nsec;

	timespecsub(&ts, &tp, &ts)do { (&ts)->tv_sec = (&ts)->tv_sec - (&tp)->
tv_sec; (&ts)->tv_nsec = (&ts)->tv_nsec - (&
tp)->tv_nsec; if ((&ts)->tv_nsec < 0) { (&ts
)->tv_sec--; (&ts)->tv_nsec += 1000000000L; } } while
 (0);
	triptime = ((double)ts.tv_sec) * 1000.0 +
	    ((double)ts.tv_nsec) / 1000000.0;
	tsum += triptime;
	tsumsq += triptime * triptime;
	if (triptime < tmin)
		tmin = triptime;
	if (triptime > tmax)
		tmax = triptime;
}

if (TST(ntohs(seq) % mx_dup_ck)(rcvd_tbl[((__uint16_t)(__builtin_constant_p(seq) ? (__uint16_t
)(((__uint16_t)(seq) & 0xffU) << 8 | ((__uint16_t)(
seq) & 0xff00U) >> 8) : __swap16md(seq)) % mx_dup_ck
)>>3] & (1 << (((__uint16_t)(__builtin_constant_p
(seq) ? (__uint16_t)(((__uint16_t)(seq) & 0xffU) <<
| ((__uint16_t)(seq) & 0xff00U) >> 8) : __swap16md
(seq)) % mx_dup_ck) & 0x07)))) {
	++nrepeats;
	--nreceived;
	dupflag = 1;
} else {
	SET(ntohs(seq) % mx_dup_ck)(rcvd_tbl[((__uint16_t)(__builtin_constant_p(seq) ? (__uint16_t
)(((__uint16_t)(seq) & 0xffU) << 8 | ((__uint16_t)(
seq) & 0xff00U) >> 8) : __swap16md(seq)) % mx_dup_ck
)>>3] |= (1 << (((__uint16_t)(__builtin_constant_p
(seq) ? (__uint16_t)(((__uint16_t)(seq) & 0xffU) <<
| ((__uint16_t)(seq) & 0xff00U) >> 8) : __swap16md
(seq)) % mx_dup_ck) & 0x07)));
	dupflag = 0;
}

if (options & F_QUIET0x0010)
	return;

if (options & F_FLOOD0x0001)
	write(STDOUT_FILENO1, &BSPACE, 1);
else if (options & F_SHOWCHAR0x0080) {
	if (dupflag)
		putchar('D')(!__isthreaded ? __sputc('D', (&__sF[1])) : (putc)('D', (
&__sF[1])));
	else if (cc - ECHOLEN8 < datalen)
		putchar('T')(!__isthreaded ? __sputc('T', (&__sF[1])) : (putc)('T', (
&__sF[1])));
	else
		putchar('!')(!__isthreaded ? __sputc('!', (&__sF[1])) : (putc)('!', (
&__sF[1])));
} else {
	printf("%d bytes from %s: icmp_seq=%u", cc,
	    pr_addr(from, fromlen), ntohs(seq)(__uint16_t)(__builtin_constant_p(seq) ? (__uint16_t)(((__uint16_t
)(seq) & 0xffU) << 8 | ((__uint16_t)(seq) & 0xff00U
) >> 8) : __swap16md(seq)));
	if (v6flag)
		printf(" hlim=%d", hoplim);
	else
		printf(" ttl=%d", ip->ip_ttl);
	if (cc >= ECHOLEN8 + ECHOTMLENsizeof(struct payload))
		printf(" time=%.3f ms", triptime);
	if (dupflag)
		printf(" (DUP!)");
	/* check the data */
	if (cc - ECHOLEN8 < datalen)
		printf(" (TRUNC!)");
	if (v6flag)
		cp = buf + ECHOLEN8 + ECHOTMLENsizeof(struct payload);
	else
		cp = (u_char *)&icp->icmp_dataicmp_dun.id_data[ECHOTMLENsizeof(struct payload)];
	dp = &outpack[ECHOLEN8 + ECHOTMLENsizeof(struct payload)];
	for (i = ECHOLEN8 + ECHOTMLENsizeof(struct payload);
	    i < cc && i < datalen;
	    ++i, ++cp, ++dp) {
		if (*cp != *dp) {
			printf("\nwrong data byte #%d "
			    "should be 0x%x but was 0x%x",
			    i - ECHOLEN8, *dp, *cp);
			if (v6flag)
				cp = buf + ECHOLEN8;
			else
				cp = (u_char *)
				    &icp->icmp_dataicmp_dun.id_data[0];
			for (i = ECHOLEN8; i < cc && i < datalen;
			    ++i, ++cp) {
				if ((i % 32) == 8)
					printf("\n\t");
				printf("%x ", *cp);
			}
			break;
		}
	}
}
} else {
/* We've got something other than an ECHOREPLY */
if (!(options & F_VERBOSE0x0100))
	return;
printf("%d bytes from %s: ", cc, pr_addr(from, fromlen));
if (v6flag)
	pr_icmph6(icp6, buf + cc);
else
	pr_icmph(icp);
}

/* Display any IP options */
if (!v6flag && hlen > sizeof(struct ip))
pr_ipopt(hlen, buf);

if (!(options & F_FLOOD0x0001)) {
if (!(options & F_SHOWCHAR0x0080)) {
	putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
	if (v6flag && (options & F_VERBOSE0x0100))
		pr_exthdrs(mhdr);
}
fflush(stdout(&__sF[1]));
if (options & F_AUD_RECV0x2000)
	fputc('\a', stderr(&__sF[2]));
}
1416}

1418void
1419pr_ipopt(int hlen, u_char *buf)
1420{
static int old_rrlen;
static char old_rr[MAX_IPOPTLEN40];
struct sockaddr_in s_in;
in_addr_t l;
u_int i, j;
u_char *cp;

cp = buf + sizeof(struct ip);

s_in.sin_len = sizeof(s_in);
s_in.sin_family = AF_INET2;

for (; hlen > (int)sizeof(struct ip); --hlen, ++cp) {
switch (*cp) {
case IPOPT_EOL0:
	hlen = 0;
	break;
case IPOPT_LSRR131:
	printf("\nLSRR: ");
	hlen -= 2;
	j = *++cp;
	++cp;
	i = 0;
	if (j > IPOPT_MINOFF4) {
		for (;;) {
			l = *++cp;
			l = (l<<8) + *++cp;
			l = (l<<8) + *++cp;
			l = (l<<8) + *++cp;
			if (l == 0)
				printf("\t0.0.0.0");
			else {
				s_in.sin_addr.s_addr = ntohl(l)(__uint32_t)(__builtin_constant_p(l) ? (__uint32_t)(((__uint32_t
)(l) & 0xff) << 24 | ((__uint32_t)(l) & 0xff00)
 << 8 | ((__uint32_t)(l) & 0xff0000) >> 8 | (
(__uint32_t)(l) & 0xff000000) >> 24) : __swap32md(l
));
				printf("\t%s",
				    pr_addr((struct sockaddr*)
				    &s_in, sizeof(s_in)));
			}
			hlen -= 4;
			j -= 4;
			i += 4;
			if (j <= IPOPT_MINOFF4)
				break;
			if (i >= MAX_IPOPTLEN40) {
				printf("\t(truncated route)");
				break;
			}
			putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
		}
	}
	break;
case IPOPT_RR7:
	j = *++cp;		/* get length */
	i = *++cp;		/* and pointer */
	hlen -= 2;
	if (i > j)
		i = j;
	i -= IPOPT_MINOFF4;
	if (i <= 0)
		continue;
	if (i == old_rrlen &&
	    cp == buf + sizeof(struct ip) + 2 &&
	    !memcmp(cp, old_rr, i) &&
	    !(options & F_FLOOD0x0001)) {
		printf("\t(same route)");
		i = (i + 3) & ~0x3;
		hlen -= i;
		cp += i;
		break;
	}
	if (i < MAX_IPOPTLEN40) {
		old_rrlen = i;
		memcpy(old_rr, cp, i);
	} else
		old_rrlen = 0;

	printf("\nRR: ");
	j = 0;
	for (;;) {
		l = *++cp;
		l = (l<<8) + *++cp;
		l = (l<<8) + *++cp;
		l = (l<<8) + *++cp;
		if (l == 0)
			printf("\t0.0.0.0");
		else {
			s_in.sin_addr.s_addr = ntohl(l)(__uint32_t)(__builtin_constant_p(l) ? (__uint32_t)(((__uint32_t
)(l) & 0xff) << 24 | ((__uint32_t)(l) & 0xff00)
 << 8 | ((__uint32_t)(l) & 0xff0000) >> 8 | (
(__uint32_t)(l) & 0xff000000) >> 24) : __swap32md(l
));
			printf("\t%s",
			    pr_addr((struct sockaddr*)&s_in,
			    sizeof(s_in)));
		}
		hlen -= 4;
		i -= 4;
		j += 4;
		if (i <= 0)
			break;
		if (j >= MAX_IPOPTLEN40) {
			printf("\t(truncated route)");
			break;
		}
		putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
	}
	break;
case IPOPT_NOP1:
	printf("\nNOP");
	break;
default:
	printf("\nunknown option %x", *cp);
	if (cp[IPOPT_OLEN1] > 0 && (cp[IPOPT_OLEN1] - 1) <= hlen) {
		hlen = hlen - (cp[IPOPT_OLEN1] - 1);
		cp = cp + (cp[IPOPT_OLEN1] - 1);
	} else
		hlen = 0;
	break;
}
}
1536}

1538/*
* in_cksum --
*	Checksum routine for Internet Protocol family headers (C Version)
*/
1542int
1543in_cksum(u_short *addr, int len)
1544{
int nleft = len;
u_short *w = addr;
int sum = 0;
u_short answer = 0;

/*
* Our algorithm is simple, using a 32 bit accumulator (sum), we add
* sequential 16 bit words to it, and at the end, fold back all the
* carry bits from the top 16 bits into the lower 16 bits.
*/
while (nleft > 1) {
sum += *w++;
nleft -= 2;
}

/* mop up an odd byte, if necessary */
if (nleft == 1) {
*(u_char *)(&answer) = *(u_char *)w ;
sum += answer;
}

/* add back carry outs from top 16 bits to low 16 bits */
sum = (sum >> 16) + (sum & 0xffff);	/* add hi 16 to low 16 */
sum += (sum >> 16);			/* add carry */
answer = ~sum;				/* truncate to 16 bits */
return(answer);
1571}

1573/*
* pr_icmph --
*	Print a descriptive string about an ICMP header.
*/
1577void
1578pr_icmph(struct icmp *icp)
1579{
switch(icp->icmp_type) {
case ICMP_ECHOREPLY0:
printf("Echo Reply\n");
/* XXX ID + Seq + Data */
break;
case ICMP_UNREACH3:
switch(icp->icmp_code) {
case ICMP_UNREACH_NET0:
	printf("Destination Net Unreachable\n");
	break;
case ICMP_UNREACH_HOST1:
	printf("Destination Host Unreachable\n");
	break;
case ICMP_UNREACH_PROTOCOL2:
	printf("Destination Protocol Unreachable\n");
	break;
case ICMP_UNREACH_PORT3:
	printf("Destination Port Unreachable\n");
	break;
case ICMP_UNREACH_NEEDFRAG4:
	if (icp->icmp_nextmtuicmp_hun.ih_pmtu.ipm_nextmtu != 0)
		printf("frag needed and DF set (MTU %d)\n",
		    ntohs(icp->icmp_nextmtu)(__uint16_t)(__builtin_constant_p(icp->icmp_hun.ih_pmtu.ipm_nextmtu
) ? (__uint16_t)(((__uint16_t)(icp->icmp_hun.ih_pmtu.ipm_nextmtu
) & 0xffU) << 8 | ((__uint16_t)(icp->icmp_hun.ih_pmtu
.ipm_nextmtu) & 0xff00U) >> 8) : __swap16md(icp->
icmp_hun.ih_pmtu.ipm_nextmtu)));
	else
		printf("frag needed and DF set\n");
	break;
case ICMP_UNREACH_SRCFAIL5:
	printf("Source Route Failed\n");
	break;
case ICMP_UNREACH_NET_UNKNOWN6:
	printf("Network Unknown\n");
	break;
case ICMP_UNREACH_HOST_UNKNOWN7:
	printf("Host Unknown\n");
	break;
case ICMP_UNREACH_ISOLATED8:
	printf("Source Isolated\n");
	break;
case ICMP_UNREACH_NET_PROHIB9:
	printf("Dest. Net Administratively Prohibited\n");
	break;
case ICMP_UNREACH_HOST_PROHIB10:
	printf("Dest. Host Administratively Prohibited\n");
	break;
case ICMP_UNREACH_TOSNET11:
	printf("Destination Net Unreachable for TOS\n");
	break;
case ICMP_UNREACH_TOSHOST12:
	printf("Destination Host Unreachable for TOS\n");
	break;
case ICMP_UNREACH_FILTER_PROHIB13:
	printf("Route administratively prohibited\n");
	break;
case ICMP_UNREACH_HOST_PRECEDENCE14:
	printf("Host Precedence Violation\n");
	break;
case ICMP_UNREACH_PRECEDENCE_CUTOFF15:
	printf("Precedence Cutoff\n");
	break;
default:
	printf("Dest Unreachable, Unknown Code: %d\n",
	    icp->icmp_code);
	break;
}
/* Print returned IP header information */
pr_retip((struct ip *)icp->icmp_dataicmp_dun.id_data);
break;
case ICMP_SOURCEQUENCH4:
printf("Source Quench\n");
pr_retip((struct ip *)icp->icmp_dataicmp_dun.id_data);
break;
case ICMP_REDIRECT5:
switch(icp->icmp_code) {
case ICMP_REDIRECT_NET0:
	printf("Redirect Network");
	break;
case ICMP_REDIRECT_HOST1:
	printf("Redirect Host");
	break;
case ICMP_REDIRECT_TOSNET2:
	printf("Redirect Type of Service and Network");
	break;
case ICMP_REDIRECT_TOSHOST3:
	printf("Redirect Type of Service and Host");
	break;
default:
	printf("Redirect, Unknown Code: %d", icp->icmp_code);
	break;
}
printf("(New addr: %s)\n",
    inet_ntoa(icp->icmp_gwaddricmp_hun.ih_gwaddr));
pr_retip((struct ip *)icp->icmp_dataicmp_dun.id_data);
break;
case ICMP_ECHO8:
printf("Echo Request\n");
/* XXX ID + Seq + Data */
break;
case ICMP_ROUTERADVERT9:
/* RFC1256 */
printf("Router Discovery Advertisement\n");
printf("(%d entries, lifetime %d seconds)\n",
    icp->icmp_num_addrsicmp_hun.ih_rtradv.irt_num_addrs, ntohs(icp->icmp_lifetime)(__uint16_t)(__builtin_constant_p(icp->icmp_hun.ih_rtradv.
irt_lifetime) ? (__uint16_t)(((__uint16_t)(icp->icmp_hun.ih_rtradv
.irt_lifetime) & 0xffU) << 8 | ((__uint16_t)(icp->
icmp_hun.ih_rtradv.irt_lifetime) & 0xff00U) >> 8) :
 __swap16md(icp->icmp_hun.ih_rtradv.irt_lifetime)));
break;
case ICMP_ROUTERSOLICIT10:
/* RFC1256 */
printf("Router Discovery Solicitation\n");
break;
case ICMP_TIMXCEED11:
switch(icp->icmp_code) {
case ICMP_TIMXCEED_INTRANS0:
	printf("Time to live exceeded\n");
	break;
case ICMP_TIMXCEED_REASS1:
	printf("Frag reassembly time exceeded\n");
	break;
default:
	printf("Time exceeded, Unknown Code: %d\n",
	    icp->icmp_code);
	break;
}
pr_retip((struct ip *)icp->icmp_dataicmp_dun.id_data);
break;
case ICMP_PARAMPROB12:
switch(icp->icmp_code) {
case ICMP_PARAMPROB_OPTABSENT1:
	printf("Parameter problem, required option "
	    "absent: pointer = 0x%02x\n",
	    ntohs(icp->icmp_hun.ih_pptr)(__uint16_t)(__builtin_constant_p(icp->icmp_hun.ih_pptr) ?
 (__uint16_t)(((__uint16_t)(icp->icmp_hun.ih_pptr) & 0xffU
) << 8 | ((__uint16_t)(icp->icmp_hun.ih_pptr) & 0xff00U
) >> 8) : __swap16md(icp->icmp_hun.ih_pptr)));
	break;
default:
	printf("Parameter problem: pointer = 0x%02x\n",
	    ntohs(icp->icmp_hun.ih_pptr)(__uint16_t)(__builtin_constant_p(icp->icmp_hun.ih_pptr) ?
 (__uint16_t)(((__uint16_t)(icp->icmp_hun.ih_pptr) & 0xffU
) << 8 | ((__uint16_t)(icp->icmp_hun.ih_pptr) & 0xff00U
) >> 8) : __swap16md(icp->icmp_hun.ih_pptr)));
	break;
}
pr_retip((struct ip *)icp->icmp_dataicmp_dun.id_data);
break;
case ICMP_TSTAMP13:
printf("Timestamp\n");
/* XXX ID + Seq + 3 timestamps */
break;
case ICMP_TSTAMPREPLY14:
printf("Timestamp Reply\n");
/* XXX ID + Seq + 3 timestamps */
break;
case ICMP_IREQ15:
printf("Information Request\n");
/* XXX ID + Seq */
break;
case ICMP_IREQREPLY16:
printf("Information Reply\n");
/* XXX ID + Seq */
break;
case ICMP_MASKREQ17:
printf("Address Mask Request\n");
break;
case ICMP_MASKREPLY18:
printf("Address Mask Reply (Mask 0x%08x)\n",
    ntohl(icp->icmp_mask)(__uint32_t)(__builtin_constant_p(icp->icmp_dun.id_mask) ?
 (__uint32_t)(((__uint32_t)(icp->icmp_dun.id_mask) & 0xff
) << 24 | ((__uint32_t)(icp->icmp_dun.id_mask) &
 0xff00) << 8 | ((__uint32_t)(icp->icmp_dun.id_mask)
 & 0xff0000) >> 8 | ((__uint32_t)(icp->icmp_dun.
id_mask) & 0xff000000) >> 24) : __swap32md(icp->
icmp_dun.id_mask)));
break;
default:
printf("Unknown ICMP type: %d\n", icp->icmp_type);
}
1742}

1744/*
* pr_iph --
*	Print an IP header with options.
*/
1748void
1749pr_iph(struct ip *ip)
1750{
int hlen;
u_char *cp;

hlen = ip->ip_hl << 2;
cp = (u_char *)ip + 20;		/* point to options */

printf("Vr HL TOS  Len   ID Flg  off TTL Pro  cks      Src      Dst Data\n");
printf(" %1x  %1x  %02x %04x %04x",
   ip->ip_v, ip->ip_hl, ip->ip_tos, ip->ip_len, ip->ip_id);
printf("   %1x %04x", ((ip->ip_off) & 0xe000) >> 13,
   (ip->ip_off) & 0x1fff);
printf("  %02x  %02x %04x", ip->ip_ttl, ip->ip_p, ip->ip_sum);
printf(" %s ", inet_ntoa(*(struct in_addr *)&ip->ip_src.s_addr));
printf(" %s ", inet_ntoa(*(struct in_addr *)&ip->ip_dst.s_addr));
/* dump and option bytes */
while (hlen-- > 20) {
printf("%02x", *cp++);
}
putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
1770}

1772/*
* pr_retip --
*	Dump some info on a returned (via ICMP) IP packet.
*/
1776void
1777pr_retip(struct ip *ip)
1778{
int hlen;
u_char *cp;

pr_iph(ip);
hlen = ip->ip_hl << 2;
cp = (u_char *)ip + hlen;

if (ip->ip_p == 6)
printf("TCP: from port %u, to port %u (decimal)\n",
    (*cp * 256 + *(cp + 1)), (*(cp + 2) * 256 + *(cp + 3)));
else if (ip->ip_p == 17)
printf("UDP: from port %u, to port %u (decimal)\n",
    (*cp * 256 + *(cp + 1)), (*(cp + 2) * 256 + *(cp + 3)));
1792}

1794#ifndef SMALL
1795int
1796map_tos(char *key, int *val)
1797{
/* DiffServ Codepoints and other TOS mappings */
const struct toskeywords {
const char	*keyword;
int		 val;
} *t, toskeywords[] = {
{ "af11",		IPTOS_DSCP_AF110x28 },
{ "af12",		IPTOS_DSCP_AF120x30 },
{ "af13",		IPTOS_DSCP_AF130x38 },
{ "af21",		IPTOS_DSCP_AF210x48 },
{ "af22",		IPTOS_DSCP_AF220x50 },
{ "af23",		IPTOS_DSCP_AF230x58 },
{ "af31",		IPTOS_DSCP_AF310x68 },
{ "af32",		IPTOS_DSCP_AF320x70 },
{ "af33",		IPTOS_DSCP_AF330x78 },
{ "af41",		IPTOS_DSCP_AF410x88 },
{ "af42",		IPTOS_DSCP_AF420x90 },
{ "af43",		IPTOS_DSCP_AF430x98 },
{ "critical",		IPTOS_PREC_CRITIC_ECP0xa0 },
{ "cs0",		IPTOS_DSCP_CS00x00 },
{ "cs1",		IPTOS_DSCP_CS10x20 },
{ "cs2",		IPTOS_DSCP_CS20x40 },
{ "cs3",		IPTOS_DSCP_CS30x60 },
{ "cs4",		IPTOS_DSCP_CS40x80 },
{ "cs5",		IPTOS_DSCP_CS50xa0 },
{ "cs6",		IPTOS_DSCP_CS60xc0 },
{ "cs7",		IPTOS_DSCP_CS70xe0 },
{ "ef",			IPTOS_DSCP_EF0xb8 },
{ "inetcontrol",	IPTOS_PREC_INTERNETCONTROL0xc0 },
{ "lowdelay",		IPTOS_LOWDELAY0x10 },
{ "netcontrol",		IPTOS_PREC_NETCONTROL0xe0 },
{ "reliability",	IPTOS_RELIABILITY0x04 },
{ "throughput",		IPTOS_THROUGHPUT0x08 },
{ NULL((void *)0),			-1 },
};

for (t = toskeywords; t->keyword != NULL((void *)0); t++) {
if (strcmp(key, t->keyword) == 0) {
	*val = t->val;
	return (1);
}
}

return (0);
1841}
1842#endif	/* SMALL */

1844void
1845pr_exthdrs(struct msghdr *mhdr)
1846{
struct cmsghdr *cm;

for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(mhdr)((mhdr)->msg_controllen >= sizeof(struct cmsghdr) ? (struct
 cmsghdr *)(mhdr)->msg_control : (struct cmsghdr *)((void *
)0)); cm;
   cm = (struct cmsghdr *)CMSG_NXTHDR(mhdr, cm)(((char *)(cm) + (((unsigned long)((cm)->cmsg_len) + (sizeof
(long) - 1)) &~(sizeof(long) - 1)) + (((unsigned long)(sizeof
(struct cmsghdr)) + (sizeof(long) - 1)) &~(sizeof(long) -
 1)) > ((char *)(mhdr)->msg_control) + (mhdr)->msg_controllen
) ? (struct cmsghdr *)((void *)0) : (struct cmsghdr *)((char *
)(cm) + (((unsigned long)((cm)->cmsg_len) + (sizeof(long) -
 1)) &~(sizeof(long) - 1))))) {
if (cm->cmsg_level != IPPROTO_IPV641)
	continue;

switch (cm->cmsg_type) {
case IPV6_HOPOPTS49:
	printf("  HbH Options: ");
	pr_ip6opt(CMSG_DATA(cm)((unsigned char *)(cm) + (((unsigned long)(sizeof(struct cmsghdr
)) + (sizeof(long) - 1)) &~(sizeof(long) - 1))));
	break;
case IPV6_DSTOPTS50:
case IPV6_RTHDRDSTOPTS35:
	printf("  Dst Options: ");
	pr_ip6opt(CMSG_DATA(cm)((unsigned char *)(cm) + (((unsigned long)(sizeof(struct cmsghdr
)) + (sizeof(long) - 1)) &~(sizeof(long) - 1))));
	break;
case IPV6_RTHDR51:
	printf("  Routing: ");
	pr_rthdr(CMSG_DATA(cm)((unsigned char *)(cm) + (((unsigned long)(sizeof(struct cmsghdr
)) + (sizeof(long) - 1)) &~(sizeof(long) - 1))));
	break;
}
}
1870}

1872void
1873pr_ip6opt(void *extbuf)
1874{
struct ip6_hbh *ext;
int currentlen;
u_int8_t type;
size_t extlen;
socklen_t len;
void *databuf;
u_int16_t value2;
u_int32_t value4;

ext = (struct ip6_hbh *)extbuf;
extlen = (ext->ip6h_len + 1) * 8;
printf("nxt %u, len %u (%lu bytes)\n", ext->ip6h_nxt,
   (unsigned int)ext->ip6h_len, (unsigned long)extlen);

currentlen = 0;
while (1) {
currentlen = inet6_opt_next(extbuf, extlen, currentlen,
    &type, &len, &databuf);
if (currentlen == -1)
	break;
switch (type) {
/*
 * Note that inet6_opt_next automatically skips any padding
 * options.
 */
case IP6OPT_JUMBO0xC2:
	inet6_opt_get_val(databuf, 0, &value4, sizeof(value4));
	printf("    Jumbo Payload Opt: Length %u\n",
	    (u_int32_t)ntohl(value4)(__uint32_t)(__builtin_constant_p(value4) ? (__uint32_t)(((__uint32_t
)(value4) & 0xff) << 24 | ((__uint32_t)(value4) &
 0xff00) << 8 | ((__uint32_t)(value4) & 0xff0000) >>
| ((__uint32_t)(value4) & 0xff000000) >> 24) : __swap32md
(value4)));
	break;
case IP6OPT_ROUTER_ALERT0x05:
	inet6_opt_get_val(databuf, 0, &value2, sizeof(value2));
	printf("    Router Alert Opt: Type %u\n",
	    ntohs(value2)(__uint16_t)(__builtin_constant_p(value2) ? (__uint16_t)(((__uint16_t
)(value2) & 0xffU) << 8 | ((__uint16_t)(value2) &
 0xff00U) >> 8) : __swap16md(value2)));
	break;
default:
	printf("    Received Opt %u len %lu\n",
	    type, (unsigned long)len);
	break;
}
}
return;
1917}

1919void
1920pr_rthdr(void *extbuf)
1921{
struct in6_addr *in6;
char ntopbuf[INET6_ADDRSTRLEN46];
struct ip6_rthdr *rh = (struct ip6_rthdr *)extbuf;
int i, segments;

/* print fixed part of the header */
printf("nxt %u, len %u (%d bytes), type %u, ", rh->ip6r_nxt,
   rh->ip6r_len, (rh->ip6r_len + 1) << 3, rh->ip6r_type);
if ((segments = inet6_rth_segments(extbuf)) >= 0)
printf("%d segments, ", segments);
else
printf("segments unknown, ");
printf("%d left\n", rh->ip6r_segleft);

for (i = 0; i < segments; i++) {
in6 = inet6_rth_getaddr(extbuf, i);
if (in6 == NULL((void *)0))
	printf("   [%d]<NULL>\n", i);
else {
	if (!inet_ntop(AF_INET624, in6, ntopbuf,
	    sizeof(ntopbuf)))
		strncpy(ntopbuf, "?", sizeof(ntopbuf));
	printf("   [%d]%s\n", i, ntopbuf);
}
}

return;

1950}

1952int
1953get_hoplim(struct msghdr *mhdr)
1954{
struct cmsghdr *cm;

for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(mhdr)((mhdr)->msg_controllen >= sizeof(struct cmsghdr) ? (struct
 cmsghdr *)(mhdr)->msg_control : (struct cmsghdr *)((void *
)0)); cm;
    cm = (struct cmsghdr *)CMSG_NXTHDR(mhdr, cm)(((char *)(cm) + (((unsigned long)((cm)->cmsg_len) + (sizeof
(long) - 1)) &~(sizeof(long) - 1)) + (((unsigned long)(sizeof
(struct cmsghdr)) + (sizeof(long) - 1)) &~(sizeof(long) -
 1)) > ((char *)(mhdr)->msg_control) + (mhdr)->msg_controllen
) ? (struct cmsghdr *)((void *)0) : (struct cmsghdr *)((char *
)(cm) + (((unsigned long)((cm)->cmsg_len) + (sizeof(long) -
 1)) &~(sizeof(long) - 1))))) {
if (cm->cmsg_len == 0)
	return(-1);

if (cm->cmsg_level == IPPROTO_IPV641 &&
    cm->cmsg_type == IPV6_HOPLIMIT47 &&
    cm->cmsg_len == CMSG_LEN(sizeof(int))((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (sizeof(int))))
	return(*(int *)CMSG_DATA(cm)((unsigned char *)(cm) + (((unsigned long)(sizeof(struct cmsghdr
)) + (sizeof(long) - 1)) &~(sizeof(long) - 1))));
}

return(-1);
1969}

1971int
1972get_pathmtu(struct msghdr *mhdr, struct sockaddr_in6 *dst)
1973{
struct cmsghdr *cm;
struct ip6_mtuinfo *mtuctl = NULL((void *)0);

for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(mhdr)((mhdr)->msg_controllen >= sizeof(struct cmsghdr) ? (struct
 cmsghdr *)(mhdr)->msg_control : (struct cmsghdr *)((void *
)0)); cm;
   cm = (struct cmsghdr *)CMSG_NXTHDR(mhdr, cm)(((char *)(cm) + (((unsigned long)((cm)->cmsg_len) + (sizeof
(long) - 1)) &~(sizeof(long) - 1)) + (((unsigned long)(sizeof
(struct cmsghdr)) + (sizeof(long) - 1)) &~(sizeof(long) -
 1)) > ((char *)(mhdr)->msg_control) + (mhdr)->msg_controllen
) ? (struct cmsghdr *)((void *)0) : (struct cmsghdr *)((char *
)(cm) + (((unsigned long)((cm)->cmsg_len) + (sizeof(long) -
 1)) &~(sizeof(long) - 1))))) {
if (cm->cmsg_len == 0)
	return(0);

if (cm->cmsg_level == IPPROTO_IPV641 &&
    cm->cmsg_type == IPV6_PATHMTU44 &&
    cm->cmsg_len == CMSG_LEN(sizeof(struct ip6_mtuinfo))((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (sizeof(struct ip6_mtuinfo)))) {
	mtuctl = (struct ip6_mtuinfo *)CMSG_DATA(cm)((unsigned char *)(cm) + (((unsigned long)(sizeof(struct cmsghdr
)) + (sizeof(long) - 1)) &~(sizeof(long) - 1)));

	/*
	 * If the notified destination is different from
	 * the one we are pinging, just ignore the info.
	 * We check the scope ID only when both notified value
	 * and our own value have non-0 values, because we may
	 * have used the default scope zone ID for sending,
	 * in which case the scope ID value is 0.
	 */
	if (!IN6_ARE_ADDR_EQUAL(&mtuctl->ip6m_addr.sin6_addr,(memcmp(&(&mtuctl->ip6m_addr.sin6_addr)->__u6_addr
.__u6_addr8[0], &(&dst->sin6_addr)->__u6_addr.__u6_addr8
[0], sizeof(struct in6_addr)) == 0)
	    &dst->sin6_addr)(memcmp(&(&mtuctl->ip6m_addr.sin6_addr)->__u6_addr
.__u6_addr8[0], &(&dst->sin6_addr)->__u6_addr.__u6_addr8
[0], sizeof(struct in6_addr)) == 0) ||
	    (mtuctl->ip6m_addr.sin6_scope_id &&
	    dst->sin6_scope_id &&
	    mtuctl->ip6m_addr.sin6_scope_id !=
	    dst->sin6_scope_id)) {
		if (options & F_VERBOSE0x0100) {
			printf("path MTU for %s is notified. "
			    "(ignored)\n",
			    pr_addr((struct sockaddr *)
			    &mtuctl->ip6m_addr,
			    sizeof(mtuctl->ip6m_addr)));
		}
		return(0);
	}

	/*
	 * Ignore an invalid MTU. XXX: can we just believe
	 * the kernel check?
	 */
	if (mtuctl->ip6m_mtu < IPV6_MMTU1280)
		return(0);

	/* notification for our destination. return the MTU. */
	return((int)mtuctl->ip6m_mtu);
}
}
return(0);
2023}

2025/*
* pr_icmph6 --
*	Print a descriptive string about an ICMP header.
*/
2029void
2030pr_icmph6(struct icmp6_hdr *icp, u_char *end)
2031{
char ntop_buf[INET6_ADDRSTRLEN46];
struct nd_redirect *red;

switch (icp->icmp6_type) {
case ICMP6_DST_UNREACH1:
switch (icp->icmp6_code) {
case ICMP6_DST_UNREACH_NOROUTE0:
	printf("No Route to Destination\n");
	break;
case ICMP6_DST_UNREACH_ADMIN1:
	printf("Destination Administratively "
	    "Unreachable\n");
	break;
case ICMP6_DST_UNREACH_BEYONDSCOPE2:
	printf("Destination Unreachable Beyond Scope\n");
	break;
case ICMP6_DST_UNREACH_ADDR3:
	printf("Destination Host Unreachable\n");
	break;
case ICMP6_DST_UNREACH_NOPORT4:
	printf("Destination Port Unreachable\n");
	break;
default:
	printf("Destination Unreachable, Bad Code: %d\n",
	    icp->icmp6_code);
	break;
}
/* Print returned IP header information */
pr_retip6((struct ip6_hdr *)(icp + 1), end);
break;
case ICMP6_PACKET_TOO_BIG2:
printf("Packet too big mtu = %d\n",
    (int)ntohl(icp->icmp6_mtu)(__uint32_t)(__builtin_constant_p(icp->icmp6_dataun.icmp6_un_data32
[0]) ? (__uint32_t)(((__uint32_t)(icp->icmp6_dataun.icmp6_un_data32
[0]) & 0xff) << 24 | ((__uint32_t)(icp->icmp6_dataun
.icmp6_un_data32[0]) & 0xff00) << 8 | ((__uint32_t)
(icp->icmp6_dataun.icmp6_un_data32[0]) & 0xff0000) >>
| ((__uint32_t)(icp->icmp6_dataun.icmp6_un_data32[0]) &
 0xff000000) >> 24) : __swap32md(icp->icmp6_dataun.icmp6_un_data32
[0])));
pr_retip6((struct ip6_hdr *)(icp + 1), end);
break;
case ICMP6_TIME_EXCEEDED3:
switch (icp->icmp6_code) {
case ICMP6_TIME_EXCEED_TRANSIT0:
	printf("Time to live exceeded\n");
	break;
case ICMP6_TIME_EXCEED_REASSEMBLY1:
	printf("Frag reassembly time exceeded\n");
	break;
default:
	printf("Time exceeded, Bad Code: %d\n",
	    icp->icmp6_code);
	break;
}
pr_retip6((struct ip6_hdr *)(icp + 1), end);
break;
case ICMP6_PARAM_PROB4:
printf("Parameter problem: ");
switch (icp->icmp6_code) {
case ICMP6_PARAMPROB_HEADER0:
	printf("Erroneous Header ");
	break;
case ICMP6_PARAMPROB_NEXTHEADER1:
	printf("Unknown Nextheader ");
	break;
case ICMP6_PARAMPROB_OPTION2:
	printf("Unrecognized Option ");
	break;
default:
	printf("Bad code(%d) ", icp->icmp6_code);
	break;
}
printf("pointer = 0x%02x\n",
    (u_int32_t)ntohl(icp->icmp6_pptr)(__uint32_t)(__builtin_constant_p(icp->icmp6_dataun.icmp6_un_data32
[0]) ? (__uint32_t)(((__uint32_t)(icp->icmp6_dataun.icmp6_un_data32
[0]) & 0xff) << 24 | ((__uint32_t)(icp->icmp6_dataun
.icmp6_un_data32[0]) & 0xff00) << 8 | ((__uint32_t)
(icp->icmp6_dataun.icmp6_un_data32[0]) & 0xff0000) >>
| ((__uint32_t)(icp->icmp6_dataun.icmp6_un_data32[0]) &
 0xff000000) >> 24) : __swap32md(icp->icmp6_dataun.icmp6_un_data32
[0])));
pr_retip6((struct ip6_hdr *)(icp + 1), end);
break;
case ICMP6_ECHO_REQUEST128:
printf("Echo Request");
/* XXX ID + Seq + Data */
break;
case ICMP6_ECHO_REPLY129:
printf("Echo Reply");
/* XXX ID + Seq + Data */
break;
case ICMP6_MEMBERSHIP_QUERY130:
printf("Listener Query");
break;
case ICMP6_MEMBERSHIP_REPORT131:
printf("Listener Report");
break;
case ICMP6_MEMBERSHIP_REDUCTION132:
printf("Listener Done");
break;
case ND_ROUTER_SOLICIT133:
printf("Router Solicitation");
break;
case ND_ROUTER_ADVERT134:
printf("Router Advertisement");
break;
case ND_NEIGHBOR_SOLICIT135:
printf("Neighbor Solicitation");
break;
case ND_NEIGHBOR_ADVERT136:
printf("Neighbor Advertisement");
break;
case ND_REDIRECT137:
red = (struct nd_redirect *)icp;
printf("Redirect\n");
if (!inet_ntop(AF_INET624, &red->nd_rd_dst, ntop_buf,
    sizeof(ntop_buf)))
	strncpy(ntop_buf, "?", sizeof(ntop_buf));
printf("Destination: %s", ntop_buf);
if (!inet_ntop(AF_INET624, &red->nd_rd_target, ntop_buf,
    sizeof(ntop_buf)))
	strncpy(ntop_buf, "?", sizeof(ntop_buf));
printf(" New Target: %s", ntop_buf);
break;
default:
printf("Bad ICMP type: %d", icp->icmp6_type);
}
2146}

2148/*
* pr_iph6 --
*	Print an IP6 header.
*/
2152void
2153pr_iph6(struct ip6_hdr *ip6)
2154{
u_int32_t flow = ip6->ip6_flowip6_ctlun.ip6_un1.ip6_un1_flow & IPV6_FLOWLABEL_MASK0xffff0f00;
u_int8_t tc;
char ntop_buf[INET6_ADDRSTRLEN46];

tc = *(&ip6->ip6_vfcip6_ctlun.ip6_un2_vfc + 1); /* XXX */
tc = (tc >> 4) & 0x0f;
tc |= (ip6->ip6_vfcip6_ctlun.ip6_un2_vfc << 4);

printf("Vr TC  Flow Plen Nxt Hlim\n");
printf(" %1x %02x %05x %04x  %02x   %02x\n",
   (ip6->ip6_vfcip6_ctlun.ip6_un2_vfc & IPV6_VERSION_MASK0xf0) >> 4, tc, (u_int32_t)ntohl(flow)(__uint32_t)(__builtin_constant_p(flow) ? (__uint32_t)(((__uint32_t
)(flow) & 0xff) << 24 | ((__uint32_t)(flow) & 0xff00
) << 8 | ((__uint32_t)(flow) & 0xff0000) >> 8
 | ((__uint32_t)(flow) & 0xff000000) >> 24) : __swap32md
(flow)),
   ntohs(ip6->ip6_plen)(__uint16_t)(__builtin_constant_p(ip6->ip6_ctlun.ip6_un1.ip6_un1_plen
) ? (__uint16_t)(((__uint16_t)(ip6->ip6_ctlun.ip6_un1.ip6_un1_plen
) & 0xffU) << 8 | ((__uint16_t)(ip6->ip6_ctlun.ip6_un1
.ip6_un1_plen) & 0xff00U) >> 8) : __swap16md(ip6->
ip6_ctlun.ip6_un1.ip6_un1_plen)), ip6->ip6_nxtip6_ctlun.ip6_un1.ip6_un1_nxt, ip6->ip6_hlimip6_ctlun.ip6_un1.ip6_un1_hlim);
if (!inet_ntop(AF_INET624, &ip6->ip6_src, ntop_buf, sizeof(ntop_buf)))
strncpy(ntop_buf, "?", sizeof(ntop_buf));
printf("%s->", ntop_buf);
if (!inet_ntop(AF_INET624, &ip6->ip6_dst, ntop_buf, sizeof(ntop_buf)))
strncpy(ntop_buf, "?", sizeof(ntop_buf));
printf("%s\n", ntop_buf);
2173}

2175/*
* pr_retip6 --
*	Dump some info on a returned (via ICMPv6) IPv6 packet.
*/
2179void
2180pr_retip6(struct ip6_hdr *ip6, u_char *end)
2181{
u_char *cp = (u_char *)ip6, nh;
int hlen;

if (end - (u_char *)ip6 < sizeof(*ip6)) {
printf("IP6");
goto trunc;
}
pr_iph6(ip6);
hlen = sizeof(*ip6);

nh = ip6->ip6_nxtip6_ctlun.ip6_un1.ip6_un1_nxt;
cp += hlen;
while (end - cp >= 8) {
switch (nh) {
case IPPROTO_HOPOPTS0:
	printf("HBH ");
	hlen = (((struct ip6_hbh *)cp)->ip6h_len+1) << 3;
	nh = ((struct ip6_hbh *)cp)->ip6h_nxt;
	break;
case IPPROTO_DSTOPTS60:
	printf("DSTOPT ");
	hlen = (((struct ip6_dest *)cp)->ip6d_len+1) << 3;
	nh = ((struct ip6_dest *)cp)->ip6d_nxt;
	break;
case IPPROTO_FRAGMENT44:
	printf("FRAG ");
	hlen = sizeof(struct ip6_frag);
	nh = ((struct ip6_frag *)cp)->ip6f_nxt;
	break;
case IPPROTO_ROUTING43:
	printf("RTHDR ");
	hlen = (((struct ip6_rthdr *)cp)->ip6r_len+1) << 3;
	nh = ((struct ip6_rthdr *)cp)->ip6r_nxt;
	break;
case IPPROTO_AH51:
	printf("AH ");
	hlen = (((struct ah *)cp)->ah_hl+2) << 2;
	nh = ((struct ah *)cp)->ah_nh;
	break;
case IPPROTO_ICMPV658:
	printf("ICMP6: type = %d, code = %d\n",
	    *cp, *(cp + 1));
	return;
case IPPROTO_ESP50:
	printf("ESP\n");
	return;
case IPPROTO_TCP6:
	printf("TCP: from port %u, to port %u (decimal)\n",
	    (*cp * 256 + *(cp + 1)),
	    (*(cp + 2) * 256 + *(cp + 3)));
	return;
case IPPROTO_UDP17:
	printf("UDP: from port %u, to port %u (decimal)\n",
	    (*cp * 256 + *(cp + 1)),
	    (*(cp + 2) * 256 + *(cp + 3)));
	return;
default:
	printf("Unknown Header(%d)\n", nh);
	return;
}

if ((cp += hlen) >= end)
	goto trunc;
}
if (end - cp < 8)
goto trunc;

putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
return;

trunc:
printf("...\n");
return;
2255}

2257__dead__attribute__((__noreturn__)) void
2258usage(void)
2259{
if (v6flag) {
fprintf(stderr(&__sF[2]),
    "usage: ping6 [-DdEefgHLmnqv] [-c count] [-h hoplimit] "
    "[-I sourceaddr]\n\t[-i interval] [-l preload] "
    "[-p pattern] [-s packetsize] [-T toskeyword]\n"
    "\t[-V rtable] [-w maxwait] host\n");
} else {
fprintf(stderr(&__sF[2]),
    "usage: ping [-DdEefgHLnqRv] [-c count] [-I sourceaddr] "
    "[-i interval]\n\t[-l preload] [-p pattern] [-s packetsize]"
2270#ifndef	SMALL
    " [-T toskeyword]"
2272#endif	/* SMALL */
    "\n\t[-t ttl] [-V rtable] [-w maxwait] host\n");
}
exit(1);
2276}