glxsb/nsclpcsio - cleanup

[dragonfly.git] / usr.sbin / mrouted / vif.c

/*
 * The mrouted program is covered by the license in the accompanying file
 * named "LICENSE".  Use of the mrouted program represents acceptance of
 * the terms and conditions listed in that file.
 *
 * The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
 * Leland Stanford Junior University.
 *
 *
 * vif.c,v 3.8.4.56.2.1 1999/01/20 05:18:50 fenner Exp
 *
 * $FreeBSD: src/usr.sbin/mrouted/vif.c,v 1.15 1999/08/28 01:17:09 peter Exp $
 * $DragonFly: src/usr.sbin/mrouted/vif.c,v 1.4 2004/03/15 18:10:28 dillon Exp $
 */

#include "defs.h"
#include <fcntl.h>

/*
 * Exported variables.
 */
struct uvif     uvifs[MAXVIFS]; /* array of virtual interfaces              */
vifi_t          numvifs;        /* number of vifs in use                    */
int             vifs_down;      /* 1=>some interfaces are down              */
int             phys_vif;       /* An enabled vif                           */
int             udp_socket;     /* Since the honkin' kernel doesn't support */
                                /* ioctls on raw IP sockets, we need a UDP  */
                                /* socket as well as our IGMP (raw) socket. */
                                /* How dumb.                                */
int             vifs_with_neighbors;    /* == 1 if I am a leaf              */

/*
 * Private variables.
 */
struct listaddr *nbrs[MAXNBRS]; /* array of neighbors                       */

typedef struct {
        vifi_t  vifi;
        struct listaddr *g;
        int    q_time;
} cbk_t;

/*
 * Forward declarations.
 */
static void start_vif(vifi_t vifi);
static void start_vif2(vifi_t vifi);
static void stop_vif(vifi_t vifi);
static void age_old_hosts(void);
static void send_probe_on_vif(struct uvif *v);
static void send_query(struct uvif *v);
static int info_version(char *p, int plen);
static void DelVif(void *arg);
static int SetTimer(vifi_t vifi, struct listaddr *g);
static int DeleteTimer(int id);
static void SendQuery(void *arg);
static int SetQueryTimer(struct listaddr *g, vifi_t vifi, int to_expire,
                                        int q_time);


/*
 * Initialize the virtual interfaces, but do not install
 * them in the kernel.  Start routing on all vifs that are
 * not down or disabled.
 */
void
init_vifs(void)
{
    vifi_t vifi;
    struct uvif *v;
    int enabled_vifs, enabled_phyints;
    extern char *configfilename;

    numvifs = 0;
    vifs_with_neighbors = 0;
    vifs_down = FALSE;

    /*
     * Configure the vifs based on the interface configuration of the
     * the kernel and the contents of the configuration file.
     * (Open a UDP socket for ioctl use in the config procedures if
     * the kernel can't handle IOCTL's on the IGMP socket.)
     */
#ifdef IOCTL_OK_ON_RAW_SOCKET
    udp_socket = igmp_socket;
#else
    if ((udp_socket = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
        dolog(LOG_ERR, errno, "UDP socket");
#endif
    dolog(LOG_INFO,0,"Getting vifs from kernel interfaces");
    config_vifs_from_kernel();
    dolog(LOG_INFO,0,"Getting vifs from %s",configfilename);
    config_vifs_from_file();

    /*
     * Quit if there are fewer than two enabled vifs.
     */
    enabled_vifs    = 0;
    enabled_phyints = 0;
    phys_vif        = -1;
    for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) {
        if (!(v->uv_flags & VIFF_DISABLED)) {
            ++enabled_vifs;
            if (!(v->uv_flags & VIFF_TUNNEL)) {
                if (phys_vif == -1)
                    phys_vif = vifi;
                ++enabled_phyints;
            }
        }
    }
    if (enabled_vifs < 2)
        dolog(LOG_ERR, 0, "can't forward: %s",
            enabled_vifs == 0 ? "no enabled vifs" : "only one enabled vif");

    if (enabled_phyints == 0)
        dolog(LOG_WARNING, 0,
            "no enabled interfaces, forwarding via tunnels only");

    dolog(LOG_INFO, 0, "Installing vifs in mrouted...");
    for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) {
        if (!(v->uv_flags & VIFF_DISABLED)) {
            if (!(v->uv_flags & VIFF_DOWN)) {
                if (v->uv_flags & VIFF_TUNNEL)
                    dolog(LOG_INFO, 0, "vif #%d, tunnel %s -> %s", vifi,
                                inet_fmt(v->uv_lcl_addr, s1),
                                inet_fmt(v->uv_rmt_addr, s2));
                else
                    dolog(LOG_INFO, 0, "vif #%d, phyint %s", vifi,
                                inet_fmt(v->uv_lcl_addr, s1));
                start_vif2(vifi);
            } else dolog(LOG_INFO, 0,
                     "%s is not yet up; vif #%u not in service",
                     v->uv_name, vifi);
        }
    }
}

/*
 * Initialize the passed vif with all appropriate default values.
 * "t" is true if a tunnel, or false if a phyint.
 */
void
zero_vif(struct uvif *v, int t)
{

    v->uv_flags         = 0;
    v->uv_metric        = DEFAULT_METRIC;
    v->uv_admetric      = 0;
    v->uv_threshold     = DEFAULT_THRESHOLD;
    v->uv_rate_limit    = t ? DEFAULT_TUN_RATE_LIMIT : DEFAULT_PHY_RATE_LIMIT;
    v->uv_lcl_addr      = 0;
    v->uv_rmt_addr      = 0;
    v->uv_dst_addr      = t ? 0 : dvmrp_group;
    v->uv_subnet        = 0;
    v->uv_subnetmask    = 0;
    v->uv_subnetbcast   = 0;
    v->uv_name[0]       = '\0';
    v->uv_groups        = NULL;
    v->uv_neighbors     = NULL;
    NBRM_CLRALL(v->uv_nbrmap);
    v->uv_querier       = NULL;
    v->uv_igmpv1_warn   = 0;
    v->uv_prune_lifetime = 0;
    v->uv_leaf_timer    = 0;
    v->uv_acl           = NULL;
    v->uv_addrs         = NULL;
    v->uv_filter        = NULL;
    v->uv_blasterbuf    = NULL;
    v->uv_blastercur    = NULL;
    v->uv_blasterend    = NULL;
    v->uv_blasterlen    = 0;
    v->uv_blastertimer  = 0;
    v->uv_nbrup         = 0;
    v->uv_icmp_warn     = 0;
    v->uv_nroutes       = 0;
}

/*
 * Start routing on all virtual interfaces that are not down or
 * administratively disabled.
 */
void
init_installvifs(void)
{
    vifi_t vifi;
    struct uvif *v;

    dolog(LOG_INFO, 0, "Installing vifs in kernel...");
    for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) {
        if (!(v->uv_flags & VIFF_DISABLED)) {
            if (!(v->uv_flags & VIFF_DOWN)) {
                if (v->uv_flags & VIFF_TUNNEL)
                    dolog(LOG_INFO, 0, "vif #%d, tunnel %s -> %s", vifi,
                                inet_fmt(v->uv_lcl_addr, s1),
                                inet_fmt(v->uv_rmt_addr, s2));
                else
                    dolog(LOG_INFO, 0, "vif #%d, phyint %s", vifi,
                                inet_fmt(v->uv_lcl_addr, s1));
                k_add_vif(vifi, &uvifs[vifi]);
            } else dolog(LOG_INFO, 0,
                     "%s is not yet up; vif #%u not in service",
                     v->uv_name, vifi);
        }
    }
}

