/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright (c) 1983, 1988, 1993
 *      The Regents of the University of California.  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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgment:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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: src/sbin/routed/main.c,v 1.14 2000/08/11 08:24:38 sheldonh Exp $
 * char copyright[] = "@(#) Copyright (c) 1983, 1988, 1993\n"
 * " The Regents of the University of California.  All rights reserved.\n";
 */

#include "defs.h"
#include "pathnames.h"
#include <signal.h>
#include <fcntl.h>
#include <sys/file.h>
#include <userdefs.h>
#include <sys/stat.h>

#define IN_ROUTED_VERSION       "2.22"

int             stopint;
boolean_t       supplier;       /* supply or broadcast updates */
boolean_t       supplier_set;
/* -S option. _B_TRUE=treat all RIP speakers as default routers. */
boolean_t       save_space = _B_FALSE;

static boolean_t default_gateway;       /* _B_TRUE=advertise default */
static boolean_t background = _B_TRUE;
boolean_t       ridhosts;       /* _B_TRUE=reduce host routes */
boolean_t       mhome;          /* _B_TRUE=want multi-homed host route */
boolean_t       advertise_mhome;  /* _B_TRUE=must continue advertising it */
boolean_t       auth_ok = _B_TRUE; /* _B_TRUE=ignore auth if we don't care */
boolean_t       no_install;     /* _B_TRUE=don't install in kernel */

struct timeval epoch;           /* when started */
struct timeval clk;
static struct timeval prev_clk;
static int usec_fudge;
struct timeval now;             /* current idea of time */
/* If a route's rts_time is <= to now_stale, the route is stale. */
time_t  now_stale;
/* If a route's rts_time is <= to now_expire, the route is expired */
time_t  now_expire;
/* If a route's rts_time is <= to now_garbage, the route needs to be deleted */
time_t  now_garbage;

static struct timeval next_bcast;       /* next general broadcast */
struct timeval no_flash = {             /* inhibit flash update */
        EPOCH+SUPPLY_INTERVAL, 0
};

/* When now reaches this time, it's time to call sync_kern() */
static struct timeval sync_kern_timer;

static fd_set   fdbits;
static int      sock_max;
int             rip_sock = -1;  /* RIP socket */
boolean_t       rip_enabled;
static boolean_t        openlog_done;

/*
 * The interface to which rip_sock is currently pointing for
 * output.
 */
struct interface *rip_sock_interface;

int     rt_sock;                        /* routing socket */


static  int open_rip_sock();
static void timevalsub(struct timeval *, struct timeval *, struct timeval *);
static void     sigalrm(int);
static void     sigterm(int);

int
main(int argc, char *argv[])
{
        int n, off;
        char *p, *q;
        const char *cp;
        struct timeval select_timeout, result;
        fd_set ibits;
        in_addr_t p_net, p_mask;
        struct parm parm;
        char *tracename = NULL;
        boolean_t vflag = _B_FALSE;
        boolean_t version = _B_FALSE;
        int sigerr = 0;
        FILE *pidfp;
        mode_t pidmode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); /* 0644 */

        (void) setlocale(LC_ALL, "");

