dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / cmd / cmd-inet / usr.sbin / in.routed / if.c

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright (c) 1983, 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/if.c,v 1.8 2000/08/11 08:24:38 sheldonh Exp $
 */

#include "defs.h"
#include "pathnames.h"
#include <sys/sockio.h>
#include <inet/ip.h>
#include <kstat.h>
#include <stropts.h>
#include <fcntl.h>
#include <stddef.h>
#include <assert.h>

/* linked list of all interfaces */
struct interface *ifnet;

/*
 * Acceptable sizes (in number of interfaces) for the interface hash
 * tables.  These must all be prime.  The interface hash tables all
 * start with a size of hash_table_sizes[0], and increase as needed.
 */
size_t hash_table_sizes[] = { 67, 131, 257, 521, 1031, 2053, 4099, 0 };

struct htbl {
        void            **htbl_ptrs;
        uint_t          (*htbl_hash)(const void *, size_t);
        size_t          htbl_link_off;  /* offset of the linkage structure */
        size_t          htbl_key_off;   /* offset of the key value (rehash) */
        size_t          htbl_size;      /* size of the hash */
        uint_t          htbl_size_index;
        uint_t          htbl_ifcount;   /* count of entries */
        boolean_t       htbl_grow;      /* growth allowed */
};

/* Get first element -- for iteration */
#define HFIRST(htbl, arg) \
        ((htbl)->htbl_ptrs[(htbl)->htbl_hash((arg), 0) % (htbl)->htbl_size])

/* Add an element to a hash */
#define HADD(htbl, strp) \
        hash_link((htbl), (htbl)->htbl_hash((strp), (htbl)->htbl_key_off), \
            (strp))

uint_t  tot_interfaces;                 /* # of remote and local interfaces */
uint_t  rip_interfaces;                 /* # of interfaces doing RIP */
uint_t  ripout_interfaces;              /* # of interfaces advertising RIP */
uint_t  fwd_interfaces;                 /* # of interfaces ip_forwarding=1 */
static boolean_t foundloopback;         /* valid flag for loopaddr */
in_addr_t       loopaddr;               /* our address on loopback */
static struct   rt_spare loop_rts;

struct timeval ifscan_timer;
static struct timeval last_ifscan;
#define IF_RESCAN_DELAY() \
        (last_ifscan.tv_sec == now.tv_sec && \
            last_ifscan.tv_usec == now.tv_usec && \
            timercmp(&ifscan_timer, &now, > /* */))

boolean_t               have_ripv1_out; /* have a RIPv1 interface */
static boolean_t        have_ripv1_in;

static void             if_bad(struct interface *, boolean_t);
static boolean_t        addrouteforif(struct interface *);
static int      get_if_kstats(struct interface *, struct phyi_data *);
static uint_t   ahash(const void *, uint_t);
static uint_t   ihash(const void *, uint_t);
static uint_t   nhash(const void *, uint_t);
static void     htbl_grow(struct htbl *);

/*
 * Table of all interfaces, hashed by interface address.  For remote
 * interfaces, the gateway address is used.
 */
static struct htbl ahash_tbl = {
    NULL, ahash, offsetof(struct interface, int_ahash),
    offsetof(struct interface, int_addr),
    0, 0, 0, _B_TRUE };
/*
 * Table of broadcast capable interfaces, hashed by interface broadcast
 * address.
 */
static struct htbl bhash_tbl = {
    NULL, ahash, offsetof(struct interface, int_bhash),
    offsetof(struct interface, int_brdaddr),
    0, 0, 0, _B_TRUE };
/*
 * Table of physical_interface structures (lists of interfaces by ifIndex),
 * hashed by interface index.
 */
static struct htbl ihash_tbl = {
    NULL, ihash, offsetof(struct physical_interface, phyi_link),
    offsetof(struct physical_interface, phyi_index),
    0, 0, 0, _B_TRUE };
/*
 * Table of all interfaces, hashed by interface name.
 */
static struct htbl nhash_tbl = {
    NULL, nhash, offsetof(struct interface, int_nhash),
    offsetof(struct interface, int_name),
    0, 0, 0, _B_TRUE };

static struct physical_interface dummy_phyi;
struct interface dummy_ifp;

/* Hash based on an IP address. */
static uint_t
ahash(const void *arg, size_t voffs)
{
        /* LINTED */
        return ((uint_t)*(const in_addr_t *)((const char *)arg + voffs));
}

static uint_t
ihash(const void *arg, size_t voffs)
{
        /* LINTED */
        return ((uint_t)*(const uint32_t *)((const char *)arg + voffs));
}

static uint_t
nhash(const void *arg, size_t voffs)
{
        const char *cp = (const char *)arg + voffs;
        uint_t i;

        for (i = 0; *cp != '\0'; cp++) {
                i = ((i<<1) & 0x7fffffff) | ((i>>30) & 0x00000003);
                i ^= *cp;
        }
        return (i);
}

/*
 * Add an element to the head of the list.
 */
static void
link_in(void **head, void *strp, size_t loffs)
{
        struct hlinkage *hlp;

        /* LINTED: alignment known to be good. */
        hlp = (struct hlinkage *)((char *)strp + loffs);
        hlp->hl_prev = head;
        if ((hlp->hl_next = *head) != NULL) {
                /* LINTED */
                ((struct hlinkage *)((char *)*head + loffs))->hl_prev =
                    &hlp->hl_next;
        }
        *head = strp;
}

/* Remove from a list */
static void
link_out(void *strp, size_t loffs)
{
        struct hlinkage *hlp;

        /* LINTED: alignment known to be good. */
        hlp = (struct hlinkage *)((char *)strp + loffs);
        if ((*hlp->hl_prev = hlp->hl_next) != NULL) {
                /* LINTED */
                ((struct hlinkage *)((char *)hlp->hl_next + loffs))->hl_prev =
                    hlp->hl_prev;
        }
}

/* Add to a hash */
static void
hash_link(struct htbl *htbl, uint_t hval, void *strp)
{
        void **hep;

        if (htbl->htbl_grow && htbl->htbl_ifcount >= htbl->htbl_size * 5)
                htbl_grow(htbl);

        hep = &htbl->htbl_ptrs[hval % htbl->htbl_size];
        link_in(hep, strp, htbl->htbl_link_off);
        htbl->htbl_ifcount++;
}

/* Remove from a hash */
static void
hash_unlink(struct htbl *htbl, void *strp)
{
        link_out(strp, htbl->htbl_link_off);
        htbl->htbl_ifcount--;
}

static void
dummy_ifp_init(void)
{
        dummy_phyi.phyi_interface = &dummy_ifp;
        dummy_ifp.int_phys = &dummy_phyi;
        (void) strcpy(dummy_phyi.phyi_name, "wildcard");
        (void) strcpy(dummy_ifp.int_name, "wildcard");
        dummy_ifp.int_dstaddr = dummy_ifp.int_addr = INADDR_NONE;
        dummy_ifp.int_mask = IP_HOST_MASK;
        dummy_ifp.int_metric = HOPCNT_INFINITY;
        dummy_ifp.int_state = (IS_BROKE|IS_PASSIVE|IS_NO_RIP|IS_NO_RDISC);
        dummy_ifp.int_std_mask = std_mask(dummy_ifp.int_addr);
        dummy_ifp.int_std_net = dummy_ifp.int_net & dummy_ifp.int_std_mask;
        dummy_ifp.int_std_addr = htonl(dummy_ifp.int_std_net);
}

/* allocate the interface hash tables */
void
iftbl_alloc(void)
{
        size_t initial_size = hash_table_sizes[0];

        errno = 0;
        ahash_tbl.htbl_ptrs = calloc(initial_size, sizeof (void *));
        bhash_tbl.htbl_ptrs = calloc(initial_size, sizeof (void *));
        ihash_tbl.htbl_ptrs = calloc(initial_size, sizeof (void *));
        nhash_tbl.htbl_ptrs = calloc(initial_size, sizeof (void *));

        if (errno != 0)
                BADERR(_B_FALSE, "Unable to allocate interface tables");

        ahash_tbl.htbl_size = initial_size;
        bhash_tbl.htbl_size = initial_size;
        ihash_tbl.htbl_size = initial_size;
        nhash_tbl.htbl_size = initial_size;

        dummy_ifp_init();
}