/*
 * See if any interfaces have changed from up state to down, or vice versa,
 * including any non-multicast-capable interfaces that are in use as local
 * tunnel end-points.  Ignore interfaces that have been administratively
 * disabled.
 */
void
check_vif_state(void)
{
    vifi_t vifi;
    struct uvif *v;
    struct ifreq ifr;
    static int checking_vifs = 0;

    /*
     * If we get an error while checking, (e.g. two interfaces go down
     * at once, and we decide to send a prune out one of the failed ones)
     * then don't go into an infinite loop!
     */
    if (checking_vifs)
        return;

    vifs_down = FALSE;
    checking_vifs = 1;
    for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) {

        if (v->uv_flags & VIFF_DISABLED) continue;

        strncpy(ifr.ifr_name, v->uv_name, IFNAMSIZ);
        if (ioctl(udp_socket, SIOCGIFFLAGS, (char *)&ifr) < 0)
            dolog(LOG_ERR, errno,
                "ioctl SIOCGIFFLAGS for %s", ifr.ifr_name);

        if (v->uv_flags & VIFF_DOWN) {
            if (ifr.ifr_flags & IFF_UP) {
                dolog(LOG_NOTICE, 0,
                    "%s has come up; vif #%u now in service",
                    v->uv_name, vifi);
                v->uv_flags &= ~VIFF_DOWN;
                start_vif(vifi);
            }
            else vifs_down = TRUE;
        }
        else {
            if (!(ifr.ifr_flags & IFF_UP)) {
                dolog(LOG_NOTICE, 0,
                    "%s has gone down; vif #%u taken out of service",
                    v->uv_name, vifi);
                stop_vif(vifi);
                v->uv_flags |= VIFF_DOWN;
                vifs_down = TRUE;
            }
        }
    }
    checking_vifs = 0;
}

/*
 * Send a DVMRP message on the specified vif.  If DVMRP messages are
 * to be encapsulated and sent "inside" the tunnel, use the special
 * encapsulator.  If it's not a tunnel or DVMRP messages are to be
 * sent "beside" the tunnel, as required by earlier versions of mrouted,
 * then just send the message.
 */
void
send_on_vif(struct uvif *v, u_int32 dst, int code, int datalen)
{
    u_int32 group = htonl(MROUTED_LEVEL | 
                        ((v->uv_flags & VIFF_LEAF) ? 0 : LEAF_FLAGS));

    /*
     * The UNIX kernel will not decapsulate unicasts.
     * Therefore, we don't send encapsulated unicasts.
     */
    if ((v->uv_flags & (VIFF_TUNNEL|VIFF_OTUNNEL)) == VIFF_TUNNEL &&
        ((dst == 0) || IN_MULTICAST(ntohl(dst))))
        send_ipip(v->uv_lcl_addr, dst ? dst : dvmrp_group, IGMP_DVMRP,
                                                code, group, datalen, v);
    else
        send_igmp(v->uv_lcl_addr, dst ? dst : v->uv_dst_addr, IGMP_DVMRP,
                                                code, group, datalen);
}


/*
 * Send a probe message on vif v
 */
static void
send_probe_on_vif(struct uvif *v)
{
    char *p;
    int datalen = 0;
    struct listaddr *nbr;
    int i;

    if ((v->uv_flags & VIFF_PASSIVE && v->uv_neighbors == NULL) ||
        (v->uv_flags & VIFF_FORCE_LEAF))
        return;

    p = send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN;

    for (i = 0; i < 4; i++)
        *p++ = ((char *)&(dvmrp_genid))[i];
    datalen += 4;

    /*
     * add the neighbor list on the interface to the message
     */
    nbr = v->uv_neighbors;

    while (nbr) {
        for (i = 0; i < 4; i++)
            *p++ = ((char *)&nbr->al_addr)[i];
        datalen +=4;
        nbr = nbr->al_next;
    }

    send_on_vif(v, 0, DVMRP_PROBE, datalen);
}

static void
send_query(struct uvif *v)
{
    IF_DEBUG(DEBUG_IGMP)
    dolog(LOG_DEBUG, 0, "sending %squery on vif %d",
                (v->uv_flags & VIFF_IGMPV1) ? "v1 " : "",
                v - uvifs);
    send_igmp(v->uv_lcl_addr, allhosts_group,
                IGMP_MEMBERSHIP_QUERY, 
                (v->uv_flags & VIFF_IGMPV1) ? 0 :
                IGMP_MAX_HOST_REPORT_DELAY * IGMP_TIMER_SCALE, 0, 0);
}

/*
 * Add a vifi to the kernel and start routing on it.
 */
static void
start_vif(vifi_t vifi)
{
    /*
     * Install the interface in the kernel's vif structure.
     */
    k_add_vif(vifi, &uvifs[vifi]);

    start_vif2(vifi);
}

/*
 * Add a vifi to all the user-level data structures but don't add
 * it to the kernel yet.
 */
static void
start_vif2(vifi_t vifi)
{
    struct uvif *v;
    u_int32 src;
    struct phaddr *p;

    v   = &uvifs[vifi];
    src = v->uv_lcl_addr;

    /*
     * Update the existing route entries to take into account the new vif.
     */
    add_vif_to_routes(vifi);

    if (!(v->uv_flags & VIFF_TUNNEL)) {
        /*
         * Join the DVMRP multicast group on the interface.
         * (This is not strictly necessary, since the kernel promiscuously
         * receives IGMP packets addressed to ANY IP multicast group while
         * multicast routing is enabled.  However, joining the group allows
         * this host to receive non-IGMP packets as well, such as 'pings'.)
         */
        k_join(dvmrp_group, src);

        /*
         * Join the ALL-ROUTERS multicast group on the interface.
         * This allows mtrace requests to loop back if they are run
         * on the multicast router.
         */
        k_join(allrtrs_group, src);

        /*
         * Install an entry in the routing table for the subnet to which
         * the interface is connected.
         */
        start_route_updates();
        update_route(v->uv_subnet, v->uv_subnetmask, 0, 0, vifi, NULL);
        for (p = v->uv_addrs; p; p = p->pa_next) {
            start_route_updates();
            update_route(p->pa_subnet, p->pa_subnetmask, 0, 0, vifi, NULL);
        }

        /*
         * Until neighbors are discovered, assume responsibility for sending
         * periodic group membership queries to the subnet.  Send the first
         * query.
         */
        v->uv_flags |= VIFF_QUERIER;
        IF_DEBUG(DEBUG_IGMP)
        dolog(LOG_DEBUG, 0, "assuming querier duties on vif %d", vifi);
        send_query(v);
    }

    v->uv_leaf_timer = LEAF_CONFIRMATION_TIME;

    /*
     * Send a probe via the new vif to look for neighbors.
     */
    send_probe_on_vif(v);
}

/*
 * Stop routing on the specified virtual interface.
 */