#if     !defined(TEXT_DOMAIN)   /* Should be defined by cc -D */
#define TEXT_DOMAIN     "SYS_TEXT"
#endif  /* ! TEXT_DOMAIN */

        (void) textdomain(TEXT_DOMAIN);

        /*
         * Some shells are badly broken and send SIGHUP to backgrounded
         * processes.
         */
        if (signal(SIGHUP, SIG_IGN) == SIG_ERR)
                sigerr = errno;

        ftrace = stdout;

        if (gettimeofday(&clk, 0) == -1) {
                logbad(_B_FALSE, "gettimeofday: %s", rip_strerror(errno));
        }
        prev_clk = clk;
        epoch = clk;
        epoch.tv_sec -= EPOCH;
        now.tv_sec = EPOCH;
        now_stale = EPOCH - STALE_TIME;
        now_expire = EPOCH - EXPIRE_TIME;
        now_garbage = EPOCH - GARBAGE_TIME;
        select_timeout.tv_sec = 0;

        while ((n = getopt(argc, argv, "sSqdghmpAztVvnT:F:P:")) != -1) {
                switch (n) {
                case 'A':
                        /*
                         * Ignore authentication if we do not care.
                         * Crazy as it is, that is what RFC 2453 requires.
                         */
                        auth_ok = _B_FALSE;
                        break;

                case 't':
                        if (new_tracelevel < 2)
                                new_tracelevel = 2;
                        background = _B_FALSE;
                        break;

                case 'd':       /* put in.routed in foreground */
                        background = _B_FALSE;
                        break;

                case 'F':               /* minimal routes for SLIP */
                        n = FAKE_METRIC;
                        p = strchr(optarg, ',');
                        if (p != NULL) {
                                n = (int)strtoul(p+1, &q, 0);
                                if (*q == '\0' && p+1 != q &&
                                    n <= HOPCNT_INFINITY-1 && n >= 1)
                                        *p = '\0';
                        }
                        if (!getnet(optarg, &p_net, &p_mask)) {
                                if (p != NULL)
                                        *p = ',';
                                msglog(gettext("bad network; \"-F %s\""),
                                    optarg);
                                break;
                        }
                        (void) memset(&parm, 0, sizeof (parm));
                        parm.parm_net = p_net;
                        parm.parm_mask = p_mask;
                        parm.parm_d_metric = n;
                        cp = insert_parm(&parm);
                        if (cp != NULL)
                                msglog(gettext("bad -F: %s"), cp);
                        break;

                case 'g':
                        (void) memset(&parm, 0, sizeof (parm));
                        parm.parm_d_metric = 1;
                        cp = insert_parm(&parm);
                        if (cp != NULL)
                                msglog(gettext("bad -g: %s"), cp);
                        else
                                default_gateway = _B_TRUE;
                        break;

                case 'h':               /* suppress extra host routes */
                        ridhosts = _B_TRUE;
                        break;

                case 'm':               /* advertise host route */
                        mhome = _B_TRUE;        /* on multi-homed hosts */
                        break;

                case 'n':       /* No-install mode */
                        no_install = _B_TRUE;
                        break;

                case 'P':
                        /* handle arbitrary parameters. */
                        q = strdup(optarg);
                        if (q == NULL)
                                logbad(_B_FALSE, "strdup: %s",
                                    rip_strerror(errno));
                        cp = parse_parms(q, _B_FALSE);
                        if (cp != NULL)
                                msglog(gettext("%1$s in \"-P %2$s\""), cp,
                                    optarg);
                        free(q);
                        break;

                case 'q':
                        supplier = _B_FALSE;
                        supplier_set = _B_TRUE;
                        break;

                case 's':
                        supplier = _B_TRUE;
                        supplier_set = _B_TRUE;
                        break;

                case 'S':       /* save-space option */
                        save_space = _B_TRUE;
                        break;

                case 'T':
                        tracename = optarg;
                        break;

                case 'V':
                        /* display version */
                        version = _B_TRUE;
                        msglog(gettext("version " IN_ROUTED_VERSION));
                        break;

                case 'v':
                        /* display route changes to supplied logfile */
                        new_tracelevel = 1;
                        vflag = _B_TRUE;
                        break;

                case 'z':       /* increase debug-level */
                        new_tracelevel++;
                        break;

                default:
                        goto usage;
                }
        }
        argc -= optind;
        argv += optind;

        if (tracename == NULL && argc >= 1) {
                tracename = *argv++;
                argc--;
        }
        if (tracename != NULL && tracename[0] == '\0')
                goto usage;
        if (vflag && tracename == NULL)
                goto usage;
        if (argc != 0) {
usage:
                (void) fprintf(stderr, gettext(
                    "usage: in.routed [-AdghmnqsStVvz] "
                    "[-T <tracefile>]\n"));
                (void) fprintf(stderr,
                    gettext("\t[-F <net>[/<mask>][,<metric>]] [-P <parms>]\n"));
                logbad(_B_FALSE, gettext("excess arguments"));
        }
        if (geteuid() != 0) {
                /*
                 * Regular users are allowed to run in.routed for the
                 * sole purpose of obtaining the version number.  In
                 * that case, exit(EXIT_SUCCESS) without complaining.
                 */
                if (version)
                        exit(EXIT_SUCCESS);
                logbad(_B_FALSE, gettext("requires UID 0"));
        }

        if (default_gateway) {
                if (supplier_set && !supplier) {
                        msglog(gettext("-g and -q are incompatible"));
                } else {
                        supplier = _B_TRUE;
                        supplier_set = _B_TRUE;
                }
        }

        if (signal(SIGALRM, sigalrm) == SIG_ERR)
                sigerr = errno;
        /* SIGHUP fatal during debugging */
        if (!background)
                if (signal(SIGHUP, sigterm) == SIG_ERR)
                        sigerr = errno;
        if (signal(SIGTERM, sigterm) == SIG_ERR)
                sigerr = errno;
        if (signal(SIGINT, sigterm) == SIG_ERR)
                sigerr = errno;
        if (signal(SIGUSR1, sigtrace_more) == SIG_ERR)
                sigerr = errno;
        if (signal(SIGUSR2, sigtrace_less) == SIG_ERR)
                sigerr = errno;
        if (signal(SIGHUP, sigtrace_dump) == SIG_ERR)
                sigerr = errno;

        if (sigerr)
                msglog("signal: %s", rip_strerror(sigerr));

        /* get into the background */
        if (background && daemon(0, 0) < 0)
                BADERR(_B_FALSE, "daemon()");

        /* Store our process id, blow away any existing file if it exists. */
        if ((pidfp = fopen(PATH_PID, "w")) == NULL) {
                (void) fprintf(stderr,
                    gettext("in.routed: unable to open " PATH_PID ": %s\n"),
                    strerror(errno));
        } else {
                (void) fprintf(pidfp, "%ld\n", getpid());
                (void) fclose(pidfp);
                (void) chmod(PATH_PID, pidmode);
        }

        srandom((int)(clk.tv_sec ^ clk.tv_usec ^ getpid()));

        /* allocate the interface tables */
        iftbl_alloc();

        /* prepare socket connected to the kernel. */
        rt_sock = socket(PF_ROUTE, SOCK_RAW, AF_INET);
        if (rt_sock < 0)
                BADERR(_B_TRUE, "rt_sock = socket()");
        if (fcntl(rt_sock, F_SETFL, O_NONBLOCK) == -1)
                logbad(_B_TRUE, "fcntl(rt_sock) O_NONBLOCK: %s",
                    rip_strerror(errno));
        off = 0;
        if (setsockopt(rt_sock, SOL_SOCKET, SO_USELOOPBACK,
            &off, sizeof (off)) < 0)
                LOGERR("setsockopt(SO_USELOOPBACK,0)");

        fix_select();


        if (tracename != NULL) {
                (void) strlcpy(inittracename, tracename,
                    sizeof (inittracename));
                set_tracefile(inittracename, "%s", -1);
        } else {
                tracelevel_msg("%s", -1);   /* turn on tracing to stdio */
        }

        bufinit();

        /* initialize radix tree */
        rtinit();

        /*
         * Pick a random part of the second for our output to minimize
         * collisions.
         *
         * Start broadcasting after hearing from other routers, and
         * at a random time so a bunch of systems do not get synchronized
         * after a power failure.
         *
         * Since now is the number of seconds since epoch (this is initially
         * EPOCH seconds), these times are really relative to now.
         */
        intvl_random(&next_bcast, EPOCH+MIN_WAITTIME, EPOCH+SUPPLY_INTERVAL);
        age_timer.tv_usec = next_bcast.tv_usec;
        age_timer.tv_sec = EPOCH+MIN_WAITTIME;
        rdisc_timer = next_bcast;
        ifscan_timer.tv_usec = next_bcast.tv_usec;

        /*
         * Open the global rip socket.  From now on, this socket can be
         * assumed to be open.  It will remain open until in.routed
         * exits.
         */
        rip_sock = open_rip_sock();

        /*
         * Collect an initial view of the world by checking the interface
         * configuration and the kludge file.
         *
         * gwkludge() could call addroutefordefault(), resulting in a call to
         * iflookup, and thus ifscan() to find the physical interfaces.
         * ifscan() will attempt to use the rip_sock in order to join
         * mcast groups, so gwkludge *must* be called after opening
         * the rip_sock.
         */
        gwkludge();

        ifscan();

        /* Ask for routes */
        rip_query();
        rdisc_sol();

        /* Now turn off stdio if not tracing */
        if (new_tracelevel == 0)
                trace_close(background);

        /* Loop until a fatal error occurs, listening and broadcasting. */
        for (;;) {
                prev_clk = clk;
                if (gettimeofday(&clk, 0) == -1) {
                        logbad(_B_FALSE, "gettimeofday: %s",
                            rip_strerror(errno));
                }
                if (prev_clk.tv_sec == clk.tv_sec &&
                    prev_clk.tv_usec == clk.tv_usec+usec_fudge) {
                        /*
                         * Much of `in.routed` depends on time always advancing.
                         * On systems that do not guarantee that gettimeofday()
                         * produces unique timestamps even if called within
                         * a single tick, use trickery like that in classic
                         * BSD kernels.
                         */
                        clk.tv_usec += ++usec_fudge;

                } else {
                        time_t dt;

                        usec_fudge = 0;

                        timevalsub(&result, &clk, &prev_clk);
                        if (result.tv_sec < 0 || result.tv_sec >
                            select_timeout.tv_sec + 5) {
                                /*
                                 * Deal with time changes before other
                                 * housekeeping to keep everything straight.
                                 */
                                dt = result.tv_sec;
                                if (dt > 0)
                                        dt -= select_timeout.tv_sec;
                                trace_act("time changed by %d sec", (int)dt);
                                epoch.tv_sec += dt;
                        }
                }
                timevalsub(&now, &clk, &epoch);
                now_stale = now.tv_sec - STALE_TIME;
                now_expire = now.tv_sec - EXPIRE_TIME;
                now_garbage = now.tv_sec - GARBAGE_TIME;

                /* deal with signals that should affect tracing */
                set_tracelevel();

                if (stopint != 0) {
                        trace_off("exiting with signal %d", stopint);
                        break;
                }

                /* look for new or dead interfaces */
                timevalsub(&select_timeout, &ifscan_timer, &now);
                if (select_timeout.tv_sec <= 0) {
                        select_timeout.tv_sec = 0;
                        ifscan();
                        rip_query();
                        continue;
                }

                /*
                 * Check the kernel table occassionally for mysteriously
                 * evaporated routes
                 */
                timevalsub(&result, &sync_kern_timer, &now);
                if (result.tv_sec <= 0) {
                        sync_kern();
                        sync_kern_timer.tv_sec = (now.tv_sec
                            + CHECK_QUIET_INTERVAL);
                        continue;
                }
                if (timercmp(&result, &select_timeout, < /* */))
                        select_timeout = result;

                /* If it is time, then broadcast our routes. */
                if (should_supply(NULL) || advertise_mhome) {
                        timevalsub(&result, &next_bcast, &now);
                        if (result.tv_sec <= 0) {
                                /*
                                 * Synchronize the aging and broadcast
                                 * timers to minimize awakenings
                                 */
                                age(0);
                                age_peer_info();

                                rip_bcast(0);

                                /*
                                 * It is desirable to send routing updates
                                 * regularly.  So schedule the next update
                                 * 30 seconds after the previous one was
                                 * scheduled, instead of 30 seconds after
                                 * the previous update was finished.
                                 * Even if we just started after discovering
                                 * a 2nd interface or were otherwise delayed,
                                 * pick a 30-second aniversary of the
                                 * original broadcast time.
                                 */
                                n = 1 + (0-result.tv_sec)/SUPPLY_INTERVAL;
                                next_bcast.tv_sec += n*SUPPLY_INTERVAL;

                                continue;
                        }

                        if (timercmp(&result, &select_timeout, < /* */))
                                select_timeout = result;
                }

                /*
                 * If we need a flash update, either do it now or
                 * set the delay to end when it is time.
                 *
                 * If we are within MIN_WAITTIME seconds of a full update,
                 * do not bother.
                 */
                if (need_flash && should_supply(NULL) &&
                    no_flash.tv_sec+MIN_WAITTIME < next_bcast.tv_sec) {
                        /* accurate to the millisecond */
                        if (!timercmp(&no_flash, &now, > /* */))
                                rip_bcast(1);
                        timevalsub(&result, &no_flash, &now);
                        if (timercmp(&result, &select_timeout, < /* */))
                                select_timeout = result;
                }

                /* trigger the main aging timer. */
                timevalsub(&result, &age_timer, &now);
                if (result.tv_sec <= 0) {
                        age(0);
                        continue;
                }
                if (timercmp(&result, &select_timeout, < /* */))
                        select_timeout = result;

                /* update the kernel routing table */
                timevalsub(&result, &need_kern, &now);
                if (result.tv_sec <= 0) {
                        age(0);
                        continue;
                }
                if (timercmp(&result, &select_timeout, < /* */))
                        select_timeout = result;

                /*
                 * take care of router discovery.  We compare timeval
                 * structures here to have millisecond granularity.
                 */
                if (!timercmp(&rdisc_timer, &now, > /* */)) {
                        rdisc_age(0);
                        continue;
                }
                timevalsub(&result, &rdisc_timer, &now);
                if (timercmp(&result, &select_timeout, < /* */))
                        select_timeout = result;

                /*
                 * Well-known bit of select(3c) silliness inherited
                 * from BSD: anything over 100 million seconds is
                 * considered an "error."  Reset that to zero.
                 */
                if (select_timeout.tv_sec > 100000000)
                        select_timeout.tv_sec = 0;

                /* wait for input or a timer to expire. */
                trace_flush();
                ibits = fdbits;
                n = select(sock_max, &ibits, 0, 0, &select_timeout);
                if (n <= 0) {
                        if (n < 0 && errno != EINTR && errno != EAGAIN)
                                BADERR(_B_TRUE, "select");
                        continue;
                }

                if (FD_ISSET(rt_sock, &ibits)) {
                        read_rt();
                        n--;
                }
                if (rdisc_sock >= 0 && FD_ISSET(rdisc_sock, &ibits)) {
                        read_d();
                        n--;
                }
                if (rdisc_mib_sock >= 0 && FD_ISSET(rdisc_mib_sock, &ibits)) {
                        process_d_mib_sock();
                        n--;
                }
                if (rip_sock >= 0 && FD_ISSET(rip_sock, &ibits)) {
                        if (read_rip() == -1) {
                                rip_enabled = _B_FALSE;
                                trace_off("main rip socket failed");
                                (void) close(rip_sock);
                                rip_sock = -1;
                                fix_select();
                                break;
                        }
                        n--;
                }
        }
        rip_bcast(0);
        rdisc_adv(_B_FALSE);
        (void) unlink(PATH_PID);
        return (stopint | 128);
}


