/*
 * Copyright (c) 1983, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#ifndef lint
static char sccsid[] = "@(#)if.c	8.1 (Berkeley) 6/5/93";
#endif /* not lint */

#ident "$Revision: 1.1 $"

#include "defs.h"
#include "pathnames.h"

struct	interface *ifnet;		/* all interfaces */
int	tot_interfaces;			/* # of remote and local interfaces */
int	rip_interfaces;			/* # of interfaces doing RIP */
int	foundloopback;			/* valid flag for loopaddr */
naddr	loopaddr;			/* our address on loopback */

struct timeval ifinit_timer;

int	have_ripv1;			/* have a RIPv1 interface */


/* Find the interface with an address
 */
struct interface *
ifwithaddr(naddr addr,
	   int	bcast,			/* notice IFF_BROADCAST address */
	   int	remote)			/* include IS_REMOTE interfaces */
{
	struct interface *ifp, *possible = 0;

	for (ifp = ifnet; ifp; ifp = ifp->int_next) {
		if ((ifp->int_state & IS_REMOTE) && !remote)
			continue;

		if (ifp->int_addr == addr
		    || ((ifp->int_if_flags & IFF_BROADCAST)
			&& ifp->int_brdaddr == addr
			&& bcast)) {
			if (!(ifp->int_state & IS_BROKE))
				return ifp;
			possible = ifp;
		}
	}

	return possible;
}


/* find the interface with a name
 */
struct interface *
ifwithname(char *name,			/* enp0 or whatever */
	   naddr addr)			/* 0 or network address */
{
	struct interface *ifp;


	for (ifp = ifnet; 0 != ifp; ifp = ifp->int_next) {
		if (!strcmp(ifp->int_name, name)
		    && ((addr == 0 && !(ifp->int_state & IS_ALIAS)
			 || ifp->int_addr == addr)))
			return ifp;
	}
	return 0;
}


struct interface *
ifwithindex(u_short index)
{
	struct interface *ifp;


	for (ifp = ifnet; 0 != ifp; ifp = ifp->int_next) {
		if (ifp->int_index == index)
			return ifp;
	}
	return 0;
}


/* Find an interface from which the specified address
 * should have come from.  Used for figuring out which
 * interface a packet came in on -- for tracing.
 */
struct interface *
iflookup(naddr addr)
{
	struct interface *ifp, *maybe;
	int twice;

	twice = 0;
	maybe = 0;
	do {
		for (ifp = ifnet; ifp; ifp = ifp->int_next) {
			/* finished with an exact match */
			if (ifp->int_addr == addr)
				return ifp;

			if ((ifp->int_if_flags & IFF_BROADCAST)
			    && ifp->int_brdaddr == addr)
				return ifp;

			if ((ifp->int_if_flags & IFF_POINTOPOINT)
			    && ifp->int_dstaddr == addr)
				return ifp;

			/* Look for the longest approximate match.
			 */
			if (on_net(addr,
				   ifp->int_net, ifp->int_mask)
			    && (maybe == 0
				|| ifp->int_mask > maybe->int_mask))
				maybe = ifp;
		}

		if (maybe != 0)
			return maybe;

		/* See if an interface has come up since we checked.
		 */
		ifinit();
	} while (twice++ == 0);

	return 0;
}


/* Return the classical netmask for an IP address.
 */
naddr
std_mask(naddr addr)
{
	NTOHL(addr);			/* was a host, not a network */

	if (addr == 0)			/* default route has mask 0 */
		return 0;
	if (IN_CLASSA(addr))
		return IN_CLASSA_NET;
	if (IN_CLASSB(addr))
		return IN_CLASSB_NET;
	return IN_CLASSC_NET;
}


/* find the netmask that would be inferred by RIPv1 listeners
 * on the given interface
 */
naddr
ripv1_mask_net(naddr addr,		/* in network byte order */
	       struct interface *ifp1,	/* as seen on this interface */
	       struct interface *ifp2)	/* but not this interface */
{
	naddr mask = 0;

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