static void
stop_vif(vifi_t vifi)
{
    struct uvif *v;
    struct listaddr *a;
    struct phaddr *p;

    v = &uvifs[vifi];

    if (!(v->uv_flags & VIFF_TUNNEL)) {
        /*
         * Depart from the DVMRP multicast group on the interface.
         */
        k_leave(dvmrp_group, v->uv_lcl_addr);

        /*
         * Depart from the ALL-ROUTERS multicast group on the interface.
         */
        k_leave(allrtrs_group, v->uv_lcl_addr);

        /*
         * Update the entry in the routing table for the subnet to which
         * the interface is connected, to take into account the interface
         * failure.
         */
        start_route_updates();
        update_route(v->uv_subnet, v->uv_subnetmask, UNREACHABLE, 0, vifi, NULL);
        for (p = v->uv_addrs; p; p = p->pa_next) {
            start_route_updates();
            update_route(p->pa_subnet, p->pa_subnetmask, UNREACHABLE, 0, vifi, NULL);
        }

        /*
         * Discard all group addresses.  (No need to tell kernel;
         * the k_del_vif() call, below, will clean up kernel state.)
         */
        while (v->uv_groups != NULL) {
            a = v->uv_groups;
            v->uv_groups = a->al_next;
            free((char *)a);
        }

        IF_DEBUG(DEBUG_IGMP)
        dolog(LOG_DEBUG, 0, "releasing querier duties on vif %d", vifi);
        v->uv_flags &= ~VIFF_QUERIER;
    }

    /*
     * Update the existing route entries to take into account the vif failure.
     */
    delete_vif_from_routes(vifi);

    /*
     * Delete the interface from the kernel's vif structure.
     */
    k_del_vif(vifi);

    /*
     * Discard all neighbor addresses.
     */
    if (!NBRM_ISEMPTY(v->uv_nbrmap))
        vifs_with_neighbors--;

    while (v->uv_neighbors != NULL) {
        a = v->uv_neighbors;
        v->uv_neighbors = a->al_next;
        nbrs[a->al_index] = NULL;
        free((char *)a);
    }
    NBRM_CLRALL(v->uv_nbrmap);
}


/*
 * stop routing on all vifs
 */
void
stop_all_vifs(void)
{
    vifi_t vifi;
    struct uvif *v;
    struct listaddr *a;
    struct vif_acl *acl;

    for (vifi = 0; vifi < numvifs; vifi++) {
        v = &uvifs[vifi];
        while (v->uv_groups != NULL) {
            a = v->uv_groups;
            v->uv_groups = a->al_next;
            free((char *)a);
        }
        while (v->uv_neighbors != NULL) {
            a = v->uv_neighbors;
            v->uv_neighbors = a->al_next;
            nbrs[a->al_index] = NULL;
            free((char *)a);
        }
        while (v->uv_acl != NULL) {
            acl = v->uv_acl;
            v->uv_acl = acl->acl_next;
            free((char *)acl);
        }
    }
}


/*
 * Find the virtual interface from which an incoming packet arrived,
 * based on the packet's source and destination IP addresses.
 */
vifi_t
find_vif(u_int32 src, u_int32 dst)
{
    vifi_t vifi;
    struct uvif *v;
    struct phaddr *p;

    for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) {
        if (!(v->uv_flags & (VIFF_DOWN|VIFF_DISABLED))) {
            if (v->uv_flags & VIFF_TUNNEL) {
                if (src == v->uv_rmt_addr && (dst == v->uv_lcl_addr ||
                                              dst == dvmrp_group))
                    return(vifi);
            }
            else {
                if ((src & v->uv_subnetmask) == v->uv_subnet &&
                    ((v->uv_subnetmask == 0xffffffff) ||
                     (src != v->uv_subnetbcast)))
                    return(vifi);
                for (p=v->uv_addrs; p; p=p->pa_next) {
                    if ((src & p->pa_subnetmask) == p->pa_subnet &&
                        ((p->pa_subnetmask == 0xffffffff) ||
                         (src != p->pa_subnetbcast)))
                        return(vifi);
                }
            }
        }
    }
    return (NO_VIF);
}

static void
age_old_hosts(void)
{
    vifi_t vifi;
    struct uvif *v;
    struct listaddr *g;

    /*
     * Decrement the old-hosts-present timer for each
     * active group on each vif.
     */
    for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++)
        for (g = v->uv_groups; g != NULL; g = g->al_next)
            if (g->al_old)
                g->al_old--;
}


/*
 * Send group membership queries on each interface for which I am querier.
 * Note that technically, there should be a timer per interface, as the
 * dynamics of querier election can cause the "right" time to send a
 * query to be different on different interfaces.  However, this simple
 * implementation only ever sends queries sooner than the "right" time,
 * so can not cause loss of membership (but can send more packets than
 * necessary)
 */
void
query_groups(void)
{
    vifi_t vifi;
    struct uvif *v;

    for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) {
        if (v->uv_flags & VIFF_QUERIER) {
            send_query(v);
        }
    }
    age_old_hosts();
}

/*
 * Process an incoming host membership query.  Warn about
 * IGMP version mismatches, perform querier election, and
 * handle group-specific queries when we're not the querier.
 */
void
accept_membership_query(u_int32 src, u_int32 dst, u_int32 group, int tmo)
{
    vifi_t vifi;
    struct uvif *v;

    if ((vifi = find_vif(src, dst)) == NO_VIF ||
        (uvifs[vifi].uv_flags & VIFF_TUNNEL)) {
        dolog(LOG_INFO, 0,
            "ignoring group membership query from non-adjacent host %s",
            inet_fmt(src, s1));
        return;
    }

    v = &uvifs[vifi];

    if ((tmo == 0 && !(v->uv_flags & VIFF_IGMPV1)) ||
        (tmo != 0 &&  (v->uv_flags & VIFF_IGMPV1))) {
        int i;

        /*
         * Exponentially back-off warning rate
         */
        i = ++v->uv_igmpv1_warn;
        while (i && !(i & 1))
            i >>= 1;
        if (i == 1)
            dolog(LOG_WARNING, 0, "%s %s on vif %d, %s",
                tmo == 0 ? "Received IGMPv1 report from"
                         : "Received IGMPv2 report from",
                inet_fmt(src, s1),
                vifi,
                tmo == 0 ? "please configure vif for IGMPv1"
                         : "but I am configured for IGMPv1");
    }

    if (v->uv_querier == NULL || v->uv_querier->al_addr != src) {
        /*
         * This might be:
         * - A query from a new querier, with a lower source address
         *   than the current querier (who might be me)
         * - A query from a new router that just started up and doesn't
         *   know who the querier is.
         */
        if (ntohl(src) < (v->uv_querier ? ntohl(v->uv_querier->al_addr)
                                   : ntohl(v->uv_lcl_addr))) {
            IF_DEBUG(DEBUG_IGMP)
            dolog(LOG_DEBUG, 0, "new querier %s (was %s) on vif %d",
                       inet_fmt(src, s1),
                       v->uv_querier ? inet_fmt(v->uv_querier->al_addr, s2) :
                       "me", vifi);
            if (!v->uv_querier) {
                v->uv_querier = (struct listaddr *)
                                       malloc(sizeof(struct listaddr));
                v->uv_flags &= ~VIFF_QUERIER;
            }
            time(&v->uv_querier->al_ctime);
            v->uv_querier->al_addr = src;
        } else {
            IF_DEBUG(DEBUG_IGMP)
            dolog(LOG_DEBUG, 0, "ignoring query from %s; querier on vif %d is still %s",
                       inet_fmt(src, s1), vifi,
                       v->uv_querier ? inet_fmt(v->uv_querier->al_addr, s2) :
                       "me");

            return;
        }
    }

    /*
     * Reset the timer since we've received a query.
     */
    if (v->uv_querier && src == v->uv_querier->al_addr)
        v->uv_querier->al_timer = 0;

    /*
     * If this is a Group-Specific query which we did not source,
     * we must set our membership timer to [Last Member Query Count] *
     * the [Max Response Time] in the packet.
     */
    if (!(v->uv_flags & (VIFF_IGMPV1|VIFF_QUERIER)) && group != 0 &&
                                        src != v->uv_lcl_addr) {
        struct listaddr *g;

        IF_DEBUG(DEBUG_IGMP)
        dolog(LOG_DEBUG, 0,
            "%s for %s from %s on vif %d, timer %d",
            "Group-specific membership query",
            inet_fmt(group, s2), inet_fmt(src, s1), vifi, tmo);
        
        for (g = v->uv_groups; g != NULL; g = g->al_next) {
            if (group == g->al_addr && g->al_query == 0) {
                /* setup a timeout to remove the group membership */
                if (g->al_timerid)
                    g->al_timerid = DeleteTimer(g->al_timerid);
                g->al_timer = IGMP_LAST_MEMBER_QUERY_COUNT *
                                           tmo / IGMP_TIMER_SCALE;
                /* use al_query to record our presence in last-member state */
                g->al_query = -1;
                g->al_timerid = SetTimer(vifi, g);
                IF_DEBUG(DEBUG_IGMP)
                dolog(LOG_DEBUG, 0,
                    "timer for grp %s on vif %d set to %d",
                    inet_fmt(group, s2), vifi, g->al_timer);
                break;
            }
        }
    }
}