static void
sigalrm(int sig)
{
        /*
         * Historically, SIGALRM would cause the daemon to check for
         * new and broken interfaces.
         */
        ifscan_timer.tv_sec = now.tv_sec;
        trace_act("SIGALRM");
        if (signal(sig, sigalrm) == SIG_ERR)
                msglog("signal: %s", rip_strerror(errno));
}


/* watch for fatal signals */
static void
sigterm(int sig)
{
        stopint = sig;
        if (signal(sig, SIG_DFL) == SIG_ERR)    /* catch it only once */
                msglog("signal: %s", rip_strerror(errno));
}


void
fix_select(void)
{
        (void) FD_ZERO(&fdbits);
        sock_max = 0;

        FD_SET(rt_sock, &fdbits);
        if (sock_max <= rt_sock)
                sock_max = rt_sock+1;
        if (rip_sock >= 0) {
                FD_SET(rip_sock, &fdbits);
                if (sock_max <= rip_sock)
                        sock_max = rip_sock+1;
        }
        if (rdisc_sock >= 0) {
                FD_SET(rdisc_sock, &fdbits);
                if (sock_max <= rdisc_sock)
                        sock_max = rdisc_sock+1;
                FD_SET(rdisc_mib_sock, &fdbits);
                if (sock_max <= rdisc_mib_sock)
                        sock_max = rdisc_mib_sock+1;
        }
}


