text: /*
   * 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 $
   */
  
  #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 = NULL;
  
  	for (la = v->uv_neighbors; la; la = la->al_next) {
  
  	    /* Make sure that there's room for this neighbor... */
  	    if (datalen + (ncount == NULL ? 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 = NULL;
  	    }
  
  	    /* Put out the header for this neighbor list... */
  	    if (ncount == NULL) {
  		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 = NULL;
  	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 == NULL ? 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 = NULL;
  		}
  		/* Put out the header for this neighbor list... */
  		if (ncount == NULL) {
  		    /* 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);
  }
  