/*
 * Process an incoming group membership report.
 */
void
accept_group_report(u_int32 src, u_int32 dst, u_int32 group, int r_type)
{
    vifi_t vifi;
    struct uvif *v;
    struct listaddr *g;

    if ((vifi = find_vif(src, dst)) == NO_VIF ||
        (uvifs[vifi].uv_flags & VIFF_TUNNEL)) {
        dolog(LOG_INFO, 0,
            "ignoring group membership report from non-adjacent host %s",
            inet_fmt(src, s1));
        return;
    }

    v = &uvifs[vifi];

    /*
     * Look for the group in our group list; if found, reset its timer.
     */
    for (g = v->uv_groups; g != NULL; g = g->al_next) {
        if (group == g->al_addr) {
            if (r_type == IGMP_V1_MEMBERSHIP_REPORT)
                g->al_old = OLD_AGE_THRESHOLD;

            g->al_reporter = src;

            /** delete old timers, set a timer for expiration **/
            g->al_timer = IGMP_GROUP_MEMBERSHIP_INTERVAL;
            if (g->al_query)
                g->al_query = DeleteTimer(g->al_query);
            if (g->al_timerid)
                g->al_timerid = DeleteTimer(g->al_timerid);
            g->al_timerid = SetTimer(vifi, g);  
            break;
        }
    }

    /*
     * If not found, add it to the list and update kernel cache.
     */
    if (g == NULL) {
        g = (struct listaddr *)malloc(sizeof(struct listaddr));
        if (g == NULL)
            dolog(LOG_ERR, 0, "ran out of memory");    /* fatal */

        g->al_addr   = group;
        if (r_type == IGMP_V1_MEMBERSHIP_REPORT)
            g->al_old = OLD_AGE_THRESHOLD;
        else
            g->al_old = 0;

        /** set a timer for expiration **/
        g->al_query     = 0;
        g->al_timer     = IGMP_GROUP_MEMBERSHIP_INTERVAL;
        g->al_reporter  = src;
        g->al_timerid   = SetTimer(vifi, g);
        g->al_next      = v->uv_groups;
        v->uv_groups    = g;
        time(&g->al_ctime);

        update_lclgrp(vifi, group);
    }

    /* 
     * Check if a graft is necessary for this group
     */
    chkgrp_graft(vifi, group);
}

/*
 * Process an incoming IGMPv2 Leave Group message.
 */
void
accept_leave_message(u_int32 src, u_int32 dst, u_int32 group)
{
    vifi_t vifi;
    struct uvif *v;
    struct listaddr *g;

    if ((vifi = find_vif(src, dst)) == NO_VIF ||
        (uvifs[vifi].uv_flags & VIFF_TUNNEL)) {
        dolog(LOG_INFO, 0,
            "ignoring group leave report from non-adjacent host %s",
            inet_fmt(src, s1));
        return;
    }

    v = &uvifs[vifi];

    if (!(v->uv_flags & VIFF_QUERIER) || (v->uv_flags & VIFF_IGMPV1))
        return;

    /*
     * Look for the group in our group list in order to set up a short-timeout
     * query.
     */
    for (g = v->uv_groups; g != NULL; g = g->al_next) {
        if (group == g->al_addr) {
            IF_DEBUG(DEBUG_IGMP)
            dolog(LOG_DEBUG, 0,
                "[vif.c, _accept_leave_message] %d %d \n",
                g->al_old, g->al_query);

            /* Ignore the leave message if there are old hosts present */
            if (g->al_old)
                return;

            /* still waiting for a reply to a query, ignore the leave */
            if (g->al_query)
                return;

            /** delete old timer set a timer for expiration **/
            if (g->al_timerid)
                g->al_timerid = DeleteTimer(g->al_timerid);

#if IGMP_LAST_MEMBER_QUERY_COUNT != 2
This code needs to be updated to keep a counter of the number
of queries remaining.
#endif
            /** send a group specific querry **/
            g->al_timer = IGMP_LAST_MEMBER_QUERY_INTERVAL *
                        (IGMP_LAST_MEMBER_QUERY_COUNT + 1);
            send_igmp(v->uv_lcl_addr, g->al_addr,
                        IGMP_MEMBERSHIP_QUERY, 
                        IGMP_LAST_MEMBER_QUERY_INTERVAL * IGMP_TIMER_SCALE,
                        g->al_addr, 0);
            g->al_query = SetQueryTimer(g, vifi,
                        IGMP_LAST_MEMBER_QUERY_INTERVAL,
                        IGMP_LAST_MEMBER_QUERY_INTERVAL * IGMP_TIMER_SCALE);
            g->al_timerid = SetTimer(vifi, g);  
            break;
        }
    }
}


/*
 * Send a periodic probe on all vifs.
 * Useful to determine one-way interfaces.
 * Detect neighbor loss faster.
 */
void
probe_for_neighbors(void)
{
    vifi_t vifi;
    struct uvif *v;

    for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) {
        if (!(v->uv_flags & (VIFF_DOWN|VIFF_DISABLED))) {
            send_probe_on_vif(v);
        }
    }
}


/*
 * Send a list of all of our neighbors to the requestor, `src'.
 */
void
accept_neighbor_request(u_int32 src, u_int32 dst)
{
    vifi_t vifi;
    struct uvif *v;
    u_char *p, *ncount;
    struct listaddr *la;
    int datalen;
    u_int32 temp_addr, them = src;

#define PUT_ADDR(a)     temp_addr = ntohl(a); \
                        *p++ = temp_addr >> 24; \
                        *p++ = (temp_addr >> 16) & 0xFF; \
                        *p++ = (temp_addr >> 8) & 0xFF; \
                        *p++ = temp_addr & 0xFF;

    p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN);
    datalen = 0;

    for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) {
        if (v->uv_flags & VIFF_DISABLED)
            continue;

        ncount = 0;

        for (la = v->uv_neighbors; la; la = la->al_next) {

            /* Make sure that there's room for this neighbor... */
            if (datalen + (ncount == 0 ? 4 + 3 + 4 : 4) > MAX_DVMRP_DATA_LEN) {
                send_igmp(INADDR_ANY, them, IGMP_DVMRP, DVMRP_NEIGHBORS,
                          htonl(MROUTED_LEVEL), datalen);
                p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN);
                datalen = 0;
                ncount = 0;
            }

            /* Put out the header for this neighbor list... */
            if (ncount == 0) {
                PUT_ADDR(v->uv_lcl_addr);
                *p++ = v->uv_metric;
                *p++ = v->uv_threshold;
                ncount = p;
                *p++ = 0;
                datalen += 4 + 3;
            }

            PUT_ADDR(la->al_addr);
            datalen += 4;
            (*ncount)++;
        }
    }

    if (datalen != 0)
        send_igmp(INADDR_ANY, them, IGMP_DVMRP, DVMRP_NEIGHBORS,
                        htonl(MROUTED_LEVEL), datalen);
}

