2277 lines
57 KiB
C
2277 lines
57 KiB
C
/* $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);
|
|
}
|