static void
htbl_grow(struct htbl *htbl)
{
        void *strp;
        void **new_ptrs, **saved_old_ptrs, **old_ptrs;
        size_t new_size, old_size;
        static uint_t failed_count;

        if ((new_size = hash_table_sizes[htbl->htbl_size_index + 1]) == 0)
                return;

        if ((new_ptrs = calloc(new_size, sizeof (void *))) == NULL) {
                /*
                 * This is not fatal since we already have a
                 * functional, yet crowded, interface table.
                 */
                if (++failed_count % 100 == 1)
                        msglog("%sunable to grow interface hash table: %s",
                            failed_count > 1 ? "Still " : "",
                            rip_strerror(errno));
                return;
        }

        failed_count = 0;

        saved_old_ptrs = old_ptrs = htbl->htbl_ptrs;
        old_size = htbl->htbl_size;
        htbl->htbl_ptrs = new_ptrs;
        htbl->htbl_size = new_size;
        htbl->htbl_size_index++;
        htbl->htbl_ifcount = 0;

        /*
         * Go through the list of structures, and re-link each into
         * this new table.
         */
        htbl->htbl_grow = _B_FALSE;
        while (old_size-- > 0) {
                strp = *old_ptrs++;
                HADD(htbl, strp);
        }

        htbl->htbl_grow = _B_TRUE;
        free(saved_old_ptrs);
}

/* Link a new interface into the lists and hash tables. */
void
if_link(struct interface *ifp, uint32_t ifindex)
{
        struct physical_interface *phyi;

        link_in((void **)&ifnet, ifp, offsetof(struct interface, int_link));

        HADD(&ahash_tbl, ifp);
        HADD(&nhash_tbl, ifp);

        if (ifp->int_if_flags & IFF_BROADCAST)
                HADD(&bhash_tbl, ifp);

        if (ifindex != 0) {
                for (phyi = HFIRST(&ihash_tbl, &ifindex);
                    phyi != NULL; phyi = phyi->phyi_link.hl_next) {
                        if (phyi->phyi_index == ifindex)
                                break;
                }
                if (phyi == NULL) {
                        size_t size;

                        phyi = rtmalloc(sizeof (*phyi), "physical_interface");
                        (void) memset(phyi, 0, sizeof (*phyi));
                        phyi->phyi_index = ifindex;
                        /* LINTED */
                        assert(IF_NAME_LEN >= IF_NAMESIZE);

                        size = strcspn(ifp->int_name, ":");
                        (void) strncpy(phyi->phyi_name, ifp->int_name,
                            size);
                        phyi->phyi_name[size] = '\0';
                        HADD(&ihash_tbl, phyi);
                }
                link_in((void **)&phyi->phyi_interface, ifp,
                    offsetof(struct interface, int_ilist));
                ifp->int_phys = phyi;
        }
}

/* Find the interface with an address */
struct interface *
ifwithaddr(in_addr_t addr,
    boolean_t bcast,    /* notice IFF_BROADCAST address */
    boolean_t remote)   /* include IS_REMOTE interfaces */
{
        struct interface *ifp, *possible = NULL;
        uint32_t remote_state;

        remote_state = (!remote ? IS_REMOTE : 0);

        for (ifp = HFIRST(&ahash_tbl, &addr); ifp != NULL;
            ifp = ifp->int_ahash.hl_next) {
                if (ifp->int_addr != addr)
                        continue;
                if (ifp->int_state & remote_state)
                        continue;
                if (!(ifp->int_state & (IS_BROKE | IS_PASSIVE)))
                        return (ifp);
                possible = ifp;
        }

        if (possible != NULL || !bcast)
                return (possible);

        for (ifp = HFIRST(&bhash_tbl, &addr); ifp != NULL;
            ifp = ifp->int_bhash.hl_next) {
                if (ifp->int_brdaddr != addr)
                        continue;
                if (ifp->int_state & remote_state)
                        continue;
                if (!(ifp->int_state & (IS_BROKE | IS_PASSIVE)))
                        return (ifp);
                possible = ifp;
        }

        return (possible);
}


/* find the interface with the specified name ("hme0" for example) */
struct interface *
ifwithname(const char *name)
{
        struct interface *ifp;

        for (;;) {
                for (ifp = HFIRST(&nhash_tbl, name); ifp != NULL;
                    ifp = ifp->int_nhash.hl_next) {
                        if (strcmp(ifp->int_name, name) == 0)
                                return (ifp);
                }

                /*
                 * If there is no known interface, maybe there is a
                 * new interface.  So just once look for new interfaces.
                 */
                if (IF_RESCAN_DELAY())
                        return (NULL);
                ifscan();
        }
}

/* Return physical interface with the specified name */
struct physical_interface *
phys_byname(const char *name)
{
        int nlen;
        size_t i;
        struct physical_interface *phyi;

        nlen = strcspn(name, ":");
        for (i = 0; i < ihash_tbl.htbl_size; i++) {
                for (phyi = ihash_tbl.htbl_ptrs[i]; phyi != NULL;
                    phyi = phyi->phyi_link.hl_next) {
                        if (strncmp(phyi->phyi_name, name, nlen) == 0 &&
                            phyi->phyi_name[nlen] == '\0')
                                return (phyi);
                }
        }
        return (NULL);
}

struct interface *
findremoteif(in_addr_t addr)
{
        struct interface *ifp;

        for (ifp = HFIRST(&ahash_tbl, &addr); ifp != NULL;
            ifp = ifp->int_ahash.hl_next) {
                if ((ifp->int_state & IS_REMOTE) && ifp->int_addr == addr)
                        return (ifp);
        }

        return (NULL);
}

struct interface *
findifaddr(in_addr_t addr)
{
        struct interface *ifp;

        for (ifp = HFIRST(&ahash_tbl, &addr); ifp != NULL;
            ifp = ifp->int_ahash.hl_next) {
                if (ifp->int_addr == addr)
                        return (ifp);
        }

        return (NULL);
}

/*
 * Return the first interface with the given index.
 */
struct interface *
ifwithindex(ulong_t index,
    boolean_t rescan_ok)
{
        struct physical_interface *phyi;

        for (;;) {
                for (phyi = HFIRST(&ihash_tbl, &index); phyi != NULL;
                    phyi = phyi->phyi_link.hl_next) {
                        if (phyi->phyi_index == index)
                                return (phyi->phyi_interface);
                }

                /*
                 * If there is no known interface, maybe there is a
                 * new interface.  So just once look for new interfaces.
                 */
                if (!rescan_ok || IF_RESCAN_DELAY())
                        return (NULL);
                rescan_ok = _B_FALSE;
                ifscan();
        }
}

/*
 * Returns true only if given ifp has the exact address else returns
 * false and sets best if an ifp matches partially and is a better
 * match than the previous one passed via best.
 */
boolean_t
addr_on_ifp(in_addr_t addr, struct interface *ifp,
    struct interface **best)
{
        struct interface *p_best = *best;

        /*
         * Don't use a duplicate interface since it is unusable for output.
         */
        if (ifp->int_state & IS_DUP)
                return (_B_FALSE);

        if (ifp->int_if_flags & IFF_POINTOPOINT) {
                if (ifp->int_dstaddr == addr) {
                        *best = NULL;
                        return (_B_TRUE);
                }
        } else {
                if (ifp->int_addr == addr) {
                        if (IS_PASSIVE_IFP(ifp))
                                trace_misc("addr_on_ifp "
                                    "returning passive intf %s",
                                    ifp->int_name);
                        *best = NULL;
                        return (_B_TRUE);
                }

                /* Look for the longest approximate match. */
                if (on_net(addr, ifp->int_net, ifp->int_mask) &&
                    (p_best == NULL ||
                    ifp->int_mask > p_best->int_mask)) {
                        *best = ifp;
                }
        }
        return (_B_FALSE);
}

/*
 * Find an interface which should be receiving packets sent from the
 * given address.  Used as a last ditch effort for figuring out which
 * interface a packet came in on.  Also used for finding out which
 * interface points towards the gateway of static routes learned from
 * the kernel.
 */
struct interface *
iflookup(in_addr_t addr)
{
        struct interface *ifp, *maybe;

        maybe = NULL;
        for (;;) {
                for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) {

                        /* Exact match found */
                        if (addr_on_ifp(addr, ifp, &maybe))
                                return (ifp);
                }

                /*
                 * If there is no known interface, maybe there is a
                 * new interface.  So just once look for new interfaces.
                 */
                if (maybe == NULL && !IF_RESCAN_DELAY())
                        ifscan();
                else
                        break;
        }

        if (maybe != NULL && IS_PASSIVE_IFP(maybe)) {
                trace_misc("iflookup returning passive intf %s",
                    maybe->int_name);
        }
        return (maybe);
}

/*
 * Find the netmask that would be inferred by RIPv1 listeners
 *      on the given interface for a given network.
 *      If no interface is specified, look for the best fitting interface.
 */
