freebsd-dev/usr.sbin/rtsold/rtsold.c
Kristof Provost 476babaea7 rtsol: introduce an 'always' script
In addition to the 'M' and 'O' scripts (for when 'Managed' and 'Other'
flags are set) also introduce an 'always' script that is called for any
router advertisement (so even if M and O are not set).

This is primarly useful for systems like pfSense that wish to be
informed of routers for further system configuration.

See also https://redmine.pfsense.org/issues/14072

Reviewed by:	melifaro
Sponsored by:	Rubicon Communications, LLC ("Netgate")
Differential Revision:	https://reviews.freebsd.org/D39931
2023-05-02 18:07:36 +02:00

941 lines
22 KiB
C

/* $KAME: rtsold.c,v 1.67 2003/05/17 18:16:15 itojun Exp $ */
/*-
* SPDX-License-Identifier: BSD-3-Clause
*
* 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.
*
* $FreeBSD$
*/
#include <sys/param.h>
#include <sys/capsicum.h>
#include <sys/event.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <netinet/in.h>
#include <netinet/icmp6.h>
#include <netinet/in_var.h>
#include <arpa/inet.h>
#include <netinet6/nd6.h>
#include <capsicum_helpers.h>
#include <err.h>
#include <errno.h>
#include <ifaddrs.h>
#include <libgen.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <time.h>
#include <unistd.h>
#include <libcasper.h>
#include <casper/cap_syslog.h>
#include <libutil.h>
#include "rtsold.h"
#define RTSOL_DUMPFILE "/var/run/rtsold.dump"
struct timespec tm_max;
static int log_upto = 999;
static int fflag = 0;
int Fflag = 0; /* force setting sysctl parameters */
int aflag = 0;
int dflag = 0;
int uflag = 0;
const char *managedconf_script;
const char *otherconf_script;
const char *alwaysconf_script;
const char *resolvconf_script = "/sbin/resolvconf";
cap_channel_t *capllflags, *capscript, *capsendmsg, *capsyslog;
/* protocol constants */
#define MAX_RTR_SOLICITATION_DELAY 1 /* second */
#define RTR_SOLICITATION_INTERVAL 4 /* seconds */
#define MAX_RTR_SOLICITATIONS 3 /* times */
/*
* implementation dependent constants in seconds
* XXX: should be configurable
*/
#define PROBE_INTERVAL 60
/* static variables and functions */
static int mobile_node = 0;
static int no_solicitation_delay = 0;
static sig_atomic_t do_dump, do_exit;
static struct pidfh *pfh;
static char **autoifprobe(void);
static int ifconfig(char *ifname);
static int init_capabilities(void);
static int make_packet(struct ifinfo *);
static struct timespec *rtsol_check_timer(void);
static void set_dumpfile(int);
static void set_exit(int);
static void usage(const char *progname);
int
main(int argc, char **argv)
{
struct kevent events[2];
FILE *dumpfp;
struct ifinfo *ifi;
struct timespec *timeout;
const char *opts, *pidfilepath, *progname;
int ch, error, kq, once, rcvsock, rtsock;
progname = basename(argv[0]);
if (strcmp(progname, "rtsold") == 0) {
opts = "adDfFim1M:O:A:p:R:u";
once = 0;
pidfilepath = NULL;
} else {
opts = "adDFiM:O:A:R:u";
fflag = 1;
once = 1;
}
while ((ch = getopt(argc, argv, opts)) != -1) {
switch (ch) {
case 'a':
aflag = 1;
break;
case 'd':
dflag += 1;
break;
case 'D':
dflag += 2;
break;
case 'f':
fflag = 1;
break;
case 'F':
Fflag = 1;
break;
case 'i':
no_solicitation_delay = 1;
break;
case 'm':
mobile_node = 1;
break;
case '1':
once = 1;
break;
case 'M':
managedconf_script = optarg;
break;
case 'O':
otherconf_script = optarg;
break;
case 'A':
alwaysconf_script = optarg;
break;
case 'p':
pidfilepath = optarg;
break;
case 'R':
resolvconf_script = optarg;
break;
case 'u':
uflag = 1;
break;
default:
usage(progname);
}
}
argc -= optind;
argv += optind;
if ((!aflag && argc == 0) || (aflag && argc != 0))
usage(progname);
/* Generate maximum time in timespec. */
tm_max.tv_sec = (-1) & ~((time_t)1 << ((sizeof(tm_max.tv_sec) * 8) - 1));
tm_max.tv_nsec = (-1) & ~((long)1 << ((sizeof(tm_max.tv_nsec) * 8) - 1));
/* set log level */
if (dflag > 1)
log_upto = LOG_DEBUG;
else if (dflag > 0)
log_upto = LOG_INFO;
else
log_upto = LOG_NOTICE;
if (managedconf_script != NULL && *managedconf_script != '/')
errx(1, "configuration script (%s) must be an absolute path",
managedconf_script);
if (otherconf_script != NULL && *otherconf_script != '/')
errx(1, "configuration script (%s) must be an absolute path",
otherconf_script);
if (alwaysconf_script != NULL && *alwaysconf_script != '/')
errx(1, "configuration script (%s) must be an absolute path",
alwaysconf_script);
if (*resolvconf_script != '/')
errx(1, "configuration script (%s) must be an absolute path",
resolvconf_script);
if (!fflag) {
pfh = pidfile_open(pidfilepath, 0644, NULL);
if (pfh == NULL)
errx(1, "failed to open pidfile: %s", strerror(errno));
if (daemon(0, 0) != 0)
errx(1, "failed to daemonize");
}
if ((error = init_capabilities()) != 0)
err(1, "failed to initialize capabilities");
if (!fflag) {
cap_openlog(capsyslog, progname, LOG_NDELAY | LOG_PID,
LOG_DAEMON);
if (log_upto >= 0)
(void)cap_setlogmask(capsyslog, LOG_UPTO(log_upto));
(void)signal(SIGTERM, set_exit);
(void)signal(SIGINT, set_exit);
(void)signal(SIGUSR1, set_dumpfile);
dumpfp = rtsold_init_dumpfile(RTSOL_DUMPFILE);
} else
dumpfp = NULL;
kq = kqueue();
if (kq < 0) {
warnmsg(LOG_ERR, __func__, "failed to create a kqueue: %s",
strerror(errno));
exit(1);
}
/* Open global sockets and register for read events. */
if ((rtsock = rtsock_open()) < 0) {
warnmsg(LOG_ERR, __func__, "failed to open routing socket");
exit(1);
}
if ((rcvsock = recvsockopen()) < 0) {
warnmsg(LOG_ERR, __func__, "failed to open receive socket");
exit(1);
}
EV_SET(&events[0], rtsock, EVFILT_READ, EV_ADD, 0, 0, NULL);
EV_SET(&events[1], rcvsock, EVFILT_READ, EV_ADD, 0, 0, NULL);
if (kevent(kq, events, 2, NULL, 0, NULL) < 0) {
warnmsg(LOG_ERR, __func__, "kevent(): %s", strerror(errno));
exit(1);
}
/* Probe network interfaces and set up tracking info. */
if (ifinit() != 0) {
warnmsg(LOG_ERR, __func__, "failed to initialize interfaces");
exit(1);
}
if (aflag)
argv = autoifprobe();
while (argv && *argv) {
if (ifconfig(*argv)) {
warnmsg(LOG_ERR, __func__,
"failed to initialize %s", *argv);
exit(1);
}
argv++;
}
/* Write to our pidfile. */
if (pfh != NULL && pidfile_write(pfh) != 0) {
warnmsg(LOG_ERR, __func__,
"failed to open pidfile: %s", strerror(errno));
exit(1);
}
/* Enter capability mode. */
caph_cache_catpages();
if (caph_enter_casper() != 0) {
warnmsg(LOG_ERR, __func__, "caph_enter(): %s", strerror(errno));
exit(1);
}
for (;;) {
if (do_exit) {
/* Handle SIGTERM, SIGINT. */
if (pfh != NULL)
pidfile_remove(pfh);
break;
}
if (do_dump) {
/* Handle SIGUSR1. */
do_dump = 0;
if (dumpfp != NULL)
rtsold_dump(dumpfp);
}
timeout = rtsol_check_timer();
if (once) {
/* if we have no timeout, we are done (or failed) */
if (timeout == NULL)
break;
/* if all interfaces have got RA packet, we are done */
TAILQ_FOREACH(ifi, &ifinfo_head, ifi_next) {
if (ifi->state != IFS_DOWN && ifi->racnt == 0)
break;
}
if (ifi == NULL)
break;
}
error = kevent(kq, NULL, 0, &events[0], 1, timeout);
if (error < 1) {
if (error < 0 && errno != EINTR)
warnmsg(LOG_ERR, __func__, "kevent(): %s",
strerror(errno));
continue;
}
if (events[0].ident == (uintptr_t)rtsock)
rtsock_input(rtsock);
else
rtsol_input(rcvsock);
}
return (0);
}
static int
init_capabilities(void)
{
#ifdef WITH_CASPER
const char *const scripts[] =
{ resolvconf_script, managedconf_script, otherconf_script,
alwaysconf_script };
cap_channel_t *capcasper;
nvlist_t *limits;
capcasper = cap_init();
if (capcasper == NULL)
return (-1);
capllflags = cap_service_open(capcasper, "rtsold.llflags");
if (capllflags == NULL)
return (-1);
capscript = cap_service_open(capcasper, "rtsold.script");
if (capscript == NULL)
return (-1);
limits = nvlist_create(0);
for (size_t i = 0; i < nitems(scripts); i++)
if (scripts[i] != NULL)
nvlist_append_string_array(limits, "scripts",
scripts[i]);
if (cap_limit_set(capscript, limits) != 0)
return (-1);
capsendmsg = cap_service_open(capcasper, "rtsold.sendmsg");
if (capsendmsg == NULL)
return (-1);
if (!fflag) {
capsyslog = cap_service_open(capcasper, "system.syslog");
if (capsyslog == NULL)
return (-1);
}
cap_close(capcasper);
#endif /* WITH_CASPER */
return (0);
}
static int
ifconfig(char *ifname)
{
struct ifinfo *ifi;
struct sockaddr_dl *sdl;
int flags;
ifi = NULL;
if ((sdl = if_nametosdl(ifname)) == NULL) {
warnmsg(LOG_ERR, __func__,
"failed to get link layer information for %s", ifname);
goto bad;
}
if (find_ifinfo(sdl->sdl_index)) {
warnmsg(LOG_ERR, __func__,
"interface %s was already configured", ifname);
goto bad;
}
if (Fflag) {
struct in6_ndireq nd;
int s;
if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
warnmsg(LOG_ERR, __func__, "socket() failed.");
goto bad;
}
memset(&nd, 0, sizeof(nd));
strlcpy(nd.ifname, ifname, sizeof(nd.ifname));
if (ioctl(s, SIOCGIFINFO_IN6, (caddr_t)&nd) < 0) {
warnmsg(LOG_ERR, __func__,
"cannot get accept_rtadv flag");
(void)close(s);
goto bad;
}
nd.ndi.flags |= ND6_IFF_ACCEPT_RTADV;
if (ioctl(s, SIOCSIFINFO_IN6, (caddr_t)&nd) < 0) {
warnmsg(LOG_ERR, __func__,
"cannot set accept_rtadv flag");
(void)close(s);
goto bad;
}
(void)close(s);
}
if ((ifi = malloc(sizeof(*ifi))) == NULL) {
warnmsg(LOG_ERR, __func__, "memory allocation failed");
goto bad;
}
memset(ifi, 0, sizeof(*ifi));
ifi->sdl = sdl;
ifi->ifi_rdnss = IFI_DNSOPT_STATE_NOINFO;
ifi->ifi_dnssl = IFI_DNSOPT_STATE_NOINFO;
TAILQ_INIT(&ifi->ifi_rainfo);
strlcpy(ifi->ifname, ifname, sizeof(ifi->ifname));
/* construct a router solicitation message */
if (make_packet(ifi))
goto bad;
/* set link ID of this interface. */
#ifdef HAVE_SCOPELIB
if (inet_zoneid(AF_INET6, 2, ifname, &ifi->linkid))
goto bad;
#else
/* XXX: assume interface IDs as link IDs */
ifi->linkid = ifi->sdl->sdl_index;
#endif
/*
* check if the interface is available.
* also check if SIOCGIFMEDIA ioctl is OK on the interface.
*/
ifi->mediareqok = 1;
ifi->active = interface_status(ifi);
if (!ifi->mediareqok) {
/*
* probe routers periodically even if the link status
* does not change.
*/
ifi->probeinterval = PROBE_INTERVAL;
}
/* activate interface: interface_up returns 0 on success */
flags = interface_up(ifi->ifname);
if (flags == 0)
ifi->state = IFS_DELAY;
else if (flags == IFS_TENTATIVE)
ifi->state = IFS_TENTATIVE;
else
ifi->state = IFS_DOWN;
rtsol_timer_update(ifi);
TAILQ_INSERT_TAIL(&ifinfo_head, ifi, ifi_next);
return (0);
bad:
free(sdl);
free(ifi);
return (-1);
}
struct rainfo *
find_rainfo(struct ifinfo *ifi, struct sockaddr_in6 *sin6)
{
struct rainfo *rai;
TAILQ_FOREACH(rai, &ifi->ifi_rainfo, rai_next)
if (memcmp(&rai->rai_saddr.sin6_addr, &sin6->sin6_addr,
sizeof(rai->rai_saddr.sin6_addr)) == 0)
return (rai);
return (NULL);
}
struct ifinfo *
find_ifinfo(int ifindex)
{
struct ifinfo *ifi;
TAILQ_FOREACH(ifi, &ifinfo_head, ifi_next) {
if (ifi->sdl->sdl_index == ifindex)
return (ifi);
}
return (NULL);
}
static int
make_packet(struct ifinfo *ifi)
{
size_t packlen = sizeof(struct nd_router_solicit), lladdroptlen = 0;
struct nd_router_solicit *rs;
char *buf;
if ((lladdroptlen = lladdropt_length(ifi->sdl)) == 0) {
warnmsg(LOG_INFO, __func__,
"link-layer address option has null length"
" on %s. Treat as not included.", ifi->ifname);
}
packlen += lladdroptlen;
ifi->rs_datalen = packlen;
/* allocate buffer */
if ((buf = malloc(packlen)) == NULL) {
warnmsg(LOG_ERR, __func__,
"memory allocation failed for %s", ifi->ifname);
return (-1);
}
ifi->rs_data = buf;
/* fill in the message */
rs = (struct nd_router_solicit *)buf;
rs->nd_rs_type = ND_ROUTER_SOLICIT;
rs->nd_rs_code = 0;
rs->nd_rs_cksum = 0;
rs->nd_rs_reserved = 0;
buf += sizeof(*rs);
/* fill in source link-layer address option */
if (lladdroptlen)
lladdropt_fill(ifi->sdl, (struct nd_opt_hdr *)buf);
return (0);
}
static struct timespec *
rtsol_check_timer(void)
{
static struct timespec returnval;
struct timespec now, rtsol_timer;
struct ifinfo *ifi;
struct rainfo *rai;
struct ra_opt *rao, *raotmp;
int error, flags;
clock_gettime(CLOCK_MONOTONIC_FAST, &now);
rtsol_timer = tm_max;
TAILQ_FOREACH(ifi, &ifinfo_head, ifi_next) {
if (TS_CMP(&ifi->expire, &now, <=)) {
warnmsg(LOG_DEBUG, __func__, "timer expiration on %s, "
"state = %d", ifi->ifname, ifi->state);
while((rai = TAILQ_FIRST(&ifi->ifi_rainfo)) != NULL) {
/* Remove all RA options. */
TAILQ_REMOVE(&ifi->ifi_rainfo, rai, rai_next);
while ((rao = TAILQ_FIRST(&rai->rai_ra_opt)) !=
NULL) {
TAILQ_REMOVE(&rai->rai_ra_opt, rao,
rao_next);
if (rao->rao_msg != NULL)
free(rao->rao_msg);
free(rao);
}
free(rai);
}
switch (ifi->state) {
case IFS_DOWN:
case IFS_TENTATIVE:
/* interface_up returns 0 on success */
flags = interface_up(ifi->ifname);
if (flags == 0)
ifi->state = IFS_DELAY;
else if (flags == IFS_TENTATIVE)
ifi->state = IFS_TENTATIVE;
else
ifi->state = IFS_DOWN;
break;
case IFS_IDLE:
{
int oldstatus = ifi->active;
int probe = 0;
ifi->active = interface_status(ifi);
if (oldstatus != ifi->active) {
warnmsg(LOG_DEBUG, __func__,
"%s status is changed"
" from %d to %d",
ifi->ifname,
oldstatus, ifi->active);
probe = 1;
ifi->state = IFS_DELAY;
} else if (ifi->probeinterval &&
(ifi->probetimer -=
ifi->timer.tv_sec) <= 0) {
/* probe timer expired */
ifi->probetimer =
ifi->probeinterval;
probe = 1;
ifi->state = IFS_PROBE;
}
/*
* If we need a probe, clear the previous
* status wrt the "managed/other" configuration.
*/
if (probe) {
ifi->managedconfig = 0;
ifi->otherconfig = 0;
ifi->alwaysconfig = 0;
}
if (probe && mobile_node) {
error = cap_probe_defrouters(capsendmsg,
ifi);
if (error != 0)
warnmsg(LOG_DEBUG, __func__,
"failed to probe routers: %d",
error);
}
break;
}
case IFS_DELAY:
ifi->state = IFS_PROBE;
(void)cap_rssend(capsendmsg, ifi);
break;
case IFS_PROBE:
if (ifi->probes < MAX_RTR_SOLICITATIONS)
(void)cap_rssend(capsendmsg, ifi);
else {
warnmsg(LOG_INFO, __func__,
"No answer after sending %d RSs",
ifi->probes);
ifi->probes = 0;
ifi->state = IFS_IDLE;
}
break;
}
rtsol_timer_update(ifi);
} else {
/* Expiration check for RA options. */
int expire = 0;
TAILQ_FOREACH(rai, &ifi->ifi_rainfo, rai_next) {
TAILQ_FOREACH_SAFE(rao, &rai->rai_ra_opt,
rao_next, raotmp) {
warnmsg(LOG_DEBUG, __func__,
"RA expiration timer: "
"type=%d, msg=%s, expire=%s",
rao->rao_type, (char *)rao->rao_msg,
sec2str(&rao->rao_expire));
if (TS_CMP(&now, &rao->rao_expire,
>=)) {
warnmsg(LOG_DEBUG, __func__,
"RA expiration timer: "
"expired.");
TAILQ_REMOVE(&rai->rai_ra_opt,
rao, rao_next);
if (rao->rao_msg != NULL)
free(rao->rao_msg);
free(rao);
expire = 1;
}
}
}
if (expire)
ra_opt_handler(ifi);
}
if (TS_CMP(&ifi->expire, &rtsol_timer, <))
rtsol_timer = ifi->expire;
}
if (TS_CMP(&rtsol_timer, &tm_max, ==)) {
warnmsg(LOG_DEBUG, __func__, "there is no timer");
return (NULL);
} else if (TS_CMP(&rtsol_timer, &now, <))
/* this may occur when the interval is too small */
returnval.tv_sec = returnval.tv_nsec = 0;
else
TS_SUB(&rtsol_timer, &now, &returnval);
now.tv_sec += returnval.tv_sec;
now.tv_nsec += returnval.tv_nsec;
warnmsg(LOG_DEBUG, __func__, "New timer is %s",
sec2str(&now));
return (&returnval);
}
void
rtsol_timer_update(struct ifinfo *ifi)
{
#define MILLION 1000000
#define DADRETRY 10 /* XXX: adhoc */
long interval;
struct timespec now;
bzero(&ifi->timer, sizeof(ifi->timer));
switch (ifi->state) {
case IFS_DOWN:
case IFS_TENTATIVE:
if (++ifi->dadcount > DADRETRY) {
ifi->dadcount = 0;
ifi->timer.tv_sec = PROBE_INTERVAL;
} else
ifi->timer.tv_sec = 1;
break;
case IFS_IDLE:
if (mobile_node)
/* XXX should be configurable */
ifi->timer.tv_sec = 3;
else
ifi->timer = tm_max; /* stop timer(valid?) */
break;
case IFS_DELAY:
if (no_solicitation_delay)
interval = 0;
else
interval = arc4random_uniform(MAX_RTR_SOLICITATION_DELAY * MILLION);
ifi->timer.tv_sec = interval / MILLION;
ifi->timer.tv_nsec = (interval % MILLION) * 1000;
break;
case IFS_PROBE:
if (ifi->probes < MAX_RTR_SOLICITATIONS)
ifi->timer.tv_sec = RTR_SOLICITATION_INTERVAL;
else
/*
* After sending MAX_RTR_SOLICITATIONS solicitations,
* we're just waiting for possible replies; there
* will be no more solicitation. Thus, we change
* the timer value to MAX_RTR_SOLICITATION_DELAY based
* on RFC 2461, Section 6.3.7.
*/
ifi->timer.tv_sec = MAX_RTR_SOLICITATION_DELAY;
break;
default:
warnmsg(LOG_ERR, __func__,
"illegal interface state(%d) on %s",
ifi->state, ifi->ifname);
return;
}
/* reset the timer */
if (TS_CMP(&ifi->timer, &tm_max, ==)) {
ifi->expire = tm_max;
warnmsg(LOG_DEBUG, __func__,
"stop timer for %s", ifi->ifname);
} else {
clock_gettime(CLOCK_MONOTONIC_FAST, &now);
TS_ADD(&now, &ifi->timer, &ifi->expire);
now.tv_sec += ifi->timer.tv_sec;
now.tv_nsec += ifi->timer.tv_nsec;
warnmsg(LOG_DEBUG, __func__, "set timer for %s to %s",
ifi->ifname, sec2str(&now));
}
#undef MILLION
}
static void
set_dumpfile(int sig __unused)
{
do_dump = 1;
}
static void
set_exit(int sig __unused)
{
do_exit = 1;
}
static void
usage(const char *progname)
{
if (strcmp(progname, "rtsold") == 0) {
fprintf(stderr, "usage: rtsold [-dDfFm1] [-O script-name] "
"[-M script-name ] [-A script-name ] "
"[-p pidfile] [-R script-name] interface ...\n");
fprintf(stderr, "usage: rtsold [-dDfFm1] [-O script-name] "
"[-M script-name ] [-A script-name ] "
"[-p pidfile] [-R script-name] -a\n");
} else {
fprintf(stderr, "usage: rtsol [-dDF] [-O script-name] "
"[-M script-name ] [-A script-name ] "
"[-p pidfile] [-R script-name] interface ...\n");
fprintf(stderr, "usage: rtsol [-dDF] [-O script-name] "
"[-M script-name ] [-A script-name ] "
"[-p pidfile] [-R script-name] -a\n");
}
exit(1);
}
void
warnmsg(int priority, const char *func, const char *msg, ...)
{
va_list ap;
char buf[BUFSIZ];
va_start(ap, msg);
if (fflag) {
if (priority <= log_upto)
vwarnx(msg, ap);
} else {
snprintf(buf, sizeof(buf), "<%s> %s", func, msg);
msg = buf;
cap_vsyslog(capsyslog, priority, msg, ap);
}
va_end(ap);
}
/*
* return a list of interfaces which is suitable to sending an RS.
*/
static char **
autoifprobe(void)
{
static char **argv = NULL;
static int n = 0;
char **a;
int s = 0, i, found;
struct ifaddrs *ifap, *ifa;
struct in6_ndireq nd;
/* initialize */
while (n--)
free(argv[n]);
if (argv) {
free(argv);
argv = NULL;
}
n = 0;
if (getifaddrs(&ifap) != 0)
return (NULL);
if (!Fflag && (s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
warnmsg(LOG_ERR, __func__, "socket");
exit(1);
}
/* find an ethernet */
for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
if ((ifa->ifa_flags & IFF_UP) == 0)
continue;
if ((ifa->ifa_flags & IFF_LOOPBACK) != 0)
continue;
if ((ifa->ifa_flags & IFF_MULTICAST) == 0)
continue;
if (ifa->ifa_addr->sa_family != AF_INET6)
continue;
found = 0;
for (i = 0; i < n; i++) {
if (strcmp(argv[i], ifa->ifa_name) == 0) {
found++;
break;
}
}
if (found)
continue;
/*
* Skip the interfaces which IPv6 and/or accepting RA
* is disabled.
*/
if (!Fflag) {
memset(&nd, 0, sizeof(nd));
strlcpy(nd.ifname, ifa->ifa_name, sizeof(nd.ifname));
if (ioctl(s, SIOCGIFINFO_IN6, (caddr_t)&nd) < 0) {
warnmsg(LOG_ERR, __func__,
"ioctl(SIOCGIFINFO_IN6)");
exit(1);
}
if ((nd.ndi.flags & ND6_IFF_IFDISABLED))
continue;
if (!(nd.ndi.flags & ND6_IFF_ACCEPT_RTADV))
continue;
}
/* if we find multiple candidates, just warn. */
if (n != 0 && dflag > 1)
warnmsg(LOG_WARNING, __func__,
"multiple interfaces found");
a = realloc(argv, (n + 1) * sizeof(char *));
if (a == NULL) {
warnmsg(LOG_ERR, __func__, "realloc");
exit(1);
}
argv = a;
argv[n] = strdup(ifa->ifa_name);
if (!argv[n]) {
warnmsg(LOG_ERR, __func__, "malloc");
exit(1);
}
n++;
}
if (n) {
a = realloc(argv, (n + 1) * sizeof(char *));
if (a == NULL) {
warnmsg(LOG_ERR, __func__, "realloc");
exit(1);
}
argv = a;
argv[n] = NULL;
if (dflag > 0) {
for (i = 0; i < n; i++)
warnmsg(LOG_WARNING, __func__, "probing %s",
argv[i]);
}
}
if (!Fflag)
close(s);
freeifaddrs(ifap);
return (argv);
}