xref: /src/usr.sbin/ifwatchd/ifwatchd.c

/*	$NetBSD: ifwatchd.c,v 1.47 2023/07/01 12:36:10 mlelstv Exp $	*/
#include <sys/cdefs.h>
__RCSID("$NetBSD: ifwatchd.c,v 1.47 2023/07/01 12:36:10 mlelstv Exp $");

/*-
 * Copyright (c) 2002, 2003 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Martin Husemann <martin (at) NetBSD.org>.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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/types.h>
#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/queue.h>
#include <sys/wait.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/route.h>
#include <netinet/in.h>
#include <netinet/in_var.h>
#include <arpa/inet.h>

#include <err.h>
#include <errno.h>
#include <ifaddrs.h>
#include <netdb.h>
#include <paths.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>

enum event { ARRIVAL, DEPARTURE, UP, DOWN, CARRIER, NO_CARRIER };
enum addrflag { NOTREADY, DETACHED, DEPRECATED, READY };

/* local functions */
__dead static void usage(void);
static void dispatch(const void *, size_t);
static enum addrflag check_addrflags(int af, int addrflags);
static void check_addrs(const struct ifa_msghdr *ifam);
static void invoke_script(const char *ifname, enum event ev,
    const struct sockaddr *sa, const struct sockaddr *dst);
static void list_interfaces(const char *ifnames);
static void check_announce(const struct if_announcemsghdr *ifan);
static void check_carrier(const struct if_msghdr *ifm);
static void free_interfaces(void);
static struct interface_data * find_interface(int index);
static void run_initial_ups(bool);

/* global variables */
static int verbose = 0, quiet = 0;
static int inhibit_initial = 0;
static const char *arrival_script = NULL;
static const char *departure_script = NULL;
static const char *up_script = NULL;
static const char *down_script = NULL;
static const char *carrier_script = NULL;
static const char *no_carrier_script = NULL;
static const char DummyTTY[] = _PATH_DEVNULL;
static const char DummySpeed[] = "9600";
static const char **scripts[] = {
	&arrival_script,
	&departure_script,
	&up_script,
	&down_script,
	&carrier_script,
	&no_carrier_script
};

struct interface_data {
	SLIST_ENTRY(interface_data) next;
	int index;
	int last_carrier_status;
	char * ifname;
};
static SLIST_HEAD(,interface_data) ifs = SLIST_HEAD_INITIALIZER(ifs);

int
main(int argc, char **argv)
{
	int c, s, n;
	int errs = 0;
	struct msghdr msg;
	struct iovec iov[1];
	char buf[2048];
	unsigned char msgfilter[] = {
		RTM_IFINFO, RTM_IFANNOUNCE,
		RTM_NEWADDR, RTM_DELADDR,
	};

	openlog(argv[0], LOG_PID|LOG_CONS, LOG_DAEMON);
	while ((c = getopt(argc, argv, "qvhic:n:u:d:A:D:")) != -1) {
		switch (c) {
		case 'h':
			usage();
			return 0;

		case 'i':
			inhibit_initial = 1;
			break;

		case 'v':
			verbose++;
			break;

		case 'q':
			quiet = 1;
			break;

		case 'c':
			carrier_script = optarg;
			break;

		case 'n':
			no_carrier_script = optarg;
			break;

		case 'u':
			up_script = optarg;
			break;

		case 'd':
			down_script = optarg;
			break;

		case 'A':
			arrival_script = optarg;
			break;

		case 'D':
			departure_script = optarg;
			break;

		default:
			errs++;
			break;
		}
	}

	if (errs)
		usage();

	argv += optind;
	argc -= optind;

	if (argc <= 0)
		usage();

	if (verbose) {
		printf("up_script: %s\ndown_script: %s\n",
			up_script, down_script);
		printf("arrival_script: %s\ndeparture_script: %s\n",
			arrival_script, departure_script);
		printf("carrier_script: %s\nno_carrier_script: %s\n",
			carrier_script, no_carrier_script);
		printf("verbosity = %d\n", verbose);
	}

	while (argc > 0) {
		list_interfaces(argv[0]);
		argv++;
		argc--;
	}

	if (!verbose)
		daemon(0, 0);

	s = socket(PF_ROUTE, SOCK_RAW, 0);
	if (s < 0) {
		syslog(LOG_ERR, "error opening routing socket: %m");
		exit(EXIT_FAILURE);
	}
	if (setsockopt(s, PF_ROUTE, RO_MSGFILTER,
	    &msgfilter, sizeof(msgfilter)) < 0)
		syslog(LOG_ERR, "RO_MSGFILTER: %m");
	n = 1;
	if (setsockopt(s, SOL_SOCKET, SO_RERROR, &n, sizeof(n)) < 0)
		syslog(LOG_ERR, "SO_RERROR: %m");

	if (!inhibit_initial)
		run_initial_ups(true);

	iov[0].iov_base = buf;
	iov[0].iov_len = sizeof(buf);
	memset(&msg, 0, sizeof(msg));
	msg.msg_iov = iov;
	msg.msg_iovlen = 1;

	for (;;) {
		n = recvmsg(s, &msg, 0);
		if (n == -1) {
			if (errno == ENOBUFS) {
				syslog(LOG_ERR,
				    "routing socket overflow detected");
				/* XXX We don't track addresses, so they
				 * won't be reported. */
				if (!inhibit_initial)
					run_initial_ups(false);
				continue;
			}
			syslog(LOG_ERR, "recvmsg: %m");
			exit(EXIT_FAILURE);
		}
		if (n != 0)
			dispatch(iov[0].iov_base, n);
	}

	close(s);
	free_interfaces();
	closelog();

	return EXIT_SUCCESS;
}