in_addr_t
ripv1_mask_net(in_addr_t addr,  /* in network byte order */
    const struct interface *ifp)        /* as seen on this interface */
{
        const struct r1net *r1p;
        in_addr_t mask = 0;

        if (addr == 0)                  /* default always has 0 mask */
                return (mask);

        if (ifp != NULL && ifp->int_ripv1_mask != HOST_MASK) {
                /*
                 * If the target network is that of the associated interface
                 * on which it arrived, then use the netmask of the interface.
                 */
                if (on_net(addr, ifp->int_net, ifp->int_std_mask))
                        mask = ifp->int_ripv1_mask;

        } else {
                /*
                 * Examine all interfaces, and if it the target seems
                 * to have the same network number of an interface, use the
                 * netmask of that interface.  If there is more than one
                 * such interface, prefer the interface with the longest
                 * match.
                 */
                for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) {
                        if (on_net(addr, ifp->int_std_net, ifp->int_std_mask) &&
                            ifp->int_ripv1_mask > mask &&
                            ifp->int_ripv1_mask != HOST_MASK)
                                mask = ifp->int_ripv1_mask;
                }

        }

        if (mask == 0) {
                /*
                 * Check to see if the user has supplied an applicable
                 * netmask as a ripv1_mask option in /etc/gateways.
                 */
                for (r1p = r1nets; r1p != NULL; r1p = r1p->r1net_next) {
                        /*
                         * If the address is is on a matching network
                         * and we haven't already found a longer match,
                         * use the matching netmask.
                         */
                        if (on_net(addr, r1p->r1net_net, r1p->r1net_match) &&
                            r1p->r1net_mask > mask)
                                mask = r1p->r1net_mask;
                }

                /* Otherwise, make the classic A/B/C guess. */
                if (mask == 0)
                        mask = std_mask(addr);
        }

        return (mask);
}


in_addr_t
ripv1_mask_host(in_addr_t addr,         /* in network byte order */
    const struct interface *ifp)        /* as seen on this interface */
{
        in_addr_t mask = ripv1_mask_net(addr, ifp);


        /*
         * If the computed netmask does not mask all of the set bits
         * in the address, then assume it is a host address
         */
        if ((ntohl(addr) & ~mask) != 0)
                mask = HOST_MASK;
        return (mask);
}


/* See if a IP address looks reasonable as a destination */
boolean_t                       /* _B_FALSE=bad _B_TRUE=good */
check_dst(in_addr_t addr)
{
        addr = ntohl(addr);

        if (IN_CLASSA(addr)) {
                if (addr == 0)
                        return (_B_TRUE);       /* default */

                addr >>= IN_CLASSA_NSHIFT;
                return (addr != 0 && addr != IN_LOOPBACKNET);
        }

        /* Must not allow destination to be link local address. */
        if (IN_LINKLOCAL(addr))
                return (_B_FALSE);

        if (IN_CLASSB(addr) || IN_CLASSC(addr))
                return (_B_TRUE);

        if (IN_CLASSD(addr))
                return (_B_FALSE);

        return (_B_TRUE);

}

/*
 * Find an existing interface which has the given parameters, but don't
 * return the interface with name "name" if "name" is specified.
 */
struct interface *
check_dup(const char *name,     /* Don't return this interface */
    in_addr_t addr,     /* IP address, so network byte order */
    in_addr_t dstaddr,  /* ditto */
    in_addr_t mask,     /* mask, so host byte order */
    uint64_t if_flags,  /* set IFF_POINTOPOINT to ignore local int_addr */
    boolean_t allowdups)        /* set true to include duplicates */
{
        struct interface *best_ifp = NULL;
        struct interface *ifp;
        in_addr_t dstaddr_h = ntohl(dstaddr);
        int best_pref = 0;
        int pref;

        for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) {
                /* This interface, not a duplicate. */
                if (name != NULL && strcmp(name, ifp->int_name) == 0)
                        continue;

                /*
                 * Find an interface which isn't already a duplicate to
                 * avoid cyclical duplication.  (i.e. qfe0:1 is a duplicate
                 * of qfe0, and qfe0 is a duplicate of qfe0:1.  That would
                 * be bad)
                 */
                if (!allowdups && (ifp->int_state & IS_DUP))
                        continue;

                if (ifp->int_mask != mask)
                        continue;

                if (!IS_IFF_UP(ifp->int_if_flags))
                        continue;

                /*
                 * The local address can only be shared with a point-to-point
                 * link.
                 */
                if ((ifp->int_addr == addr &&
                    ((if_flags|ifp->int_if_flags) & IFF_POINTOPOINT) == 0) ||
                    on_net(ifp->int_dstaddr, dstaddr_h, mask)) {
                        pref = 0;
                        if (!(ifp->int_state & IS_ALIAS))
                                pref++;
                        if (!IS_RIP_OUT_OFF(ifp->int_state))
                                pref += 2;
                        if (IS_IFF_ROUTING(ifp->int_if_flags))
                                pref += 4;
                        if (pref > best_pref) {
                                best_pref = pref;
                                best_ifp = ifp;
                        }
                }
        }
        return (best_ifp);
}


/*
 * See that a remote gateway is reachable.
 *      Note that the answer can change as real interfaces come and go.
 */
boolean_t                       /* _B_FALSE=bad _B_TRUE=good */
check_remote(struct interface *ifp)
{
        struct rt_entry *rt;

        /* do not worry about other kinds */
        if (!(ifp->int_state & IS_REMOTE))
                return (_B_TRUE);

        rt = rtfind(ifp->int_addr);
        if (rt != NULL &&
            rt->rt_ifp != NULL &&
            on_net(ifp->int_addr, rt->rt_ifp->int_net, rt->rt_ifp->int_mask)) {
                return (_B_TRUE);
        }

        /*
         * the gateway cannot be reached directly from one of our
         * interfaces
         */
        if (!(ifp->int_state & IS_BROKE)) {
                msglog("unreachable gateway %s in "PATH_GATEWAYS,
                    naddr_ntoa(ifp->int_addr));
                if_bad(ifp, _B_FALSE);
        }
        return (_B_FALSE);
}

/* Delete an interface. */
static void
ifdel(struct interface *ifp)
{
        struct rewire_data wire;
        boolean_t resurrected;
        struct physical_interface *phyi;

        trace_if("Del", ifp);

        ifp->int_state |= IS_BROKE;

        /* unlink the interface */
        link_out(ifp, offsetof(struct interface, int_link));
        hash_unlink(&ahash_tbl, ifp);
        hash_unlink(&nhash_tbl, ifp);
        if (ifp->int_if_flags & IFF_BROADCAST)
                hash_unlink(&bhash_tbl, ifp);

        /* Remove from list of interfaces with this ifIndex */
        if ((phyi = ifp->int_phys) != NULL) {
                link_out(ifp, offsetof(struct interface, int_ilist));
                if (phyi->phyi_interface == NULL) {
                        hash_unlink(&ihash_tbl, phyi);
                        free(phyi);
                }
        }

        /*
         * If this is a lead interface, then check first for
         * duplicates of this interface with an eye towards promoting
         * one of them.
         */
        resurrected = _B_FALSE;
        if (!(ifp->int_state & IS_DUP) &&
            (wire.if_new = check_dup(ifp->int_name, ifp->int_addr,
            ifp->int_dstaddr, ifp->int_mask, ifp->int_if_flags,
            _B_TRUE)) != NULL &&
            !IS_IFF_QUIET(wire.if_new->int_if_flags)) {

                trace_act("promoting duplicate %s in place of %s",
                    wire.if_new->int_name, ifp->int_name);

                /* Rewire routes with the replacement interface */
                wire.if_old = ifp;
                wire.metric_delta = wire.if_new->int_metric - ifp->int_metric;
                (void) rn_walktree(rhead, walk_rewire, &wire);
                kern_rewire_ifp(wire.if_old, wire.if_new);
                if_rewire_rdisc(wire.if_old, wire.if_new);

                /* Mark the replacement as being no longer a duplicate */
                wire.if_new->int_state &= ~IS_DUP;
                tot_interfaces++;
                if (!IS_RIP_OFF(wire.if_new->int_state))
                        rip_interfaces++;
                if (!IS_RIP_OUT_OFF(wire.if_new->int_state))
                        ripout_interfaces++;
                if (IS_IFF_ROUTING(wire.if_new->int_if_flags))
                        fwd_interfaces++;

                set_rdisc_mg(wire.if_new, 1);
                rip_mcast_on(wire.if_new);

                /* We came out ok; no need to clobber routes over this. */
                resurrected = _B_TRUE;
        }

        rip_mcast_off(ifp);
        if (rip_sock_interface == ifp)
                rip_sock_interface = NULL;

        set_rdisc_mg(ifp, 0);

        /*
         * Note that duplicates are not counted in the total number of
         * interfaces.
         */
        if (!(ifp->int_state & IS_DUP) && !IS_IFF_QUIET(ifp->int_if_flags)) {
                tot_interfaces--;
                if (!IS_RIP_OFF(ifp->int_state))
                        rip_interfaces--;
                if (!IS_RIP_OUT_OFF(ifp->int_state))
                        ripout_interfaces--;
                if (IS_IFF_ROUTING(ifp->int_if_flags))
                        fwd_interfaces--;
        }

        if (!resurrected) {
                /*
                 * Zap all routes associated with this interface.
                 * Assume routes just using gateways beyond this interface
                 * will timeout naturally, and have probably already died.
                 */
                (void) rn_walktree(rhead, walk_bad, ifp);
                kern_flush_ifp(ifp);

                if_bad_rdisc(ifp);
        }

        free(ifp);
}