/*
 * Send a list of all of our neighbors to the requestor, `src'.
 */
void
accept_neighbor_request2(u_int32 src, u_int32 dst)
{
    vifi_t vifi;
    struct uvif *v;
    u_char *p, *ncount;
    struct listaddr *la;
    int datalen;
    u_int32 them = src;

    p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN);
    datalen = 0;

    for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) {
        u_short vflags = v->uv_flags;
        u_char rflags = 0;

        if (vflags & VIFF_TUNNEL)
            rflags |= DVMRP_NF_TUNNEL;
        if (vflags & VIFF_SRCRT)
            rflags |= DVMRP_NF_SRCRT;
        if (vflags & VIFF_DOWN)
            rflags |= DVMRP_NF_DOWN;
        if (vflags & VIFF_DISABLED)
            rflags |= DVMRP_NF_DISABLED;
        if (vflags & VIFF_QUERIER)
            rflags |= DVMRP_NF_QUERIER;
        if (vflags & VIFF_LEAF)
            rflags |= DVMRP_NF_LEAF;
        ncount = 0;
        la = v->uv_neighbors;
        if (la == NULL) {
            /*
             * include down & disabled interfaces and interfaces on
             * leaf nets.
             */
            if (rflags & DVMRP_NF_TUNNEL)
                rflags |= DVMRP_NF_DOWN;
            if (datalen > MAX_DVMRP_DATA_LEN - 12) {
                send_igmp(INADDR_ANY, them, IGMP_DVMRP, DVMRP_NEIGHBORS2,
                          htonl(MROUTED_LEVEL), datalen);
                p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN);
                datalen = 0;
            }
            *(u_int*)p = v->uv_lcl_addr;
            p += 4;
            *p++ = v->uv_metric;
            *p++ = v->uv_threshold;
            *p++ = rflags;
            *p++ = 1;
            *(u_int*)p =  v->uv_rmt_addr;
            p += 4;
            datalen += 12;
        } else {
            for ( ; la; la = la->al_next) {
                /* Make sure that there's room for this neighbor... */
                if (datalen + (ncount == 0 ? 4+4+4 : 4) > MAX_DVMRP_DATA_LEN) {
                    send_igmp(INADDR_ANY, them, IGMP_DVMRP, DVMRP_NEIGHBORS2,
                              htonl(MROUTED_LEVEL), datalen);
                    p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN);
                    datalen = 0;
                    ncount = 0;
                }
                /* Put out the header for this neighbor list... */
                if (ncount == 0) {
                    /* If it's a one-way tunnel, mark it down. */
                    if (rflags & DVMRP_NF_TUNNEL && la->al_flags & NBRF_ONEWAY)
                        rflags |= DVMRP_NF_DOWN;
                    *(u_int*)p = v->uv_lcl_addr;
                    p += 4;
                    *p++ = v->uv_metric;
                    *p++ = v->uv_threshold;
                    *p++ = rflags;
                    ncount = p;
                    *p++ = 0;
                    datalen += 4 + 4;
                }
                /* Don't report one-way peering on phyint at all */
                if (!(rflags & DVMRP_NF_TUNNEL) && la->al_flags & NBRF_ONEWAY)
                    continue;
                *(u_int*)p = la->al_addr;
                p += 4;
                datalen += 4;
                (*ncount)++;
            }
            if (*ncount == 0) {
                *(u_int*)p = v->uv_rmt_addr;
                p += 4;
                datalen += 4;
                (*ncount)++;
            }
        }
    }
    if (datalen != 0)
        send_igmp(INADDR_ANY, them, IGMP_DVMRP, DVMRP_NEIGHBORS2,
                htonl(MROUTED_LEVEL), datalen);
}

void
accept_info_request(u_int32 src, u_int32 dst, u_char *p, int datalen)
{
    u_char *q;
    int len;
    int outlen = 0;

    q = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN);

    /* To be general, this must deal properly with breaking up over-sized
     * packets.  That implies passing a length to each function, and
     * allowing each function to request to be called again.  Right now,
     * we're only implementing the one thing we are positive will fit into
     * a single packet, so we wimp out.
     */
    while (datalen > 0) {
        len = 0;
        switch (*p) {
            case DVMRP_INFO_VERSION:
                len = info_version(q, RECV_BUF_SIZE-(q-(u_char *)send_buf));
                break;

            case DVMRP_INFO_NEIGHBORS:
            default:
                dolog(LOG_INFO, 0, "ignoring unknown info type %d", *p);
                break;
        }
        *(q+1) = len++;
        outlen += len * 4;
        q += len * 4;
        len = (*(p+1) + 1) * 4;
        p += len;
        datalen -= len;
    }

    if (outlen != 0)
        send_igmp(INADDR_ANY, src, IGMP_DVMRP, DVMRP_INFO_REPLY,
                        htonl(MROUTED_LEVEL), outlen);
}

/*
 * Information response -- return version string
 */
static int
info_version(char *p, int plen)
{
    int len;
    extern char versionstring[];

    *p++ = DVMRP_INFO_VERSION;
    p++;        /* skip over length */
    *p++ = 0;   /* zero out */
    *p++ = 0;   /* reserved fields */
    strncpy(p, versionstring, plen - 4);
    p[plen-5] = '\0';

    len = strlen(versionstring);
    return ((len + 3) / 4);
}

/*
 * Process an incoming neighbor-list message.
 */
void
accept_neighbors(u_int32 src, u_int32 dst, u_char *p, int datalen,
                 u_int32 level)
{
    dolog(LOG_INFO, 0, "ignoring spurious DVMRP neighbor list from %s to %s",
        inet_fmt(src, s1), inet_fmt(dst, s2));
}


/*
 * Process an incoming neighbor-list message.
 */
void
accept_neighbors2(u_int32 src, u_int32 dst, u_char *p, int datalen,
                  u_int32 level)
{
    IF_DEBUG(DEBUG_PKT)
    dolog(LOG_DEBUG, 0, "ignoring spurious DVMRP neighbor list2 from %s to %s",
        inet_fmt(src, s1), inet_fmt(dst, s2));
}

/*
 * Process an incoming info reply message.
 */
void
accept_info_reply(u_int32 src, u_int32 dst, u_char *p, int datalen)
{
    IF_DEBUG(DEBUG_PKT)
    dolog(LOG_DEBUG, 0, "ignoring spurious DVMRP info reply from %s to %s",
        inet_fmt(src, s1), inet_fmt(dst, s2));
}


/*
 * Update the neighbor entry for neighbor 'addr' on vif 'vifi'.
 * 'msgtype' is the type of DVMRP message received from the neighbor.
 * Return the neighbor entry if 'addr' is a valid neighbor, FALSE otherwise.
 */