static void
usage(void)
{
	fprintf(stderr,
	    "usage:\n"
	    "\tifwatchd [-hiqv] [-A arrival-script] [-D departure-script]\n"
	    "\t\t  [-d down-script] [-u up-script]\n"
	    "\t\t  [-c carrier-script] [-n no-carrier-script] ifname(s)\n"
	    "\twhere:\n"
	    "\t -A <cmd> specify command to run on interface arrival event\n"
	    "\t -c <cmd> specify command to run on interface carrier-detect event\n"
	    "\t -D <cmd> specify command to run on interface departure event\n"
	    "\t -d <cmd> specify command to run on interface down event\n"
	    "\t -n <cmd> specify command to run on interface no-carrier-detect event\n"
	    "\t -h       show this help message\n"
	    "\t -i       no (!) initial run of the up script if the interface\n"
	    "\t          is already up on ifwatchd startup\n"
	    "\t -q       quiet mode, don't syslog informational messages\n"
	    "\t -u <cmd> specify command to run on interface up event\n"
	    "\t -v       verbose/debug output, don't run in background\n");
	exit(EXIT_FAILURE);
}

static void
dispatch(const void *msg, size_t len)
{
	const struct rt_msghdr *hd = msg;

	if (hd->rtm_version != RTM_VERSION)
		return;

	switch (hd->rtm_type) {
	case RTM_NEWADDR:
	case RTM_DELADDR:
		check_addrs(msg);
		break;
	case RTM_IFANNOUNCE:
		check_announce(msg);
		break;
	case RTM_IFINFO:
		check_carrier(msg);
		break;
	default:
		/* Should be impossible as we filter messages. */
		if (verbose)
			printf("unknown message ignored (%d)\n", hd->rtm_type);
		break;
	}
}

static enum addrflag
check_addrflags(int af, int addrflags)
{

	switch (af) {
	case AF_INET:
		if (addrflags & IN_IFF_NOTREADY)
			return NOTREADY;
		if (addrflags & IN_IFF_DETACHED)
			return DETACHED;
		break;
	case AF_INET6:
		if (addrflags & IN6_IFF_NOTREADY)
			return NOTREADY;
		if (addrflags & IN6_IFF_DETACHED)
			return DETACHED;
		if (addrflags & IN6_IFF_DEPRECATED)
			return DEPRECATED;
		break;
	}
	return READY;
}