	if (ifp1 != 0) {
		/* If the target is that of the associated interface on which
		 * it arrived, then use the netmask of the interface.
		 */
		if (on_net(addr, ifp1->int_net, ifp1->int_std_mask))
			mask = ifp1->int_mask;

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

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

	return mask;
}


naddr
ripv1_mask_host(naddr addr,		/* in network byte order */
		struct interface *ifp1,	/* as seen on this interface */
		struct interface *ifp2)	/* but not this interface */
{
	naddr mask = ripv1_mask_net(addr, ifp1, ifp2);


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


/* See if a IP address looks reasonable as a destination
 */
int					/* 0=bad */
check_dst(naddr addr)
{
	NTOHL(addr);

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

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

	return (IN_CLASSB(addr) || IN_CLASSC(addr));
}


/* Delete an interface.
 */
static void
ifdel(struct interface *ifp)
{
	struct ip_mreq m;
	struct interface *ifp1;


	if (TRACEACTIONS)
		trace_if("Del", ifp);

	if (!(ifp->int_state & IS_ALIAS)) {
		if ((ifp->int_if_flags & IFF_MULTICAST)
#ifdef MCAST_PPP_BUG
		    && !(ifp->int_if_flags & IFF_POINTOPOINT)
#endif
		    && rip_sock >= 0) {
			m.imr_multiaddr.s_addr = htonl(INADDR_RIP_GROUP);
			m.imr_interface.s_addr = ((ifp->int_if_flags
						   & IFF_POINTOPOINT)
						  ? ifp->int_dstaddr
						  : ifp->int_addr);
			if (setsockopt(rip_sock,IPPROTO_IP,IP_DROP_MEMBERSHIP,
				       &m, sizeof(m)) < 0)
				DBGERR(1,"setsockopt(IP_DROP_MEMBERSHIP"
				       " RIP)");
		}
		if (ifp->int_rip_sock >= 0) {
			(void)close(ifp->int_rip_sock);
			ifp->int_rip_sock = -1;
			fix_select();
		}
		set_rdisc_mg(ifp, 0);
	}

	/* Zap all routes associated with this interface.
	 * Assume routes just using gateways beyond this interface will
	 * timeout naturally, and have probably already died.
	 */
	ifp->int_state |= IS_BROKE;
	(void)rn_walktree(rhead, walk_bad, 0);
	ifbad_rdisc(ifp);

	if (!(ifp->int_state & IS_ALIAS)) {
		tot_interfaces--;
		if (0 == (ifp->int_state & (IS_NO_RIP_IN|IS_PASSIVE)))
			rip_interfaces--;
	}

	/* unlink and forget the interface */
	if (rip_sock_mcast == ifp)
		rip_sock_mcast = 0;
	if (ifp->int_next != 0)
		ifp->int_next->int_prev = ifp->int_prev;
	if (ifp->int_prev != 0)
		ifp->int_prev->int_next = ifp->int_next;
	else
		ifnet = ifp->int_next;

	if (!(ifp->int_state & IS_ALIAS)) {
		/* delete aliases of primary interface */
		for (ifp1 = ifnet; 0 != ifp1; ifp1 = ifp1->int_next) {
			if (!strcmp(ifp->int_name, ifp1->int_name))
				ifdel(ifp1);
		}
	}

	free(ifp);
}


/* Mark an interface dead.
 */
void
ifbad(struct interface *ifp,
      char *pat)
{
	if (ifp->int_state & IS_BROKE)
		return;

	if (pat)
		msglog(pat, ifp->int_name, naddr_ntoa(ifp->int_addr));

	LIM_SEC(ifinit_timer, now.tv_sec+CHECK_BAD_INTERVAL);

	ifp->int_state |= IS_BROKE;
	ifp->int_state &= ~(IS_RIP_QUERIED | IS_ACTIVE | IS_QUIET);
	ifp->int_quiet_time = now.tv_sec - MaxMaxAdvertiseInterval;
	ifp->int_data_ts = 0;

	trace_if("Chg", ifp);

	(void)rn_walktree(rhead, walk_bad, 0);

	ifbad_rdisc(ifp);
}


/* Mark an interface alive
 */
int					/* 1=it was dead */
ifok(struct interface *ifp,
     char *type)
{
	if (!(ifp->int_state & IS_BROKE))
		return 0;

	msglog("%sinterface %s to %s restored",
	       type, ifp->int_name, naddr_ntoa(ifp->int_addr));
	ifp->int_state &= ~IS_BROKE;
	ifp->int_data_ts = 0;

	ifok_rdisc(ifp);
	return 1;
}


struct rt_addrinfo rtinfo;

/* disassemble routing message
 */
void
rt_xaddrs(struct sockaddr *sa,
	  struct sockaddr *lim,
	  int addrs)
{
	int i;
#ifdef _HAVE_SA_LEN
	static struct sockaddr sa_zero;
#endif
#ifdef sgi
#define ROUNDUP(a) ((a) > 0 ? (1 + (((a) - 1) | (sizeof(__uint64_t) - 1))) \
		    : sizeof(__uint64_t))
#else
#define ROUNDUP(a) ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) \
		    : sizeof(long))
#endif


