www.pudn.com > iputils.rar > ping6.c
/*
*
* Modified for AF_INET6 by Pedro Roque
*
*
*
* Original copyright notice included bellow
*/
/*
* Copyright (c) 1989 The Regents of the University of California.
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Mike Muuss.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. 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.
*/
#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1989 The Regents of the University of California.\n\
All rights reserved.\n";
#endif /* not lint */
/*
* P I N G . C
*
* Using the InterNet Control Message Protocol (ICMP) "ECHO" facility,
* measure round-trip-delays and packet loss across network paths.
*
* Author -
* Mike Muuss
* U. S. Army Ballistic Research Laboratory
* December, 1983
*
* Status -
* Public Domain. Distribution Unlimited.
* Bugs -
* More statistics could always be gathered.
* This program has to run SUID to ROOT to access the ICMP socket.
*/
#include "ping_common.h"
#include
#include
#include
#define BIT_CLEAR(nr, addr) do { ((__u32 *)(addr))[(nr) >> 5] &= ~(1U << ((nr) & 31)); } while(0)
#define BIT_SET(nr, addr) do { ((__u32 *)(addr))[(nr) >> 5] |= (1U << ((nr) & 31)); } while(0)
#define BIT_TEST(nr, addr) do { (__u32 *)(addr))[(nr) >> 5] & (1U << ((nr) & 31)); } while(0)
#define ICMPV6_FILTER_WILLPASS(type, filterp) \
(BIT_TEST((type), filterp) == 0)
#define ICMPV6_FILTER_WILLBLOCK(type, filterp) \
BIT_TEST((type), filterp)
#define ICMPV6_FILTER_SETPASS(type, filterp) \
BIT_CLEAR((type), filterp)
#define ICMPV6_FILTER_SETBLOCK(type, filterp) \
BIT_SET((type), filterp)
#define ICMPV6_FILTER_SETPASSALL(filterp) \
memset(filterp, 0, sizeof(struct icmp6_filter));
#define ICMPV6_FILTER_SETBLOCKALL(filterp) \
memset(filterp, 0xFF, sizeof(struct icmp6_filter));
#define MAXPACKET 128000 /* max packet size */
#ifdef SO_TIMESTAMP
#define HAVE_SIN6_SCOPEID 1
#endif
__u32 flowlabel;
__u32 tclass;
struct cmsghdr *srcrt;
struct sockaddr_in6 whereto; /* who to ping */
u_char outpack[MAXPACKET];
int maxpacket = sizeof(outpack);
static unsigned char cmsgbuf[4096];
static int cmsglen = 0;
static char * pr_addr(struct in6_addr *addr);
static char * pr_addr_n(struct in6_addr *addr);
static int pr_icmph(__u8 type, __u8 code, __u32 info);
static void usage(void) __attribute((noreturn));
struct sockaddr_in6 source;
char *device;
int pmtudisc=-1;
static int icmp_sock;
static struct in6_addr in6_anyaddr;
static __inline__ int ipv6_addr_any(struct in6_addr *addr)
{
return (memcmp(addr, &in6_anyaddr, 16) == 0);
}
size_t inet6_srcrt_space(int type, int segments)
{
if (type != 0 || segments > 24)
return 0;
return (sizeof(struct cmsghdr) + sizeof(struct rt0_hdr) +
segments * sizeof(struct in6_addr));
}
extern struct cmsghdr * inet6_srcrt_init(void *bp, int type)
{
struct cmsghdr *cmsg;
if (type)
return NULL;
memset(bp, 0, sizeof(struct cmsghdr) + sizeof(struct rt0_hdr));
cmsg = (struct cmsghdr *) bp;
cmsg->cmsg_len = sizeof(struct cmsghdr) + sizeof(struct rt0_hdr);
cmsg->cmsg_level = SOL_IPV6;
cmsg->cmsg_type = IPV6_RTHDR;
return cmsg;
}
int inet6_srcrt_add(struct cmsghdr *cmsg, const struct in6_addr *addr)
{
struct rt0_hdr *hdr;
hdr = (struct rt0_hdr *) CMSG_DATA(cmsg);
cmsg->cmsg_len += sizeof(struct in6_addr);
hdr->rt_hdr.hdrlen += sizeof(struct in6_addr) / 8;
memcpy(&hdr->addr[hdr->rt_hdr.segments_left++], addr,
sizeof(struct in6_addr));
return 0;
}
int main(int argc, char *argv[])
{
int ch, hold, packlen;
u_char *packet;
char *target;
struct sockaddr_in6 firsthop;
int socket_errno;
struct icmp6_filter filter;
int err, csum_offset, sz_opt;
icmp_sock = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
socket_errno = errno;
uid = getuid();
setuid(uid);
source.sin6_family = AF_INET6;
memset(&firsthop, 0, sizeof(firsthop));
firsthop.sin6_family = AF_INET6;
preload = 1;
while ((ch = getopt(argc, argv, COMMON_OPTSTR "F:")) != EOF) {
switch(ch) {
case 'F':
sscanf(optarg, "%x", &flowlabel);
options |= F_FLOWINFO;
break;
case 'Q':
sscanf(optarg, "%x", &tclass);
options |= F_TCLASS;
break;
case 'I':
if (strchr(optarg, ':')) {
if (inet_pton(AF_INET6, optarg, (char*)&source.sin6_addr) <= 0) {
fprintf(stderr, "ping: invalid source address %s\n", optarg);
exit(2);
}
options |= F_STRICTSOURCE;
} else {
device = optarg;
}
break;
case 'M':
if (strcmp(optarg, "do") == 0)
pmtudisc = IPV6_PMTUDISC_DO;
else if (strcmp(optarg, "dont") == 0)
pmtudisc = IPV6_PMTUDISC_DONT;
else if (strcmp(optarg, "want") == 0)
pmtudisc = IPV6_PMTUDISC_WANT;
else {
fprintf(stderr, "ping: wrong value for -M: do, dont, want are valid ones.\n");
exit(2);
}
break;
case 'V':
printf("ping6 utility, iputils-ss%s\n", SNAPSHOT);
exit(0);
COMMON_OPTIONS
common_options(ch);
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
while (argc > 1) {
struct in6_addr addr;
if (srcrt == NULL) {
int space;
space = inet6_srcrt_space(IPV6_SRCRT_TYPE_0, argc - 1);
if (space == 0) {
fprintf(stderr, "srcrt_space failed\n");
exit(2);
}
if (space + cmsglen > sizeof(cmsgbuf)) {
fprintf(stderr, "no room for options\n");
exit(2);
}
srcrt = (struct cmsghdr*)(cmsgbuf+cmsglen);
cmsglen += CMSG_ALIGN(space);
inet6_srcrt_init(srcrt, IPV6_SRCRT_TYPE_0);
}
target = *argv;
if (inet_pton(AF_INET6, target, &addr) <= 0) {
struct hostent *hp;
hp = gethostbyname2(target, AF_INET6);
if (hp == NULL) {
fprintf(stderr, "unknown host %s\n", target);
exit(2);
}
memcpy(&addr, hp->h_addr_list[0], 16);
}
inet6_srcrt_add(srcrt, &addr);
if (ipv6_addr_any(&firsthop.sin6_addr))
memcpy(&firsthop.sin6_addr, &addr, 16);
argv++;
argc--;
}
if (argc != 1)
usage();
target = *argv;
memset(&whereto, 0, sizeof(struct sockaddr_in6));
whereto.sin6_family = AF_INET6;
whereto.sin6_port = htons(IPPROTO_ICMPV6);
if (inet_pton(AF_INET6, target, &whereto.sin6_addr) <= 0) {
struct hostent *hp;
hp = gethostbyname2(target, AF_INET6);
if (hp == NULL) {
fprintf(stderr, "unknown host\n");
exit(2);
}
memcpy(&whereto.sin6_addr, hp->h_addr_list[0], 16);
} else {
options |= F_NUMERIC;
}
if (ipv6_addr_any(&firsthop.sin6_addr))
memcpy(&firsthop.sin6_addr, &whereto.sin6_addr, 16);
hostname = target;
if (ipv6_addr_any(&source.sin6_addr)) {
int alen;
int probe_fd = socket(AF_INET6, SOCK_DGRAM, 0);
if (probe_fd < 0) {
perror("socket");
exit(2);
}
if (device) {
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, device, IFNAMSIZ-1);
if (setsockopt(probe_fd, SOL_SOCKET, SO_BINDTODEVICE, device, strlen(device)+1) == -1) {
#ifdef HAVE_SIN6_SCOPEID
if ((firsthop.sin6_addr.s6_addr16[0]&htons(0xffc0)) == htons (0xfe80) ||
(firsthop.sin6_addr.s6_addr16[0]&htons(0xffff)) == htons (0xff02)) {
if (ioctl(probe_fd, SIOCGIFINDEX, &ifr) < 0) {
fprintf(stderr, "ping: unknown iface %s\n", device);
exit(2);
}
firsthop.sin6_scope_id = ifr.ifr_ifindex;
}
#endif
}
}
firsthop.sin6_port = htons(1025);
if (connect(probe_fd, (struct sockaddr*)&firsthop, sizeof(firsthop)) == -1) {
perror("connect");
exit(2);
}
alen = sizeof(source);
if (getsockname(probe_fd, (struct sockaddr*)&source, &alen) == -1) {
perror("getsockname");
exit(2);
}
source.sin6_port = 0;
close(probe_fd);
}
if (icmp_sock < 0) {
errno = socket_errno;
perror("ping: icmp open socket");
exit(2);
}
if (device) {
struct ifreq ifr;
struct cmsghdr *cmsg;
struct in6_pktinfo *ipi;
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, device, IFNAMSIZ-1);
if (ioctl(icmp_sock, SIOCGIFINDEX, &ifr) < 0) {
fprintf(stderr, "ping: unknown iface %s\n", device);
exit(2);
}
cmsg = (struct cmsghdr*)cmsgbuf;
cmsglen += CMSG_SPACE(sizeof(*ipi));
cmsg->cmsg_len = CMSG_LEN(sizeof(*ipi));
cmsg->cmsg_level = SOL_IPV6;
cmsg->cmsg_type = IPV6_PKTINFO;
ipi = (struct in6_pktinfo*)CMSG_DATA(cmsg);
memset(ipi, 0, sizeof(*ipi));
ipi->ipi6_ifindex = ifr.ifr_ifindex;
}
if ((whereto.sin6_addr.s6_addr16[0]&htons(0xff00)) == htons (0xff00)) {
if (uid) {
if (interval < 1000) {
fprintf(stderr, "ping: multicast ping with too short interval.\n");
exit(2);
}
if (pmtudisc >= 0 && pmtudisc != IPV6_PMTUDISC_DO) {
fprintf(stderr, "ping: multicast ping does not fragment.\n");
exit(2);
}
}
if (pmtudisc < 0)
pmtudisc = IPV6_PMTUDISC_DO;
}
if (pmtudisc >= 0) {
if (setsockopt(icmp_sock, SOL_IPV6, IPV6_MTU_DISCOVER, &pmtudisc, sizeof(pmtudisc)) == -1) {
perror("ping: IPV6_MTU_DISCOVER");
exit(2);
}
}
if ((options&F_STRICTSOURCE) &&
bind(icmp_sock, (struct sockaddr*)&source, sizeof(source)) == -1) {
perror("ping: bind icmp socket");
exit(2);
}
if (datalen >= sizeof(struct timeval)) /* can we time transfer */
timing = 1;
packlen = datalen + 8 + 4096 + 40 + 8; /* 4096 for rthdr */
if (!(packet = (u_char *)malloc((u_int)packlen))) {
fprintf(stderr, "ping: out of memory.\n");
exit(2);
}
working_recverr = 1;
hold = 1;
if (setsockopt(icmp_sock, SOL_IPV6, IPV6_RECVERR, (char *)&hold, sizeof(hold))) {
fprintf(stderr, "WARNING: your kernel is veeery old. No problems.\n");
working_recverr = 0;
}
/* Estimate memory eaten by single packet. It is rough estimate.
* Actually, for small datalen's it depends on kernel side a lot. */
hold = datalen+8;
hold += ((hold+511)/512)*(40+16+64+160);
sock_setbufs(icmp_sock, hold);
csum_offset = 2;
sz_opt = sizeof(int);
err = setsockopt(icmp_sock, SOL_RAW, IPV6_CHECKSUM, &csum_offset, sz_opt);
if (err < 0) {
perror("setsockopt(RAW_CHECKSUM)");
exit(2);
}
/*
* select icmp echo reply as icmp type to receive
*/
ICMPV6_FILTER_SETBLOCKALL(&filter);
if (!working_recverr) {
ICMPV6_FILTER_SETPASS(ICMPV6_DEST_UNREACH, &filter);
ICMPV6_FILTER_SETPASS(ICMPV6_PKT_TOOBIG, &filter);
ICMPV6_FILTER_SETPASS(ICMPV6_TIME_EXCEED, &filter);
ICMPV6_FILTER_SETPASS(ICMPV6_PARAMPROB, &filter);
}
ICMPV6_FILTER_SETPASS(ICMPV6_ECHO_REPLY, &filter);
err = setsockopt(icmp_sock, SOL_ICMPV6, ICMPV6_FILTER, &filter,
sizeof(struct icmp6_filter));
if (err < 0) {
perror("setsockopt(ICMPV6_FILTER)");
exit(2);
}
if (options & F_NOLOOP) {
int loop = 0;
if (setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
&loop, sizeof(loop)) == -1) {
perror ("can't disable multicast loopback");
exit(2);
}
}
if (options & F_TTL) {
if (setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
&ttl, sizeof(ttl)) == -1) {
perror ("can't set multicast hop limit");
exit(2);
}
if (setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_UNICAST_HOPS,
&ttl, sizeof(ttl)) == -1) {
perror ("can't set unicast hop limit");
exit(2);
}
}
if (1) {
int on = 1;
if (setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_HOPLIMIT,
&on, sizeof(on)) == -1) {
perror ("can't receive hop limit");
exit(2);
}
}
if (options&F_FLOWINFO) {
#ifdef IPV6_FLOWLABEL_MGR
char freq_buf[CMSG_ALIGN(sizeof(struct in6_flowlabel_req)) + cmsglen];
struct in6_flowlabel_req *freq = (struct in6_flowlabel_req *)freq_buf;
int freq_len = sizeof(*freq);
if (srcrt)
freq_len = CMSG_ALIGN(sizeof(*freq)) + srcrt->cmsg_len;
memset(freq, 0, sizeof(*freq));
freq->flr_label = htonl(flowlabel&0xFFFFF);
freq->flr_action = IPV6_FL_A_GET;
freq->flr_flags = IPV6_FL_F_CREATE;
freq->flr_share = IPV6_FL_S_EXCL;
memcpy(&freq->flr_dst, &whereto.sin6_addr, 16);
if (srcrt)
memcpy(freq_buf + CMSG_ALIGN(sizeof(*freq)), srcrt, srcrt->cmsg_len);
if (setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_FLOWLABEL_MGR,
freq, freq_len) == -1) {
perror ("can't set flowlabel");
exit(2);
}
flowlabel = freq->flr_label;
if (srcrt) {
cmsglen = (char*)srcrt - (char*)cmsgbuf;
srcrt = NULL;
}
#else
fprintf(stderr, "Flow labels are not supported.\n");
exit(2);
#endif
}
if (options&(F_FLOWINFO|F_TCLASS)) {
#ifdef IPV6_FLOWINFO_SEND
int on = 1;
whereto.sin6_flowinfo = flowlabel | htonl((tclass&0xFF)<<20);
if (setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_FLOWINFO_SEND,
&on, sizeof(on)) == -1) {
perror ("can't send flowinfo");
exit(2);
}
#else
fprintf(stderr, "Flowinfo is not supported.\n");
exit(2);
#endif
}
printf("PING %s(%s) ", hostname, pr_addr(&whereto.sin6_addr));
if (flowlabel)
printf(", flow 0x%05x, ", (unsigned)ntohl(flowlabel));
if (device || (options&F_STRICTSOURCE)) {
printf("from %s %s: ",
pr_addr_n(&source.sin6_addr), device ? : "");
}
printf("%d data bytes\n", datalen);
setup(icmp_sock);
main_loop(icmp_sock, packet, packlen);
}
int receive_error_msg()
{
int res;
char cbuf[512];
struct iovec iov;
struct msghdr msg;
struct cmsghdr *cmsg;
struct sock_extended_err *e;
struct icmp6hdr icmph;
struct sockaddr_in6 target;
int net_errors = 0;
int local_errors = 0;
int saved_errno = errno;
iov.iov_base = &icmph;
iov.iov_len = sizeof(icmph);
msg.msg_name = (void*)⌖
msg.msg_namelen = sizeof(target);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_flags = 0;
msg.msg_control = cbuf;
msg.msg_controllen = sizeof(cbuf);
res = recvmsg(icmp_sock, &msg, MSG_ERRQUEUE|MSG_DONTWAIT);
if (res < 0)
goto out;
e = NULL;
for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
if (cmsg->cmsg_level == SOL_IPV6) {
if (cmsg->cmsg_type == IPV6_RECVERR)
e = (struct sock_extended_err *)CMSG_DATA(cmsg);
}
}
if (e == NULL)
abort();
if (e->ee_origin == SO_EE_ORIGIN_LOCAL) {
local_errors++;
if (options & F_QUIET)
goto out;
if (options & F_FLOOD)
write(STDOUT_FILENO, "E", 1);
else if (e->ee_errno != EMSGSIZE)
fprintf(stderr, "ping: local error: %s\n", strerror(e->ee_errno));
else
fprintf(stderr, "ping: local error: Message too long, mtu=%u\n", e->ee_info);
nerrors++;
} else if (e->ee_origin == SO_EE_ORIGIN_ICMP6) {
struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)(e+1);
if (res < sizeof(icmph) ||
memcmp(&target.sin6_addr, &whereto.sin6_addr, 16) ||
icmph.icmp6_type != ICMPV6_ECHO_REQUEST ||
icmph.icmp6_identifier != ident) {
/* Not our error, not an error at all. Clear. */
saved_errno = 0;
goto out;
}
net_errors++;
nerrors++;
if (options & F_QUIET)
goto out;
if (options & F_FLOOD) {
write(STDOUT_FILENO, "\bE", 2);
} else {
printf("From %s icmp_seq=%u ", pr_addr(&sin6->sin6_addr), ntohs(icmph.icmp6_sequence));
pr_icmph(e->ee_type, e->ee_code, e->ee_info);
putchar('\n');
fflush(stdout);
}
}
out:
errno = saved_errno;
return net_errors ? : -local_errors;
}
/*
* pinger --
* Compose and transmit an ICMP ECHO REQUEST packet. The IP packet
* will be added on by the kernel. The ID field is our UNIX process ID,
* 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 send_probe(void)
{
struct icmp6hdr *icmph;
int cc;
int i;
icmph = (struct icmp6hdr *)outpack;
icmph->icmp6_type = ICMPV6_ECHO_REQUEST;
icmph->icmp6_code = 0;
icmph->icmp6_cksum = 0;
icmph->icmp6_sequence = htons(ntransmitted+1);
icmph->icmp6_identifier = ident;
CLR((ntransmitted+1) % mx_dup_ck);
if (timing)
gettimeofday((struct timeval *)&outpack[8],
(struct timezone *)NULL);
cc = datalen + 8; /* skips ICMP portion */
if (cmsglen == 0) {
i = sendto(icmp_sock, (char *)outpack, cc, confirm,
(struct sockaddr *) &whereto,
sizeof(struct sockaddr_in6));
} else {
struct msghdr mhdr;
struct iovec iov;
iov.iov_len = cc;
iov.iov_base = outpack;
mhdr.msg_name = &whereto;
mhdr.msg_namelen = sizeof(struct sockaddr_in6);
mhdr.msg_iov = &iov;
mhdr.msg_iovlen = 1;
mhdr.msg_control = cmsgbuf;
mhdr.msg_controllen = cmsglen;
i = sendmsg(icmp_sock, &mhdr, confirm);
}
confirm = 0;
return (cc == i ? 0 : i);
}
/*
* parse_reply --
* 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!).
*/
int
parse_reply(struct msghdr *msg, int cc, void *addr, struct timeval *tv)
{
struct sockaddr_in6 *from = addr;
__u8 *buf = msg->msg_iov->iov_base;
struct cmsghdr *c;
struct icmp6hdr *icmph;
int hops = -1;
for (c = CMSG_FIRSTHDR(msg); c; c = CMSG_NXTHDR(msg, c)) {
if (c->cmsg_level != SOL_IPV6 ||
c->cmsg_type != IPV6_HOPLIMIT)
continue;
if (c->cmsg_len < CMSG_LEN(sizeof(int)))
continue;
hops = *(int*)CMSG_DATA(c);
}
/* Now the ICMP part */
icmph = (struct icmp6hdr *) buf;
if (cc < 8) {
if (options & F_VERBOSE)
fprintf(stderr, "ping: packet too short (%d bytes)\n", cc);
return 1;
}
if (icmph->icmp6_type == ICMPV6_ECHO_REPLY) {
if (icmph->icmp6_identifier != ident)
return 1;
if (gather_statistics((__u8*)(icmph+1), cc,
ntohs(icmph->icmp6_sequence),
hops, 0, tv, pr_addr(&from->sin6_addr)))
return 0;
} else {
int nexthdr;
struct ipv6hdr *iph1 = (struct ipv6hdr*)(icmph+1);
struct icmp6hdr *icmph1 = (struct icmp6hdr *)(iph1+1);
/* We must not ever fall here. All the messages but
* echo reply are blocked by filter and error are
* received with IPV6_RECVERR. Ugly code is preserved
* however, just to remember what crap we avoided
* using RECVRERR. :-)
*/
if (cc < 8+sizeof(struct ipv6hdr)+8)
return 1;
if (memcmp(&iph1->daddr, &whereto.sin6_addr, 16))
return 1;
nexthdr = iph1->nexthdr;
if (nexthdr == 44) {
nexthdr = *(__u8*)icmph1;
icmph1++;
}
if (nexthdr == IPPROTO_ICMPV6) {
if (icmph1->icmp6_type != ICMPV6_ECHO_REQUEST ||
icmph1->icmp6_identifier != ident)
return 1;
acknowledge(ntohs(icmph1->icmp6_sequence));
if (working_recverr)
return 0;
nerrors++;
if (options & F_FLOOD) {
write(STDOUT_FILENO, "\bE", 2);
return 0;
}
printf("From %s: icmp_seq=%u ", pr_addr(&from->sin6_addr), ntohs(icmph1->icmp6_sequence));
} else {
/* We've got something other than an ECHOREPLY */
if (!(options & F_VERBOSE) || uid)
return 1;
printf("From %s: ", pr_addr(&from->sin6_addr));
}
pr_icmph(icmph->icmp6_type, icmph->icmp6_code, ntohl(icmph->icmp6_mtu));
}
if (!(options & F_FLOOD)) {
if (options & F_AUDIBLE)
putchar('\a');
putchar('\n');
fflush(stdout);
}
return 0;
}
int pr_icmph(__u8 type, __u8 code, __u32 info)
{
switch(type) {
case ICMPV6_DEST_UNREACH:
printf("Destination unreachable: ");
switch (code) {
case ICMPV6_NOROUTE:
printf("No route");
break;
case ICMPV6_ADM_PROHIBITED:
printf("Administratively prohibited");
break;
case ICMPV6_NOT_NEIGHBOUR:
printf("Not neighbour");
break;
case ICMPV6_ADDR_UNREACH:
printf("Address unreachable");
break;
case ICMPV6_PORT_UNREACH:
printf("Port unreachable");
break;
default:
printf("Unknown code %d", code);
break;
}
break;
case ICMPV6_PKT_TOOBIG:
printf("Packet too big: mtu=%u", info);
if (code)
printf(", code=%d", code);
break;
case ICMPV6_TIME_EXCEED:
printf("Time exceeded: ");
if (code == ICMPV6_EXC_HOPLIMIT)
printf("Hop limit");
else if (code == ICMPV6_EXC_FRAGTIME)
printf("Defragmentation failure");
else
printf("code %d", code);
break;
case ICMPV6_PARAMPROB:
printf("Parameter problem: ");
if (code == ICMPV6_HDR_FIELD)
printf("Wrong header field ");
else if (code == ICMPV6_UNK_NEXTHDR)
printf("Unknown header ");
else if (code == ICMPV6_UNK_OPTION)
printf("Unknown option ");
else
printf("code %d ", code);
printf ("at %u", info);
break;
case ICMPV6_ECHO_REQUEST:
printf("Echo request");
break;
case ICMPV6_ECHO_REPLY:
printf("Echo reply");
break;
case ICMPV6_MGM_QUERY:
printf("MLD Query");
break;
case ICMPV6_MGM_REPORT:
printf("MLD Report");
break;
case ICMPV6_MGM_REDUCTION:
printf("MLD Reduction");
break;
default:
printf("unknown icmp type");
}
return 0;
}
#include
void install_filter(void)
{
static int once;
static struct sock_filter insns[] = {
BPF_STMT(BPF_LD|BPF_H|BPF_ABS, 4), /* Load icmp echo ident */
BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, 0xAAAA, 0, 1), /* Ours? */
BPF_STMT(BPF_RET|BPF_K, ~0U), /* Yes, it passes. */
BPF_STMT(BPF_LD|BPF_B|BPF_ABS, 0), /* Load icmp type */
BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, ICMPV6_ECHO_REPLY, 1, 0), /* Echo? */
BPF_STMT(BPF_RET|BPF_K, ~0U), /* No. It passes. This must not happen. */
BPF_STMT(BPF_RET|BPF_K, 0), /* Echo with wrong ident. Reject. */
};
static struct sock_fprog filter = {
sizeof insns / sizeof(insns[0]),
insns
};
if (once)
return;
once = 1;
/* Patch bpflet for current identifier. */
insns[1] = (struct sock_filter)BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, __constant_htons(ident), 0, 1);
if (setsockopt(icmp_sock, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter)))
perror("WARNING: failed to install socket filter\n");
}
/*
* pr_addr --
* Return an ascii host address as a dotted quad and optionally with
* a hostname.
*/
char * pr_addr(struct in6_addr *addr)
{
struct hostent *hp = NULL;
if (!(options&F_NUMERIC))
hp = gethostbyaddr((__u8*)addr, sizeof(struct in6_addr), AF_INET6);
return hp ? hp->h_name : pr_addr_n(addr);
}
char * pr_addr_n(struct in6_addr *addr)
{
static char str[64];
inet_ntop(AF_INET6, addr, str, sizeof(str));
return str;
}
void usage(void)
{
fprintf(stderr,
"Usage: ping6 [-LUdfnqrvVaA] [-c count] [-i interval] [-w deadline]\n"
" [-p pattern] [-s packetsize] [-t ttl] [-I interface]\n"
" [-M mtu discovery hint] [-S sndbuf]\n"
" [-F flow label] [-Q traffic class] [hop1 ...] destination\n");
exit(2);
}