struct listaddr *
update_neighbor(vifi_t vifi, u_int32 addr, int msgtype, char *p, int datalen,
                u_int32 level)
{
    struct uvif *v;
    struct listaddr *n;
    int pv = level & 0xff;
    int mv = (level >> 8) & 0xff;
    int has_genid = 0;
    int in_router_list = 0;
    int dvmrpspec = 0;
    u_int32 genid;
    u_int32 send_tables = 0;
    int i;
    int do_reset = FALSE;

    v = &uvifs[vifi];

    /*
     * Confirm that 'addr' is a valid neighbor address on vif 'vifi'.
     * IT IS ASSUMED that this was preceded by a call to find_vif(), which
     * checks that 'addr' is either a valid remote tunnel endpoint or a
     * non-broadcast address belonging to a directly-connected subnet.
     * Therefore, here we check only that 'addr' is not our own address
     * (due to an impostor or erroneous loopback) or an address of the form
     * {subnet,0} ("the unknown host").  These checks are not performed in
     * find_vif() because those types of address are acceptable for some
     * types of IGMP message (such as group membership reports).
     */
    if (!(v->uv_flags & VIFF_TUNNEL) &&
        (addr == v->uv_lcl_addr ||
         addr == v->uv_subnet )) {
        dolog(LOG_WARNING, 0,
            "received DVMRP message from %s: %s",
            (addr == v->uv_lcl_addr) ? "self (check device loopback)" :
                                       "'the unknown host'",
            inet_fmt(addr, s1));
        return NULL;
    }

    /*
     * Ignore all neighbors on vifs forced into leaf mode
     */
    if (v->uv_flags & VIFF_FORCE_LEAF) {
        return NULL;
    }

    /*
     * mrouted's version 3.3 and later include the generation ID
     * and the list of neighbors on the vif in their probe messages.
     */
    if (msgtype == DVMRP_PROBE && ((pv == 3 && mv > 2) ||
                                   (pv > 3 && pv < 10))) {
        u_int32 router;

        IF_DEBUG(DEBUG_PEER)
        dolog(LOG_DEBUG, 0, "checking probe from %s (%d.%d) on vif %d",
            inet_fmt(addr, s1), pv, mv, vifi);

        if (datalen < 4) {
            dolog(LOG_WARNING, 0,
                "received truncated probe message from %s (len %d)",
                inet_fmt(addr, s1), datalen);
            return NULL;
        }

        has_genid = 1;

        for (i = 0; i < 4; i++)
          ((char *)&genid)[i] = *p++;
        datalen -= 4;

        while (datalen > 0) {
            if (datalen < 4) {
                dolog(LOG_WARNING, 0,
                    "received truncated probe message from %s (len %d)",
                    inet_fmt(addr, s1), datalen);
                return NULL;
            }
            for (i = 0; i < 4; i++)
              ((char *)&router)[i] = *p++;
            datalen -= 4;

            if (router == v->uv_lcl_addr) {
                in_router_list = 1;
                break;
            }
        }
    }

    if ((pv == 3 && mv == 255) || (pv > 3 && pv < 10))
        dvmrpspec = 1;

    /*
     * Look for addr in list of neighbors.
     */
    for (n = v->uv_neighbors; n != NULL; n = n->al_next) {
        if (addr == n->al_addr) {
            break;
        }
    }

    if (n == NULL) {
        /*
         * New neighbor.
         *
         * If this neighbor follows the DVMRP spec, start the probe
         * handshake.  If not, then it doesn't require the probe
         * handshake, so establish the peering immediately.
         */
        if (dvmrpspec && (msgtype != DVMRP_PROBE))
            return NULL;

        for (i = 0; i < MAXNBRS; i++)
            if (nbrs[i] == NULL)
                break;

        if (i == MAXNBRS) {
            /* XXX This is a severe new restriction. */
            /* XXX want extensible bitmaps! */
            dolog(LOG_ERR, 0, "Can't handle %dth neighbor %s on vif %d!",
                MAXNBRS, inet_fmt(addr, s1), vifi);
            /*NOTREACHED*/
        }

        /*
         * Add it to our list of neighbors.
         */
        IF_DEBUG(DEBUG_PEER)
        dolog(LOG_DEBUG, 0, "New neighbor %s on vif %d v%d.%d nf 0x%02x idx %d",
            inet_fmt(addr, s1), vifi, level & 0xff, (level >> 8) & 0xff,
            (level >> 16) & 0xff, i);

        n = (struct listaddr *)malloc(sizeof(struct listaddr));
        if (n == NULL)
            dolog(LOG_ERR, 0, "ran out of memory");    /* fatal */

        n->al_addr      = addr;
        n->al_pv        = pv;
        n->al_mv        = mv;
        n->al_genid     = has_genid ? genid : 0;
        n->al_index     = i;
        nbrs[i] = n;

        time(&n->al_ctime);
        n->al_timer     = 0;
        n->al_flags     = has_genid ? NBRF_GENID : 0;
        n->al_next      = v->uv_neighbors;
        v->uv_neighbors = n;

        /*
         * If we are not configured to peer with non-pruning routers,
         * check the deprecated "I-know-how-to-prune" bit.  This bit
         * was MBZ in early mrouted implementations (<3.5) and is required
         * to be set by the DVMRPv3 specification.
         */
        if (!(v->uv_flags & VIFF_ALLOW_NONPRUNERS) &&
            !((level & 0x020000) || (pv == 3 && mv < 5))) {
            n->al_flags |= NBRF_TOOOLD;
        }

        /*
         * If this router implements the DVMRPv3 spec, then don't peer
         * with him if we haven't yet established a bidirectional connection.
         */
        if (dvmrpspec) {
            if (!in_router_list) {
                IF_DEBUG(DEBUG_PEER)
                dolog(LOG_DEBUG, 0, "waiting for probe from %s with my addr",
                    inet_fmt(addr, s1));
                n->al_flags |= NBRF_WAITING;
                return NULL;
            }
        }

        if (n->al_flags & NBRF_DONTPEER) {
            IF_DEBUG(DEBUG_PEER)
            dolog(LOG_DEBUG, 0, "not peering with %s on vif %d because %x",
                inet_fmt(addr, s1), vifi, n->al_flags & NBRF_DONTPEER);
            return NULL;
        }

        /*
         * If we thought that we had no neighbors on this vif, send a route
         * report to the vif.  If this is just a new neighbor on the same
         * vif, send the route report just to the new neighbor.
         */
        if (NBRM_ISEMPTY(v->uv_nbrmap)) {
            send_tables = v->uv_dst_addr;
            vifs_with_neighbors++;
        } else {
            send_tables = addr;
        }


        NBRM_SET(i, v->uv_nbrmap);
        add_neighbor_to_routes(vifi, i);
    } else {
        /*
         * Found it.  Reset its timer.
         */
        n->al_timer = 0;

        if (n->al_flags & NBRF_WAITING && msgtype == DVMRP_PROBE) {
            n->al_flags &= ~NBRF_WAITING;
            if (!in_router_list) {
                dolog(LOG_WARNING, 0, "possible one-way peering with %s on vif %d",
                    inet_fmt(addr, s1), vifi);
                n->al_flags |= NBRF_ONEWAY;
                return NULL;
            } else {
                if (NBRM_ISEMPTY(v->uv_nbrmap)) {
                    send_tables = v->uv_dst_addr;
                    vifs_with_neighbors++;
                } else {
                    send_tables = addr;
                }
                NBRM_SET(n->al_index, v->uv_nbrmap);
                add_neighbor_to_routes(vifi, n->al_index);
                IF_DEBUG(DEBUG_PEER)
                dolog(LOG_DEBUG, 0, "%s on vif %d exits WAITING",
                    inet_fmt(addr, s1), vifi);
            }
        }

        if (n->al_flags & NBRF_ONEWAY && msgtype == DVMRP_PROBE) {
            if (in_router_list) {
                if (NBRM_ISEMPTY(v->uv_nbrmap))
                    vifs_with_neighbors++;
                NBRM_SET(n->al_index, v->uv_nbrmap);
                add_neighbor_to_routes(vifi, n->al_index);
                dolog(LOG_NOTICE, 0, "peering with %s on vif %d is no longer one-way",
                        inet_fmt(addr, s1), vifi);
                n->al_flags &= ~NBRF_ONEWAY;
            } else {
                /* XXX rate-limited warning message? */
                IF_DEBUG(DEBUG_PEER)
                dolog(LOG_DEBUG, 0, "%s on vif %d is still ONEWAY",
                    inet_fmt(addr, s1), vifi);
            }
        }

        /*
         * When peering with a genid-capable but pre-DVMRP spec peer,
         * we might bring up the peering with a route report and not
         * remember his genid.  Assume that he doesn't send a route
         * report and then reboot before sending a probe.
         */
        if (has_genid && !(n->al_flags & NBRF_GENID)) {
            n->al_flags |= NBRF_GENID;
            n->al_genid = genid;
        }

        /*
         * update the neighbors version and protocol number and genid
         * if changed => router went down and came up, 
         * so take action immediately.
         */
        if ((n->al_pv != pv) ||
            (n->al_mv != mv) ||
            (has_genid && n->al_genid != genid)) {

            do_reset = TRUE;
            IF_DEBUG(DEBUG_PEER)
            dolog(LOG_DEBUG, 0,
                "version/genid change neighbor %s [old:%d.%d/%8x, new:%d.%d/%8x]",
                inet_fmt(addr, s1),
                n->al_pv, n->al_mv, n->al_genid, pv, mv, genid);
            
            n->al_pv = pv;
            n->al_mv = mv;
            n->al_genid = genid;
            time(&n->al_ctime);
        }

        if ((pv == 3 && mv > 2) || (pv > 3 && pv < 10)) {
            if (!(n->al_flags & VIFF_ONEWAY) && has_genid && !in_router_list &&
                                (time(NULL) - n->al_ctime > 20)) {
                if (NBRM_ISSET(n->al_index, v->uv_nbrmap)) {
                    NBRM_CLR(n->al_index, v->uv_nbrmap);
                    if (NBRM_ISEMPTY(v->uv_nbrmap))
                        vifs_with_neighbors--;
                }
                delete_neighbor_from_routes(addr, vifi, n->al_index);
                reset_neighbor_state(vifi, addr);
                dolog(LOG_WARNING, 0, "peering with %s on vif %d is one-way",
                        inet_fmt(addr, s1), vifi);
                n->al_flags |= NBRF_ONEWAY;
            }
        }

        if (n->al_flags & NBRF_DONTPEER) {
            IF_DEBUG(DEBUG_PEER)
            dolog(LOG_DEBUG, 0, "not peering with %s on vif %d because %x",
                inet_fmt(addr, s1), vifi, n->al_flags & NBRF_DONTPEER);
            return NULL;
        }

        /* check "leaf" flag */
    }
    if (do_reset) {
        reset_neighbor_state(vifi, addr);
        if (!send_tables)
            send_tables = addr;
    }
    if (send_tables) {
        send_probe_on_vif(v);
        report(ALL_ROUTES, vifi, send_tables);
    }
    v->uv_leaf_timer = 0;
    v->uv_flags &= ~VIFF_LEAF;

    return n;
}