void
fix_sock(int sock,
    const char *name)
{
        int on;
#define MIN_SOCKBUF (4*1024)
        static int rbuf;

        if (fcntl(sock, F_SETFL, O_NONBLOCK) == -1)
                logbad(_B_TRUE, "fcntl(%s) O_NONBLOCK: %s", name,
                    rip_strerror(errno));
        on = 1;
        if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &on, sizeof (on)) < 0)
                msglog("setsockopt(%s,SO_BROADCAST): %s",
                    name, rip_strerror(errno));

        if (rbuf >= MIN_SOCKBUF) {
                if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF,
                    &rbuf, sizeof (rbuf)) < 0)
                        msglog("setsockopt(%s,SO_RCVBUF=%d): %s",
                            name, rbuf, rip_strerror(errno));
        } else {
                for (rbuf = 60*1024; ; rbuf -= 4096) {
                        if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF,
                            &rbuf, sizeof (rbuf)) == 0) {
                                trace_act("RCVBUF=%d", rbuf);
                                break;
                        }
                        if (rbuf < MIN_SOCKBUF) {
                                msglog("setsockopt(%s,SO_RCVBUF = %d): %s",
                                    name, rbuf, rip_strerror(errno));
                                break;
                        }
                }
        }
}


/*
 * Open and return the global rip socket.  It is guaranteed to return
 * a good file descriptor.
 */