	bzero(rtinfo.rti_info, sizeof(rtinfo.rti_info));
	rtinfo.rti_addrs = addrs;

	for (i = 0; i < RTAX_MAX && sa < lim; i++) {
		if ((addrs & (1 << i)) == 0)
			continue;
#ifdef _HAVE_SA_LEN
		rtinfo.rti_info[i] = (sa->sa_len != 0) ? sa : &sa_zero;
		sa = (struct sockaddr *)((char*)(sa)
					 + ROUNDUP(sa->sa_len));
#else
		rtinfo.rti_info[i] = sa;
		sa = (struct sockaddr *)((char*)(sa)
					 + ROUNDUP(_FAKE_SA_LEN_DST(sa)));
#endif
	}
}


/* Find the network interfaces which have configured themselves.
 *	This must be done regularly, if only for extra addresses
 *	that come and go on interfaces.
 */
void
ifinit(void)
{
	static char *sysctl_buf;
	static size_t sysctl_buf_size = 0;
	uint complaints = 0;
	static u_int prev_complaints = 0;
#	define COMP_NOT_INET	0x01
#	define COMP_WIERD	0x02
#	define COMP_NOADDR	0x04
#	define COMP_NODST	0x08
#	define COMP_NOBADR	0x10
#	define COMP_NOMASK	0x20
#	define COMP_DUP		0x40

	struct interface ifs, ifs0, *ifp, *ifp1;
	struct rt_entry *rt;
	size_t needed;
	int mib[6];
	struct if_msghdr *ifm;
	struct ifa_msghdr *ifam, *ifam_lim, *ifam2;
	struct sockaddr_dl *sdl;
	int in, ierr, out, oerr;
	struct intnet *intnetp;
#ifdef SIOCGIFMETRIC
	struct ifreq ifr;
#endif


	ifinit_timer.tv_sec = now.tv_sec + (supplier
					    ? CHECK_ACT_INTERVAL
					    : CHECK_QUIET_INTERVAL);

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

	/* Fetch the interface list, without too many system calls
	 * since we do it repeatedly.
	 */
	mib[0] = CTL_NET;
	mib[1] = PF_ROUTE;
	mib[2] = 0;
	mib[3] = AF_INET;
	mib[4] = NET_RT_IFLIST;
	mib[5] = 0;
	for (;;) {
		if ((needed = sysctl_buf_size) != 0) {
			if (sysctl(mib, 6, sysctl_buf,&needed, 0, 0) >= 0)
				break;

			if (errno != ENOMEM && errno != EFAULT)
				BADERR(1, "ifinit: get interface table");
			free(sysctl_buf);
			needed = 0;
		}
		if (sysctl(mib, 6, 0, &needed, 0, 0) < 0)
			BADERR(1,"ifinit: route-sysctl-estimate");
		if ((sysctl_buf = malloc(sysctl_buf_size = needed)) == 0)
			BADERR(1,"ifinit: malloc");
	}

	ifam_lim = (struct ifa_msghdr *)(sysctl_buf + needed);
	for (ifam = (struct ifa_msghdr *)sysctl_buf;
	     ifam < ifam_lim;
	     ifam = ifam2) {

		ifam2 = (struct ifa_msghdr*)((char*)ifam + ifam->ifam_msglen);

		if (ifam->ifam_type == RTM_IFINFO) {
			ifm = (struct if_msghdr *)ifam;
			bzero(&ifs0, sizeof(ifs0));
			ifs0.int_rip_sock = -1;
			ifs0.int_index = ifm->ifm_index;
			ifs0.int_if_flags = ifm->ifm_flags;
			ifs0.int_state = IS_CHECKED;
			ifs0.int_act_time = now.tv_sec;
			ifs0.int_quiet_time = (now.tv_sec
					       - MaxMaxAdvertiseInterval);
			ifs0.int_data_ts = now.tv_sec;
			ifs0.int_data_ipackets = ifm->ifm_data.ifi_ipackets;
			ifs0.int_data_ierrors = ifm->ifm_data.ifi_ierrors;
			ifs0.int_data_opackets = ifm->ifm_data.ifi_opackets;
			ifs0.int_data_oerrors = ifm->ifm_data.ifi_oerrors;
#ifdef sgi
			ifs0.int_data_odrops = ifm->ifm_data.ifi_odrops;
#endif
			sdl = (struct sockaddr_dl *)(ifm + 1);
			sdl->sdl_data[sdl->sdl_nlen] = 0;
			continue;
		}
		if (ifam->ifam_type != RTM_NEWADDR) {
			DBGERR(1,"ifinit: out of sync");
			continue;
		}

		rt_xaddrs((struct sockaddr *)(ifam+1),
			  (struct sockaddr *)ifam2,
			  ifam->ifam_addrs);

		if (RTINFO_IFA == 0) {
			if (iff_alive(ifs.int_if_flags)) {
				if (!(prev_complaints & COMP_NOADDR))
					msglog("%s has a bad address",
					       sdl->sdl_data);
				complaints |= COMP_NOADDR;
			}
			continue;
		}
		if (RTINFO_IFA->sa_family != AF_INET) {
			if (iff_alive(ifs.int_if_flags)) {
				if (!(prev_complaints & COMP_NOT_INET))
					trace_msg("%s: not AF_INET",
						  sdl->sdl_data);
				complaints |= COMP_NOT_INET;
			}
			continue;
		}

		bcopy(&ifs0, &ifs, sizeof(ifs0));
		ifs0.int_state |= IS_ALIAS; /* next will be an alias */

		ifs.int_addr = S_ADDR(RTINFO_IFA);

		if (ifs.int_if_flags & IFF_BROADCAST) {
			if (RTINFO_NETMASK == 0) {
				if (iff_alive(ifs.int_if_flags)) {
					if (!(prev_complaints & COMP_NOMASK))
						msglog("%s has no netmask",
						       sdl->sdl_data);
					complaints |= COMP_NOMASK;
				}
				continue;
			}
			ifs.int_mask = ntohl(S_ADDR(RTINFO_NETMASK));
			ifs.int_net = ntohl(ifs.int_addr) & ifs.int_mask;
			ifs.int_std_mask = std_mask(ifs.int_addr);
			if (ifs.int_mask != ifs.int_std_mask)
				ifs.int_state |= IS_SUBNET;

			if (RTINFO_BRD == 0) {
				if (iff_alive(ifs.int_if_flags)) {
					if (!(prev_complaints & COMP_NOBADR))
						msglog("%s has no"
						       " broadcast address",
						       sdl->sdl_data);
					complaints |= COMP_NOBADR;
				}
				continue;
			}
			ifs.int_brdaddr = S_ADDR(RTINFO_BRD);

		} else if (ifs.int_if_flags & IFF_POINTOPOINT) {
			if (RTINFO_BRD == 0
			    || RTINFO_BRD->sa_family != AF_INET) {
				if (iff_alive(ifs.int_if_flags)) {
					if (!(prev_complaints & COMP_NODST))
						msglog("%s has a bad"
						       " destination address",
						       sdl->sdl_data);
					complaints |= COMP_NODST;
				}
				continue;
			}
			ifs.int_dstaddr = S_ADDR(RTINFO_BRD);
			ifs.int_net = ntohl(ifs.int_dstaddr);
			ifs.int_mask = HOST_MASK;
			ifs.int_std_mask = std_mask(ifs.int_dstaddr);

		} else if (ifs.int_if_flags & IFF_LOOPBACK) {
			ifs.int_state |= IS_PASSIVE;
			ifs.int_dstaddr = ifs.int_addr;
			ifs.int_net = ntohl(ifs.int_dstaddr);
			ifs.int_mask = HOST_MASK;
			ifs.int_std_mask = std_mask(ifs.int_dstaddr);
			if (!foundloopback) {
				foundloopback = 1;
				loopaddr = ifs.int_addr;
			}

		} else {
			if (TRACEACTIONS
			    && !(prev_complaints & COMP_WIERD))
				msglog("%s is neither broadcast"
				       " nor point-to-point nor loopback",
				       sdl->sdl_data);
			complaints |= COMP_WIERD;
			continue;
		}
		ifs.int_std_net = ifs.int_net & ifs.int_std_mask;
		ifs.int_std_addr = htonl(ifs.int_std_net);

		/* Use a minimum metric of one.  Treat the interface metric
		 * (default 0) as an increment to the hop count of one.
		 *
		 * The metric obtained from the routing socket dump of
		 * interface addresses is wrong.  It is not set by the
		 * SIOCSIFMETRIC ioctl.
		 */
#ifdef SIOCGIFMETRIC
		strncpy(ifr.ifr_name, sdl->sdl_data, sizeof(ifr.ifr_name));
		if (ioctl(rt_sock, SIOCGIFMETRIC, &ifr) < 0) {
			DBGERR(1, "ioctl(SIOCGIFMETRIC)");
			ifs.int_metric = HOPCNT_INFINITY;
		} else {
			ifs.int_metric = ifr.ifr_metric+1;
		}
#else
		ifs.int_metric = ifam->ifam_metric+1;
#endif
		if (ifs.int_metric >= HOPCNT_INFINITY)
			ifs.int_metric = HOPCNT_INFINITY;

		/* See if this is a familiar interface.
		 * If so, stop worrying about it if it is the same.
		 * Start it over if it now is to somewhere else, as happens
		 * frequently with PPP and SLIP.
		 */
		ifp = ifwithname(sdl->sdl_data, ((ifs.int_state & IS_ALIAS)
						 ? ifs.int_addr
						 : 0));
		if (ifp != 0) {
			ifp->int_state |= IS_CHECKED;

			if (0 != ((ifp->int_if_flags ^ ifs.int_if_flags)
				  & (IFF_BROADCAST
				     | IFF_LOOPBACK
				     | IFF_POINTOPOINT
				     | IFF_MULTICAST))
			    || 0 != ((ifp->int_state ^ ifs.int_state)
				     & IS_ALIAS)
			    || ifp->int_addr != ifs.int_addr
			    || ifp->int_brdaddr != ifs.int_brdaddr
			    || ifp->int_dstaddr != ifs.int_dstaddr
			    || ifp->int_mask != ifs.int_mask
			    || ifp->int_metric != ifs.int_metric) {
				/* Forget old information about
				 * a changed interface.
				 */
				trace_msg("interface %s has changed",
					  ifp->int_name);
				ifdel(ifp);
				ifp = 0;
			}
		}

		if (ifp != 0) {
			/* note interfaces that have been turned off
			 */
			if (!iff_alive(ifs.int_if_flags)) {
				if (iff_alive(ifp->int_if_flags))
					ifbad(ifp, "interface %s to %s"
					      " turned off");
				ifp->int_if_flags &= ~IFF_UP_RUNNING;
				continue;
			}
			/* or that were off and are now ok */
			if (!iff_alive(ifp->int_if_flags)) {
				ifp->int_if_flags |= IFF_UP_RUNNING;
				(void)ifok(ifp, "");
			}

			/* If it has been long enough,
			 * see if the interface is broken.
			 */
			if (now.tv_sec < ifp->int_data_ts+CHECK_BAD_INTERVAL)
				continue;

			in = ifs.int_data_ipackets - ifp->int_data_ipackets;
			ierr = ifs.int_data_ierrors - ifp->int_data_ierrors;
			out = ifs.int_data_opackets - ifp->int_data_opackets;
#ifdef sgi
			oerr = (ifs.int_data_oerrors - ifp->int_data_oerrors
				+ ifs.int_data_odrops - ifp->int_data_odrops);
#else
			oerr = ifs.int_data_oerrors - ifp->int_data_oerrors;
#endif

			ifp->int_data_ipackets = ifs.int_data_ipackets;
			ifp->int_data_ierrors = ifs.int_data_ierrors;
			ifp->int_data_opackets = ifs.int_data_opackets;
			ifp->int_data_oerrors = ifs.int_data_oerrors;
#ifdef sgi
			ifp->int_data_odrops = ifs.int_data_odrops;
#endif

			/* If the interface just awoke, restart the counters.
			 */
			if (ifp->int_data_ts == 0) {
				ifp->int_data_ts = now.tv_sec;
				continue;
			}
			ifp->int_data_ts = now.tv_sec;

			/* Withhold judgement when the short error
			 * counters wrap or the interface is reset.
			 */
			if (ierr < 0 || in < 0 || oerr < 0 || out < 0)
				continue;

			/* Withhold judgement when there is no traffic
			 */
			if (in == 0 && out == 0 && ierr == 0 && oerr == 0) {
				if (!(ifp->int_state & IS_QUIET)) {
					ifp->int_state |= IS_QUIET;
					ifp->int_quiet_time = now.tv_sec;
				}
				continue;
			}

			/* It is bad if input or output is not working
			 */
			if ((in <= ierr && ierr > 0)
			    || (out <= oerr && oerr > 0)) {
				ifbad(ifp,"interface %s to %s not working");
				continue;
			}

			/* otherwise, it is active and healthy
			 */
			ifp->int_act_time = now.tv_sec;
			ifp->int_state &= ~IS_QUIET;
			if (ifok(ifp, ""))
				addrouteforif(ifp);
			continue;
		}

		/* See if this new interface duplicates an existing
		 * interface.
		 */
		for (ifp = ifnet; 0 != ifp; ifp = ifp->int_next) {
			if (ifp->int_addr == ifs.int_addr
			    && ifp->int_mask == ifs.int_mask)
				break;
		}
		if (ifp != 0) {
			if (iff_alive(ifs.int_if_flags)) {
				if (!(prev_complaints & COMP_DUP))
					msglog("%s is duplicated by %s at %s",
					       sdl->sdl_data, ifp->int_name,
					       naddr_ntoa(ifp->int_addr));
				complaints |= COMP_DUP;
			}
			continue;
		}

		strncpy(ifs.int_name, sdl->sdl_data,
			MIN(sizeof(ifs.int_name)-1, sdl->sdl_nlen));

		get_parms(&ifs);

		ifok_rdisc(&ifs);

		/* create the interface */
		ifp = (struct interface *)malloc(sizeof(*ifp));
		if (ifp == 0)
			BADERR(1,"ifinit: out of memory");
		bcopy(&ifs, ifp, sizeof(*ifp));
		if (ifnet != 0) {
			ifp->int_next = ifnet;
			ifnet->int_prev = ifp;
		}
		ifnet = ifp;

		/* Count the # of directly connected networks.
		 */
		if (!(ifp->int_state & IS_ALIAS)) {
			if (!(ifp->int_if_flags & IFF_LOOPBACK))
				tot_interfaces++;
			if (0 == (ifp->int_state & (IS_NO_RIP_IN|IS_PASSIVE)))
				rip_interfaces++;
		}

		/* note dead interfaces */
		if (iff_alive(ifs.int_if_flags)) {
			set_rdisc_mg(ifp, 1);
		} else {
			LIM_SEC(ifinit_timer, now.tv_sec+CHECK_BAD_INTERVAL);
			ifp->int_state |= IS_BROKE;
		}

		if (TRACEACTIONS)
			trace_if("Add", ifp);

		rip_on(ifp);
	}

	/* If we are multi-homed and have at least one interface
	 * listening to RIP, then output by default.
	 */
	if (!supplier_set && rip_interfaces > 1)
		set_supplier();

	/* If we are multi-homed, optionally advertise a route to
	 * our main address.
	 */
	if (advertise_mhome
	    || (tot_interfaces > 1
		&& mhome
		&& (ifp = ifwithaddr(myaddr, 0, 0)) != 0
		&& foundloopback)) {
		advertise_mhome = 1;
		del_static(myaddr, HOST_MASK, 0);
		rt = rtget(myaddr, HOST_MASK);
		if (rt != 0) {
			if (rt->rt_ifp != ifp
			    || rt->rt_router != loopaddr) {
				rtdelete(rt);
				rt = 0;
			} else {
				rtchange(rt, rt->rt_state | RS_MHOME,
					 loopaddr, loopaddr,
					 ifp->int_metric, 0,
					 ifp, rt->rt_time, 0);
			}
		}
		if (rt == 0)
			rtadd(myaddr, HOST_MASK, loopaddr, loopaddr,
			      ifp->int_metric, 0, RS_MHOME, ifp);
	}

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

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

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

		/* If we ever have a RIPv1 interface, assume we always will.
		 * It might come back if it ever goes away.
		 */
		if ((ifp->int_state & IS_NO_RIPV2_OUT)
		    && !(ifp->int_if_flags & IFF_LOOPBACK))
			have_ripv1 = 1;
	}

	/* add the authority interfaces */
	for (intnetp = intnets; intnetp!=0; intnetp = intnetp->intnet_next) {
		rt = rtget(intnetp->intnet_addr, intnetp->intnet_mask);
		if (rt != 0
		    && !(rt->rt_state & RS_IF)
		    && !(rt->rt_state & RS_NET_INT)) {
			rtdelete(rt);
			rt = 0;
		}
		if (rt == 0)
			rtadd(intnetp->intnet_addr, intnetp->intnet_mask,
			      loopaddr, loopaddr,
			      1, 0, RS_NET_INT, 0);
	}

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

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

	prev_complaints = complaints;
}