/*
 * On every timer interrupt, advance the timer in each neighbor and
 * group entry on every vif.
 */
void
age_vifs(void)
{
    vifi_t vifi;
    struct uvif *v;
    struct listaddr *a, *prev_a;
    u_int32 addr;

    for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v ) {
        if (v->uv_leaf_timer && (v->uv_leaf_timer -= TIMER_INTERVAL == 0)) {
                v->uv_flags |= VIFF_LEAF;
        }

        for (prev_a = (struct listaddr *)&(v->uv_neighbors),
             a = v->uv_neighbors;
             a != NULL;
             prev_a = a, a = a->al_next) {
            int exp_time;
            int idx;

            if (((a->al_pv == 3) && (a->al_mv >= 3)) ||
                ((a->al_pv > 3) && (a->al_pv < 10)))
                exp_time = NEIGHBOR_EXPIRE_TIME;
            else
                exp_time = OLD_NEIGHBOR_EXPIRE_TIME;

            if ((a->al_timer += TIMER_INTERVAL) < exp_time)
                continue;

            IF_DEBUG(DEBUG_PEER)
            dolog(LOG_DEBUG, 0, "Neighbor %s (%d.%d) expired after %d seconds",
                    inet_fmt(a->al_addr, s1), a->al_pv, a->al_mv, exp_time);

            /*
             * Neighbor has expired; delete it from the neighbor list,
             * delete it from the 'dominants' and 'subordinates arrays of
             * any route entries.
             */
            NBRM_CLR(a->al_index, v->uv_nbrmap);
            nbrs[a->al_index] = NULL;   /* XXX is it a good idea to reuse indxs? */
            idx = a->al_index;
            addr = a->al_addr;
            prev_a->al_next = a->al_next;
            free((char *)a);
            a = prev_a;/*XXX use ** */

            delete_neighbor_from_routes(addr, vifi, idx);
            reset_neighbor_state(vifi, addr);

            if (NBRM_ISEMPTY(v->uv_nbrmap))
                vifs_with_neighbors--;

            v->uv_leaf_timer = LEAF_CONFIRMATION_TIME;
        }

        if (v->uv_querier &&
            (v->uv_querier->al_timer += TIMER_INTERVAL) >
                IGMP_OTHER_QUERIER_PRESENT_INTERVAL) {
            /*
             * The current querier has timed out.  We must become the
             * querier.
             */
            IF_DEBUG(DEBUG_IGMP)
            dolog(LOG_DEBUG, 0, "querier %s timed out",
                    inet_fmt(v->uv_querier->al_addr, s1));
            free(v->uv_querier);
            v->uv_querier = NULL;
            v->uv_flags |= VIFF_QUERIER;
            send_query(v);
        }
    }
}

/*
 * Returns the neighbor info struct for a given neighbor
 */
struct listaddr *
neighbor_info(vifi_t vifi, u_int32 addr)
{
    struct listaddr *u;

    for (u = uvifs[vifi].uv_neighbors; u; u = u->al_next)
        if (u->al_addr == addr)
            return u;

    return NULL;
}

static struct vnflags {
        int     vn_flag;
        char   *vn_name;
} vifflags[] = {
        { VIFF_DOWN,            "down" },
        { VIFF_DISABLED,        "disabled" },
        { VIFF_QUERIER,         "querier" },
        { VIFF_ONEWAY,          "one-way" },
        { VIFF_LEAF,            "leaf" },
        { VIFF_IGMPV1,          "IGMPv1" },
        { VIFF_REXMIT_PRUNES,   "rexmit_prunes" },
        { VIFF_PASSIVE,         "passive" },
        { VIFF_ALLOW_NONPRUNERS,"allow_nonpruners" },
        { VIFF_NOFLOOD,         "noflood" },
        { VIFF_NOTRANSIT,       "notransit" },
        { VIFF_BLASTER,         "blaster" },
        { VIFF_FORCE_LEAF,      "force_leaf" },
        { VIFF_OTUNNEL,         "old-tunnel" },
};

static struct vnflags nbrflags[] = {
        { NBRF_LEAF,            "leaf" },
        { NBRF_GENID,           "have-genid" },
        { NBRF_WAITING,         "waiting" },
        { NBRF_ONEWAY,          "one-way" },
        { NBRF_TOOOLD,          "too old" },
        { NBRF_TOOMANYROUTES,   "too many routes" },
        { NBRF_NOTPRUNING,      "not pruning?" },
};

/*
 * Print the contents of the uvifs array on file 'fp'.
 */