static int
open_rip_sock()
{
        struct sockaddr_in sin;
        unsigned char ttl;
        int s;
        int on = 1;


        if ((s = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
                BADERR(_B_TRUE, "rip_sock = socket()");

        (void) memset(&sin, 0, sizeof (sin));
        sin.sin_family = AF_INET;
        sin.sin_port = htons(RIP_PORT);
        sin.sin_addr.s_addr = INADDR_ANY;
        if (bind(s, (struct sockaddr *)&sin, sizeof (sin)) < 0) {
                BADERR(_B_FALSE, "bind(rip_sock)");
        }
        fix_sock(s, "rip_sock");

        ttl = 1;
        if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL,
            &ttl, sizeof (ttl)) < 0)
                DBGERR(_B_TRUE, "rip_sock setsockopt(IP_MULTICAST_TTL)");

        if (setsockopt(s, IPPROTO_IP, IP_RECVIF, &on, sizeof (on)))
                BADERR(_B_FALSE, "setsockopt(IP_RECVIF)");

        return (s);
}


/*
 * Disable RIP.  Note that we don't close the global rip socket since
 * it is used even when RIP is disabled to receive and answer certain
 * queries.
 */
void
rip_off(void)
{
        struct ip_mreq m;
        struct interface *ifp;
        char addrstr[INET_ADDRSTRLEN];

        if (rip_enabled && !mhome) {
                trace_act("turn off RIP");

                /*
                 * Unsubscribe from the 224.0.0.9  RIP multicast
                 * group address
                 */
                for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) {
                        if ((ifp->int_if_flags & IFF_MULTICAST) &&
                            !IS_IFF_QUIET(ifp->int_if_flags) &&
                            !IS_RIP_IN_OFF(ifp->int_state) &&
                            !(ifp->int_state & IS_DUP)) {
                                m.imr_multiaddr.s_addr =
                                    htonl(INADDR_RIP_GROUP);
                                m.imr_interface.s_addr =
                                    (ifp->int_if_flags & IFF_POINTOPOINT) ?
                                    ifp->int_dstaddr : ifp->int_addr;
                                (void) strlcpy(addrstr,
                                    inet_ntoa(m.imr_multiaddr),
                                    sizeof (addrstr));
                                if (setsockopt(rip_sock, IPPROTO_IP,
                                    IP_DROP_MEMBERSHIP, &m,
                                    sizeof (m)) < 0 &&
                                    errno != EADDRNOTAVAIL && errno != ENOENT)
                                        writelog(LOG_WARNING,
                                            "%s: setsockopt(IP_DROP_MEMBERSHIP "
                                            "%s, %s): %s", ifp->int_name,
                                            addrstr, inet_ntoa(m.imr_interface),
                                            rip_strerror(errno));
                        }
                }
                rip_enabled = _B_FALSE;

                age(0);
        }
}