static void
add_net_sub(struct interface *ifp,
	      naddr dst,
	      naddr mask,
	      u_int state)
{
	struct rt_entry *rt;

	rt = rtget(dst, mask);
	if (rt != 0) {
		if (0 != (rt->rt_state & (RS_STATIC | RS_LOCAL
					  | RS_MHOME | RS_GW)))
			return;

		if ((rt->rt_state & state) != state
		    || rt->rt_metric != NET_S_METRIC) {
			rtchange(rt, rt->rt_state | state,
				 rt->rt_gate, rt->rt_router,
				 NET_S_METRIC, rt->rt_tag,
				 rt->rt_ifp, rt->rt_time, 0);
		}
		return;
	}

	rtadd(dst, mask, ifp->int_addr, ifp->int_addr,
	      NET_S_METRIC, 0, state, ifp);
}


static void
check_net_sub(struct interface *ifp)
{
	struct interface *ifp2;
	struct rt_entry *rt;

	/* See if there are any RIPv1 listeners, to determine if
	 * we need to synthesize a network route for an interface
	 * on a subnet.
	 */
	for (ifp2 = ifnet; ifp2; ifp2 = ifp2->int_next) {
		if (ifp2 != ifp
		    && !(ifp->int_state & IS_PASSIVE)
		    && !(ifp->int_state & IS_NO_RIPV1_OUT)
		    && !on_net(ifp->int_addr,
			       ifp2->int_std_net,
			       ifp2->int_std_mask))
			break;
	}

	/* only if running RIPv1 somewhere */
	if (ifp2 != 0) {
		ifp->int_state |= IS_NEED_NET_SUB;
		add_net_sub(ifp, ifp->int_std_addr, ifp->int_std_mask,
			    RS_IF | RS_NET_SUB);

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

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


/* Add route for interface if not currently installed.
 * Create route to other end if a point-to-point link,
 * otherwise a route to this (sub)network.
 */
void
addrouteforif(struct interface *ifp)
{
	struct rt_entry *rt;
	naddr dst, mask;


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

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

		} else if ((ifp->int_if_flags & IFF_POINTOPOINT)
			   && ridhosts) {

			/* The (dis)appearance of other interfaces can change
			 * the parent (sub)net.
			 */
			mask = ripv1_mask_net(ifp->int_dstaddr,0,ifp);
			if (mask != ifp->int_host_mask) {
				rt = rtget(ifp->int_host_addr,
					   ifp->int_host_mask);
				ifp->int_host_addr = htonl(ntohl(ifp->int_dstaddr)
							   & mask);
				ifp->int_host_mask = mask;
				if (rt != 0
				    && (rt->rt_state & RS_NET_S)
				    && rt->rt_ifp == ifp)
					rtbad_sub(rt);
			}

			add_net_sub(ifp, ifp->int_host_addr,
				    ifp->int_host_mask,
				    RS_IF | RS_NET_HOST);
		}
	}

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

	/* We are finished if the right, main interface route exists.
	 * The right route must be for the right interface, not synthesized
	 * from a subnet, be a "gateway" or not as appropriate, and so forth.
	 */
	del_static(dst, ifp->int_mask, 0);
	rt = rtget(dst, ifp->int_mask);
	if (rt != 0) {
		if (rt->rt_ifp != ifp
		    || rt->rt_router != ifp->int_addr) {
			rtdelete(rt);
			rt = 0;
		} else {
			rtchange(rt, ((rt->rt_state | RS_IF)
				      & ~(RS_NET_S | RS_LOCAL)),
				 ifp->int_addr, ifp->int_addr,
				 ifp->int_metric, 0, ifp, now.tv_sec, 0);
		}
	}
	if (rt == 0) {
		if (ifp->int_transitions++ > 0)
			trace_msg("re-install interface %s", ifp->int_name);

		rtadd(dst, ifp->int_mask, ifp->int_addr, ifp->int_addr,
		      ifp->int_metric, 0, RS_IF, ifp);
	}
}