void
dump_vifs(FILE *fp)
{
    vifi_t vifi;
    struct uvif *v;
    struct listaddr *a;
    struct phaddr *p;
    struct vif_acl *acl;
    int i;
    struct sioc_vif_req v_req;
    time_t now;
    char *label;

    time(&now);
    fprintf(fp, "vifs_with_neighbors = %d\n", vifs_with_neighbors);

    if (vifs_with_neighbors == 1)
        fprintf(fp,"[This host is a leaf]\n\n");

    fprintf(fp,
    "\nVirtual Interface Table\n%s",
    "Vif  Name  Local-Address                               ");
    fprintf(fp,
    "M  Thr  Rate   Flags\n");

    for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) {

        fprintf(fp, "%2u %6s  %-15s %6s: %-18s %2u %3u  %5u  ",
                vifi,
                v->uv_name,
                inet_fmt(v->uv_lcl_addr, s1),
                (v->uv_flags & VIFF_TUNNEL) ?
                        "tunnel":
                        "subnet",
                (v->uv_flags & VIFF_TUNNEL) ?
                        inet_fmt(v->uv_rmt_addr, s2) :
                        inet_fmts(v->uv_subnet, v->uv_subnetmask, s3),
                v->uv_metric,
                v->uv_threshold,
                v->uv_rate_limit);

        for (i = 0; i < sizeof(vifflags) / sizeof(struct vnflags); i++)
                if (v->uv_flags & vifflags[i].vn_flag)
                        fprintf(fp, " %s", vifflags[i].vn_name);

        fprintf(fp, "\n");
        /*
        fprintf(fp, "                          #routes: %d\n", v->uv_nroutes);
        */
        if (v->uv_admetric != 0)
            fprintf(fp, "                                        advert-metric %2u\n",
                v->uv_admetric);

        label = "alternate subnets:";
        for (p = v->uv_addrs; p; p = p->pa_next) {
            fprintf(fp, "                %18s %s\n", label,
                        inet_fmts(p->pa_subnet, p->pa_subnetmask, s1));
            label = "";
        }

        label = "peers:";
        for (a = v->uv_neighbors; a != NULL; a = a->al_next) {
            fprintf(fp, "                            %6s %s (%d.%d) [%d]",
                    label, inet_fmt(a->al_addr, s1), a->al_pv, a->al_mv,
                    a->al_index);
            for (i = 0; i < sizeof(nbrflags) / sizeof(struct vnflags); i++)
                    if (a->al_flags & nbrflags[i].vn_flag)
                            fprintf(fp, " %s", nbrflags[i].vn_name);
            fprintf(fp, " up %s\n", scaletime(now - a->al_ctime));
            /*fprintf(fp, " #routes %d\n", a->al_nroutes);*/
            label = "";
        }

        label = "group host (time left):";
        for (a = v->uv_groups; a != NULL; a = a->al_next) {
            fprintf(fp, "           %23s %-15s %-15s (%s)\n",
                    label,
                    inet_fmt(a->al_addr, s1),
                    inet_fmt(a->al_reporter, s2),
                    scaletime(timer_leftTimer(a->al_timerid)));
            label = "";
        }
        label = "boundaries:";
        for (acl = v->uv_acl; acl != NULL; acl = acl->acl_next) {
            fprintf(fp, "                       %11s %-18s\n", label,
                        inet_fmts(acl->acl_addr, acl->acl_mask, s1));
            label = "";
        }
        if (v->uv_filter) {
            struct vf_element *vfe;
            char lbuf[100];

            sprintf(lbuf, "%5s %7s filter:",
                        v->uv_filter->vf_flags & VFF_BIDIR ? "bidir"
                                                           : "     ",
                        v->uv_filter->vf_type == VFT_ACCEPT ? "accept"
                                                            : "deny");
            label = lbuf;
            for (vfe = v->uv_filter->vf_filter;
                                        vfe != NULL; vfe = vfe->vfe_next) {
                fprintf(fp, "           %23s %-18s%s\n",
                        label,
                        inet_fmts(vfe->vfe_addr, vfe->vfe_mask, s1),
                        vfe->vfe_flags & VFEF_EXACT ? " (exact)" : "");
                label = "";
            }
        }
        if (!(v->uv_flags & (VIFF_TUNNEL|VIFF_DOWN|VIFF_DISABLED))) {
            fprintf(fp, "                     IGMP querier: ");
            if (v->uv_querier == NULL)
                if (v->uv_flags & VIFF_QUERIER)
                    fprintf(fp, "%-18s (this system)\n",
                                    inet_fmt(v->uv_lcl_addr, s1));
                else
                    fprintf(fp, "NONE - querier election failure?\n");
            else
                fprintf(fp, "%-18s up %s last heard %s ago\n",
                        inet_fmt(v->uv_querier->al_addr, s1),
                        scaletime(now - v->uv_querier->al_ctime),
                        scaletime(v->uv_querier->al_timer));
        }
        if (v->uv_flags & VIFF_BLASTER)
            fprintf(fp, "                  blasterbuf size: %dk\n",
                        v->uv_blasterlen / 1024);
        fprintf(fp, "                      Nbr bitmaps: 0x%08lx%08lx\n",/*XXX*/
                        v->uv_nbrmap.hi, v->uv_nbrmap.lo);
        if (v->uv_prune_lifetime != 0)
            fprintf(fp, "                   Prune Lifetime: %d seconds\n",
                                            v->uv_prune_lifetime);

        v_req.vifi = vifi;
        if (did_final_init)
            if (ioctl(udp_socket, SIOCGETVIFCNT, (char *)&v_req) < 0) {
                dolog(LOG_WARNING, errno,
                    "SIOCGETVIFCNT fails on vif %d", vifi);
            } else {
                fprintf(fp, "                   pkts/bytes in : %lu/%lu\n",
                        v_req.icount, v_req.ibytes);
                fprintf(fp, "                   pkts/bytes out: %lu/%lu\n",
                        v_req.ocount, v_req.obytes);
            }
        fprintf(fp, "\n");
    }
    fprintf(fp, "\n");
}

/*
 * Time out record of a group membership on a vif
 */
static void
DelVif(void *arg)
{
    cbk_t *cbk = (cbk_t *)arg;
    vifi_t vifi = cbk->vifi;
    struct uvif *v = &uvifs[vifi];
    struct listaddr *a, **anp, *g = cbk->g;

    /*
     * Group has expired
     * delete all kernel cache entries with this group
     */
    if (g->al_query)
        DeleteTimer(g->al_query);

    delete_lclgrp(vifi, g->al_addr);

    anp = &(v->uv_groups);
    while ((a = *anp) != NULL) {
        if (a == g) {
            *anp = a->al_next;
            free((char *)a);
        } else {
            anp = &a->al_next;
        }
    }

    free(cbk);
}

/*
 * Set a timer to delete the record of a group membership on a vif.
 */
static int
SetTimer(vifi_t vifi, struct listaddr *g)
{
    cbk_t *cbk;

    cbk = (cbk_t *) malloc(sizeof(cbk_t));
    cbk->g = g;
    cbk->vifi = vifi;
    return timer_setTimer(g->al_timer, DelVif, cbk);
}

/*
 * Delete a timer that was set above.
 */
static int
DeleteTimer(int id)
{
    timer_clearTimer(id);
    return 0;
}

/*
 * Send a group-specific query.
 */
static void
SendQuery(void *arg)
{
    cbk_t *cbk = (cbk_t *)arg;
    struct uvif *v = &uvifs[cbk->vifi];

    send_igmp(v->uv_lcl_addr, cbk->g->al_addr,
              IGMP_MEMBERSHIP_QUERY,
              cbk->q_time, cbk->g->al_addr, 0);
    cbk->g->al_query = 0;
    free(cbk);
}

/*
 * Set a timer to send a group-specific query.
 */
static int
SetQueryTimer(struct listaddr *g, vifi_t vifi, int to_expire, int q_time)
{
    cbk_t *cbk;

    cbk = (cbk_t *) malloc(sizeof(cbk_t));
    cbk->g = g;
    cbk->q_time = q_time;
    cbk->vifi = vifi;
    return timer_setTimer(to_expire, SendQuery, cbk);
}