/* turn on RIP multicast input via an interface */
void
rip_mcast_on(struct interface *ifp)
{
        struct ip_mreq m;

        if (!IS_RIP_IN_OFF(ifp->int_state) &&
            (ifp->int_if_flags & IFF_MULTICAST) &&
            !IS_IFF_QUIET(ifp->int_if_flags) &&
            !(ifp->int_state & IS_DUP)) {
                m.imr_multiaddr.s_addr = htonl(INADDR_RIP_GROUP);
                m.imr_interface.s_addr = (ifp->int_if_flags & IFF_POINTOPOINT) ?
                    ifp->int_dstaddr : ifp->int_addr;
                if ((setsockopt(rip_sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
                    &m, sizeof (m)) < 0) && !(ifp->int_state & IS_BROKE))
                        writelog(LOG_WARNING,
                            "Could not join 224.0.0.9 on interface %s: %s",
                            ifp->int_name, rip_strerror(errno));
        }
}

/* turn off RIP multicast input via an interface */
void
rip_mcast_off(struct interface *ifp)
{
        struct ip_mreq m;

        if ((ifp->int_if_flags & IFF_MULTICAST) &&
            !IS_IFF_QUIET(ifp->int_if_flags) && rip_enabled) {
                m.imr_multiaddr.s_addr = htonl(INADDR_RIP_GROUP);
                m.imr_interface.s_addr = (ifp->int_if_flags & IFF_POINTOPOINT) ?
                    ifp->int_dstaddr : ifp->int_addr;
                if ((setsockopt(rip_sock, IPPROTO_IP, IP_DROP_MEMBERSHIP,
                    &m, sizeof (m)) < 0) && errno != EADDRNOTAVAIL &&
                    errno != ENOENT)
                        writelog(LOG_WARNING,
                            "setsockopt(IP_DROP_MEMBERSHIP RIP) for %s: %s",
                            ifp->int_name, rip_strerror(errno));
        }
}