/* Mark an interface ill. */
void
if_sick(struct interface *ifp, boolean_t recurse)
{
        struct interface *ifp1;

        if (0 == (ifp->int_state & (IS_SICK | IS_BROKE))) {
                ifp->int_state |= IS_SICK;
                ifp->int_act_time = NEVER;
                trace_if("Chg", ifp);

                LIM_SEC(ifscan_timer, now.tv_sec+CHECK_BAD_INTERVAL);
                if (recurse && ifp->int_phys != NULL) {
                        /* If an interface is sick, so are its aliases. */
                        for (ifp1 = ifp->int_phys->phyi_interface;
                            ifp1 != NULL; ifp1 = ifp1->int_ilist.hl_next) {
                                if (ifp1 != ifp)
                                        if_sick(ifp1, _B_FALSE);
                        }
                }
        }
}


/* Mark an interface dead. */
static void
if_bad(struct interface *ifp, boolean_t recurse)
{
        struct interface *ifp1;
        struct rewire_data wire;

        if (ifp->int_state & IS_BROKE)
                return;

        LIM_SEC(ifscan_timer, now.tv_sec+CHECK_BAD_INTERVAL);

        ifp->int_state |= (IS_BROKE | IS_SICK);
        ifp->int_act_time = NEVER;
        ifp->int_query_time = NEVER;
        /* Note: don't reset the stats timestamp here */

        trace_if("Chg", ifp);

        if (recurse && ifp->int_phys != NULL) {
                /* If an interface is bad, so are its aliases. */
                for (ifp1 = ifp->int_phys->phyi_interface;
                    ifp1 != NULL; ifp1 = ifp1->int_ilist.hl_next) {
                        if (ifp1 != ifp)
                                if_bad(ifp1, _B_FALSE);
                }
        }

        /* If we can find a replacement, then pick it up. */
        if (!(ifp->int_state & IS_DUP) &&
            (wire.if_new = check_dup(ifp->int_name, ifp->int_addr,
            ifp->int_dstaddr, ifp->int_mask, ifp->int_if_flags,
            _B_TRUE)) != NULL &&
            !IS_IFF_QUIET(wire.if_new->int_if_flags)) {
                trace_act("promoting duplicate %s in place of %s",
                    wire.if_new->int_name, ifp->int_name);
                wire.if_old = ifp;
                wire.metric_delta = wire.if_new->int_metric - ifp->int_metric;
                (void) rn_walktree(rhead, walk_rewire, &wire);
                if_rewire_rdisc(wire.if_old, wire.if_new);

                /* The broken guy becomes the duplicate */
                wire.if_new->int_state &= ~IS_DUP;
                set_rdisc_mg(ifp, 0);
                rip_mcast_off(ifp);
                ifp->int_state |= IS_DUP;

                /* join the mcast groups for the replacement */
                set_rdisc_mg(wire.if_new, 1);
                rip_mcast_on(wire.if_new);

                if (rip_sock_interface == ifp)
                        rip_sock_interface = NULL;
        } else {
                (void) rn_walktree(rhead, walk_bad, ifp);
                if_bad_rdisc(ifp);
        }
}


/* Mark an interface alive */
void
if_ok(struct interface *ifp, const char *type, boolean_t recurse)
{
        struct interface *ifp1;
        boolean_t wasbroken = _B_FALSE;

        if (ifp->int_state & IS_BROKE) {
                writelog(LOG_WARNING, "%sinterface %s to %s restored",
                    type, ifp->int_name, naddr_ntoa(ifp->int_dstaddr));
                ifp->int_state &= ~(IS_BROKE | IS_SICK);
                wasbroken = _B_TRUE;
        } else if (ifp->int_state & IS_SICK) {
                trace_act("%sinterface %s to %s working better",
                    type, ifp->int_name, naddr_ntoa(ifp->int_dstaddr));
                ifp->int_state &= ~IS_SICK;
        }

        if (recurse && ifp->int_phys != NULL && IS_IFF_UP(ifp->int_if_flags)) {
                ifp->int_phys->phyi_data.ts = 0;

                /* Also mark all aliases of this interface as ok */
                for (ifp1 = ifp->int_phys->phyi_interface;
                    ifp1 != NULL; ifp1 = ifp1->int_ilist.hl_next) {
                        if (ifp1 != ifp)
                                if_ok(ifp1, type, _B_FALSE);
                }
        }

        if (wasbroken) {
                if (!(ifp->int_state & IS_DUP))
                        if_ok_rdisc(ifp);

                if (ifp->int_state & IS_REMOTE)
                        (void) addrouteforif(ifp);
        }
}

boolean_t
remote_address_ok(struct interface *ifp, in_addr_t addr)
{
        if (ifp->int_if_flags & IFF_POINTOPOINT) {
                if (addr == ifp->int_dstaddr)
                        return (_B_TRUE);
        } else if (on_net(addr, ifp->int_net, ifp->int_mask)) {
                return (_B_TRUE);
        }
        return (_B_FALSE);
}

/*
 * Find the network interfaces which have configured themselves.
 *      This must be done regularly, if only for extra addresses
 *      that come and go on interfaces.
 */
void
ifscan(void)
{
        uint_t complaints = 0;
        static uint_t prev_complaints = 0;
#define COMP_BADADDR    0x001
#define COMP_NODST      0x002
#define COMP_NOBADDR    0x004
#define COMP_NOMASK     0x008
#define COMP_BAD_METRIC 0x010
#define COMP_NETMASK    0x020
#define COMP_NO_INDEX   0x040
#define COMP_BAD_FLAGS  0x080
#define COMP_NO_KSTATS  0x100
#define COMP_IPFORWARD  0x200

        struct interface ifs, *ifp, *ifp1;
        struct rt_entry *rt;
        size_t needed;
        static size_t lastneeded = 0;
        char *buf;
        static char *lastbuf = NULL;
        int32_t in, ierr, out, oerr;
        struct intnet *intnetp;
        int sock;
        struct lifnum lifn;
        struct lifconf lifc;
        struct lifreq *lifrp, *lifrp_lim;
        struct sockaddr_in *sinp;
        in_addr_t haddr;
        static in_addr_t myaddr = 0;
        uint32_t ifindex;
        struct phyi_data newstats;
        struct physical_interface *phyi;

        last_ifscan = now;
        ifscan_timer.tv_sec = now.tv_sec +
            (supplier || tot_interfaces != 1 ?
            CHECK_ACT_INTERVAL : CHECK_QUIET_INTERVAL);

        /* mark all interfaces so we can get rid of those that disappear */
        for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next)
                ifp->int_state &= ~IS_CHECKED;

        /* Fetch the size of the current interface list */
        if ((sock = socket(PF_INET, SOCK_DGRAM, 0)) == -1)
                BADERR(_B_TRUE, "ifscan: socket(SOCK_DGRAM)");
        lifn.lifn_family = AF_INET;     /* Only count IPv4 interfaces */
        /*
         * Include IFF_NOXMIT interfaces.  Such interfaces are exluded
         * from protocol operations, but their inclusion in the
         * internal table enables us to know when packets arrive on
         * such interfaces.
         */
        lifn.lifn_flags = LIFC_NOXMIT;
