SecBSD
/
src
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
src/sbin/ping/ping.c

2277 lines
57 KiB
C
Raw Permalink Blame History

/* $OpenBSD: ping.c,v 1.249 2024/04/23 13:34:50 jsg Exp $ */
/*
* 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.
*/
/*
* 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.
*/
/*
* 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.
*/
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/uio.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include <netinet/ip_var.h>
#include <netinet/ip6.h>
#include <netinet/icmp6.h>
#include <netinet/ip_ah.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <limits.h>
#include <math.h>
#include <poll.h>
#include <pwd.h>
#include <signal.h>
#include <siphash.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
struct tv64 {
u_int64_t tv64_sec;
u_int64_t tv64_nsec;
};
struct payload {
struct tv64 tv64;
u_int8_t mac[SIPHASH_DIGEST_LENGTH];
};
#define ECHOLEN 8 /* icmp echo header len excluding time */
#define ECHOTMLEN sizeof(struct payload)
#define DEFDATALEN (64 - ECHOLEN) /* default data length */
#define MAXIPLEN 60
#define MAXICMPLEN 76
#define MAXPAYLOAD (IP_MAXPACKET - MAXIPLEN - ECHOLEN)
#define IP6LEN 40
#define EXTRA 256 /* for AH and various other headers. weird. */
#define MAXPAYLOAD6 IPV6_MAXPACKET - IP6LEN - ECHOLEN
#define MAXWAIT_DEFAULT 10 /* secs to wait for response */
#define NROUTES 9 /* number of record route slots */
#define A(bit) rcvd_tbl[(bit)>>3] /* identify byte in array */
#define B(bit) (1 << ((bit) & 0x07)) /* identify bit in byte */
#define SET(bit) (A(bit) |= B(bit))
#define CLR(bit) (A(bit) &= (~B(bit)))
#define TST(bit) (A(bit) & B(bit))
/* various options */
int options;
#define F_FLOOD 0x0001
#define F_INTERVAL 0x0002
#define F_HOSTNAME 0x0004
#define F_PINGFILLED 0x0008
#define F_QUIET 0x0010
#define F_RROUTE 0x0020
#define F_SO_DEBUG 0x0040
#define F_SHOWCHAR 0x0080
#define F_VERBOSE 0x0100
/* 0x0200 */
#define F_HDRINCL 0x0400
#define F_TTL 0x0800
#define F_TOS 0x1000
#define F_AUD_RECV 0x2000
#define F_AUD_MISS 0x4000
/* multicast options */
int moptions;
#define MULTICAST_NOLOOP 0x001
#define MULTICAST_TTL 0x002
#define DUMMY_PORT 10101
#define PING_USER "_ping"
/*
* 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...
*/
#define MAX_DUP_CHK (8 * 8192)
int mx_dup_ck = MAX_DUP_CHK;
char rcvd_tbl[MAX_DUP_CHK / 8];
int datalen = DEFDATALEN;
int maxpayload = MAXPAYLOAD;
u_char outpackhdr[IP_MAXPACKET+sizeof(struct ip)];
u_char *outpack = outpackhdr+sizeof(struct ip);
char BSPACE = '\b'; /* characters written for flood */
char DOT = '.';
char *hostname;
int ident; /* random number to identify our packets */
int v6flag; /* are we ping6? */
/* counters */
int64_t npackets; /* max packets to transmit */
int64_t nreceived; /* # of packets we got back */
int64_t nrepeats; /* number of duplicates */
int64_t ntransmitted; /* sequence # for outbound packets = #sent */
int64_t nmissedmax = 1; /* max value of ntransmitted - nreceived - 1 */
struct timeval interval = {1, 0}; /* interval between packets */
/* timing */
int timing; /* flag to do timing */
int timinginfo;
unsigned int maxwait = MAXWAIT_DEFAULT; /* max seconds to wait for response */
double tmin = 999999999.0; /* minimum round trip time */
double tmax; /* maximum round trip time */
double tsum; /* sum of all times, for doing average */
double tsumsq; /* sum of all times squared, for std. dev. */
struct tv64 tv64_offset;
SIPHASH_KEY mac_key;
struct msghdr smsghdr;
struct iovec smsgiov;
volatile sig_atomic_t seenalrm;
volatile sig_atomic_t seenint;
volatile sig_atomic_t seeninfo;
void fill(char *, char *);
void summary(void);
void onsignal(int);
void retransmit(int);
int pinger(int);
const char *pr_addr(struct sockaddr *, socklen_t);
void pr_pack(u_char *, int, struct msghdr *);
__dead void usage(void);
/* IPv4 specific functions */
void pr_ipopt(int, u_char *);
int in_cksum(u_short *, int);
void pr_icmph(struct icmp *);
void pr_retip(struct ip *);
void pr_iph(struct ip *);
#ifndef SMALL
int map_tos(char *, int *);
#endif /* SMALL */
/* IPv6 specific functions */
int get_hoplim(struct msghdr *);
int get_pathmtu(struct msghdr *, struct sockaddr_in6 *);
void pr_icmph6(struct icmp6_hdr *, u_char *);
void pr_iph6(struct ip6_hdr *);
void pr_exthdrs(struct msghdr *);
void pr_ip6opt(void *);
void pr_rthdr(void *);
void pr_retip6(struct ip6_hdr *, u_char *);
int
main(int argc, char *argv[])
{
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;
struct in6_pktinfo *pktinfo = NULL;
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_MAXPACKET, hoplimit = -1, mflag = 0;
u_char *datap, *packet;
u_char ttl = MAXTTL;
char *e, *target, hbuf[NI_MAXHOST], *source = NULL;
char rspace[3 + 4 * NROUTES + 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)
err(1, "unveil /");
if (unveil(NULL, NULL) == -1)
err(1, "unveil");
if (strcmp("ping6", __progname) == 0) {
v6flag = 1;
maxpayload = MAXPAYLOAD6;
if ((s = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6)) == -1)
err(1, "socket");
} else {
if ((s = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP)) == -1)
err(1, "socket");
}
/* revoke privs */
ouid = getuid();
if (ouid == 0 && (pw = getpwnam(PING_USER)) != NULL) {
uid = pw->pw_uid;
gid = pw->pw_gid;
} else {
uid = getuid();
gid = getgid();
}
if (ouid && (setgroups(1, &gid) ||
setresgid(gid, gid, gid) ||
setresuid(uid, uid, uid)))
err(1, "unable to revoke privs");
preload = 0;
datap = &outpack[ECHOLEN + ECHOTMLEN];
while ((ch = getopt(argc, argv, v6flag ?
"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_MAX, &errstr);
if (errstr)
errx(1,
"number of packets to transmit is %s: %s",
errstr, optarg);
break;
case 'D':
options |= F_HDRINCL;
df = 1;
break;
case 'd':
options |= F_SO_DEBUG;
break;
case 'E':
options |= F_AUD_MISS;
break;
case 'e':
options |= F_AUD_RECV;
break;
case 'f':
if (ouid)
errc(1, EPERM, NULL);
options |= F_FLOOD;
setvbuf(stdout, NULL, _IONBF, 0);
break;
case 'g':
options |= F_SHOWCHAR;
break;
case 'H':
options |= F_HOSTNAME;
break;
case 'h': /* hoplimit */
hoplimit = strtonum(optarg, 0, IPV6_MAXHLIM, &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_MAX)
errx(1, "interval is too large: %s", optarg);
interval.tv_sec = integral;
interval.tv_usec = fraction * 1000000.0;
if (!timerisset(&interval))
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_INTERVAL;
break;
case 'L':
moptions |= MULTICAST_NOLOOP;
break;
case 'l':
if (ouid)
errc(1, EPERM, NULL);
preload = strtonum(optarg, 1, INT64_MAX, &errstr);
if (errstr)
errx(1, "preload value is %s: %s", errstr,
optarg);
break;
case 'm':
mflag++;
break;
case 'n':
options &= ~F_HOSTNAME;
break;
case 'p': /* fill buffer with user pattern */
options |= F_PINGFILLED;
fill((char *)datap, optarg);
break;
case 'q':
options |= F_QUIET;
break;
case 'R':
options |= F_RROUTE;
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;
#ifndef SMALL
case 'T':
options |= F_HDRINCL;
options |= F_TOS;
errno = 0;
errstr = NULL;
if (map_tos(optarg, &tos))
break;
if (strlen(optarg) > 1 && optarg[0] == '0' &&
optarg[1] == 'x')
tos = (int)strtol(optarg, NULL, 16);
else
tos = strtonum(optarg, 0, 255, &errstr);
if (tos < 0 || tos > 255 || errstr || errno)
errx(1, "illegal tos value %s", optarg);
break;
#endif /* SMALL */
case 't':
options |= F_TTL;
ttl = strtonum(optarg, 0, MAXTTL, &errstr);
if (errstr)
errx(1, "ttl value is %s: %s", errstr, optarg);
break;
case 'V':
rtableid = strtonum(optarg, 0, RT_TABLEID_MAX, &errstr);
if (errstr)
errx(1, "rtable value is %s: %s", errstr,
optarg);
if (setsockopt(s, SOL_SOCKET, SO_RTABLE, &rtableid,
sizeof(rtableid)) == -1)
err(1, "setsockopt SO_RTABLE");
break;
case 'v':
options |= F_VERBOSE;
break;
case 'w':
maxwait = strtonum(optarg, 1, INT_MAX, &errstr);
if (errstr)
errx(1, "maxwait value is %s: %s",
errstr, optarg);
break;
default:
usage();
}
}
if (ouid == 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)
usage();
memset(&dst4, 0, sizeof(dst4));
memset(&dst6, 0, sizeof(dst6));
target = *argv;
memset(&hints, 0, sizeof(hints));
hints.ai_family = v6flag ? AF_INET6 : AF_INET;
hints.ai_socktype = SOCK_RAW;
hints.ai_protocol = 0;
hints.ai_flags = AI_CANONNAME;
if ((error = getaddrinfo(target, NULL, &hints, &res)))
errx(1, "%s", gai_strerror(error));
switch (res->ai_family) {
case AF_INET:
dst = (struct sockaddr *)&dst4;
from = (struct sockaddr *)&from4;
break;
case AF_INET6:
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) {
hostname = res->ai_canonname ? strdup(res->ai_canonname) :
target;
if (!hostname)
err(1, "malloc");
}
if (res->ai_next) {
if (getnameinfo(res->ai_addr, res->ai_addrlen, hbuf,
sizeof(hbuf), NULL, 0, NI_NUMERICHOST) != 0)
strlcpy(hbuf, "?", sizeof(hbuf));
warnx("Warning: %s has multiple "
"addresses; using %s", hostname, hbuf);
}
freeaddrinfo(res);
if (source) {
memset(&hints, 0, sizeof(hints));
hints.ai_family = dst->sa_family;
if ((error = getaddrinfo(source, NULL, &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))) {
if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_IF,
&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_VERBOSE) {
/*
* 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_DGRAM, 0)) == -1)
err(1, "UDP socket");
memcpy(from, dst, dst->sa_len);
if (v6flag) {
from6.sin6_port = ntohs(DUMMY_PORT);
if (pktinfo &&
setsockopt(dummy, IPPROTO_IPV6, IPV6_PKTINFO,
pktinfo, sizeof(*pktinfo)))
err(1, "UDP setsockopt(IPV6_PKTINFO)");
if (hoplimit != -1 &&
setsockopt(dummy, IPPROTO_IPV6, IPV6_UNICAST_HOPS,
&hoplimit, sizeof(hoplimit)))
err(1, "UDP setsockopt(IPV6_UNICAST_HOPS)");
if (hoplimit != -1 &&
setsockopt(dummy, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
&hoplimit, sizeof(hoplimit)))
err(1, "UDP setsockopt(IPV6_MULTICAST_HOPS)");
} else {
u_char loop = 0;
from4.sin_port = ntohs(DUMMY_PORT);
if ((moptions & MULTICAST_NOLOOP) && setsockopt(dummy,
IPPROTO_IP, IP_MULTICAST_LOOP, &loop,
sizeof(loop)) == -1)
err(1, "setsockopt IP_MULTICAST_LOOP");
if ((moptions & MULTICAST_TTL) && setsockopt(dummy,
IPPROTO_IP, IP_MULTICAST_TTL, &ttl,
sizeof(ttl)) == -1)
err(1, "setsockopt IP_MULTICAST_TTL");
}
if (rtableid > 0 &&
setsockopt(dummy, SOL_SOCKET, SO_RTABLE, &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_DEBUG)
(void)setsockopt(s, SOL_SOCKET, SO_DEBUG, &optval,
sizeof(optval));
if ((options & F_FLOOD) && (options & F_INTERVAL))
errx(1, "-f and -i options are incompatible");
if ((options & F_FLOOD) && (options & (F_AUD_RECV | F_AUD_MISS)))
warnx("No audible output for flood pings");
if (datalen >= sizeof(struct payload)) /* can we time transfer */
timing = 1;
if (v6flag) {
/* in F_VERBOSE case, we may get non-echoreply packets*/
if ((options & F_VERBOSE) && datalen < 2048) /* XXX 2048? */
packlen = 2048 + IP6LEN + ECHOLEN + EXTRA;
else
packlen = datalen + IP6LEN + ECHOLEN + EXTRA;
} else
packlen = datalen + MAXIPLEN + MAXICMPLEN;
if (!(packet = malloc(packlen)))
err(1, "malloc");
if (!(options & F_PINGFILLED))
for (i = ECHOTMLEN; 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_SOCKET, SO_SNDBUF, &maxsize, &maxsizelen) == -1)
err(1, "getsockopt");
if (maxsize < packlen &&
setsockopt(s, SOL_SOCKET, SO_SNDBUF, &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_SOCKET, SO_RCVBUF,
&bufspace, sizeof(bufspace)) == -1) {
if ((bufspace -= 1024) <= 0)
err(1, "Cannot set the receive buffer size");
}
if (bufspace < IP_MAXPACKET)
warnx("Could only allocate a receive buffer of %d bytes "
"(default %d)", bufspace, IP_MAXPACKET);
if (v6flag) {
unsigned int loop = 0;
/*
* let the kernel pass extension headers of incoming packets,
* for privileged socket options
*/
if (options & F_VERBOSE) {
int opton = 1;
if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVHOPOPTS,
&opton, sizeof(opton)))
err(1, "setsockopt(IPV6_RECVHOPOPTS)");
if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVDSTOPTS,
&opton, sizeof(opton)))
err(1, "setsockopt(IPV6_RECVDSTOPTS)");
if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVRTHDR,
&opton, sizeof(opton)))
err(1, "setsockopt(IPV6_RECVRTHDR)");
ICMP6_FILTER_SETPASSALL(&filt);
} else {
ICMP6_FILTER_SETBLOCKALL(&filt);
ICMP6_FILTER_SETPASS(ICMP6_ECHO_REPLY, &filt);
}
if ((moptions & MULTICAST_NOLOOP) &&
setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
&loop, sizeof(loop)) == -1)
err(1, "setsockopt IPV6_MULTICAST_LOOP");
optval = IPV6_DEFHLIM;
if (IN6_IS_ADDR_MULTICAST(&dst6.sin6_addr)) {
if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
&optval, sizeof(optval)) == -1)
err(1, "IPV6_MULTICAST_HOPS");
}
if (mflag != 1) {
optval = mflag > 1 ? 0 : 1;
if (setsockopt(s, IPPROTO_IPV6, IPV6_USE_MIN_MTU,
&optval, sizeof(optval)) == -1)
err(1, "setsockopt(IPV6_USE_MIN_MTU)");
} else {
optval = 1;
if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVPATHMTU,
&optval, sizeof(optval)) == -1)
err(1, "setsockopt(IPV6_RECVPATHMTU)");
}
if (setsockopt(s, IPPROTO_ICMPV6, ICMP6_FILTER,
&filt, sizeof(filt)) == -1)
err(1, "setsockopt(ICMP6_FILTER)");
if (hoplimit != -1) {
/* set IP6 packet options */
if ((scmsg = malloc( CMSG_SPACE(sizeof(int)))) == NULL)
err(1, "malloc");
smsghdr.msg_control = (caddr_t)scmsg;
smsghdr.msg_controllen = CMSG_SPACE(sizeof(int));
scmsg->cmsg_len = CMSG_LEN(sizeof(int));
scmsg->cmsg_level = IPPROTO_IPV6;
scmsg->cmsg_type = IPV6_HOPLIMIT;
*(int *)(CMSG_DATA(scmsg)) = hoplimit;
}
if (options & F_TOS) {
optval = tos;
if (setsockopt(s, IPPROTO_IPV6, IPV6_TCLASS,
&optval, sizeof(optval)) == -1)
err(1, "setsockopt(IPV6_TCLASS)");
}
if (df) {
optval = 1;
if (setsockopt(s, IPPROTO_IPV6, IPV6_DONTFRAG,
&optval, sizeof(optval)) == -1)
err(1, "setsockopt(IPV6_DONTFRAG)");
}
optval = 1;
if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVPKTINFO,
&optval, sizeof(optval)) == -1)
err(1, "setsockopt(IPV6_RECVPKTINFO)");
if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVHOPLIMIT,
&optval, sizeof(optval)) == -1)
err(1, "setsockopt(IPV6_RECVHOPLIMIT)");
} else {
u_char loop = 0;
if (options & F_TTL) {
if (IN_MULTICAST(ntohl(dst4.sin_addr.s_addr)))
moptions |= MULTICAST_TTL;
else
options |= F_HDRINCL;
}
if ((options & F_RROUTE) && (options & F_HDRINCL))
errx(1, "-R option and -D or -T, or -t to unicast"
" destinations are incompatible");
if (options & F_HDRINCL) {
struct ip *ip = (struct ip *)outpackhdr;
if (setsockopt(s, IPPROTO_IP, IP_HDRINCL,
&optval, sizeof(optval)) == -1)
err(1, "setsockopt(IP_HDRINCL)");
ip->ip_v = IPVERSION;
ip->ip_hl = sizeof(struct ip) >> 2;
ip->ip_tos = tos;
ip->ip_id = 0;
ip->ip_off = htons(df ? IP_DF : 0);
ip->ip_ttl = ttl;
ip->ip_p = IPPROTO_ICMP;
if (source)
ip->ip_src = from4.sin_addr;
else
ip->ip_src.s_addr = INADDR_ANY;
ip->ip_dst = dst4.sin_addr;
}
/* record route option */
if (options & F_RROUTE) {
if (IN_MULTICAST(ntohl(dst4.sin_addr.s_addr)))
errx(1, "record route not valid to multicast"
" destinations");
memset(rspace, 0, sizeof(rspace));
rspace[IPOPT_OPTVAL] = IPOPT_RR;
rspace[IPOPT_OLEN] = sizeof(rspace)-1;
rspace[IPOPT_OFFSET] = IPOPT_MINOFF;
if (setsockopt(s, IPPROTO_IP, IP_OPTIONS,
rspace, sizeof(rspace)) == -1)
err(1, "record route");
}
if ((moptions & MULTICAST_NOLOOP) &&
setsockopt(s, IPPROTO_IP, IP_MULTICAST_LOOP,
&loop, sizeof(loop)) == -1)
err(1, "setsockopt IP_MULTICAST_LOOP");
if ((moptions & MULTICAST_TTL) &&
setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL,
&ttl, sizeof(ttl)) == -1)
err(1, "setsockopt IP_MULTICAST_TTL");
}
if (options & F_HOSTNAME) {
if (pledge("stdio inet dns", NULL) == -1)
err(1, "pledge");
} else {
if (pledge("stdio inet", NULL) == -1)
err(1, "pledge");
}
arc4random_buf(&tv64_offset, sizeof(tv64_offset));
arc4random_buf(&mac_key, sizeof(mac_key));
printf("PING %s (", hostname);
if (options & F_VERBOSE)
printf("%s --> ", pr_addr(from, from->sa_len));
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(SIGALRM, onsignal);
memset(&itimer, 0, sizeof(itimer));
itimer.it_value.tv_sec = 1; /* make sure we don't get stuck */
(void)setitimer(ITIMER_REAL, &itimer, NULL);
for (;;) {
struct msghdr m;
union {
struct cmsghdr hdr;
u_char buf[CMSG_SPACE(1024)];
} 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 = POLLIN;
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 != EINTR)
break;
}
memset(&itimer, 0, sizeof(itimer));
(void)setitimer(ITIMER_REAL, &itimer, NULL);
while (preload--) /* Fire off them quickies. */
pinger(s);
(void)signal(SIGINT, onsignal);
(void)signal(SIGINFO, onsignal);
if (!(options & F_FLOOD)) {
(void)signal(SIGALRM, onsignal);
itimer.it_interval = interval;
itimer.it_value = interval;
(void)setitimer(ITIMER_REAL, &itimer, NULL);
if (ntransmitted == 0)
retransmit(s);
}
seenalrm = seenint = 0;
seeninfo = 0;
for (;;) {
struct msghdr m;
union {
struct cmsghdr hdr;
u_char buf[CMSG_SPACE(1024)];
} 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_FLOOD) &&
(options & F_AUD_MISS))
fputc('\a', stderr);
if ((options & F_SHOWCHAR) &&
!(options & F_FLOOD)) {
putchar('.');
fflush(stdout);
}
}
continue;
}
if (seeninfo) {
summary();
seeninfo = 0;
continue;
}
if ((options & F_FLOOD && !flooddone)) {
if (pinger(s) != 0) {
(void)signal(SIGALRM, onsignal);
timeout = INFTIM;
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_REAL, &itimer, NULL);
/* When the alarm goes off we are done. */
flooddone = 1;
} else
timeout = 10;
} else
timeout = INFTIM;
pfd.fd = s;
pfd.events = POLLIN;
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 != EINTR) {
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_VERBOSE) {
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);
}
void
onsignal(int sig)
{
switch (sig) {
case SIGALRM:
seenalrm++;
break;
case SIGINT:
seenint++;
break;
case SIGINFO:
seeninfo++;
break;
}
}
void
fill(char *bp, char *patp)
{
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 - (ECHOLEN + ECHOTMLEN + ii);
kk += ii)
for (jj = 0; jj < ii; ++jj)
bp[jj + kk] = pat[jj];
if (!(options & F_QUIET)) {
printf("PATTERN: 0x");
for (jj = 0; jj < ii; ++jj)
printf("%02x", bp[jj] & 0xFF);
printf("\n");
}
}
void
summary(void)
{
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);
}
}
/*
* pr_addr --
* Return address in numeric form or a host name
*/
const char *
pr_addr(struct sockaddr *addr, socklen_t addrlen)
{
static char buf[NI_MAXHOST];
int flag = 0;
if (!(options & F_HOSTNAME))
flag |= NI_NUMERICHOST;
if (getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0, flag) == 0)
return (buf);
else
return "?";
}
/*
* retransmit --
* This routine transmits another ping.
*/
void
retransmit(int s)
{
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_REAL, &itimer, NULL);
/* When the alarm goes off we are done. */
last_time = 1;
}
/*
* 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.
*/
int
pinger(int s)
{
struct icmp *icp = NULL;
struct icmp6_hdr *icp6 = NULL;
int cc, i;
u_int16_t seq;
if (npackets && ntransmitted >= npackets)
return(-1); /* no more transmission */
seq = htons(ntransmitted++);
if (v6flag) {
icp6 = (struct icmp6_hdr *)outpack;
memset(icp6, 0, sizeof(*icp6));
icp6->icmp6_cksum = 0;
icp6->icmp6_type = ICMP6_ECHO_REQUEST;
icp6->icmp6_code = 0;
icp6->icmp6_id = ident;
icp6->icmp6_seq = seq;
} else {
icp = (struct icmp *)outpack;
icp->icmp_type = ICMP_ECHO;
icp->icmp_code = 0;
icp->icmp_cksum = 0;
icp->icmp_seq = seq;
icp->icmp_id = ident;
}
CLR(ntohs(seq) % mx_dup_ck);
if (timing) {
SIPHASH_CTX ctx;
struct timespec ts;
struct payload payload;
struct tv64 *tv64 = &payload.tv64;
if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1)
err(1, "clock_gettime(CLOCK_MONOTONIC)");
tv64->tv64_sec = htobe64((u_int64_t)ts.tv_sec +
tv64_offset.tv64_sec);
tv64->tv64_nsec = htobe64((u_int64_t)ts.tv_nsec +
tv64_offset.tv64_nsec);
SipHash24_Init(&ctx, &mac_key);
SipHash24_Update(&ctx, tv64, sizeof(*tv64));
SipHash24_Update(&ctx, &ident, sizeof(ident));
SipHash24_Update(&ctx, &seq, sizeof(seq));
SipHash24_Final(&payload.mac, &ctx);
memcpy(&outpack[ECHOLEN], &payload, sizeof(payload));
}
cc = ECHOLEN + datalen;
if (!v6flag) {
/* compute ICMP checksum here */
icp->icmp_cksum = in_cksum((u_short *)icp, cc);
if (options & F_HDRINCL) {
struct ip *ip = (struct ip *)outpackhdr;
smsgiov.iov_base = (caddr_t)outpackhdr;
cc += sizeof(struct ip);
ip->ip_len = htons(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_QUIET) && (options & F_FLOOD))
write(STDOUT_FILENO, &DOT, 1);
return (0);
}
/*
* 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!).
*/
void
pr_pack(u_char *buf, int cc, struct msghdr *mhdr)
{
struct ip *ip = NULL;
struct icmp *icp = NULL;
struct icmp6_hdr *icp6 = NULL;
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_MONOTONIC, &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_INET6) {
if (options & F_VERBOSE)
warnx("invalid peername");
return;
}
from = (struct sockaddr *)mhdr->msg_name;
fromlen = mhdr->msg_namelen;
if (cc < sizeof(struct icmp6_hdr)) {
if (options & F_VERBOSE)
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_REPLY) {
if (icp6->icmp6_id != ident)
return; /* 'Twas not our ECHO */
seq = icp6->icmp6_seq;
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_INET) {
if (options & F_VERBOSE)
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_MINLEN) {
if (options & F_VERBOSE)
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_ECHOREPLY) {
if (icp->icmp_id != ident)
return; /* 'Twas not our ECHO */
seq = icp->icmp_seq;
echo_reply = 1;
pkttime = (char *)icp->icmp_data;
}
}
if (echo_reply) {
++nreceived;
if (cc >= ECHOLEN + ECHOTMLEN) {
SIPHASH_CTX ctx;
struct tv64 *tv64;
u_int8_t mac[SIPHASH_DIGEST_LENGTH];
memcpy(&payload, pkttime, sizeof(payload));
tv64 = &payload.tv64;
SipHash24_Init(&ctx, &mac_key);
SipHash24_Update(&ctx, tv64, sizeof(*tv64));
SipHash24_Update(&ctx, &ident, sizeof(ident));
SipHash24_Update(&ctx, &seq, sizeof(seq));
SipHash24_Final(mac, &ctx);
if (timingsafe_memcmp(mac, &payload.mac,
sizeof(mac)) != 0) {
printf("signature mismatch from %s: "
"icmp_seq=%u\n", pr_addr(from, fromlen),
ntohs(seq));
--nreceived;
return;
}
timinginfo=1;
tp.tv_sec = betoh64(tv64->tv64_sec) -
tv64_offset.tv64_sec;
tp.tv_nsec = betoh64(tv64->tv64_nsec) -
tv64_offset.tv64_nsec;
timespecsub(&ts, &tp, &ts);
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)) {
++nrepeats;
--nreceived;
dupflag = 1;
} else {
SET(ntohs(seq) % mx_dup_ck);
dupflag = 0;
}
if (options & F_QUIET)
return;
if (options & F_FLOOD)
write(STDOUT_FILENO, &BSPACE, 1);
else if (options & F_SHOWCHAR) {
if (dupflag)
putchar('D');
else if (cc - ECHOLEN < datalen)
putchar('T');
else
putchar('!');
} else {
printf("%d bytes from %s: icmp_seq=%u", cc,
pr_addr(from, fromlen), ntohs(seq));
if (v6flag)
printf(" hlim=%d", hoplim);
else
printf(" ttl=%d", ip->ip_ttl);
if (cc >= ECHOLEN + ECHOTMLEN)
printf(" time=%.3f ms", triptime);
if (dupflag)
printf(" (DUP!)");
/* check the data */
if (cc - ECHOLEN < datalen)
printf(" (TRUNC!)");
if (v6flag)
cp = buf + ECHOLEN + ECHOTMLEN;
else
cp = (u_char *)&icp->icmp_data[ECHOTMLEN];
dp = &outpack[ECHOLEN + ECHOTMLEN];
for (i = ECHOLEN + ECHOTMLEN;
i < cc && i < datalen;
++i, ++cp, ++dp) {
if (*cp != *dp) {
printf("\nwrong data byte #%d "
"should be 0x%x but was 0x%x",
i - ECHOLEN, *dp, *cp);
if (v6flag)
cp = buf + ECHOLEN;
else
cp = (u_char *)
&icp->icmp_data[0];
for (i = ECHOLEN; 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_VERBOSE))
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_FLOOD)) {
if (!(options & F_SHOWCHAR)) {
putchar('\n');
if (v6flag && (options & F_VERBOSE))
pr_exthdrs(mhdr);
}
fflush(stdout);
if (options & F_AUD_RECV)
fputc('\a', stderr);
}
}
void
pr_ipopt(int hlen, u_char *buf)
{
static int old_rrlen;
static char old_rr[MAX_IPOPTLEN];
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_INET;
for (; hlen > (int)sizeof(struct ip); --hlen, ++cp) {
switch (*cp) {
case IPOPT_EOL:
hlen = 0;
break;
case IPOPT_LSRR:
printf("\nLSRR: ");
hlen -= 2;
j = *++cp;
++cp;
i = 0;
if (j > IPOPT_MINOFF) {
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);
printf("\t%s",
pr_addr((struct sockaddr*)
&s_in, sizeof(s_in)));
}
hlen -= 4;
j -= 4;
i += 4;
if (j <= IPOPT_MINOFF)
break;
if (i >= MAX_IPOPTLEN) {
printf("\t(truncated route)");
break;
}
putchar('\n');
}
}
break;
case IPOPT_RR:
j = *++cp; /* get length */
i = *++cp; /* and pointer */
hlen -= 2;
if (i > j)
i = j;
i -= IPOPT_MINOFF;
if (i <= 0)
continue;
if (i == old_rrlen &&
cp == buf + sizeof(struct ip) + 2 &&
!memcmp(cp, old_rr, i) &&
!(options & F_FLOOD)) {
printf("\t(same route)");
i = (i + 3) & ~0x3;
hlen -= i;
cp += i;
break;
}
if (i < MAX_IPOPTLEN) {
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);
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_IPOPTLEN) {
printf("\t(truncated route)");
break;
}
putchar('\n');
}
break;
case IPOPT_NOP:
printf("\nNOP");
break;
default:
printf("\nunknown option %x", *cp);
if (cp[IPOPT_OLEN] > 0 && (cp[IPOPT_OLEN] - 1) <= hlen) {
hlen = hlen - (cp[IPOPT_OLEN] - 1);
cp = cp + (cp[IPOPT_OLEN] - 1);
} else
hlen = 0;
break;
}
}
}
/*
* in_cksum --
* Checksum routine for Internet Protocol family headers (C Version)
*/
int
in_cksum(u_short *addr, int len)
{
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);
}
/*
* pr_icmph --
* Print a descriptive string about an ICMP header.
*/
void
pr_icmph(struct icmp *icp)
{
switch(icp->icmp_type) {
case ICMP_ECHOREPLY:
printf("Echo Reply\n");
/* XXX ID + Seq + Data */
break;
case ICMP_UNREACH:
switch(icp->icmp_code) {
case ICMP_UNREACH_NET:
printf("Destination Net Unreachable\n");
break;
case ICMP_UNREACH_HOST:
printf("Destination Host Unreachable\n");
break;
case ICMP_UNREACH_PROTOCOL:
printf("Destination Protocol Unreachable\n");
break;
case ICMP_UNREACH_PORT:
printf("Destination Port Unreachable\n");
break;
case ICMP_UNREACH_NEEDFRAG:
if (icp->icmp_nextmtu != 0)
printf("frag needed and DF set (MTU %d)\n",
ntohs(icp->icmp_nextmtu));
else
printf("frag needed and DF set\n");
break;
case ICMP_UNREACH_SRCFAIL:
printf("Source Route Failed\n");
break;
case ICMP_UNREACH_NET_UNKNOWN:
printf("Network Unknown\n");
break;
case ICMP_UNREACH_HOST_UNKNOWN:
printf("Host Unknown\n");
break;
case ICMP_UNREACH_ISOLATED:
printf("Source Isolated\n");
break;
case ICMP_UNREACH_NET_PROHIB:
printf("Dest. Net Administratively Prohibited\n");
break;
case ICMP_UNREACH_HOST_PROHIB:
printf("Dest. Host Administratively Prohibited\n");
break;
case ICMP_UNREACH_TOSNET:
printf("Destination Net Unreachable for TOS\n");
break;
case ICMP_UNREACH_TOSHOST:
printf("Destination Host Unreachable for TOS\n");
break;
case ICMP_UNREACH_FILTER_PROHIB:
printf("Route administratively prohibited\n");
break;
case ICMP_UNREACH_HOST_PRECEDENCE:
printf("Host Precedence Violation\n");
break;
case ICMP_UNREACH_PRECEDENCE_CUTOFF:
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_data);
break;
case ICMP_SOURCEQUENCH:
printf("Source Quench\n");
pr_retip((struct ip *)icp->icmp_data);
break;
case ICMP_REDIRECT:
switch(icp->icmp_code) {
case ICMP_REDIRECT_NET:
printf("Redirect Network");
break;
case ICMP_REDIRECT_HOST:
printf("Redirect Host");
break;
case ICMP_REDIRECT_TOSNET:
printf("Redirect Type of Service and Network");
break;
case ICMP_REDIRECT_TOSHOST:
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_gwaddr));
pr_retip((struct ip *)icp->icmp_data);
break;
case ICMP_ECHO:
printf("Echo Request\n");
/* XXX ID + Seq + Data */
break;
case ICMP_ROUTERADVERT:
/* RFC1256 */
printf("Router Discovery Advertisement\n");
printf("(%d entries, lifetime %d seconds)\n",
icp->icmp_num_addrs, ntohs(icp->icmp_lifetime));
break;
case ICMP_ROUTERSOLICIT:
/* RFC1256 */
printf("Router Discovery Solicitation\n");
break;
case ICMP_TIMXCEED:
switch(icp->icmp_code) {
case ICMP_TIMXCEED_INTRANS:
printf("Time to live exceeded\n");
break;
case ICMP_TIMXCEED_REASS:
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_data);
break;
case ICMP_PARAMPROB:
switch(icp->icmp_code) {
case ICMP_PARAMPROB_OPTABSENT:
printf("Parameter problem, required option "
"absent: pointer = 0x%02x\n",
ntohs(icp->icmp_hun.ih_pptr));
break;
default:
printf("Parameter problem: pointer = 0x%02x\n",
ntohs(icp->icmp_hun.ih_pptr));
break;
}
pr_retip((struct ip *)icp->icmp_data);
break;
case ICMP_TSTAMP:
printf("Timestamp\n");
/* XXX ID + Seq + 3 timestamps */
break;
case ICMP_TSTAMPREPLY:
printf("Timestamp Reply\n");
/* XXX ID + Seq + 3 timestamps */
break;
case ICMP_IREQ:
printf("Information Request\n");
/* XXX ID + Seq */
break;
case ICMP_IREQREPLY:
printf("Information Reply\n");
/* XXX ID + Seq */
break;
case ICMP_MASKREQ:
printf("Address Mask Request\n");
break;
case ICMP_MASKREPLY:
printf("Address Mask Reply (Mask 0x%08x)\n",
ntohl(icp->icmp_mask));
break;
default:
printf("Unknown ICMP type: %d\n", icp->icmp_type);
}
}
/*
* pr_iph --
* Print an IP header with options.
*/
void
pr_iph(struct ip *ip)
{
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');
}
/*
* pr_retip --
* Dump some info on a returned (via ICMP) IP packet.
*/
void
pr_retip(struct ip *ip)
{
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)));
}
#ifndef SMALL
int
map_tos(char *key, int *val)
{
/* DiffServ Codepoints and other TOS mappings */
const struct toskeywords {
const char *keyword;
int val;
} *t, toskeywords[] = {
{ "af11", IPTOS_DSCP_AF11 },
{ "af12", IPTOS_DSCP_AF12 },
{ "af13", IPTOS_DSCP_AF13 },
{ "af21", IPTOS_DSCP_AF21 },
{ "af22", IPTOS_DSCP_AF22 },
{ "af23", IPTOS_DSCP_AF23 },
{ "af31", IPTOS_DSCP_AF31 },
{ "af32", IPTOS_DSCP_AF32 },
{ "af33", IPTOS_DSCP_AF33 },
{ "af41", IPTOS_DSCP_AF41 },
{ "af42", IPTOS_DSCP_AF42 },
{ "af43", IPTOS_DSCP_AF43 },
{ "critical", IPTOS_PREC_CRITIC_ECP },
{ "cs0", IPTOS_DSCP_CS0 },
{ "cs1", IPTOS_DSCP_CS1 },
{ "cs2", IPTOS_DSCP_CS2 },
{ "cs3", IPTOS_DSCP_CS3 },
{ "cs4", IPTOS_DSCP_CS4 },
{ "cs5", IPTOS_DSCP_CS5 },
{ "cs6", IPTOS_DSCP_CS6 },
{ "cs7", IPTOS_DSCP_CS7 },
{ "ef", IPTOS_DSCP_EF },
{ "inetcontrol", IPTOS_PREC_INTERNETCONTROL },
{ "lowdelay", IPTOS_LOWDELAY },
{ "netcontrol", IPTOS_PREC_NETCONTROL },
{ "reliability", IPTOS_RELIABILITY },
{ "throughput", IPTOS_THROUGHPUT },
{ NULL, -1 },
};
for (t = toskeywords; t->keyword != NULL; t++) {
if (strcmp(key, t->keyword) == 0) {
*val = t->val;
return (1);
}
}
return (0);
}
#endif /* SMALL */
void
pr_exthdrs(struct msghdr *mhdr)
{
struct cmsghdr *cm;
for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(mhdr); cm;
cm = (struct cmsghdr *)CMSG_NXTHDR(mhdr, cm)) {
if (cm->cmsg_level != IPPROTO_IPV6)
continue;
switch (cm->cmsg_type) {
case IPV6_HOPOPTS:
printf(" HbH Options: ");
pr_ip6opt(CMSG_DATA(cm));
break;
case IPV6_DSTOPTS:
case IPV6_RTHDRDSTOPTS:
printf(" Dst Options: ");
pr_ip6opt(CMSG_DATA(cm));
break;
case IPV6_RTHDR:
printf(" Routing: ");
pr_rthdr(CMSG_DATA(cm));
break;
}
}
}
void
pr_ip6opt(void *extbuf)
{
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_JUMBO:
inet6_opt_get_val(databuf, 0, &value4, sizeof(value4));
printf(" Jumbo Payload Opt: Length %u\n",
(u_int32_t)ntohl(value4));
break;
case IP6OPT_ROUTER_ALERT:
inet6_opt_get_val(databuf, 0, &value2, sizeof(value2));
printf(" Router Alert Opt: Type %u\n",
ntohs(value2));
break;
default:
printf(" Received Opt %u len %lu\n",
type, (unsigned long)len);
break;
}
}
return;
}
void
pr_rthdr(void *extbuf)
{
struct in6_addr *in6;
char ntopbuf[INET6_ADDRSTRLEN];
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)
printf(" [%d]<NULL>\n", i);
else {
if (!inet_ntop(AF_INET6, in6, ntopbuf,
sizeof(ntopbuf)))
strncpy(ntopbuf, "?", sizeof(ntopbuf));
printf(" [%d]%s\n", i, ntopbuf);
}
}
return;
}
int
get_hoplim(struct msghdr *mhdr)
{
struct cmsghdr *cm;
for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(mhdr); cm;
cm = (struct cmsghdr *)CMSG_NXTHDR(mhdr, cm)) {
if (cm->cmsg_len == 0)
return(-1);
if (cm->cmsg_level == IPPROTO_IPV6 &&
cm->cmsg_type == IPV6_HOPLIMIT &&
cm->cmsg_len == CMSG_LEN(sizeof(int)))
return(*(int *)CMSG_DATA(cm));
}
return(-1);
}
int
get_pathmtu(struct msghdr *mhdr, struct sockaddr_in6 *dst)
{
struct cmsghdr *cm;
struct ip6_mtuinfo *mtuctl = NULL;
for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(mhdr); cm;
cm = (struct cmsghdr *)CMSG_NXTHDR(mhdr, cm)) {
if (cm->cmsg_len == 0)
return(0);
if (cm->cmsg_level == IPPROTO_IPV6 &&
cm->cmsg_type == IPV6_PATHMTU &&
cm->cmsg_len == CMSG_LEN(sizeof(struct ip6_mtuinfo))) {
mtuctl = (struct ip6_mtuinfo *)CMSG_DATA(cm);
/*
* 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,
&dst->sin6_addr) ||
(mtuctl->ip6m_addr.sin6_scope_id &&
dst->sin6_scope_id &&
mtuctl->ip6m_addr.sin6_scope_id !=
dst->sin6_scope_id)) {
if (options & F_VERBOSE) {
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_MMTU)
return(0);
/* notification for our destination. return the MTU. */
return((int)mtuctl->ip6m_mtu);
}
}
return(0);
}
/*
* pr_icmph6 --
* Print a descriptive string about an ICMP header.
*/
void
pr_icmph6(struct icmp6_hdr *icp, u_char *end)
{
char ntop_buf[INET6_ADDRSTRLEN];
struct nd_redirect *red;
switch (icp->icmp6_type) {
case ICMP6_DST_UNREACH:
switch (icp->icmp6_code) {
case ICMP6_DST_UNREACH_NOROUTE:
printf("No Route to Destination\n");
break;
case ICMP6_DST_UNREACH_ADMIN:
printf("Destination Administratively "
"Unreachable\n");
break;
case ICMP6_DST_UNREACH_BEYONDSCOPE:
printf("Destination Unreachable Beyond Scope\n");
break;
case ICMP6_DST_UNREACH_ADDR:
printf("Destination Host Unreachable\n");
break;
case ICMP6_DST_UNREACH_NOPORT:
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_BIG:
printf("Packet too big mtu = %d\n",
(int)ntohl(icp->icmp6_mtu));
pr_retip6((struct ip6_hdr *)(icp + 1), end);
break;
case ICMP6_TIME_EXCEEDED:
switch (icp->icmp6_code) {
case ICMP6_TIME_EXCEED_TRANSIT:
printf("Time to live exceeded\n");
break;
case ICMP6_TIME_EXCEED_REASSEMBLY:
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_PROB:
printf("Parameter problem: ");
switch (icp->icmp6_code) {
case ICMP6_PARAMPROB_HEADER:
printf("Erroneous Header ");
break;
case ICMP6_PARAMPROB_NEXTHEADER:
printf("Unknown Nextheader ");
break;
case ICMP6_PARAMPROB_OPTION:
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));
pr_retip6((struct ip6_hdr *)(icp + 1), end);
break;
case ICMP6_ECHO_REQUEST:
printf("Echo Request");
/* XXX ID + Seq + Data */
break;
case ICMP6_ECHO_REPLY:
printf("Echo Reply");
/* XXX ID + Seq + Data */
break;
case ICMP6_MEMBERSHIP_QUERY:
printf("Listener Query");
break;
case ICMP6_MEMBERSHIP_REPORT:
printf("Listener Report");
break;
case ICMP6_MEMBERSHIP_REDUCTION:
printf("Listener Done");
break;
case ND_ROUTER_SOLICIT:
printf("Router Solicitation");
break;
case ND_ROUTER_ADVERT:
printf("Router Advertisement");
break;
case ND_NEIGHBOR_SOLICIT:
printf("Neighbor Solicitation");
break;
case ND_NEIGHBOR_ADVERT:
printf("Neighbor Advertisement");
break;
case ND_REDIRECT:
red = (struct nd_redirect *)icp;
printf("Redirect\n");
if (!inet_ntop(AF_INET6, &red->nd_rd_dst, ntop_buf,
sizeof(ntop_buf)))
strncpy(ntop_buf, "?", sizeof(ntop_buf));
printf("Destination: %s", ntop_buf);
if (!inet_ntop(AF_INET6, &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);
}
}
/*
* pr_iph6 --
* Print an IP6 header.
*/
void
pr_iph6(struct ip6_hdr *ip6)
{
u_int32_t flow = ip6->ip6_flow & IPV6_FLOWLABEL_MASK;
u_int8_t tc;
char ntop_buf[INET6_ADDRSTRLEN];
tc = *(&ip6->ip6_vfc + 1); /* XXX */
tc = (tc >> 4) & 0x0f;
tc |= (ip6->ip6_vfc << 4);
printf("Vr TC Flow Plen Nxt Hlim\n");
printf(" %1x %02x %05x %04x %02x %02x\n",
(ip6->ip6_vfc & IPV6_VERSION_MASK) >> 4, tc, (u_int32_t)ntohl(flow),
ntohs(ip6->ip6_plen), ip6->ip6_nxt, ip6->ip6_hlim);
if (!inet_ntop(AF_INET6, &ip6->ip6_src, ntop_buf, sizeof(ntop_buf)))
strncpy(ntop_buf, "?", sizeof(ntop_buf));
printf("%s->", ntop_buf);
if (!inet_ntop(AF_INET6, &ip6->ip6_dst, ntop_buf, sizeof(ntop_buf)))
strncpy(ntop_buf, "?", sizeof(ntop_buf));
printf("%s\n", ntop_buf);
}
/*
* pr_retip6 --
* Dump some info on a returned (via ICMPv6) IPv6 packet.
*/
void
pr_retip6(struct ip6_hdr *ip6, u_char *end)
{
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_nxt;
cp += hlen;
while (end - cp >= 8) {
switch (nh) {
case IPPROTO_HOPOPTS:
printf("HBH ");
hlen = (((struct ip6_hbh *)cp)->ip6h_len+1) << 3;
nh = ((struct ip6_hbh *)cp)->ip6h_nxt;
break;
case IPPROTO_DSTOPTS:
printf("DSTOPT ");
hlen = (((struct ip6_dest *)cp)->ip6d_len+1) << 3;
nh = ((struct ip6_dest *)cp)->ip6d_nxt;
break;
case IPPROTO_FRAGMENT:
printf("FRAG ");
hlen = sizeof(struct ip6_frag);
nh = ((struct ip6_frag *)cp)->ip6f_nxt;
break;
case IPPROTO_ROUTING:
printf("RTHDR ");
hlen = (((struct ip6_rthdr *)cp)->ip6r_len+1) << 3;
nh = ((struct ip6_rthdr *)cp)->ip6r_nxt;
break;
case IPPROTO_AH:
printf("AH ");
hlen = (((struct ah *)cp)->ah_hl+2) << 2;
nh = ((struct ah *)cp)->ah_nh;
break;
case IPPROTO_ICMPV6:
printf("ICMP6: type = %d, code = %d\n",
*cp, *(cp + 1));
return;
case IPPROTO_ESP:
printf("ESP\n");
return;
case IPPROTO_TCP:
printf("TCP: from port %u, to port %u (decimal)\n",
(*cp * 256 + *(cp + 1)),
(*(cp + 2) * 256 + *(cp + 3)));
return;
case IPPROTO_UDP:
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');
return;
trunc:
printf("...\n");
return;
}
__dead void
usage(void)
{
if (v6flag) {
fprintf(stderr,
"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,
"usage: ping [-DdEefgHLnqRv] [-c count] [-I sourceaddr] "
"[-i interval]\n\t[-l preload] [-p pattern] [-s packetsize]"
#ifndef SMALL
" [-T toskeyword]"
#endif /* SMALL */
"\n\t[-t ttl] [-V rtable] [-w maxwait] host\n");
}
exit(1);
}
Reference in New Issue View Git Blame Copy Permalink