/* enable RIP */
void
rip_on(struct interface *ifp)
{
        /*
         * If RIP is already enabled, only start receiving
         * multicasts for this interface.
         */
        if (rip_enabled) {
                if (ifp != NULL)
                        rip_mcast_on(ifp);
                return;
        }

        /*
         * If RIP is disabled and it makes sense to enable it, then enable
         * it on all of the interfaces.  It makes sense if either router
         * discovery is off, or if router discovery is on and at most one
         * interface is doing RIP.
         */
        if (rip_interfaces > 0 && (!rdisc_ok || rip_interfaces > 1)) {
                trace_act("turn on RIP");

                rip_enabled = _B_TRUE;
                rip_sock_interface = NULL;

                /* Do not advertise anything until we have heard something */
                if (next_bcast.tv_sec < now.tv_sec+MIN_WAITTIME)
                        next_bcast.tv_sec = now.tv_sec+MIN_WAITTIME;

                for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) {
                        ifp->int_query_time = NEVER;
                        rip_mcast_on(ifp);
                }
                ifscan_timer.tv_sec = now.tv_sec;
        }

        fix_select();
}


/* die if malloc(3) fails */
void *
rtmalloc(size_t size,
    const char *msg)
{
        void *p = malloc(size);
        if (p == NULL)
                logbad(_B_TRUE, "malloc(%lu) failed in %s: %s", (ulong_t)size,
                    msg, rip_strerror(errno));
        return (p);
}


/* get a random instant in an interval */
void
intvl_random(struct timeval *tp,        /* put value here */
    ulong_t lo,                 /* value is after this second */
    ulong_t hi)                 /* and before this */
{
        tp->tv_sec = (time_t)(hi == lo ? lo : (lo + random() % ((hi - lo))));
        tp->tv_usec = random() % 1000000;
}


