void
test_rth_add()
{
int i, ret;
char buf[10240];
struct addrinfo *res;
struct addrinfo hints;
set_funcname("test_rth_add", sizeof("test_rth_add\0"));
if (NULL == inet6_rth_init(buf, 10240, IPV6_RTHDR_TYPE_0, 127))
abort();
memset((void *)&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_INET6;
hints.ai_flags = AI_NUMERICHOST;
if (0 != getaddrinfo("::1", NULL, (const struct addrinfo *)&hints, &res))
abort();
for (i = 0; i < 127; i++)
inet6_rth_add((void *)buf,
&((struct sockaddr_in6 *)(res->ai_addr))->sin6_addr);
checknum(127, ((struct ip6_rthdr0 *)buf)->ip6r0_segleft, 0,
"add 127 segments\0");
ret = inet6_rth_add((void *)buf,
&((struct sockaddr_in6 *)(res->ai_addr))->sin6_addr);
checknum(-1, ret, 0, "add 128th segment to 127 segment header\0");
freeaddrinfo(res);
}
int
main(int argc, char *argv[])
{
int mib[4] = { CTL_NET, PF_INET6, IPPROTO_IPV6, IPV6CTL_DEFHLIM };
char hbuf[NI_MAXHOST], src0[NI_MAXHOST], *ep;
int ch, i, on = 1, seq, rcvcmsglen, error, minlen;
struct addrinfo hints, *res;
static u_char *rcvcmsgbuf;
u_long probe, hops, lport;
struct hostent *hp;
size_t size;
uid_t uid;
/*
* Receive ICMP
*/
if ((rcvsock = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6)) < 0) {
perror("socket(ICMPv6)");
exit(5);
}
/* revoke privs */
uid = getuid();
if (setresuid(uid, uid, uid) == -1)
err(1, "setresuid");
size = sizeof(i);
(void) sysctl(mib, sizeof(mib)/sizeof(mib[0]), &i, &size, NULL, 0);
max_hops = i;
/* specify to tell receiving interface */
if (setsockopt(rcvsock, IPPROTO_IPV6, IPV6_RECVPKTINFO, &on,
sizeof(on)) < 0)
err(1, "setsockopt(IPV6_RECVPKTINFO)");
/* specify to tell value of hoplimit field of received IP6 hdr */
if (setsockopt(rcvsock, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &on,
sizeof(on)) < 0)
err(1, "setsockopt(IPV6_RECVHOPLIMIT)");
seq = 0;
while ((ch = getopt(argc, argv, "df:g:Ilm:np:q:rs:w:v")) != -1)
switch (ch) {
case 'd':
options |= SO_DEBUG;
break;
case 'f':
ep = NULL;
errno = 0;
first_hop = strtoul(optarg, &ep, 0);
if (errno || !*optarg || *ep|| first_hop > 255) {
fprintf(stderr,
"traceroute6: invalid min hoplimit.\n");
exit(1);
}
break;
case 'g':
hp = getipnodebyname(optarg, AF_INET6, 0, &h_errno);
if (hp == NULL) {
fprintf(stderr,
"traceroute6: unknown host %s\n", optarg);
exit(1);
}
if (rth == NULL) {
/*
* XXX: We can't detect the number of
* intermediate nodes yet.
*/
if ((rth = inet6_rth_init((void *)rtbuf,
sizeof(rtbuf), IPV6_RTHDR_TYPE_0,
0)) == NULL) {
fprintf(stderr,
"inet6_rth_init failed.\n");
exit(1);
}
}
if (inet6_rth_add((void *)rth,
(struct in6_addr *)hp->h_addr)) {
fprintf(stderr,
"inet6_rth_add failed for %s\n",
optarg);
exit(1);
}
freehostent(hp);
break;
case 'I':
useicmp++;
ident = htons(getpid() & 0xffff); /* same as ping6 */
break;
case 'l':
lflag++;
break;
case 'm':
ep = NULL;
errno = 0;
max_hops = strtoul(optarg, &ep, 0);
if (errno || !*optarg || *ep || max_hops > 255) {
fprintf(stderr,
"traceroute6: invalid max hoplimit.\n");
exit(1);
}
break;
case 'n':
nflag++;
break;
case 'p':
ep = NULL;
errno = 0;
lport = strtoul(optarg, &ep, 0);
if (errno || !*optarg || *ep) {
fprintf(stderr, "traceroute6: invalid port.\n");
exit(1);
}
if (lport == 0 || lport != (lport & 0xffff)) {
fprintf(stderr,
"traceroute6: port out of range.\n");
exit(1);
}
port = lport & 0xffff;
break;
case 'q':
ep = NULL;
errno = 0;
nprobes = strtoul(optarg, &ep, 0);
if (errno || !*optarg || *ep) {
fprintf(stderr,
"traceroute6: invalid nprobes.\n");
exit(1);
}
if (nprobes < 1) {
fprintf(stderr,
"traceroute6: nprobes must be >0.\n");
exit(1);
}
break;
case 'r':
options |= SO_DONTROUTE;
break;
case 's':
/*
* set the ip source address of the outbound
* probe (e.g., on a multi-homed host).
*/
source = optarg;
break;
case 'v':
verbose++;
break;
case 'w':
ep = NULL;
errno = 0;
waittime = strtoul(optarg, &ep, 0);
if (errno || !*optarg || *ep) {
fprintf(stderr,
"traceroute6: invalid wait time.\n");
exit(1);
}
if (waittime <= 1) {
fprintf(stderr,
"traceroute6: wait must be >1 sec.\n");
exit(1);
}
break;
default:
usage();
}
argc -= optind;
argv += optind;
if (max_hops < first_hop) {
fprintf(stderr,
"traceroute6: max hoplimit must be larger than first hoplimit.\n");
exit(1);
}
if (argc < 1 || argc > 2)
usage();
#if 1
setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
#else
setlinebuf(stdout);
#endif
memset(&hints, 0, sizeof(hints));
hints.ai_family = PF_INET6;
hints.ai_socktype = SOCK_RAW;
hints.ai_protocol = IPPROTO_ICMPV6;
hints.ai_flags = AI_CANONNAME;
error = getaddrinfo(*argv, NULL, &hints, &res);
if (error) {
fprintf(stderr,
"traceroute6: %s\n", gai_strerror(error));
exit(1);
}
if (res->ai_addrlen != sizeof(Dst)) {
fprintf(stderr,
"traceroute6: size of sockaddr mismatch\n");
exit(1);
}
memcpy(&Dst, res->ai_addr, res->ai_addrlen);
hostname = res->ai_canonname ? strdup(res->ai_canonname) : *argv;
if (!hostname) {
fprintf(stderr, "traceroute6: not enough core\n");
exit(1);
}
if (res->ai_next) {
if (getnameinfo(res->ai_addr, res->ai_addrlen, hbuf,
sizeof(hbuf), NULL, 0, NI_NUMERICHOST) != 0)
strlcpy(hbuf, "?", sizeof(hbuf));
fprintf(stderr, "traceroute6: Warning: %s has multiple "
"addresses; using %s\n", hostname, hbuf);
}
if (*++argv) {
ep = NULL;
errno = 0;
datalen = strtoul(*argv, &ep, 0);
if (errno || !*argv || *ep) {
fprintf(stderr,
"traceroute6: invalid packet length.\n");
exit(1);
}
}
if (useicmp)
minlen = ICMP6ECHOLEN + sizeof(struct tv32);
else
minlen = sizeof(struct opacket);
if (datalen < minlen)
datalen = minlen;
else if (datalen >= MAXPACKET) {
fprintf(stderr,
"traceroute6: packet size must be %d <= s < %ld.\n",
minlen, (long)MAXPACKET);
exit(1);
}
outpacket = (struct opacket *)malloc((unsigned)datalen);
if (!outpacket) {
perror("malloc");
exit(1);
}
(void) bzero((char *)outpacket, datalen);
/* initialize msghdr for receiving packets */
rcviov[0].iov_base = (caddr_t)packet;
rcviov[0].iov_len = sizeof(packet);
rcvmhdr.msg_name = (caddr_t)&Rcv;
rcvmhdr.msg_namelen = sizeof(Rcv);
rcvmhdr.msg_iov = rcviov;
rcvmhdr.msg_iovlen = 1;
rcvcmsglen = CMSG_SPACE(sizeof(struct in6_pktinfo)) +
CMSG_SPACE(sizeof(int));
if ((rcvcmsgbuf = malloc(rcvcmsglen)) == NULL) {
fprintf(stderr, "traceroute6: malloc failed\n");
exit(1);
}
rcvmhdr.msg_control = (caddr_t) rcvcmsgbuf;
rcvmhdr.msg_controllen = rcvcmsglen;
if (options & SO_DEBUG)
(void) setsockopt(rcvsock, SOL_SOCKET, SO_DEBUG,
(char *)&on, sizeof(on));
if (options & SO_DONTROUTE)
(void) setsockopt(rcvsock, SOL_SOCKET, SO_DONTROUTE,
(char *)&on, sizeof(on));
/*
* Send UDP or ICMP
*/
if (useicmp) {
sndsock = rcvsock;
} else {
if ((sndsock = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
perror("socket(SOCK_DGRAM)");
exit(5);
}
}
#ifdef SO_SNDBUF
i = datalen;
if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, (char *)&i,
sizeof(i)) < 0) {
perror("setsockopt(SO_SNDBUF)");
exit(6);
}
#endif /* SO_SNDBUF */
if (options & SO_DEBUG)
(void) setsockopt(sndsock, SOL_SOCKET, SO_DEBUG,
(char *)&on, sizeof(on));
if (options & SO_DONTROUTE)
(void) setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE,
(char *)&on, sizeof(on));
if (rth) {/* XXX: there is no library to finalize the header... */
rth->ip6r_len = rth->ip6r_segleft * 2;
if (setsockopt(sndsock, IPPROTO_IPV6, IPV6_RTHDR,
(void *)rth, (rth->ip6r_len + 1) << 3)) {
fprintf(stderr, "setsockopt(IPV6_RTHDR): %s\n",
strerror(errno));
exit(1);
}
}
/*
* Source selection
*/
bzero(&Src, sizeof(Src));
if (source) {
struct addrinfo hints, *res;
int error;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET6;
hints.ai_socktype = SOCK_DGRAM; /*dummy*/
hints.ai_flags = AI_NUMERICHOST;
error = getaddrinfo(source, "0", &hints, &res);
if (error) {
printf("traceroute6: %s: %s\n", source,
gai_strerror(error));
exit(1);
}
if (res->ai_addrlen > sizeof(Src)) {
printf("traceroute6: %s: %s\n", source,
gai_strerror(error));
exit(1);
}
memcpy(&Src, res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);
} else {
struct sockaddr_in6 Nxt;
int dummy;
socklen_t len;
Nxt = Dst;
Nxt.sin6_port = htons(DUMMY_PORT);
if (cmsg != NULL)
bcopy(inet6_rthdr_getaddr(cmsg, 1), &Nxt.sin6_addr,
sizeof(Nxt.sin6_addr));
if ((dummy = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
perror("socket");
exit(1);
}
if (connect(dummy, (struct sockaddr *)&Nxt, Nxt.sin6_len) < 0) {
perror("connect");
exit(1);
}
len = sizeof(Src);
if (getsockname(dummy, (struct sockaddr *)&Src, &len) < 0) {
perror("getsockname");
exit(1);
}
if (getnameinfo((struct sockaddr *)&Src, Src.sin6_len,
src0, sizeof(src0), NULL, 0, NI_NUMERICHOST)) {
fprintf(stderr, "getnameinfo failed for source\n");
exit(1);
}
source = src0;
close(dummy);
}
Src.sin6_port = htons(0);
if (bind(sndsock, (struct sockaddr *)&Src, Src.sin6_len) < 0) {
perror("bind");
exit(1);
}
{
socklen_t len;
len = sizeof(Src);
if (getsockname(sndsock, (struct sockaddr *)&Src, &len) < 0) {
perror("getsockname");
exit(1);
}
srcport = ntohs(Src.sin6_port);
}
/*
* Message to users
*/
if (getnameinfo((struct sockaddr *)&Dst, Dst.sin6_len, hbuf,
sizeof(hbuf), NULL, 0, NI_NUMERICHOST))
strlcpy(hbuf, "(invalid)", sizeof(hbuf));
fprintf(stderr, "traceroute6");
fprintf(stderr, " to %s (%s)", hostname, hbuf);
if (source)
fprintf(stderr, " from %s", source);
fprintf(stderr, ", %lu hops max, %lu byte packets\n",
max_hops, datalen);
(void) fflush(stderr);
if (first_hop > 1)
printf("Skipping %lu intermediate hops\n", first_hop - 1);
/*
* Main loop
*/
for (hops = first_hop; hops <= max_hops; ++hops) {
struct in6_addr lastaddr;
int got_there = 0;
int unreachable = 0;
printf("%2lu ", hops);
bzero(&lastaddr, sizeof(lastaddr));
for (probe = 0; probe < nprobes; ++probe) {
int cc;
struct timeval t1, t2;
(void) gettimeofday(&t1, NULL);
send_probe(++seq, hops);
while ((cc = wait_for_reply(rcvsock, &rcvmhdr))) {
(void) gettimeofday(&t2, NULL);
if ((i = packet_ok(&rcvmhdr, cc, seq))) {
if (!IN6_ARE_ADDR_EQUAL(&Rcv.sin6_addr,
&lastaddr)) {
print(&rcvmhdr, cc);
lastaddr = Rcv.sin6_addr;
}
printf(" %g ms", deltaT(&t1, &t2));
switch (i - 1) {
case ICMP6_DST_UNREACH_NOROUTE:
++unreachable;
printf(" !N");
break;
case ICMP6_DST_UNREACH_ADMIN:
++unreachable;
printf(" !P");
break;
case ICMP6_DST_UNREACH_NOTNEIGHBOR:
++unreachable;
printf(" !S");
break;
case ICMP6_DST_UNREACH_ADDR:
++unreachable;
printf(" !A");
break;
case ICMP6_DST_UNREACH_NOPORT:
if (rcvhlim >= 0 &&
rcvhlim <= 1)
printf(" !");
++got_there;
break;
}
break;
}
}
if (cc == 0)
printf(" *");
(void) fflush(stdout);
}
putchar('\n');
if (got_there ||
(unreachable > 0 && unreachable >= ((nprobes + 1) / 2))) {
exit(0);
}
}
exit(0);
}
/*
* Initialize the msghdr for specifying hoplimit, outgoing interface and routing
* header for the probe packets.
*/
void
set_ancillary_data(struct msghdr *msgp, int hoplimit,
union any_in_addr *gwIPlist, int gw_cnt, uint_t if_index)
{
size_t hoplimit_space;
size_t rthdr_space;
size_t pktinfo_space;
size_t bufspace;
struct cmsghdr *cmsgp;
uchar_t *cmsg_datap;
int i;
msgp->msg_control = NULL;
msgp->msg_controllen = 0;
/*
* Need to figure out size of buffer needed for ancillary data
* containing routing header and packet info options.
*
* Portable heuristic to compute upper bound on space needed for
* N ancillary data options. It assumes up to _MAX_ALIGNMENT padding
* after both header and data as the worst possible upper bound on space
* consumed by padding.
* It also adds one extra "sizeof (struct cmsghdr)" for the last option.
* This is needed because we would like to use CMSG_NXTHDR() while
* composing the buffer. The CMSG_NXTHDR() macro is designed better for
* parsing than composing the buffer. It requires the pointer it returns
* to leave space in buffer for addressing a cmsghdr and we want to make
* sure it works for us while we skip beyond the last ancillary data
* option.
*
* bufspace[i] = sizeof(struct cmsghdr) + <pad after header> +
* <option[i] content length> + <pad after data>;
*
* total_bufspace = bufspace[0] + bufspace[1] + ...
* ... + bufspace[N-1] + sizeof (struct cmsghdr);
*/
rthdr_space = 0;
pktinfo_space = 0;
/* We'll always set the hoplimit of the outgoing packets */
hoplimit_space = sizeof (int);
bufspace = sizeof (struct cmsghdr) + _MAX_ALIGNMENT +
hoplimit_space + _MAX_ALIGNMENT;
if (gw_cnt > 0) {
rthdr_space = inet6_rth_space(IPV6_RTHDR_TYPE_0, gw_cnt);
bufspace += sizeof (struct cmsghdr) + _MAX_ALIGNMENT +
rthdr_space + _MAX_ALIGNMENT;
}
if (if_index != 0) {
pktinfo_space = sizeof (struct in6_pktinfo);
bufspace += sizeof (struct cmsghdr) + _MAX_ALIGNMENT +
pktinfo_space + _MAX_ALIGNMENT;
}
/*
* We need to temporarily set the msgp->msg_controllen to bufspace
* (we will later trim it to actual length used). This is needed because
* CMSG_NXTHDR() uses it to check we have not exceeded the bounds.
*/
bufspace += sizeof (struct cmsghdr);
msgp->msg_controllen = bufspace;
msgp->msg_control = (struct cmsghdr *)malloc(bufspace);
if (msgp->msg_control == NULL) {
Fprintf(stderr, "%s: malloc %s\n", prog, strerror(errno));
exit(EXIT_FAILURE);
}
cmsgp = CMSG_FIRSTHDR(msgp);
/*
* Fill ancillary data. First hoplimit, then rthdr and pktinfo if
* needed.
*/
/* set hoplimit ancillary data */
cmsgp->cmsg_level = IPPROTO_IPV6;
cmsgp->cmsg_type = IPV6_HOPLIMIT;
cmsg_datap = CMSG_DATA(cmsgp);
/* LINTED E_BAD_PTR_CAST_ALIGN */
*(int *)cmsg_datap = hoplimit;
cmsgp->cmsg_len = cmsg_datap + hoplimit_space - (uchar_t *)cmsgp;
cmsgp = CMSG_NXTHDR(msgp, cmsgp);
/* set rthdr ancillary data if needed */
if (gw_cnt > 0) {
struct ip6_rthdr0 *rthdr0p;
cmsgp->cmsg_level = IPPROTO_IPV6;
cmsgp->cmsg_type = IPV6_RTHDR;
cmsg_datap = CMSG_DATA(cmsgp);
/*
* Initialize rthdr structure
*/
/* LINTED E_BAD_PTR_CAST_ALIGN */
rthdr0p = (struct ip6_rthdr0 *)cmsg_datap;
if (inet6_rth_init(rthdr0p, rthdr_space,
IPV6_RTHDR_TYPE_0, gw_cnt) == NULL) {
Fprintf(stderr, "%s: inet6_rth_init failed\n",
prog);
exit(EXIT_FAILURE);
}
/*
* Stuff in gateway addresses
*/
for (i = 0; i < gw_cnt; i++) {
if (inet6_rth_add(rthdr0p,
&gwIPlist[i].addr6) == -1) {
Fprintf(stderr,
"%s: inet6_rth_add\n", prog);
exit(EXIT_FAILURE);
}
}
cmsgp->cmsg_len = cmsg_datap + rthdr_space - (uchar_t *)cmsgp;
cmsgp = CMSG_NXTHDR(msgp, cmsgp);
}
/* set pktinfo ancillary data if needed */
if (if_index != 0) {
struct in6_pktinfo *pktinfop;
cmsgp->cmsg_level = IPPROTO_IPV6;
cmsgp->cmsg_type = IPV6_PKTINFO;
cmsg_datap = CMSG_DATA(cmsgp);
/* LINTED E_BAD_PTR_CAST_ALIGN */
pktinfop = (struct in6_pktinfo *)cmsg_datap;
/*
* We don't know if pktinfop->ipi6_addr is aligned properly,
* therefore let's use bcopy, instead of assignment.
*/
(void) bcopy(&in6addr_any, &pktinfop->ipi6_addr,
sizeof (struct in6_addr));
/*
* We can assume pktinfop->ipi6_ifindex is 32 bit aligned.
*/
pktinfop->ipi6_ifindex = if_index;
cmsgp->cmsg_len = cmsg_datap + pktinfo_space - (uchar_t *)cmsgp;
cmsgp = CMSG_NXTHDR(msgp, cmsgp);
}
msgp->msg_controllen = (char *)cmsgp - (char *)msgp->msg_control;
}
void
Inet6_rth_add(void *rthbuf, const struct in6_addr *addr)
{
if (inet6_rth_add(rthbuf, addr) < 0)
err_quit("inet6_rth_add error");
}
int main(int argc, char *argv[])
{
int ch, hold, packlen;
u_char *packet;
char *target;
struct addrinfo hints, *ai;
int gai;
struct sockaddr_in6 firsthop;
int socket_errno = 0;
struct icmp6_filter filter;
int err;
#ifdef __linux__
int csum_offset, sz_opt;
#endif
static uint32_t scope_id = 0;
#ifdef ANDROID
android_check_security();
#endif
limit_capabilities();
#ifdef USE_IDN
setlocale(LC_ALL, "");
#endif
icmp_sock = socket(AF_INET6, SOCK_DGRAM, IPPROTO_ICMPV6);
if (icmp_sock < 0) {
enable_capability_raw();
icmp_sock = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
socket_errno = errno;
disable_capability_raw();
using_ping_socket = 0;
}
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:N:")) != EOF) {
switch(ch) {
case 'F':
flowlabel = hextoui(optarg);
if (errno || (flowlabel & ~IPV6_FLOWINFO_FLOWLABEL)) {
fprintf(stderr, "ping: Invalid flowinfo %s\n", optarg);
exit(2);
}
options |= F_FLOWINFO;
break;
case 'Q':
tclass = hextoui(optarg);
if (errno || (tclass & ~0xff)) {
fprintf(stderr, "ping: Invalid tclass %s\n", optarg);
exit(2);
}
options |= F_TCLASS;
break;
case 'I':
if (strchr(optarg, ':')) {
char *p, *addr = strdup(optarg);
if (!addr) {
fprintf(stderr, "ping: out of memory\n");
exit(2);
}
p = strchr(addr, SCOPE_DELIMITER);
if (p) {
*p = '\0';
device = optarg + (p - addr) + 1;
}
if (inet_pton(AF_INET6, addr, (char*)&source.sin6_addr) <= 0) {
fprintf(stderr, "ping: invalid source address %s\n", optarg);
exit(2);
}
options |= F_STRICTSOURCE;
free(addr);
} 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-%s\n", SNAPSHOT);
exit(0);
case 'N':
if (using_ping_socket) {
fprintf(stderr, "ping: -N requires raw socket permissions\n");
exit(2);
}
if (niquery_option_handler(optarg) < 0) {
usage();
break;
}
break;
COMMON_OPTIONS
common_options(ch);
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
#ifdef ENABLE_PING6_RTHDR
while (argc > 1) {
struct in6_addr *addr;
if (srcrt == NULL) {
int space;
fprintf(stderr, "ping6: Warning: "
"Source routing is deprecated by RFC5095.\n");
#ifdef ENABLE_PING6_RTHDR_RFC3542
space = inet6_rth_space(IPV6_RTHDR_TYPE_0, argc - 1);
#else
space = inet6_srcrt_space(IPV6_SRCRT_TYPE_0, argc - 1);
#endif
if (space == 0) {
fprintf(stderr, "srcrt_space failed\n");
exit(2);
}
#ifdef ENABLE_PING6_RTHDR_RFC3542
if (cmsglen + CMSG_SPACE(space) > sizeof(cmsgbuf)) {
fprintf(stderr, "no room for options\n");
exit(2);
}
#else
if (space + cmsglen > sizeof(cmsgbuf)) {
fprintf(stderr, "no room for options\n");
exit(2);
}
#endif
srcrt = (struct cmsghdr*)(cmsgbuf+cmsglen);
#ifdef ENABLE_PING6_RTHDR_RFC3542
memset(srcrt, 0, CMSG_SPACE(0));
srcrt->cmsg_len = CMSG_LEN(space);
srcrt->cmsg_level = IPPROTO_IPV6;
srcrt->cmsg_type = IPV6_RTHDR;
inet6_rth_init(CMSG_DATA(srcrt), space, IPV6_RTHDR_TYPE_0, argc - 1);
cmsglen += CMSG_SPACE(space);
#else
cmsglen += CMSG_ALIGN(space);
inet6_srcrt_init(srcrt, IPV6_SRCRT_TYPE_0);
#endif
}
target = *argv;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET6;
#ifdef USE_IDN
hints.ai_flags = AI_IDN;
#endif
gai = getaddrinfo(target, NULL, &hints, &ai);
if (gai) {
fprintf(stderr, "unknown host\n");
exit(2);
}
addr = &((struct sockaddr_in6 *)(ai->ai_addr))->sin6_addr;
#ifdef ENABLE_PING6_RTHDR_RFC3542
inet6_rth_add(CMSG_DATA(srcrt), addr);
#else
inet6_srcrt_add(srcrt, addr);
#endif
if (IN6_IS_ADDR_UNSPECIFIED(&firsthop.sin6_addr)) {
memcpy(&firsthop.sin6_addr, addr, 16);
#ifdef HAVE_SIN6_SCOPEID
firsthop.sin6_scope_id = ((struct sockaddr_in6 *)(ai->ai_addr))->sin6_scope_id;
/* Verify scope_id is the same as previous nodes */
if (firsthop.sin6_scope_id && scope_id && firsthop.sin6_scope_id != scope_id) {
fprintf(stderr, "scope discrepancy among the nodes\n");
exit(2);
} else if (!scope_id) {
scope_id = firsthop.sin6_scope_id;
}
#endif
}
freeaddrinfo(ai);
argv++;
argc--;
}
#endif
if (niquery_is_enabled()) {
niquery_init_nonce();
if (!niquery_is_subject_valid()) {
ni_subject = &whereto.sin6_addr;
ni_subject_len = sizeof(whereto.sin6_addr);
ni_subject_type = NI_SUBJ_IPV6;
}
}
if (argc > 1) {
#ifndef ENABLE_PING6_RTHDR
fprintf(stderr, "ping6: Source routing is deprecated by RFC5095.\n");
#endif
usage();
} else if (argc == 1) {
target = *argv;
} else {
if (ni_query < 0 && ni_subject_type != NI_SUBJ_NAME)
usage();
target = ni_group;
}
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET6;
#ifdef USE_IDN
hints.ai_flags = AI_IDN;
#endif
gai = getaddrinfo(target, NULL, &hints, &ai);
if (gai) {
fprintf(stderr, "unknown host\n");
exit(2);
}
memcpy(&whereto, ai->ai_addr, sizeof(whereto));
whereto.sin6_port = htons(IPPROTO_ICMPV6);
if (memchr(target, ':', strlen(target)))
options |= F_NUMERIC;
freeaddrinfo(ai);
if (IN6_IS_ADDR_UNSPECIFIED(&firsthop.sin6_addr)) {
memcpy(&firsthop.sin6_addr, &whereto.sin6_addr, 16);
#ifdef HAVE_SIN6_SCOPEID
firsthop.sin6_scope_id = whereto.sin6_scope_id;
/* Verify scope_id is the same as intermediate nodes */
if (firsthop.sin6_scope_id && scope_id && firsthop.sin6_scope_id != scope_id) {
fprintf(stderr, "scope discrepancy among the nodes\n");
exit(2);
} else if (!scope_id) {
scope_id = firsthop.sin6_scope_id;
}
#endif
}
hostname = target;
if (IN6_IS_ADDR_UNSPECIFIED(&source.sin6_addr)) {
socklen_t alen;
int probe_fd = socket(AF_INET6, SOCK_DGRAM, 0);
if (probe_fd < 0) {
perror("socket");
exit(2);
}
if (device) {
#if defined(IPV6_RECVPKTINFO) || defined(HAVE_SIN6_SCOPEID)
unsigned int iface = if_name2index(device);
#endif
#ifdef IPV6_RECVPKTINFO
struct in6_pktinfo ipi;
memset(&ipi, 0, sizeof(ipi));
ipi.ipi6_ifindex = iface;
#endif
#ifdef HAVE_SIN6_SCOPEID
if (IN6_IS_ADDR_LINKLOCAL(&firsthop.sin6_addr) ||
IN6_IS_ADDR_MC_LINKLOCAL(&firsthop.sin6_addr))
firsthop.sin6_scope_id = iface;
#endif
enable_capability_raw();
if (
#ifdef IPV6_RECVPKTINFO
setsockopt(probe_fd, IPPROTO_IPV6, IPV6_PKTINFO, &ipi, sizeof(ipi)) == -1 &&
#endif
setsockopt(probe_fd, SOL_SOCKET, SO_BINDTODEVICE, device, strlen(device)+1) == -1) {
perror("setsockopt(SO_BINDTODEVICE)");
exit(2);
}
disable_capability_raw();
}
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);
#ifndef WITHOUT_IFADDRS
if (device) {
struct ifaddrs *ifa0, *ifa;
if (getifaddrs(&ifa0)) {
perror("getifaddrs");
exit(2);
}
for (ifa = ifa0; ifa; ifa = ifa->ifa_next) {
if (!ifa->ifa_addr || ifa->ifa_addr->sa_family != AF_INET6)
continue;
if (!strncmp(ifa->ifa_name, device, sizeof(device) - 1) &&
IN6_ARE_ADDR_EQUAL(&((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr,
&source.sin6_addr))
break;
}
if (!ifa)
fprintf(stderr, "ping6: Warning: source address might be selected on device other than %s.\n", device);
freeifaddrs(ifa0);
}
#endif
}
#ifdef HAVE_SIN6_SCOPEID
else if (device && (IN6_IS_ADDR_LINKLOCAL(&source.sin6_addr) ||
IN6_IS_ADDR_MC_LINKLOCAL(&source.sin6_addr)))
source.sin6_scope_id = if_name2index(device);
#endif
if (icmp_sock < 0) {
errno = socket_errno;
perror("ping: icmp open socket");
exit(2);
}
if (device) {
struct cmsghdr *cmsg;
struct in6_pktinfo *ipi;
cmsg = (struct cmsghdr*)(cmsgbuf+cmsglen);
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 = if_name2index(device);
}
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) && (ni_query < 0)) {
/* 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);
if (!using_ping_socket) {
#ifdef __linux__
csum_offset = 2;
sz_opt = sizeof(int);
err = setsockopt(icmp_sock, SOL_RAW, IPV6_CHECKSUM,
&csum_offset, sz_opt);
if (err < 0) {
/* checksum should be enabled by default and setting
* this option might fail anyway.
*/
fprintf(stderr, "setsockopt(RAW_CHECKSUM) failed"
" - try to continue.");
}
#endif
/*
* select icmp echo reply as icmp type to receive
*/
ICMP6_FILTER_SETBLOCKALL(&filter);
if (!working_recverr) {
ICMP6_FILTER_SETPASS(ICMP6_DST_UNREACH, &filter);
ICMP6_FILTER_SETPASS(ICMP6_PACKET_TOO_BIG, &filter);
ICMP6_FILTER_SETPASS(ICMP6_TIME_EXCEEDED, &filter);
ICMP6_FILTER_SETPASS(ICMP6_PARAM_PROB, &filter);
}
if (niquery_is_enabled())
ICMP6_FILTER_SETPASS(ICMPV6_NI_REPLY, &filter);
else
ICMP6_FILTER_SETPASS(ICMP6_ECHO_REPLY, &filter);
err = setsockopt(icmp_sock, IPPROTO_ICMPV6, ICMP6_FILTER,
&filter, sizeof(struct icmp6_filter));
if (err < 0) {
perror("setsockopt(ICMP6_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 (
#ifdef IPV6_RECVHOPLIMIT
setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_RECVHOPLIMIT,
&on, sizeof(on)) == -1 &&
setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_2292HOPLIMIT,
&on, sizeof(on)) == -1
#else
setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_HOPLIMIT,
&on, sizeof(on)) == -1
#endif
){
perror ("can't receive hop limit");
exit(2);
}
}
if (options & F_TCLASS) {
#ifdef IPV6_TCLASS
if (setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_TCLASS,
&tclass, sizeof(tclass)) == -1) {
perror ("setsockopt(IPV6_TCLASS)");
exit(2);
}
#else
fprintf(stderr, "Traffic class is not supported.\n");
#endif
}
if (options&F_FLOWINFO) {
#ifdef IPV6_FLOWINFO_SEND
int on = 1;
#endif
#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);
#ifdef ENABLE_PING6_RTHDR
if (srcrt)
freq_len = CMSG_ALIGN(sizeof(*freq)) + srcrt->cmsg_len;
#endif
memset(freq, 0, sizeof(*freq));
freq->flr_label = htonl(flowlabel & IPV6_FLOWINFO_FLOWLABEL);
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);
#ifdef ENABLE_PING6_RTHDR
if (srcrt)
memcpy(freq_buf + CMSG_ALIGN(sizeof(*freq)), srcrt, srcrt->cmsg_len);
#endif
if (setsockopt(icmp_sock, IPPROTO_IPV6, IPV6_FLOWLABEL_MGR,
freq, freq_len) == -1) {
perror ("can't set flowlabel");
exit(2);
}
flowlabel = freq->flr_label;
#ifdef ENABLE_PING6_RTHDR
if (srcrt) {
cmsglen = (char*)srcrt - (char*)cmsgbuf;
srcrt = NULL;
}
#endif
#else
fprintf(stderr, "Flow labels are not supported.\n");
exit(2);
#endif
#ifdef IPV6_FLOWINFO_SEND
whereto.sin6_flowinfo = flowlabel;
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 ? : "");
}
/**
* mh_send - send mobility header message
* @addrs: bundle of addresses
* @mh_vec: scatter/gather array
* @iovlen: array block count
* @bind_key: key for calculating binding auth. data
*
* Sends a mobility header message to @dst with @src source address.
* Mobility header is created from the @mh_vec vector array created by
* the caller and initialized with mh_create() and mh_create_opt_*()
* calls. Padding is done automatically and mobility header length is
* set. Binding authorization data is calculated if present. Returns
* number of bytes sent on success, otherwise negative error value.
**/
int mh_send(const struct in6_addr_bundle *addrs, const struct iovec *mh_vec,
int iovlen, const uint8_t *bind_key, int oif)
{
struct ip6_mh_opt_auth_data lbad;
struct sockaddr_in6 daddr;
struct iovec iov[2*(IP6_MHOPT_MAX+1)];
struct msghdr msg;
struct cmsghdr *cmsg;
int cmsglen;
struct in6_pktinfo pinfo;
int ret = 0, on = 1;
struct ip6_mh *mh;
int iov_count;
socklen_t rthlen = 0;
iov_count = mh_try_pad(mh_vec, iov, iovlen);
mh = (struct ip6_mh *)iov[0].iov_base;
mh->ip6mh_hdrlen = (mh_length(iov, iov_count) >> 3) - 1;
/*
* We use MH out policy for all address. Then we should update it
* to refresh its bundle in kernel to be used with correct
* route, IPsec SA and neighbor cache entry for the destination.
* IKE daemon does the same thing for rekeying process.
*/
if (xfrm_cn_policy_mh_out_touch(1) < 0) {
MDBG("MH out policy touch failed: BA for "
"%x:%x:%x:%x:%x:%x:%x:%x\n", NIP6ADDR(addrs->dst));
}
MDBG("sending MH type %d\n"
"from %x:%x:%x:%x:%x:%x:%x:%x\n"
"to %x:%x:%x:%x:%x:%x:%x:%x\n",
mh->ip6mh_type, NIP6ADDR(addrs->src), NIP6ADDR(addrs->dst));
if (addrs->local_coa)
MDBG("local CoA %x:%x:%x:%x:%x:%x:%x:%x\n",
NIP6ADDR(addrs->local_coa));
if (addrs->remote_coa)
MDBG("remote CoA %x:%x:%x:%x:%x:%x:%x:%x\n",
NIP6ADDR(addrs->remote_coa));
if (bind_key) {
assert(iov_count > 1);
struct ip6_mh_opt_auth_data *bauth;
struct iovec *biov;
struct in6_addr *cn = NULL;
MDBG("Adding bind auth data\n");
if (mh->ip6mh_type == IP6_MH_TYPE_BU)
cn = addrs->dst;
else
cn = addrs->src;
assert(addrs->bind_coa != NULL && cn != NULL);
biov = &iov[iov_count - 1];
bauth = (struct ip6_mh_opt_auth_data *)biov->iov_base;
if (bauth->ip6moad_type == IP6_MHOPT_BAUTH) {
size_t orig_len = biov->iov_len;
MDBG("Adding auth_data\n");
memcpy(&lbad, bauth, sizeof(lbad));
/* temporarily set iov_len to option header
* length for auth data calculation */
biov->iov_len -= MIPV6_DIGEST_LEN;
biov->iov_base = &lbad;
calculate_auth_data(iov, iov_count, addrs->bind_coa,
cn, bind_key, lbad.ip6moad_data);
biov->iov_len = orig_len;
}
}
memset(&daddr, 0, sizeof(struct sockaddr_in6));
daddr.sin6_family = AF_INET6;
daddr.sin6_addr = *addrs->dst;
daddr.sin6_port = htons(IPPROTO_MH);
memset(&pinfo, 0, sizeof(pinfo));
pinfo.ipi6_addr = *addrs->src;
pinfo.ipi6_ifindex = oif;
cmsglen = CMSG_SPACE(sizeof(pinfo));
if (addrs->remote_coa != NULL) {
rthlen = inet6_rth_space(IPV6_RTHDR_TYPE_2, 1);
if (!rthlen) {
MDBG("inet6_rth_space error\n");
return -1;
}
cmsglen += CMSG_SPACE(rthlen);
}
cmsg = malloc(cmsglen);
if (cmsg == NULL) {
MDBG("malloc failed\n");
return -ENOMEM;
}
memset(cmsg, 0, cmsglen);
memset(&msg, 0, sizeof(msg));
msg.msg_control = cmsg;
msg.msg_controllen = cmsglen;
msg.msg_iov = iov;
msg.msg_iovlen = iov_count;
msg.msg_name = (void *)&daddr;
msg.msg_namelen = sizeof(daddr);
cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_len = CMSG_LEN(sizeof(pinfo));
cmsg->cmsg_level = IPPROTO_IPV6;
cmsg->cmsg_type = IPV6_PKTINFO;
memcpy(CMSG_DATA(cmsg), &pinfo, sizeof(pinfo));
if (addrs->remote_coa != NULL) {
void *rthp;
cmsg = CMSG_NXTHDR(&msg, cmsg);
if (cmsg == NULL) {
free(msg.msg_control);
MDBG("internal error\n");
return -2;
}
cmsg->cmsg_len = CMSG_LEN(rthlen);
cmsg->cmsg_level = IPPROTO_IPV6;
cmsg->cmsg_type = IPV6_RTHDR;
rthp = CMSG_DATA(cmsg);
rthp = inet6_rth_init(rthp, rthlen, IPV6_RTHDR_TYPE_2, 1);
if (rthp == NULL) {
free(msg.msg_control);
MDBG("inet6_rth_init error\n");
return -3;
}
inet6_rth_add(rthp, addrs->remote_coa);
rthp = NULL;
}
pthread_mutex_lock(&mh_sock.send_mutex);
setsockopt(mh_sock.fd, IPPROTO_IPV6, IPV6_PKTINFO,
&on, sizeof(int));
ret = sendmsg(mh_sock.fd, &msg, 0);
if (ret < 0)
dbg("sendmsg: %s\n", strerror(errno));
pthread_mutex_unlock(&mh_sock.send_mutex);
free(msg.msg_control);
return ret;
}
void
Inet6_rth_add(void *rthbuf, const struct in6_addr *addr)
{
if (inet6_rth_add(rthbuf, addr) < 0)
err_quit("inet6_rth_add error: %s", strerror(errno));
}