/*      $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 <[email protected]>.
*
* 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);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.