calculate_lifc_len:
        if (ioctl(sock, SIOCGLIFNUM, &lifn) == -1) {
                BADERR(_B_TRUE, "ifscan: ioctl(SIOCGLIFNUM)");
        }

        /*
         * When calculating the buffer size needed, add a small number
         * of interfaces to those we counted.  We do this to capture
         * the interface status of potential interfaces which may have
         * been plumbed between the SIOCGLIFNUM and the SIOCGLIFCONF.
         * Try to reuse the buffer we already have to avoid heap
         * thrash.
         */
        needed = (lifn.lifn_count + 4) * sizeof (struct lifreq);
        if (needed > lastneeded || needed < lastneeded/2) {
                free(lastbuf);
                if ((buf = malloc(needed)) == NULL) {
                        lastbuf = NULL;
                        msglog("ifscan: malloc: %s", rip_strerror(errno));
                        return;
                }
        } else {
                buf = lastbuf;
        }
        lastbuf = buf;
        lastneeded = needed;

        /* Get the list */
        lifc.lifc_family = AF_INET;     /* We only need IPv4 interfaces */
        lifc.lifc_flags = LIFC_NOXMIT;
        lifc.lifc_len = needed;
        lifc.lifc_buf = buf;
        if (ioctl(sock, SIOCGLIFCONF, &lifc) == -1) {
                /*
                 * IP returns EINVAL if the lifc_len we passed in is
                 * too small.  If that's the case, we need to go back
                 * and recalculate it.
                 */
                if (errno == EINVAL)
                        goto calculate_lifc_len;
                BADERR(_B_TRUE, "ifscan: ioctl(SIOCGLIFCONF)");
        }

        /*
         * If the returned lifc_len is within one lifreq of the
         * requested ammount, we may have used a buffer which
         * was too small to hold all of the interfaces.  In that
         * case go back and recalculate needed.
         */
        if (lifc.lifc_len >= needed - sizeof (struct lifreq))
                goto calculate_lifc_len;

        lifrp = lifc.lifc_req;
        lifrp_lim = lifrp + lifc.lifc_len / sizeof (*lifrp);
        for (; lifrp < lifrp_lim; lifrp++) {

                (void) memset(&ifs, 0, sizeof (ifs));

                (void) strlcpy(ifs.int_name, lifrp->lifr_name,
                    sizeof (ifs.int_name));

                /* SIOCGLIFCONF fills in the lifr_addr of each lifreq */
                ifs.int_addr = ((struct sockaddr_in *)&lifrp->lifr_addr)->
                    sin_addr.s_addr;

                if (ioctl(sock, SIOCGLIFFLAGS, lifrp) == -1) {
                        if (!(prev_complaints & COMP_BAD_FLAGS))
                                writelog(LOG_NOTICE,
                                    "unable to get interface flags for %s: %s",
                                    ifs.int_name, rip_strerror(errno));
                        complaints |= COMP_BAD_FLAGS;
                        ifs.int_if_flags = 0;
                } else {
                        ifs.int_if_flags = lifrp->lifr_flags;
                }

                if (IN_CLASSD(ntohl(ifs.int_addr)) ||
                    (ntohl(ifs.int_addr) & IN_CLASSA_NET) == 0) {
                        if (IS_IFF_UP(ifs.int_if_flags)) {
                                if (!(prev_complaints & COMP_BADADDR))
                                        writelog(LOG_NOTICE,
                                            "%s has a bad address %s",
                                            ifs.int_name,
                                            naddr_ntoa(ifs.int_addr));
                                complaints |= COMP_BADADDR;
                        }
                        continue;
                }

                /* Ignore interface with IPv4 link local address. */
                if (IN_LINKLOCAL(ntohl(ifs.int_addr)))
                        continue;

                /* Get the interface index. */
                if (ioctl(sock, SIOCGLIFINDEX, lifrp) == -1) {
                        ifindex = 0;
                        ifs.int_if_flags &= ~IFF_UP;
                        if (!(prev_complaints & COMP_NO_INDEX))
                                writelog(LOG_NOTICE, "%s has no ifIndex: %s",
                                    ifs.int_name, rip_strerror(errno));
                        complaints |= COMP_NO_INDEX;
                } else {
                        ifindex = lifrp->lifr_index;
                }

                /*
                 * Get the destination address for point-to-point
                 * interfaces.
                 */
                if (ifs.int_if_flags & IFF_POINTOPOINT) {
                        sinp = (struct sockaddr_in *)&lifrp->lifr_dstaddr;
                        if (ioctl(sock, SIOCGLIFDSTADDR, lifrp) == -1) {
                                if (IS_IFF_UP(ifs.int_if_flags)) {
                                        if (!(prev_complaints & COMP_NODST))
                                                writelog(LOG_NOTICE,
                                                    "%s has no destination "
                                                    "address : %s",
                                                    ifs.int_name,
                                                    rip_strerror(errno));
                                        complaints |= COMP_NODST;
                                }
                                continue;
                        }
                        ifs.int_net = ntohl(sinp->sin_addr.s_addr);
                        if (IN_CLASSD(ntohl(ifs.int_net)) ||
                            (ifs.int_net != 0 &&
                            (ifs.int_net & IN_CLASSA_NET) == 0)) {
                                if (IS_IFF_UP(ifs.int_if_flags)) {
                                        if (!(prev_complaints & COMP_NODST))
                                                writelog(LOG_NOTICE,
                                                    "%s has a bad "
                                                    "destination address %s",
                                                    ifs.int_name,
                                                    naddr_ntoa(ifs.int_net));
                                        complaints |= COMP_NODST;
                                }
                                continue;
                        }
                        ifs.int_dstaddr = sinp->sin_addr.s_addr;
                }

                /* Get the subnet mask */
                sinp = (struct sockaddr_in *)&lifrp->lifr_addr;
                if (ioctl(sock, SIOCGLIFNETMASK, lifrp) == -1) {
                        if (IS_IFF_UP(ifs.int_if_flags)) {
                                if (!(prev_complaints & COMP_NOMASK))
                                        writelog(LOG_NOTICE,
                                            "%s has no netmask: %s",
                                            ifs.int_name, rip_strerror(errno));
                                complaints |= COMP_NOMASK;
                        }
                        continue;
                }
                if (sinp->sin_addr.s_addr == INADDR_ANY) {
                        if (!(ifs.int_if_flags &
                            (IFF_POINTOPOINT|IFF_LOOPBACK))) {
                                if (IS_IFF_UP(ifs.int_if_flags)) {
                                        if (!(prev_complaints & COMP_NOMASK))
                                                writelog(LOG_NOTICE,
                                                    "%s has all-zero netmask",
                                                    ifs.int_name);
                                        complaints |= COMP_NOMASK;
                                }
                                continue;
                        }
                        ifs.int_mask = IP_HOST_MASK;
                } else {
                        ifs.int_mask = ntohl(sinp->sin_addr.s_addr);
                }

                /*
                 * Get the broadcast address on broadcast capable
                 * interfaces.
                 */
                if (ifs.int_if_flags & IFF_BROADCAST) {
                        if (ioctl(sock, SIOCGLIFBRDADDR, lifrp) == -1) {
                                if (IS_IFF_UP(ifs.int_if_flags)) {
                                        if (!(prev_complaints & COMP_NOBADDR))
                                                writelog(LOG_NOTICE,
                                                    "%s has no broadcast "
                                                    "address: %s",
                                                    ifs.int_name,
                                                    rip_strerror(errno));
                                        complaints |= COMP_NOBADDR;
                                }
                                continue;
                        }
                        haddr = ntohl(sinp->sin_addr.s_addr);
                        if (IN_CLASSD(haddr) ||
                            (haddr & IN_CLASSA_NET) == 0) {
                                if (IS_IFF_UP(ifs.int_if_flags)) {
                                        if (!(prev_complaints & COMP_NOBADDR))
                                                writelog(LOG_NOTICE,
                                                    "%s has a bad broadcast "
                                                    "address %s",
                                                    ifs.int_name,
                                                    naddr_ntoa(haddr));
                                        complaints |= COMP_NOBADDR;
                                }
                                continue;
                        }
                }
                ifs.int_brdaddr = sinp->sin_addr.s_addr;

                /* Get interface metric, if possible. */
                if (ioctl(sock, SIOCGLIFMETRIC, lifrp) == -1) {
                        if (IS_IFF_UP(ifs.int_if_flags)) {
                                if (!(prev_complaints & COMP_BAD_METRIC))
                                        writelog(LOG_NOTICE,
                                            "%s has no metric: %s",
                                            ifs.int_name, rip_strerror(errno));
                                complaints |= COMP_BAD_METRIC;
                        }
                } else {
                        ifs.int_metric = lifrp->lifr_metric;
                        if (ifs.int_metric > HOPCNT_INFINITY) {
                                if (IS_IFF_UP(ifs.int_if_flags)) {
                                        if (!(prev_complaints &
                                            COMP_BAD_METRIC))
                                                writelog(LOG_NOTICE,
                                                    "%s has a metric of %d, "
                                                    "defaulting to %d",
                                                    ifs.int_name,
                                                    ifs.int_metric,
                                                    HOPCNT_INFINITY);
                                        complaints |= COMP_BAD_METRIC;
                                }
                                ifs.int_metric = HOPCNT_INFINITY;
                        }
                }

                ifs.int_state |= IS_CHECKED;
                ifs.int_query_time = NEVER;

                /*
                 * If this is an alias, then mark it appropriately.
                 * Do not output RIP or Router-Discovery packets via
                 * aliases.
                 */
                if (strchr(ifs.int_name, ':') != NULL)
                        ifs.int_state |= IS_ALIAS;

                if (ifs.int_if_flags & IFF_LOOPBACK) {
                        ifs.int_state |= IS_PASSIVE | IS_NO_RIP | IS_NO_RDISC;
                        ifs.int_dstaddr = ifs.int_addr;
                        ifs.int_mask = HOST_MASK;
                        ifs.int_ripv1_mask = HOST_MASK;
                        ifs.int_std_mask = std_mask(ifs.int_dstaddr);
                        ifs.int_net = ntohl(ifs.int_dstaddr);
                        if (!foundloopback) {
                                foundloopback = _B_TRUE;
                                loopaddr = ifs.int_addr;
                                loop_rts.rts_gate = loopaddr;
                                loop_rts.rts_router = loopaddr;
                        }

                } else if (ifs.int_if_flags & IFF_POINTOPOINT) {
                        ifs.int_ripv1_mask = ifs.int_mask;
                        ifs.int_mask = HOST_MASK;
                        ifs.int_std_mask = std_mask(ifs.int_dstaddr);

                } else {
                        ifs.int_dstaddr = ifs.int_addr;
                        ifs.int_ripv1_mask = ifs.int_mask;
                        ifs.int_std_mask = std_mask(ifs.int_addr);
                        ifs.int_net = ntohl(ifs.int_addr) & ifs.int_mask;
                        if (ifs.int_mask != ifs.int_std_mask)
                                ifs.int_state |= IS_SUBNET;
                }
                ifs.int_std_net = ifs.int_net & ifs.int_std_mask;
                ifs.int_std_addr = htonl(ifs.int_std_net);

                /*
                 * If this interface duplicates another, mark it
                 * appropriately so that we don't generate duplicate
                 * packets.
                 */
                ifp = check_dup(ifs.int_name, ifs.int_addr, ifs.int_dstaddr,
                    ifs.int_mask, ifs.int_if_flags, _B_FALSE);
                if (ifp != NULL) {
                        trace_misc("%s (%s%s%s) is a duplicate of %s (%s%s%s)",
                            ifs.int_name,
                            addrname(ifs.int_addr, ifs.int_mask, 1),
                            ((ifs.int_if_flags & IFF_POINTOPOINT) ?
                            "-->" : ""),
                            ((ifs.int_if_flags & IFF_POINTOPOINT) ?
                            naddr_ntoa(ifs.int_dstaddr) : ""),
                            ifp->int_name,
                            addrname(ifp->int_addr, ifp->int_mask, 1),
                            ((ifp->int_if_flags & IFF_POINTOPOINT) ?
                            "-->" : ""),
                            ((ifp->int_if_flags & IFF_POINTOPOINT) ?
                            naddr_ntoa(ifp->int_dstaddr) : ""));
                        ifs.int_state |= IS_DUP;
                } else {
                        ifs.int_state &= ~IS_DUP;
                }

                /*
                 * See if this is a familiar interface.
                 * If so, stop worrying about it if it is the same.
                 * Start it over if it now is to somewhere else, as happens
                 * frequently with PPP and SLIP, or if its forwarding
                 * status has changed.
                 */
                ifp = ifwithname(ifs.int_name);
                if (ifp != NULL) {
                        ifp->int_state |= IS_CHECKED;
                        ifp->int_state = (ifp->int_state & ~IS_DUP) |
                            (ifs.int_state & IS_DUP);

                        if ((ifp->int_phys == NULL && ifindex != 0) ||
                            (ifp->int_phys != NULL &&
                            ifp->int_phys->phyi_index != ifindex) ||
                            0 != ((ifp->int_if_flags ^ ifs.int_if_flags)
                            & (IFF_BROADCAST | IFF_LOOPBACK |
                            IFF_POINTOPOINT | IFF_MULTICAST |
                            IFF_ROUTER | IFF_NORTEXCH | IFF_NOXMIT)) ||
                            ifp->int_addr != ifs.int_addr ||
                            ifp->int_brdaddr != ifs.int_brdaddr ||
                            ifp->int_dstaddr != ifs.int_dstaddr ||
                            ifp->int_mask != ifs.int_mask ||
                            ifp->int_metric != ifs.int_metric) {
                                /*
                                 * Forget old information about
                                 * a changed interface.
                                 */
                                trace_act("interface %s has changed",
                                    ifp->int_name);
                                ifdel(ifp);
                                ifp = NULL;
                        }
                }

                if (ifp != NULL) {
                        /* note interfaces that have been turned off */
                        if (!IS_IFF_UP(ifs.int_if_flags)) {
                                if (IS_IFF_UP(ifp->int_if_flags)) {
                                        writelog(LOG_WARNING,
                                            "interface %s to %s turned off",
                                            ifp->int_name,
                                            naddr_ntoa(ifp->int_dstaddr));
                                        if_bad(ifp, _B_FALSE);
                                        ifp->int_if_flags &= ~IFF_UP;
                                } else if (ifp->int_phys != NULL &&
                                    now.tv_sec > (ifp->int_phys->phyi_data.ts +
                                    CHECK_BAD_INTERVAL)) {
                                        trace_act("interface %s has been off"
                                            " %ld seconds; forget it",
                                            ifp->int_name,
                                            now.tv_sec -
                                            ifp->int_phys->phyi_data.ts);
                                        ifdel(ifp);
                                }
                                continue;
                        }
                        /* or that were off and are now ok */
                        if (!IS_IFF_UP(ifp->int_if_flags)) {
                                ifp->int_if_flags |= IFF_UP;
                                if_ok(ifp, "", _B_FALSE);
                        }

                        /*
                         * If it has been long enough,
                         * see if the interface is broken.
                         */
                        if ((phyi = ifp->int_phys) == NULL ||
                            now.tv_sec < phyi->phyi_data.ts +
                            CHECK_BAD_INTERVAL)
                                continue;

                        (void) memset(&newstats, 0, sizeof (newstats));
                        if (get_if_kstats(ifp, &newstats) == -1) {
                                if (!(prev_complaints & COMP_NO_KSTATS))
                                        writelog(LOG_WARNING,
                                            "unable to obtain kstats for %s",
                                            phyi->phyi_name);
                                complaints |= COMP_NO_KSTATS;
                        }

                        /*
                         * If the interface just awoke, restart the counters.
                         */
                        if (phyi->phyi_data.ts == 0) {
                                phyi->phyi_data = newstats;
                                continue;
                        }

                        in = newstats.ipackets - phyi->phyi_data.ipackets;
                        ierr = newstats.ierrors - phyi->phyi_data.ierrors;
                        out = newstats.opackets - phyi->phyi_data.opackets;
                        oerr = newstats.oerrors - phyi->phyi_data.oerrors;
                        phyi->phyi_data = newstats;

                        /*
                         * Withhold judgment when the short error counters
                         * wrap, the interface is reset, or if there are
                         * no kstats.
                         */
                        if (ierr < 0 || in < 0 || oerr < 0 || out < 0 ||
                            newstats.ts == 0) {
                                LIM_SEC(ifscan_timer,
                                    now.tv_sec + CHECK_BAD_INTERVAL);
                                continue;
                        }

                        /* Withhold judgement when there is no traffic */
                        if (in == 0 && out == 0 && ierr == 0 && oerr == 0)
                                continue;

                        /*
                         * It is bad if at least 25% of input or output on
                         * an interface results in errors.  Require
                         * presistent problems before marking it dead.
                         */
                        if ((ierr > 0 && ierr >= in/4) ||
                            (oerr > 0 && oerr >= out/4)) {
                                if (!(ifp->int_state & IS_SICK)) {
                                        trace_act("interface %s to %s"
                                            " sick: in=%d ierr=%d"
                                            " out=%d oerr=%d",
                                            ifp->int_name,
                                            naddr_ntoa(ifp->int_dstaddr),
                                            in, ierr, out, oerr);
                                        if_sick(ifp, _B_TRUE);
                                        continue;
                                }
                                if (!(ifp->int_state & IS_BROKE)) {
                                        writelog(LOG_WARNING,
                                            "interface %s to %s broken:"
                                            " in=%d ierr=%d out=%d oerr=%d",
                                            ifp->int_name,
                                            naddr_ntoa(ifp->int_dstaddr),
                                            in, ierr, out, oerr);
                                        if_bad(ifp, _B_TRUE);
                                }
                                continue;
                        }

                        /* otherwise, it is active and healthy */
                        ifp->int_act_time = now.tv_sec;
                        if_ok(ifp, "", _B_TRUE);
                        continue;
                }

                /*
                 * This is a new interface.
                 * If it is dead, forget it.
                 */
                if (!IS_IFF_UP(ifs.int_if_flags))
                        continue;

                if (0 == (ifs.int_if_flags & (IFF_POINTOPOINT |
                    IFF_BROADCAST | IFF_LOOPBACK)) &&
                    !(ifs.int_state & IS_PASSIVE)) {
                        if (!(prev_complaints & COMP_BAD_FLAGS))
                                trace_act("%s is neither broadcast, "
                                    "point-to-point, nor loopback",
                                    ifs.int_name);
                        complaints |= COMP_BAD_FLAGS;
                        if (!(ifs.int_if_flags & IFF_MULTICAST))
                                ifs.int_state |= IS_NO_RDISC;
                }


                /*
                 * It is new and ok.   Add it to the list of interfaces
                 */
                ifp = rtmalloc(sizeof (*ifp), "ifscan ifp");
                (void) memcpy(ifp, &ifs, sizeof (*ifp));
                get_parms(ifp);
                if_link(ifp, ifindex);
                trace_if("Add", ifp);

                if (ifp->int_phys != NULL &&
                    get_if_kstats(ifp, &ifp->int_phys->phyi_data) == -1) {
                        if (!(prev_complaints & COMP_NO_KSTATS))
                                writelog(LOG_NOTICE,
                                    "unable to obtain kstats for %s",
                                    ifp->int_phys->phyi_name);
                        complaints |= COMP_NO_KSTATS;
                }

                /* Detect interfaces that have conflicting netmasks. */
                if (!(ifp->int_if_flags & (IFF_POINTOPOINT|IFF_LOOPBACK))) {
                        for (ifp1 = ifnet; ifp1 != NULL;
                            ifp1 = ifp1->int_next) {
                                if (ifp1->int_mask == ifp->int_mask)
                                        continue;

                                /*
                                 * we don't care about point-to-point
                                 * or loopback aliases
                                 */
                                if (ifp1->int_if_flags &
                                    (IFF_POINTOPOINT|IFF_LOOPBACK)) {
                                        continue;
                                }

                                /* ignore aliases on the same network */
                                if (ifp->int_phys == ifp1->int_phys)
                                        continue;

                                if (on_net(ifp->int_addr,
                                    ifp1->int_net, ifp1->int_mask) ||
                                    on_net(ifp1->int_addr,
                                    ifp->int_net, ifp->int_mask)) {
                                        writelog(LOG_INFO,
                                            "possible netmask problem"
                                            " between %s:%s and %s:%s",
                                            ifp->int_name,
                                            addrname(htonl(ifp->int_net),
                                            ifp->int_mask, 1),
                                            ifp1->int_name,
                                            addrname(htonl(ifp1->int_net),
                                            ifp1->int_mask, 1));
                                        complaints |= COMP_NETMASK;
                                }
                        }
                }

                if (!(ifp->int_state & IS_DUP) &&
                    !IS_IFF_QUIET(ifp->int_if_flags)) {
                        /* Count the # of directly connected networks. */
                        tot_interfaces++;
                        if (!IS_RIP_OFF(ifp->int_state))
                                rip_interfaces++;
                        if (!IS_RIP_OUT_OFF(ifp->int_state))
                                ripout_interfaces++;
                        if (IS_IFF_ROUTING(ifp->int_if_flags))
                                fwd_interfaces++;

                        if_ok_rdisc(ifp);
                        rip_on(ifp);
                }
        }

        (void) close(sock);

        /*
         * If we are multi-homed and have at least two interfaces that
         * are able to forward, then output RIP by default.
         */
        if (!supplier_set)
                set_supplier();

        /*
         * If we are multi-homed, optionally advertise a route to
         * our main address.
         */
        if (advertise_mhome || (tot_interfaces > 1 && mhome)) {
                /* lookup myaddr if we haven't done so already */
                if (myaddr == 0) {
                        char myname[MAXHOSTNAMELEN+1];

                        /*
                         * If we are unable to resolve our hostname, don't
                         * bother trying again.
                         */
                        if (gethostname(myname, MAXHOSTNAMELEN) == -1) {
                                msglog("gethostname: %s", rip_strerror(errno));
                                advertise_mhome = _B_FALSE;
                                mhome = _B_FALSE;
                        } else if (gethost(myname, &myaddr) == 0) {
                                writelog(LOG_WARNING,
                                    "unable to resolve local hostname %s",
                                    myname);
                                advertise_mhome = _B_FALSE;
                                mhome = _B_FALSE;
                        }
                }
                if (myaddr != 0 &&
                    (ifp = ifwithaddr(myaddr, _B_FALSE, _B_FALSE)) != NULL &&
                    foundloopback) {
                        advertise_mhome = _B_TRUE;
                        rt = rtget(myaddr, HOST_MASK);
                        if (rt != NULL) {
                                if (rt->rt_ifp != ifp ||
                                    rt->rt_router != loopaddr) {
                                        rtdelete(rt);
                                        rt = NULL;
                                } else {
                                        loop_rts.rts_ifp = ifp;
                                        loop_rts.rts_metric = 0;
                                        loop_rts.rts_time = rt->rt_time;
                                        loop_rts.rts_origin = RO_LOOPBCK;
                                        rtchange(rt, rt->rt_state | RS_MHOME,
                                            &loop_rts, NULL);
                                }
                        }
                        if (rt == NULL) {
                                loop_rts.rts_ifp = ifp;
                                loop_rts.rts_metric = 0;
                                loop_rts.rts_origin = RO_LOOPBCK;
                                rtadd(myaddr, HOST_MASK, RS_MHOME, &loop_rts);
                        }
                }
        }

        for (ifp = ifnet; ifp != NULL; ifp = ifp1) {
                ifp1 = ifp->int_next;   /* because we may delete it */

                /* Forget any interfaces that have disappeared. */
                if (!(ifp->int_state & (IS_CHECKED | IS_REMOTE))) {
                        trace_act("interface %s has disappeared",
                            ifp->int_name);
                        ifdel(ifp);
                        continue;
                }

                if ((ifp->int_state & IS_BROKE) &&
                    !(ifp->int_state & IS_PASSIVE))
                        LIM_SEC(ifscan_timer, now.tv_sec+CHECK_BAD_INTERVAL);

                /*
                 * If we ever have a RIPv1 interface, assume we always will.
                 * It might come back if it ever goes away.
                 */
                if (!(ifp->int_state & (IS_NO_RIPV1_OUT | IS_DUP)) &&
                    should_supply(ifp))
                        have_ripv1_out = _B_TRUE;
                if (!(ifp->int_state & IS_NO_RIPV1_IN))
                        have_ripv1_in = _B_TRUE;
        }

        for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) {
                /*
                 * Ensure there is always a network route for interfaces,
                 * after any dead interfaces have been deleted, which
                 * might affect routes for point-to-point links.
                 */
                if (addrouteforif(ifp) == 0)
                        continue;

                /*
                 * Add routes to the local end of point-to-point interfaces
                 * using loopback.
                 */
                if ((ifp->int_if_flags & IFF_POINTOPOINT) &&
                    !(ifp->int_state & IS_REMOTE) && foundloopback) {
                        /*
                         * Delete any routes to the network address through
                         * foreign routers. Remove even static routes.
                         */
                        del_static(ifp->int_addr, HOST_MASK, 0, ifp, 0);
                        rt = rtget(ifp->int_addr, HOST_MASK);
                        if (rt != NULL && rt->rt_router != loopaddr) {
                                rtdelete(rt);
                                rt = NULL;
                        }
                        if (rt != NULL) {
                                if (!(rt->rt_state & RS_LOCAL) ||
                                    rt->rt_metric > ifp->int_metric) {
                                        ifp1 = ifp;
                                } else {
                                        ifp1 = rt->rt_ifp;
                                }
                                loop_rts.rts_ifp = ifp1;
                                loop_rts.rts_metric = 0;
                                loop_rts.rts_time = rt->rt_time;
                                loop_rts.rts_origin = RO_LOOPBCK;
                                rtchange(rt, ((rt->rt_state & ~RS_NET_SYN) |
                                    (RS_IF|RS_LOCAL)), &loop_rts, 0);
                        } else {
                                loop_rts.rts_ifp = ifp;
                                loop_rts.rts_metric = 0;
                                loop_rts.rts_origin = RO_LOOPBCK;
                                rtadd(ifp->int_addr, HOST_MASK,
                                    (RS_IF | RS_LOCAL), &loop_rts);
                        }
                }
        }

        /* add the authority routes */
        for (intnetp = intnets; intnetp != NULL;
            intnetp = intnetp->intnet_next) {
                rt = rtget(intnetp->intnet_addr, intnetp->intnet_mask);
                if (rt != NULL &&
                    !(rt->rt_state & RS_NO_NET_SYN) &&
                    !(rt->rt_state & RS_NET_INT)) {
                        rtdelete(rt);
                        rt = NULL;
                }
                if (rt == NULL) {
                        loop_rts.rts_ifp = NULL;
                        loop_rts.rts_metric = intnetp->intnet_metric-1;
                        loop_rts.rts_origin = RO_LOOPBCK;
                        rtadd(intnetp->intnet_addr, intnetp->intnet_mask,
                            RS_NET_SYN | RS_NET_INT, &loop_rts);
                }
        }

        prev_complaints = complaints;
}