void
timevaladd(struct timeval *t1,
    struct timeval *t2)
{

        t1->tv_sec += t2->tv_sec;
        if ((t1->tv_usec += t2->tv_usec) >= 1000000) {
                t1->tv_sec++;
                t1->tv_usec -= 1000000;
        }
}


/* t1 = t2 - t3 */
static void
timevalsub(struct timeval *t1,
    struct timeval *t2,
    struct timeval *t3)
{
        t1->tv_sec = t2->tv_sec - t3->tv_sec;
        if ((t1->tv_usec = t2->tv_usec - t3->tv_usec) < 0) {
                t1->tv_sec--;
                t1->tv_usec += 1000000;
        }
}

static void
do_openlog(void)
{
        openlog_done = _B_TRUE;
        openlog("in.routed", LOG_PID | LOG_ODELAY, LOG_DAEMON);
}

/* put a LOG_ERR message into the system log */
void
msglog(const char *p, ...)
{
        va_list args;

        trace_flush();

        if (!openlog_done)
                do_openlog();
        va_start(args, p);
        vsyslog(LOG_ERR, p, args);

        if (ftrace != 0) {
                if (ftrace == stdout)
                        (void) fputs("in.routed: ", ftrace);
                (void) vfprintf(ftrace, p, args);
                (void) fputc('\n', ftrace);
        }
}


/*
 * Put a message about a bad system into the system log if
 * we have not complained about it recently.
 *
 * It is desirable to complain about all bad systems, but not too often.
 * In the worst case, it is not practical to keep track of all bad systems.
 * For example, there can be many systems with the wrong password.
 */
void
msglim(struct msg_limit *lim, in_addr_t addr, const char *p, ...)
{
        va_list args;
        int i;
        struct msg_sub *ms1, *ms;
        const char *p1;

        va_start(args, p);

        /*
         * look for the oldest slot in the table
         * or the slot for the bad router.
         */
        ms = ms1 = lim->subs;
        for (i = MSG_SUBJECT_N; ; i--, ms1++) {
                if (i == 0) {
                        /* Reuse a slot at most once every 10 minutes. */
                        if (lim->reuse > now.tv_sec) {
                                ms = NULL;
                        } else {
                                lim->reuse = now.tv_sec + 10*60;
                        }
                        break;
                }
                if (ms->addr == addr) {
                        /*
                         * Repeat a complaint about a given system at
                         * most once an hour.
                         */
                        if (ms->until > now.tv_sec)
                                ms = NULL;
                        break;
                }
                if (ms->until < ms1->until)
                        ms = ms1;
        }
        if (ms != NULL) {
                ms->addr = addr;
                ms->until = now.tv_sec + 60*60; /* 60 minutes */

                if (!openlog_done)
                        do_openlog();
                trace_flush();
                for (p1 = p; *p1 == ' '; p1++)
                        continue;
                vsyslog(LOG_ERR, p1, args);
        }

        /* always display the message if tracing */
        if (ftrace != 0) {
                (void) vfprintf(ftrace, p, args);
                (void) fputc('\n', ftrace);
        }
}


void
logbad(boolean_t dump, const char *p, ...)
{
        va_list args;

        trace_flush();

        if (!openlog_done)
                do_openlog();
        va_start(args, p);
        vsyslog(LOG_ERR, p, args);

        (void) fputs(gettext("in.routed: "), stderr);
        (void) vfprintf(stderr, p, args);
        (void) fputs(gettext("; giving up\n"), stderr);
        (void) fflush(stderr);

        if (dump)
                abort();
        exit(EXIT_FAILURE);
}

/* put a message into the system log */
void
writelog(int level, const char *p, ...)
{
        va_list args;

        trace_flush();

        if (!openlog_done)
                do_openlog();
        va_start(args, p);
        vsyslog(level, p, args);

        if (ftrace != 0) {
                if (ftrace == stdout)
                        (void) fputs("in.routed: ", ftrace);
                (void) vfprintf(ftrace, p, args);
                (void) fputc('\n', ftrace);
        }
}