NetBSD/sbin/rtsol/rtsol.c

469 lines
11 KiB
C

/* $NetBSD: rtsol.c,v 1.2 1999/07/04 02:43:39 itojun 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.
*/
#include <sys/param.h>
#include <sys/socket.h>
#ifdef ADVAPI
#include <sys/uio.h>
#endif
#include <sys/ioctl.h>
#include <net/if.h>
#if defined(__FreeBSD__) && __FreeBSD__ >= 3
#include <net/if_var.h>
#endif /* __FreeBSD__ >= 3 */
#include <netinet/in.h>
#include <netinet/ip6.h>
#include <netinet/icmp6.h>
#include <unistd.h>
#include <stdio.h>
#include <err.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/sysctl.h>
#include <netdb.h>
#include <netinet6/in6.h>
#include <netinet6/in6_var.h>
#include <netinet6/nd6.h>
#define ALLROUTER "ff02::2"
int main __P((int, char **));
void usage __P((void));
int sendit __P((int, char *, int, struct sockaddr_in6 *, int));
int interface_down __P((char *));
int interface_up __P((char *));
static int getifflag6 __P((char *, int *));
static int getdadcount __P((void));
static int trick = 1;
static int verbose = 0;
#define vmsg(x) { if (verbose) fprintf x; }
extern char *optarg;
extern int optind;
int
main(argc, argv)
int argc;
char *argv[];
{
struct sockaddr_in6 to;
struct icmp6_hdr *icp;
u_int hlim = 255;
u_char outpack[sizeof(struct icmp6_hdr)];
u_short index;
int s, i, cc = sizeof(struct icmp6_hdr);
int opt;
fd_set fdset;
struct timeval timeout;
int rtsol_retry = MAX_RTR_SOLICITATIONS;
while ((opt = getopt(argc, argv, "nv")) != EOF) {
switch (opt) {
case 'n':
trick = 0;
break;
case 'v':
verbose++;
break;
default:
usage();
/*NOTREACHED*/
}
}
argc -= optind;
argv += optind;
if (argc != 1) {
usage();
/*NOTREACHED*/
}
index = (u_short)if_nametoindex(argv[0]);
if (index == 0) {
errx(1, "invalid interface %s", argv[0]);
/*NOTREACHED*/
}
if (trick) {
/*
* Notebook hack:
* It looks that, most of the pccard drivers do not reset
* multicast packet filter properly on suspend/resume session.
* bring interface down, then up, to initialize it properly.
*/
if (interface_down(argv[0]) < 0)
err(1, "interface state could not be changed");
vmsg((stderr, "a bit of delay...\n"));
usleep(500 * 1000); /* 0.5s */
}
if (interface_up(argv[0]) < 0)
err(1, "interface not ready");
{
struct addrinfo hints, *res;
int error;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET6;
error = getaddrinfo(ALLROUTER, NULL, &hints, &res);
if (error) {
errx(1, "getaddrinfo: %s", gai_strerror(error));
/*NOTREACHED*/
}
memcpy(&to, res->ai_addr, res->ai_addrlen);
}
if ((s = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6)) < 0)
err(1, "socket");
if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &hlim,
sizeof(hlim)) == -1)
err(1, "setsockopt(IPV6_MULTICAST_HOPS)");
#ifdef ICMP6_FILTER
{
struct icmp6_filter filt;
ICMP6_FILTER_SETBLOCKALL(&filt);
ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &filt);
if (setsockopt(s, IPPROTO_ICMPV6, ICMP6_FILTER, &filt,
sizeof(filt)) == -1)
err(1, "setsockopt(ICMP6_FILTER)");
}
#endif
/* fill ICMP header */
icp = (struct icmp6_hdr *)outpack;
icp->icmp6_type = ND_ROUTER_SOLICIT;
icp->icmp6_code = 0;
icp->icmp6_cksum = 0;
icp->icmp6_data32[0] = 0; /* RS reserved field */
vmsg((stderr, "sending RS for %d time%s:\n",
rtsol_retry, (1 < rtsol_retry) ? "s" : ""));
retry:
vmsg((stderr, "%d \r", rtsol_retry));
i = sendit(s, (char *)outpack, cc, &to, index);
if (i < 0) {
err(1, "rtsol: solicitation");
/*NOTREACHED*/
} else if (i != cc) {
fprintf(stderr, "rtsol: short write (wrote %d of be %d)\n",
i, cc);
}
FD_ZERO(&fdset);
FD_SET(s, &fdset);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
if (select(s + 1, &fdset, NULL, NULL, &timeout) < 1) {
if (0 < --rtsol_retry)
goto retry;
} else {
vmsg((stderr, "got a RA packet\n"));
}
close(s);
exit(0);
/*NOTREACHED*/
}
void
usage()
{
(void)fprintf(stderr, "usage: rtsol [-nv] ifname\n");
exit(1);
/*NOTREACHED*/
}
int
sendit(s, p, len, sock, ifindex)
int s;
char *p;
int len;
struct sockaddr_in6 *sock;
int ifindex;
{
#ifndef ADVAPI
sock->sin6_addr.u6_addr.u6_addr16[1] = htons(ifindex);
return sendto(s, p, len, 0, (struct sockaddr *)sock, sock->sin6_len);
#else
struct msghdr m;
struct cmsghdr *cm;
struct iovec iov[2];
u_char cmsgbuf[256];
struct in6_pktinfo *pi;
m.msg_name = (caddr_t)sock;
m.msg_namelen = sock->sin6_len;
iov[0].iov_base = p;
iov[0].iov_len = len;
m.msg_iov = iov;
m.msg_iovlen = 1;
if (!ifindex) {
m.msg_control = NULL;
m.msg_controllen = 0;
} else {
memset(cmsgbuf, 0, sizeof(cmsgbuf));
cm = (struct cmsghdr *)cmsgbuf;
m.msg_control = (caddr_t)cm;
m.msg_controllen = CMSG_SPACE(sizeof(struct in6_pktinfo));
cm->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo));
cm->cmsg_level = IPPROTO_IPV6;
cm->cmsg_type = IPV6_PKTINFO;
pi = (struct in6_pktinfo *)CMSG_DATA(cm);
memset(&pi->ipi6_addr, 0, sizeof(pi->ipi6_addr)); /*XXX*/
pi->ipi6_ifindex = ifindex;
}
return sendmsg(s, &m, 0);
#endif
}
int
interface_down(name)
char *name;
{
int s;
struct ifreq ifr;
vmsg((stderr, "make interface %s down.\n", name));
if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
err(1, "socket");
/*NOTREACHED*/
}
strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
if (ioctl(s, SIOCGIFFLAGS, (caddr_t)&ifr) < 0)
perror("ioctl(SIOCGIFFLAGS)");
ifr.ifr_flags &= ~IFF_UP;
if (ioctl(s, SIOCSIFFLAGS, (caddr_t)&ifr) < 0)
perror("ioctl(SIOCSIFFLAGS)");
close(s);
return 0;
}
int
interface_up(name)
char *name;
{
int s;
struct ifreq ifr;
int flag6;
int retry;
int wasup;
vmsg((stderr, "make interface %s up.\n", name));
if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
err(1, "socket");
/*NOTREACHED*/
}
strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
if (ioctl(s, SIOCGIFFLAGS, (caddr_t)&ifr) < 0)
perror("ioctl(SIOCGIFFLAGS)");
if (ifr.ifr_flags & IFF_UP)
wasup = 1;
else {
wasup = 0;
ifr.ifr_flags |= IFF_UP;
if (ioctl(s, SIOCSIFFLAGS, (caddr_t)&ifr) < 0)
perror("ioctl(SIOCSIFFLAGS)");
}
close(s);
retry = getdadcount();
if (retry < 0) {
retry = 10;
vmsg((stderr, "invalid dad count; setting retry to %d\n",
retry));
} else {
vmsg((stderr, "dad count is %d\n", retry));
if (!wasup)
retry += MAX_RTR_SOLICITATIONS;
retry += 2; /* to make sure */
}
vmsg((stderr, "checking if %s is ready...\n", name));
while (0 < retry--) {
if (getifflag6(name, &flag6) < 0) {
vmsg((stderr, "getifflag6() failed, anyway I'll try\n"));
return 0;
}
if (verbose) {
fprintf(stderr, "%s:", name);
if (!(flag6 & IN6_IFF_NOTREADY))
fprintf(stderr, " ready\n");
else {
if (flag6 & IN6_IFF_TENTATIVE)
fprintf(stderr, " tentative");
if (flag6 & IN6_IFF_DUPLICATED)
fprintf(stderr, " duplicatd");
fprintf(stderr, "\n");
}
}
if (flag6 & IN6_IFF_DUPLICATED)
break;
if (!(flag6 & IN6_IFF_NOTREADY))
return 0;
sleep(1);
}
fprintf(stderr, "DAD for if %s is in strange state\n", name);
return -1;
}
/*------------------------------------------------------------*/
static int
getifflag6(name, flag6)
char *name;
int *flag6;
{
int s;
struct sockaddr_in6 *sin6;
#ifndef SIOCGLIFADDR
int error;
char buf[BUFSIZ];
int i;
struct ifreq *ifr;
struct in6_ifreq ifr6;
struct ifconf ifc;
if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
err(1, "socket");
/*NOTREACHED*/
}
ifc.ifc_len = sizeof(buf);
ifc.ifc_buf = buf;
if (ioctl(s, SIOCGIFCONF, &ifc) < 0) {
err(1, "ioctl(SIOCGIFCONF)");
/*NOTREACHED*/
}
error = -1;
for (i = 0; i < ifc.ifc_len; ) {
ifr = (struct ifreq *)((caddr_t)ifc.ifc_req + i);
i += sizeof(ifr->ifr_name) +
(ifr->ifr_addr.sa_len > sizeof(struct sockaddr)
? ifr->ifr_addr.sa_len
: sizeof(struct sockaddr));
if (strncmp(name, ifr->ifr_name, sizeof(ifr->ifr_name)) != 0)
continue;
if (ifr->ifr_addr.sa_family != AF_INET6)
continue;
sin6 = (struct sockaddr_in6 *)&ifr->ifr_addr;
if (!IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr))
continue;
if (verbose) {
char addrbuf[BUFSIZ];
getnameinfo((struct sockaddr *)sin6, sin6->sin6_len,
addrbuf, sizeof(addrbuf), NULL, 0,
NI_NUMERICHOST);
fprintf(stderr, "getting flags6 for if %s addr %s\n",
ifr->ifr_name, addrbuf);
}
strcpy(ifr6.ifr_name, name);
memcpy(&ifr6.ifr_ifru.ifru_addr, &ifr->ifr_addr,
ifr->ifr_addr.sa_len);
if (ioctl(s, SIOCGIFAFLAG_IN6, &ifr6) < 0) {
err(1, "ioctl(SIOCGIFAFLAG_IN6)");
/*NOTREACHED*/
}
error = 0;
if (flag6)
*flag6 = ifr6.ifr_ifru.ifru_flags6;
break;
}
if (error < 0 && verbose)
fprintf(stderr, "getifflags6: no matches\n");
close(s);
return error;
#else
struct if_laddrreq iflr;
if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
err(1, "socket");
/*NOTREACHED*/
}
/* perform prefix match on SIOCGLIFADDR */
memset(&iflr, 0, sizeof(iflr));
strcpy(iflr.iflr_name, name);
iflr.prefixlen = 16;
iflr.flags = IFLR_PREFIX;
sin6 = (struct sockaddr_in6 *)&iflr.addr;
sin6->sin6_family = AF_INET6;
sin6->sin6_len = sizeof(*sin6);
sin6->sin6_addr.s6_addr16[0] = htons(0xfe80); /*XXX hardcode*/
if (ioctl(s, SIOCGLIFADDR, &iflr) < 0) {
if (errno == EADDRNOTAVAIL) /*no match - portability?*/
return -1;
err(1, "ioctl(SIOCGLIFADDR)");
/*NOTREACHED*/
}
if (verbose) {
char addrbuf[BUFSIZ];
getnameinfo((struct sockaddr *)sin6, sin6->sin6_len,
addrbuf, sizeof(addrbuf), NULL, 0,
NI_NUMERICHOST);
fprintf(stderr, "got flags6 for if %s addr %s=0x%08x\n",
iflr.iflr_name, addrbuf, iflr.flags);
}
if (flag6)
*flag6 = iflr.flags;
close(s);
return 0;
#endif
}
static int
getdadcount()
{
int mib[] = { CTL_NET, PF_INET6, IPPROTO_IPV6, IPV6CTL_DAD_COUNT };
int value;
size_t size;
size = sizeof(value);
if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), &value, &size, NULL, 0) < 0)
return -1;
else
return value;
}