static void
check_net_syn(struct interface *ifp)
{
        struct rt_entry *rt;
        struct rt_spare new;

        /*
         * Turn on the need to automatically synthesize a network route
         * for this interface only if we are running RIPv1 on some other
         * interface that is on a different class-A,B,or C network.
         */
        if (have_ripv1_out || have_ripv1_in) {
                ifp->int_state |= IS_NEED_NET_SYN;
                rt = rtget(ifp->int_std_addr, ifp->int_std_mask);
                if (rt != NULL &&
                    0 == (rt->rt_state & RS_NO_NET_SYN) &&
                    (!(rt->rt_state & RS_NET_SYN) ||
                    rt->rt_metric > ifp->int_metric)) {
                        rtdelete(rt);
                        rt = NULL;
                }
                if (rt == NULL) {
                        (void) memset(&new, 0, sizeof (new));
                        new.rts_ifp = ifp;
                        new.rts_gate = ifp->int_addr;
                        new.rts_router = ifp->int_addr;
                        new.rts_metric = ifp->int_metric;
                        new.rts_origin = RO_NET_SYN;
                        rtadd(ifp->int_std_addr, ifp->int_std_mask,
                            RS_NET_SYN, &new);
                }

        } else {
                ifp->int_state &= ~IS_NEED_NET_SYN;

                rt = rtget(ifp->int_std_addr, ifp->int_std_mask);
                if (rt != NULL &&
                    (rt->rt_state & RS_NET_SYN) &&
                    rt->rt_ifp == ifp)
                        rtbad_sub(rt, NULL);
        }
}