static void
check_addrs(const struct ifa_msghdr *ifam)
{
	const char *cp = (const char *)(ifam + 1);
	const struct sockaddr *sa, *ifa = NULL, *brd = NULL;
	unsigned i;
	struct interface_data *ifd = NULL;
	int aflag;
	enum event ev;

	if (ifam->ifam_addrs == 0)
		return;
	for (i = 1; i; i <<= 1) {
		if ((i & ifam->ifam_addrs) == 0)
			continue;
		sa = (const struct sockaddr *)cp;
		if (i == RTA_IFP) {
			const struct sockaddr_dl *li;

			li = (const struct sockaddr_dl *)sa;
			if ((ifd = find_interface(li->sdl_index)) == NULL) {
				if (verbose)
					printf("ignoring change"
					    " on interface #%d\n",
					    li->sdl_index);
				return;
			}
		} else if (i == RTA_IFA)
			ifa = sa;
		else if (i == RTA_BRD)
			brd = sa;
		RT_ADVANCE(cp, sa);
	}
	if (ifa != NULL && ifd != NULL) {
		ev = ifam->ifam_type == RTM_DELADDR ? DOWN : UP;
		aflag = check_addrflags(ifa->sa_family, ifam->ifam_addrflags);
		if ((ev == UP && aflag == READY) || ev == DOWN)
			invoke_script(ifd->ifname, ev, ifa, brd);
	}
}

static void
invoke_script(const char *ifname, enum event ev,
    const struct sockaddr *sa, const struct sockaddr *dest)
{
	char addr[NI_MAXHOST], daddr[NI_MAXHOST];
	const char *script;
	int status;

	if (ifname == NULL)
		return;

	script = *scripts[ev];
	if (script == NULL)
		return;

	addr[0] = daddr[0] = 0;
	if (sa != NULL) {
		const struct sockaddr_in *sin;
		const struct sockaddr_in6 *sin6;

		if (sa->sa_len == 0) {
			syslog(LOG_ERR,
			    "illegal socket address (sa_len == 0)");
			return;
		}
		switch (sa->sa_family) {
		case AF_INET:
			sin = (const struct sockaddr_in *)sa;
			if (sin->sin_addr.s_addr == INADDR_ANY ||
			    sin->sin_addr.s_addr == INADDR_BROADCAST)
				return;
			break;
		case AF_INET6:
			sin6 = (const struct sockaddr_in6 *)sa;
			if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr))
				return;
			break;
		default:
			break;
		}

		if (getnameinfo(sa, sa->sa_len, addr, sizeof addr, NULL, 0,
		    NI_NUMERICHOST)) {
			if (verbose)
				printf("getnameinfo failed\n");
			return;	/* this address can not be handled */
		}
	}

	if (dest != NULL) {
		if (getnameinfo(dest, dest->sa_len, daddr, sizeof daddr,
		    NULL, 0, NI_NUMERICHOST)) {
			if (verbose)
				printf("getnameinfo failed\n");
			return;	/* this address can not be handled */
		}
	}

	if (verbose)
		(void) printf("calling: %s %s %s %s %s %s\n",
		    script, ifname, DummyTTY, DummySpeed, addr, daddr);
	if (!quiet)
		syslog(LOG_INFO, "calling: %s %s %s %s %s %s\n",
		    script, ifname, DummyTTY, DummySpeed, addr, daddr);

	switch (vfork()) {
	case -1:
		syslog(LOG_ERR, "cannot fork: %m");
		break;
	case 0:
		if (execl(script, script, ifname, DummyTTY, DummySpeed,
		    addr, daddr, NULL) == -1) {
			syslog(LOG_ERR, "could not execute \"%s\": %m",
			    script);
		}
		_exit(EXIT_FAILURE);
	default:
		(void) wait(&status);
	}
}

static void
list_interfaces(const char *ifnames)
{
	char * names = strdup(ifnames);
	char * name, *lasts;
	static const char sep[] = " \t";
	struct interface_data * p;

	for (name = strtok_r(names, sep, &lasts);
	    name != NULL;
	    name = strtok_r(NULL, sep, &lasts)) {
		p = malloc(sizeof(*p));
		SLIST_INSERT_HEAD(&ifs, p, next);
		p->last_carrier_status = -1;
		p->ifname = strdup(name);
		p->index = if_nametoindex(p->ifname);
		if (!quiet)
			syslog(LOG_INFO, "watching interface %s", p->ifname);
		if (verbose)
			printf("interface \"%s\" has index %d\n",
			    p->ifname, p->index);
	}
	free(names);
}