/*
 * Add route for interface if not currently installed.
 * Create route to other end if a point-to-point link,
 * otherwise a route to this (sub)network.
 */
static boolean_t                        /* _B_FALSE=bad interface */
addrouteforif(struct interface *ifp)
{
        struct rt_entry *rt;
        struct rt_spare new;
        in_addr_t dst;
        uint16_t rt_newstate = RS_IF;


        /* skip sick interfaces */
        if (ifp->int_state & IS_BROKE)
                return (_B_FALSE);

        /*
         * don't install routes for duplicate interfaces, or
         * unnumbered point-to-point interfaces.
         */
        if ((ifp->int_state & IS_DUP) ||
            ((ifp->int_if_flags & IFF_POINTOPOINT) && ifp->int_dstaddr == 0))
                return (_B_TRUE);

        /*
         * If the interface on a subnet, then install a RIPv1 route to
         * the network as well (unless it is sick).
         */
        if (ifp->int_state & IS_SUBNET)
                check_net_syn(ifp);

        dst = (0 != (ifp->int_if_flags & (IFF_POINTOPOINT | IFF_LOOPBACK)) ?
            ifp->int_dstaddr : htonl(ifp->int_net));

        (void) memset(&new, 0, sizeof (new));
        new.rts_ifp = ifp;
        new.rts_router = ifp->int_addr;
        new.rts_gate = ifp->int_addr;
        new.rts_metric = ifp->int_metric;
        new.rts_time = now.tv_sec;
        if (ifp->int_if_flags & IFF_POINTOPOINT)
                new.rts_origin = RO_PTOPT;
        else if (ifp->int_if_flags & IFF_LOOPBACK)
                new.rts_origin = RO_LOOPBCK;
        else
                new.rts_origin = RO_IF;

        /*
         * If we are going to send packets to the gateway,
         * it must be reachable using our physical interfaces
         */
        if ((ifp->int_state & IS_REMOTE) &&
            !(ifp->int_state & IS_EXTERNAL) &&
            !check_remote(ifp))
                return (_B_FALSE);

        /*
         * We are finished if the correct main interface route exists.
         * The right route must be for the right interface, not synthesized
         * from a subnet, be a "gateway" or not as appropriate, and so forth.
         */
        del_static(dst, ifp->int_mask, 0, ifp, 0);
        rt = rtget(dst, ifp->int_mask);
        if (!IS_IFF_ROUTING(ifp->int_if_flags))
                rt_newstate |= RS_NOPROPAGATE;
        if (rt != NULL) {
                if ((rt->rt_ifp != ifp || rt->rt_router != ifp->int_addr) &&
                    (rt->rt_ifp == NULL ||
                    (rt->rt_ifp->int_state & IS_BROKE))) {
                        rtdelete(rt);
                        rt = NULL;
                } else {
                        rtchange(rt, ((rt->rt_state | rt_newstate) &
                            ~(RS_NET_SYN | RS_LOCAL)), &new, 0);
                }
        }
        if (rt == NULL) {
                if (ifp->int_transitions++ > 0)
                        trace_act("re-installing interface %s;"
                            " went up %d times",
                            ifp->int_name, ifp->int_transitions);

                rtadd(dst, ifp->int_mask, rt_newstate, &new);
        }

        return (_B_TRUE);
}