static void
check_carrier(const struct if_msghdr *ifm)
{
	struct interface_data * p;
	int carrier_status;
	enum event ev;

	SLIST_FOREACH(p, &ifs, next)
		if (p->index == ifm->ifm_index)
			break;

	if (p == NULL)
		return;

	/*
	 * Treat it as an event worth handling if:
	 * - the carrier status changed, or
	 * - this is the first time we've been called, and
	 * inhibit_initial is not set
	 */
	carrier_status = ifm->ifm_data.ifi_link_state;
	if (carrier_status != p->last_carrier_status) {
		switch (carrier_status) {
		case LINK_STATE_UP:
			ev = CARRIER;
			break;
		case LINK_STATE_DOWN:
			ev = NO_CARRIER;
			break;
		default:
			if (verbose)
				printf("unknown link status ignored\n");
			return;
		}
		invoke_script(p->ifname, ev, NULL, NULL);
		p->last_carrier_status = carrier_status;
	}
}

static void
do_announce(struct interface_data *ifd,
    unsigned short what, unsigned short index)
{

	switch (what) {
	case IFAN_ARRIVAL:
		ifd->index = index;
		invoke_script(ifd->ifname, ARRIVAL, NULL, NULL);
		break;
	case IFAN_DEPARTURE:
		ifd->index = -1;
		ifd->last_carrier_status = -1;
		invoke_script(ifd->ifname, DEPARTURE, NULL, NULL);
		break;
	default:
		if (verbose)
			(void) printf("unknown announce: what=%d\n", what);
		break;
	}
}

static void
check_announce(const struct if_announcemsghdr *ifan)
{
	struct interface_data * p;
	const char *ifname = ifan->ifan_name;

	SLIST_FOREACH(p, &ifs, next) {
		if (strcmp(p->ifname, ifname) != 0)
			continue;

		do_announce(p, ifan->ifan_what, ifan->ifan_index);
		return;
	}
}

static void
free_interfaces(void)
{
	struct interface_data * p;

	while (!SLIST_EMPTY(&ifs)) {
		p = SLIST_FIRST(&ifs);
		SLIST_REMOVE_HEAD(&ifs, next);
		free(p->ifname);
		free(p);
	}
}

static struct interface_data *
find_interface(int idx)
{
	struct interface_data * p;

	SLIST_FOREACH(p, &ifs, next)
		if (p->index == idx)
			return p;
	return NULL;
}

static void
run_initial_ups(bool do_addrs)
{
	struct interface_data * ifd;
	struct ifaddrs *res = NULL, *p;
	struct sockaddr *ifa;
	const struct if_data *ifi;
	int s, aflag;

	s = socket(AF_INET, SOCK_DGRAM, 0);
	if (s < 0)
		return;

	if (getifaddrs(&res) != 0)
		goto out;

	/* Check if any interfaces vanished */
	SLIST_FOREACH(ifd, &ifs, next) {
		for (p = res; p; p = p->ifa_next) {
			if (strcmp(ifd->ifname, p->ifa_name) != 0)
				continue;
			ifa = p->ifa_addr;
			if (ifa != NULL && ifa->sa_family == AF_LINK)
				break;
		}
		if (p == NULL)
			do_announce(ifd, IFAN_DEPARTURE, ifd->index);
	}

	for (p = res; p; p = p->ifa_next) {
		SLIST_FOREACH(ifd, &ifs, next) {
			if (strcmp(ifd->ifname, p->ifa_name) == 0)
				break;
		}
		if (ifd == NULL)
			continue;

		ifa = p->ifa_addr;
		if (ifa != NULL && ifa->sa_family == AF_LINK &&
		    ifd->index == -1)
			invoke_script(ifd->ifname, ARRIVAL, NULL, NULL);

		if ((p->ifa_flags & IFF_UP) == 0)
			continue;
		if (ifa == NULL)
			continue;
		if (ifa->sa_family == AF_LINK) {
			ifi = (const struct if_data *)p->ifa_data;
			if (ifd->last_carrier_status == ifi->ifi_link_state)
				continue;
			switch (ifi->ifi_link_state) {
			case LINK_STATE_UP:
				invoke_script(ifd->ifname, CARRIER, NULL, NULL);
				break;
			case LINK_STATE_DOWN:
				if (ifd->last_carrier_status == -1)
					break;
				invoke_script(ifd->ifname, CARRIER, NULL, NULL);
				break;
			}
			ifd->last_carrier_status = ifi->ifi_link_state;
			continue;
		}
		if (!do_addrs)
			continue;
		aflag = check_addrflags(ifa->sa_family, p->ifa_addrflags);
		if (aflag != READY)
			continue;
		invoke_script(ifd->ifname, UP, ifa, p->ifa_dstaddr);
	}
	freeifaddrs(res);
out:
	close(s);
}