/*
 * Obtains the named kstat, and places its value in *value.  It
 * returns 0 for success, -1 for failure.
 */
static int
kstat_named_value(kstat_t *ksp, char *name, uint32_t *value)
{
        kstat_named_t *knp;

        if (ksp == NULL)
                return (-1);

        if ((knp = kstat_data_lookup(ksp, name)) == NULL) {
                return (-1);
        } else if (knp->data_type != KSTAT_DATA_UINT32) {
                return (-1);
        } else {
                *value = knp->value.ui32;
                return (0);
        }
}

static int
get_if_kstats(struct interface *ifp, struct phyi_data *newdata)
{
        struct physical_interface *phyi = ifp->int_phys;
        kstat_ctl_t *kc;
        kstat_t *ksp;

        /* We did this recently; don't do it again. */
        if (phyi->phyi_data.ts == now.tv_sec) {
                if (newdata != &phyi->phyi_data)
                        *newdata = phyi->phyi_data;
                return (0);
        }

        if ((kc = kstat_open()) == NULL)
                return (-1);

        /*
         * First we try to query the "link" kstats in case the link is renamed.
         * If that fails, fallback to legacy ktats for those non-GLDv3 links.
         */
        if (((ksp = kstat_lookup(kc, "link", 0, phyi->phyi_name)) == NULL) &&
            ((ksp = kstat_lookup(kc, NULL, -1, phyi->phyi_name)) == NULL)) {
                (void) kstat_close(kc);
                return (-1);
        }

        if (kstat_read(kc, ksp, NULL) == -1) {
                (void) kstat_close(kc);
                return (-1);
        }

        if ((kstat_named_value(ksp, "ipackets", &newdata->ipackets) == -1) ||
            (kstat_named_value(ksp, "opackets", &newdata->opackets) == -1)) {
                newdata->ts = 0;
                (void) kstat_close(kc);
                return (-1);
        }

        /* The loopback interface does not keep track of errors */
        if (!(ifp->int_if_flags & IFF_LOOPBACK)) {
                if ((kstat_named_value(ksp, "ierrors",
                    &newdata->ierrors) == -1) ||
                    (kstat_named_value(ksp, "oerrors",
                    &newdata->oerrors) == -1)) {
                        newdata->ts = 0;
                        (void) kstat_close(kc);
                        return (-1);
                }
        }

        newdata->ts = now.tv_sec;
        (void) kstat_close(kc);
        return (0);
}

/*
 * Returns true if we should supply routes to other systems.  If the
 * user has forced us to be a supplier (by the command line) or if we
 * have more than one forwarding interface and this is one of the
 * forwarding interfaces, then behave as a RIP supplier (supply rdisc
 * advertisements and RIP responses).
 */
boolean_t
should_supply(struct interface *ifp)
{
        if (ifp != NULL && !IS_IFF_ROUTING(ifp->int_if_flags))
                return (_B_FALSE);
        return ((supplier_set && supplier) ||
            (!supplier_set && fwd_interfaces > 1));
}