/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/tihdr.h>
#include <stropts.h>
#include <fcntl.h>
#include <syslog.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <libintl.h>
#include <locale.h>
#include <unistd.h>
#include <sys/varargs.h>

#include <netinet/in.h>
#include <sys/ethernet.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/sysmacros.h>
#include <net/if.h>
#include <inet/mib2.h>
#include <inet/ip.h>
#include <net/route.h>
#include <arpa/inet.h>
#include "ncaconf.h"

/* NCA does not support IPv6... */
#ifndef	IP_DEV_NAME
#define	IP_DEV_NAME	"/dev/ip"
#endif

#ifndef	IP_MOD_NAME
#define	IP_MOD_NAME	"ip"
#endif

#ifndef	UDP_DEV_NAME
#define	UDP_DEV_NAME	"/dev/udp"
#endif

#ifndef	NCA_MOD_NAME
#define	NCA_MOD_NAME	"nca"
#endif

#ifndef	ARP_MOD_NAME
#define	ARP_MOD_NAME	"arp"
#endif

#define	IF_SEPARATOR	':'

#define	ping_prog	"/usr/sbin/ping"

/* Structure to hold info about each network interface. */
typedef struct nif_s {
	char		name[LIFNAMSIZ+1];
	struct in_addr	local_addr;
	struct in_addr	router_addr;
	uchar_t		router_ether_addr[ETHERADDRL];
} nif_t;

typedef struct mib_item_s {
	struct mib_item_s	*next_item;
	int			group;
	int			mib_id;
	int			length;
	char			*valp;
} mib_item_t;

/* The network interface array. */
static nif_t *nif_list;
/* Number of network interface to process. */
static int num_nif;

/* Interface request to IP. */
static struct lifreq lifr;

/* True if syslog is to be used. */
static boolean_t logging;
/* True if additional debugging messages are printed. */
static boolean_t debug;

/* File descriptor to the routing socket. */
static int rt_fd;

static void logperror(char *);
static void logwarn(char *, ...);
static void logdebug(char *, ...);
static int ip_domux2fd(int *, int *);
static void ip_plink(int, int);
static int find_nca_pos(int);
static int nca_set_nif(int, struct in_addr, uchar_t *);
static void nca_setup(boolean_t *);
static int get_if_ip_addr(void);
static mib_item_t *mibget(int);
static int ire_process(mib2_ipRouteEntry_t *, size_t, boolean_t *);
static int arp_process(mib2_ipNetToMediaEntry_t *, size_t, boolean_t *);
static int get_router_ip_addr(mib_item_t *, boolean_t *);
static int get_router_ether_addr(mib_item_t *, boolean_t *);
static int get_if_info(boolean_t *);
static void daemon_init(void);
static void daemon_work(void);
static void ping_them(void);

/*
 * Print out system error messages, either to syslog or stderr.  Note that
 * syslog() should print out system error messages in the correct language
 * used.  There is no need to use gettext().
 */
static void
logperror(char *str)
{
	if (logging) {
		syslog(LOG_ERR, "%s: %m\n", str);
	} else {
		(void) fprintf(stderr, "ncaconfd: %s: %s\n", str,
		    strerror(errno));
	}
}

/*
 * Print out warning messages.  The caller should use gettext() to have
 * the message printed out in the correct language.
 */
/*PRINTFLIKE1*/
static void
logwarn(char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	if (logging) {
		vsyslog(LOG_WARNING, fmt, ap);
	} else {
		(void) fprintf(stderr, "ncaconfd: ");
		(void) vfprintf(stderr, fmt, ap);
	}
	va_end(ap);
}

/*
 * Print out debugging info.  Note that syslogd(1M) should be configured to
 * take ordinary debug info for it to get this kind of info.
 */
/*PRINTFLIKE1*/
static void
logdebug(char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	if (logging) {
		vsyslog(LOG_WARNING, fmt, ap);
	} else {
		(void) fprintf(stderr, "ncaconfd: ");
		(void) vfprintf(stderr, fmt, ap);
	}
	va_end(ap);
}

/*
 * Helper function for nca_setup().  It gets a fd to the lower IP
 * stream and I_PUNLINK's the lower stream.  It also initializes the
 * global variable lifr.
 *
 * Param:
 *	int *udp_fd: (referenced) fd to /dev/udp (upper IP stream).
 *	int *fd: (referenced) fd to the lower IP stream.
 *
 * Return:
 *	-1 if operation fails, 0 otherwise.
 */
static int
ip_domux2fd(int *udp_fd, int *fd)
{
	int ip_fd;

	if ((ip_fd = open(IP_DEV_NAME, O_RDWR)) < 0) {
		logperror("Cannot open IP");
		return (-1);
	}
	if ((*udp_fd = open(UDP_DEV_NAME, O_RDWR)) < 0) {
		logperror("Cannot open UDP");
		(void) close(ip_fd);
		return (-1);
	}
	if (ioctl(ip_fd, SIOCGLIFMUXID, (caddr_t)&lifr) < 0) {
		logperror("ioctl(SIOCGLIFMUXID) failed");
		(void) close(ip_fd);
		return (-1);
	}
	if (debug) {
		logdebug("ARP_muxid %d IP_muxid %d\n", lifr.lifr_arp_muxid,
		    lifr.lifr_ip_muxid);
	}
	if ((*fd = ioctl(*udp_fd, _I_MUXID2FD, lifr.lifr_ip_muxid)) < 0) {
		logperror("ioctl(_I_MUXID2FD) failed");
		(void) close(ip_fd);
		(void) close(*udp_fd);
		return (-1);
	}
	(void) close(ip_fd);
	return (0);
}

/*
 * Helper function for nca_setup().  It I_PLINK's back the upper and
 * lower IP streams.  Note that this function must be called after
 * ip_domux2fd().  In ip_domux2fd(), the global variable lifr is initialized
 * and ip_plink() needs information in lifr.  So ip_domux2fd() and ip_plink()
 * must be called in pairs.
 *
 * Param:
 *	int udp_fd: fd to /dev/udp (upper IP stream).
 *	int fd: fd to the lower IP stream.
 */
static void
ip_plink(int udp_fd, int fd)
{
	int mux_id;

	if ((mux_id = ioctl(udp_fd, I_PLINK, fd)) < 0) {
		logperror("ioctl(I_PLINK) failed");
		return;
	}
	if (debug > 0) {
		logdebug("New IP_muxid %d\n", mux_id);
	}
	lifr.lifr_ip_muxid = mux_id;
	if (ioctl(udp_fd, SIOCSLIFMUXID, (caddr_t)&lifr) < 0) {
		logperror("ioctl(SIOCSLIFMUXID) failed");
	}
}

#define	FOUND_NCA	-1
#define	FOUND_NONE	-2
/*
 * Find the proper position to insert NCA, which is just below IP.
 *
 * Param:
 *	int fd: fd to the lower IP stream.
 *
 * Return:
 *	If positive, it is the position to insert NCA.
 *	FOUND_NCA: found NCA!  So skip this one for plumbing.  But we
 *		still keep it in the interface list.
 *	FOUND_NONE: could not find IP or encounter other errors.  Remove
 *		this interface from the	list.
 */
static int
find_nca_pos(int fd)
{
	int num_mods;
	int i, pos;
	struct str_list strlist;
	boolean_t found_ip = B_FALSE;
	boolean_t found_nca = B_FALSE;

	if ((num_mods = ioctl(fd, I_LIST, NULL)) < 0) {
		logperror("ioctl(I_LIST) failed");
		return (FOUND_NONE);
	} else {
		strlist.sl_nmods = num_mods;
		strlist.sl_modlist = calloc(num_mods,
		    sizeof (struct str_mlist));
		if (strlist.sl_modlist == NULL) {
			logperror("cannot malloc");
			return (FOUND_NONE);
		} else {
			if (ioctl(fd, I_LIST, (caddr_t)&strlist) < 0) {
				logperror("ioctl(I_LIST) failed");
			} else {
				for (i = 0; i < strlist.sl_nmods; i++) {
					if (strcmp(IP_MOD_NAME,
					    strlist.sl_modlist[i].l_name)
					    == 0) {
						found_ip = B_TRUE;
						/*
						 * NCA should be just below
						 * IP.
						 */
						pos = i + 1;
					} else if (strncmp(NCA_MOD_NAME,
					    strlist.sl_modlist[i].l_name,
					    strlen(NCA_MOD_NAME)) == 0) {
						found_nca = B_TRUE;
					}
				}
			}
			free(strlist.sl_modlist);
		}
	}
	if (found_nca) {
		return (FOUND_NCA);
	} else if (found_ip) {
		if (debug) {
			logdebug("NCA is at position %d in the stream.\n", pos);
		}
		return (pos);
	} else {
		if (debug) {
			logdebug("Cannot find IP??\n");
		}
		return (FOUND_NONE);
	}
}

/*
 * To set the local IP address and default router ethernet address.
 *
 * Param:
 *	int fd: the fd to the lower IP stream.
 *	struct in_addr local_addr: the IP address for this interface.
 *	uchar_t *ether_addr: the ethernet address of the default router for
 *		for this interface.
 *
 * Return:
 *	-1 if the system does not support this NCA ioctl(), 0 otherwise.
 */
static int
nca_set_nif(int fd, struct in_addr local_addr, uchar_t *ether_addr)
{
	struct nca_set_ioctl nca_ioctl;
	struct strioctl strioc;
	int len;
	uchar_t *dst;

	strioc.ic_cmd = NCA_SET_IF;
	strioc.ic_timout = INFTIM;
	strioc.ic_len = sizeof (nca_ioctl);
	strioc.ic_dp = (char *)&nca_ioctl;

	nca_ioctl.local_addr = local_addr.s_addr;
	dst = nca_ioctl.router_ether_addr;
	for (len = ETHERADDRL; len > 0; len--)
		*dst++ = *ether_addr++;
	nca_ioctl.action = ADD_DEF_ROUTE;

	if (ioctl(fd, I_STR, &strioc) < 0) {
		logperror("ioctl(NCA_SET_IF) failed");
		if (errno == EINVAL)
			return (-1);
	}
	return (0);
}

/*
 * To setup the NCA stream.  First insert NCA into the proper position.
 * Then tell NCA the local IP address and default router by using the
 * NCA_SET_IF ioctl.
 *
 * Param:
 *	boolean_t *active: (referenced) B_TRUE if NCA is setup to do active
 *		connection.  If NCA does not support active connection,
 *		in return, active will be set to B_FALSE.
 */
static void
nca_setup(boolean_t *active)
{
	int i;
	int udp_fd;
	int fd;
	struct strmodconf mod;
	/* 128 is enough because interface name can only be LIFNAMSIZ long. */
	char err_buf[128];

	mod.mod_name = NCA_MOD_NAME;
	lifr.lifr_addr.ss_family = AF_INET;
	for (i = 0; i < num_nif; i++) {
		if (debug) {
			logdebug("Plumbing NCA for %s\n", nif_list[i].name);
		}
		/* This interface does not exist according to IP. */
		if (nif_list[i].local_addr.s_addr == 0) {
			continue;
		}
		(void) strlcpy(lifr.lifr_name, nif_list[i].name,
		    sizeof (lifr.lifr_name));

		if (ip_domux2fd(&udp_fd, &fd) < 0) {
			continue;
		}
		if (ioctl(udp_fd, I_PUNLINK, lifr.lifr_ip_muxid) < 0) {
			(void) snprintf(err_buf, sizeof (err_buf),
			    "ioctl(I_PUNLINK) for %s failed", nif_list[i].name);
			logperror(err_buf);
			(void) close(udp_fd);
			(void) close(fd);
			continue;
		}
		if ((mod.pos = find_nca_pos(fd)) < 0) {
			if (mod.pos == FOUND_NCA) {
				if (debug) {
					logdebug("Find NCA in the %s"
					    " stream\n", nif_list[i].name);
				}
				/* Just skip plumbing NCA. */
				goto set_nif;
			}
			if (debug) {
				logdebug("Cannot find pos for %s\n",
				    nif_list[i].name);
			}
			goto clean_up;
		}
		if (ioctl(fd, _I_INSERT, (caddr_t)&mod) < 0) {
			(void) snprintf(err_buf, sizeof (err_buf),
			    "ioctl(_I_INSERT) for %s failed", nif_list[i].name);
			logperror(err_buf);
			goto clean_up;
		}

		/*
		 * Only do the following if NCA is also used to make
		 * outgoing connections, and all necessary info is
		 * there.
		 */
set_nif:
		if (*active && nif_list[i].router_addr.s_addr != 0) {
			if (nca_set_nif(fd, nif_list[i].local_addr,
			    nif_list[i].router_ether_addr) < 0) {
				/*
				 * The system does not support this ioctl()!
				 * Skip all active stack processing but
				 * continue to plumb NCA.
				 */
				logwarn("NCA does not support active stack!");
				*active = B_FALSE;
			}
		}
clean_up:
		ip_plink(udp_fd, fd);
		(void) close(udp_fd);
		(void) close(fd);
	}
}

/*
 * To get IP address of network interface from IP.
 */
static int
get_if_ip_addr(void)
{
	int sock;
	struct lifnum lifn;
	struct lifconf lifc;
	struct lifreq *lifr;
	struct sockaddr_in *sin;
	char *buf;
	int num_lifr;
	int i, j;

	/* NCA only supports IPv4... */
	if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		logperror(gettext("Cannot open socket"));
		return (-1);
	}
	lifn.lifn_family = AF_UNSPEC;
	lifn.lifn_flags = 0;
	if (ioctl(sock, SIOCGLIFNUM, (char *)&lifn) < 0) {
		logperror(gettext("ioctl(SIOCGLIFNUM) failed"));
		(void) close(sock);
		return (-1);
	}
	buf = (char *)calloc(lifn.lifn_count, sizeof (struct lifreq));
	if (buf == NULL) {
		logperror(gettext("calloc() failed"));
		(void) close(sock);
		return (-1);
	}

	lifc.lifc_family = AF_UNSPEC;
	lifc.lifc_flags = 0;
	lifc.lifc_len = lifn.lifn_count * sizeof (struct lifreq);
	lifc.lifc_buf = buf;

	if (ioctl(sock, SIOCGLIFCONF, (char *)&lifc) < 0) {
		/*
		 * NCA is set up after all the interfaces have been
		 * plumbed.  So normally we should not get any error.
		 * Just abort if we encounter an error.
		 */
		logperror(gettext("ioctl(SIOCGLIFCONF) failed"));
		free(buf);
		(void) close(sock);
		return (-1);
	}
	num_lifr = lifc.lifc_len / sizeof (struct lifreq);
	/* Find the interface and copy the local IP address. */
	for (i = 0; i < num_nif; i++) {
		lifr = (struct lifreq *)lifc.lifc_req;
		for (j = num_lifr; j > 0; j--, lifr++) {
			/* Again, NCA only supports IPv4. */
			if (lifr->lifr_addr.ss_family != AF_INET)
				continue;
			if (strncmp(nif_list[i].name, lifr->lifr_name,
			    strlen(nif_list[i].name)) == 0) {
				sin = (struct sockaddr_in *)&lifr->lifr_addr;
				nif_list[i].local_addr = sin->sin_addr;
				if (debug) {
					logdebug("IP address of %s: %s\n",
					    nif_list[i].name,
					    inet_ntoa(sin->sin_addr));
				}
				break;
			}
		}
		if (j == 0) {
			/*
			 * The interface does not exist according to IP!
			 * Log a warning and go on.
			 */
			logwarn(gettext("Network interface %s"
			    " does not exist!\n"), nif_list[i].name);
			/*
			 * Set local_addr to 0 so that nca_setup() will
			 * not do anything for this interface.
			 */
			nif_list[i].local_addr.s_addr = 0;
		}
	}
	free(buf);
	(void) close(sock);
	return (0);
}

/*
 * Get MIB2 info from IP.
 *
 * Param:
 *	int sd: descriptor to IP to send down mib request.
 */
static mib_item_t *
mibget(int sd)
{
	char			buf[1024];
	int			flags;
	int			i, j, getcode;
	struct strbuf		ctlbuf, databuf;
	/* LINTED */
	struct T_optmgmt_req	*tor = (struct T_optmgmt_req *)buf;
	/* LINTED */
	struct T_optmgmt_ack	*toa = (struct T_optmgmt_ack *)buf;
	/* LINTED */
	struct T_error_ack	*tea = (struct T_error_ack *)buf;
	struct opthdr		*req;
	mib_item_t		*first_item = (mib_item_t *)0;
	mib_item_t		*last_item  = (mib_item_t *)0;
	mib_item_t		*temp;

	tor->PRIM_type = T_SVR4_OPTMGMT_REQ;
	tor->OPT_offset = sizeof (struct T_optmgmt_req);
	tor->OPT_length = sizeof (struct opthdr);
	tor->MGMT_flags = T_CURRENT;
	req = (struct opthdr *)&tor[1];
	req->level = MIB2_IP;		/* any MIB2_xxx value ok here */
	req->name  = 0;
	req->len   = 0;

	ctlbuf.buf = buf;
	ctlbuf.len = tor->OPT_length + tor->OPT_offset;
	flags = 0;
	if (putmsg(sd, &ctlbuf, (struct strbuf *)0, flags) == -1) {
		logperror("mibget: putmsg(ctl) failed");
		goto error_exit;
	}

	/*
	 * Each reply consists of a ctl part for one fixed structure
	 * or table, as defined in mib2.h.  The format is a T_OPTMGMT_ACK,
	 * containing an opthdr structure.  level/name identify the entry,
	 * len is the size of the data part of the message.
	 */
	req = (struct opthdr *)&toa[1];
	ctlbuf.maxlen = sizeof (buf);
	j = 1;
	for (;;) {
		flags = 0;
		getcode = getmsg(sd, &ctlbuf, (struct strbuf *)0, &flags);
		if (getcode == -1) {
			logperror("mibget getmsg(ctl) failed");
			if (debug) {
				logdebug("#   level   name    len\n");
				i = 0;
				for (last_item = first_item; last_item;
					last_item = last_item->next_item)
					(void) printf("%d  %4d   %5d   %d\n",
					    ++i,
					    last_item->group,
					    last_item->mib_id,
					    last_item->length);
			}
			goto error_exit;
		}
		if (getcode == 0 &&
		    ctlbuf.len >= sizeof (struct T_optmgmt_ack) &&
		    toa->PRIM_type == T_OPTMGMT_ACK &&
		    toa->MGMT_flags == T_SUCCESS &&
		    req->len == 0) {
			if (debug) {
				logdebug("mibget getmsg() %d returned "
				    "EOD (level %ld, name %ld)\n",
				    j, req->level, req->name);
			}
			return (first_item);		/* this is EOD msg */
		}

		if (ctlbuf.len >= sizeof (struct T_error_ack) &&
		    tea->PRIM_type == T_ERROR_ACK) {
			logwarn("mibget %d gives T_ERROR_ACK: TLI_error ="
			    " 0x%lx, UNIX_error = 0x%lx\n",
			    j, tea->TLI_error, tea->UNIX_error);
			errno = (tea->TLI_error == TSYSERR) ?
			    tea->UNIX_error : EPROTO;
			goto error_exit;
		}

		if (getcode != MOREDATA ||
		    ctlbuf.len < sizeof (struct T_optmgmt_ack) ||
		    toa->PRIM_type != T_OPTMGMT_ACK ||
		    toa->MGMT_flags != T_SUCCESS) {
			logwarn("mibget getmsg(ctl) %d returned %d, "
			    "ctlbuf.len = %d, PRIM_type = %ld\n",
			    j, getcode, ctlbuf.len, toa->PRIM_type);
			if (toa->PRIM_type == T_OPTMGMT_ACK) {
				logwarn("T_OPTMGMT_ACK: "
				    "MGMT_flags = 0x%lx, req->len = %ld\n",
				    toa->MGMT_flags, req->len);
			}
			errno = ENOMSG;
			goto error_exit;
		}

		temp = (mib_item_t *)malloc(sizeof (mib_item_t));
		if (!temp) {
			logperror("mibget malloc failed");
			goto error_exit;
		}
		if (last_item)
			last_item->next_item = temp;
		else
			first_item = temp;
		last_item = temp;
		last_item->next_item = (mib_item_t *)0;
		last_item->group = req->level;
		last_item->mib_id = req->name;
		last_item->length = req->len;
		last_item->valp = malloc((int)req->len);

		databuf.maxlen = last_item->length;
		databuf.buf    = last_item->valp;
		databuf.len    = 0;
		flags = 0;
		getcode = getmsg(sd, (struct strbuf *)0, &databuf, &flags);
		if (getcode == -1) {
			logperror("mibget getmsg(data) failed");
			goto error_exit;
		} else if (getcode != 0) {
			logwarn("mibget getmsg(data) returned %d, "
			    "databuf.maxlen = %d, databuf.len = %d\n",
			    getcode, databuf.maxlen, databuf.len);
			goto error_exit;
		}
		j++;
	}

error_exit:;
	while (first_item) {
		last_item = first_item;
		first_item = first_item->next_item;
		free(last_item);
	}
	return (first_item);
}

/*
 * Examine the IPv4 routing table for default routers.  For each interface,
 * find its default router.
 *
 * Param:
 *	mib2_ipRouteEntry_t *buf: the mib info buffer.
 *	size_t len: length of buffer.
 *	boolean_t *changed (referenced): set to B_TRUE if there is a change
 *		in router info.
 *
 * Return:
 *	number of default router found.
 */
static int
ire_process(mib2_ipRouteEntry_t *buf, size_t len, boolean_t *changed)
{
	mib2_ipRouteEntry_t 	*rp;
	mib2_ipRouteEntry_t 	*rp1;
	mib2_ipRouteEntry_t 	*rp2;
	struct	in_addr		nexthop_v4;
	mib2_ipRouteEntry_t	*endp;
	char			ifname[LIFNAMSIZ + 1];
	char			*cp;
	int			i;
	int			ifname_len;
	boolean_t		found;
	int			num_found = 0;

	if (len == 0)
		return (0);
	endp = buf + (len / sizeof (mib2_ipRouteEntry_t));

	for (i = 0; i < num_nif; i++) {
		/*
		 * Loop thru the routing table entries. Process any
		 * IRE_DEFAULT ire.  Ignore the others.  For each such
		 * ire, get the nexthop gateway address.
		 */
		found = B_FALSE;
		for (rp = buf; rp < endp; rp++) {
			/*
			 * NCA is only interested in default routes associated
			 * with an interface.
			 */
			if (!(rp->ipRouteInfo.re_ire_type & IRE_DEFAULT)) {
				continue;
			}
			/*  Get the nexthop address. */
			nexthop_v4.s_addr = rp->ipRouteNextHop;

			/*
			 * Right now, not all IREs have the interface name
			 * it is associated with.
			 */
			if (rp->ipRouteIfIndex.o_length == 0) {
				/*
				 * We don't have the outgoing interface in
				 * this case.  Get the nexthop address. Then
				 * determine the outgoing interface, by
				 * examining all interface IREs, and
				 * picking the match.
				 */
				for (rp1 = buf; rp1 < endp; rp1++) {

				if (!(rp1->ipRouteInfo.re_ire_type &
				    IRE_INTERFACE)) {
					continue;
				}

				/*
				 * Determine the interface IRE that
				 * matches the nexthop. i.e.
				 * (IRE addr & IRE mask) ==
				 * (nexthop & IRE mask)
				 */
				if ((rp1->ipRouteDest & rp1->ipRouteMask) ==
				    (nexthop_v4.s_addr & rp1->ipRouteMask)) {
					/*
					 * We found the interface to go to
					 * the default router.  Check the
					 * interface name.
					 */
					/* Can this be possible?? */
					if (rp1->ipRouteIfIndex.o_length == 0)
						continue;
					rp2 = rp1;
					break;
				}

				} /* End inner for loop. */
			} else {
				rp2 = rp;
			}

			ifname_len = MIN(rp2->ipRouteIfIndex.o_length,
			    sizeof (ifname) - 1);
			(void) memcpy(ifname, rp2->ipRouteIfIndex.o_bytes,
			    ifname_len);
			ifname[ifname_len] = '\0';
			if (ifname[0] == '\0')
				continue;
			cp = strchr(ifname, IF_SEPARATOR);
			if (cp != NULL)
				*cp = '\0';

			/* We are sure both are NULL terminated. */
			if (strcmp(nif_list[i].name, ifname) == 0) {
				/* No change, do not do anything. */
				if (nexthop_v4.s_addr ==
				    nif_list[i].router_addr.s_addr) {
					found = B_TRUE;
					break;
				}
				nif_list[i].router_addr.s_addr =
				    nexthop_v4.s_addr;
				if (debug) {
					logdebug("Get default"
					    " router for %s: %s\n", ifname,
					    inet_ntoa(nexthop_v4));
				}
				found = B_TRUE;
				*changed = B_TRUE;
				break;
			}

		}
		if (!found) {
			/*
			 * The interface does not have a default router.
			 * Log a warning and go on.
			 */
			logwarn(gettext("Network interface %s"
			    " does not have a default router.\n"),
			    nif_list[i].name);
			/*
			 * Set router_addr to 0 so that we will
			 * not do anything for this interface.
			 */
			nif_list[i].router_addr.s_addr = 0;
		} else {
			num_found++;
		}
	}
	return (num_found);
}

/*
 * Examine the ARP table to find ethernet address for default routers.
 *
 * Param:
 *	mib2_ipNetToMdeiaEntry_t *buf: the mib info buffer.
 *	size_t len: length of buffer.
 *	boolean_t *changed (referenced): set to B_TRUE if there is any change
 *		in ethernet address for any default router.
 *
 * Return:
 *	number of ethernet address found.
 */
static int
arp_process(mib2_ipNetToMediaEntry_t *buf, size_t len, boolean_t *changed)
{
	mib2_ipNetToMediaEntry_t 	*rp;
	mib2_ipNetToMediaEntry_t	*endp;
	int				i;
	boolean_t			found;
	int				num_found = 0;
	uchar_t				*src, *dst;

	if (len == 0)
		return (0);
	endp = buf + (len / sizeof (mib2_ipNetToMediaEntry_t));

	for (i = 0; i < num_nif; i++) {
		/*
		 * Loop thru the arp table entries and find the ethernet
		 * address of those default routers.
		 */
		if (nif_list[i].router_addr.s_addr == 0)
			continue;
		found = B_FALSE;
		for (rp = buf; rp < endp; rp++) {
			if (rp->ipNetToMediaNetAddress ==
			    nif_list[i].router_addr.s_addr) {
				/*
				 * Sanity check.  Make sure that this
				 * default router is only reachable thru this
				 * interface.
				 */
				if (rp->ipNetToMediaIfIndex.o_length !=
				    strlen(nif_list[i].name) ||
				    strncmp(rp->ipNetToMediaIfIndex.o_bytes,
					nif_list[i].name,
					rp->ipNetToMediaIfIndex.o_length) !=
				    0) {
					break;
				}
				/* No change, do not do anything. */
				if (bcmp(nif_list[i].router_ether_addr,
				    rp->ipNetToMediaPhysAddress.o_bytes,
				    ETHERADDRL) == 0) {
					found = B_TRUE;
					continue;
				}
				dst = nif_list[i].router_ether_addr;
				src = (uchar_t *)
				    rp->ipNetToMediaPhysAddress.o_bytes;
				for (len = ETHERADDRL; len > 0; len--)
					*dst++ = *src++;
				if (debug) {
					int j;
					uchar_t *cp;
					char err_buf[128];

					(void) snprintf(err_buf,
					    sizeof (err_buf),
					    "Get address for %s: ",
					    inet_ntoa(nif_list[i].router_addr));
					cp = (uchar_t *)
					    nif_list[i].router_ether_addr;
					for (j = 0; j < ETHERADDRL; j++) {
						(void) sprintf(err_buf +
						    strlen(err_buf),
						    "%02x:", 0xff & cp[j]);
					}
					(void) sprintf(err_buf +
					    strlen(err_buf) - 1, "\n");
					logdebug(err_buf);
				}
				found = B_TRUE;
				*changed = B_TRUE;
			}
		}
		if (!found) {
			logwarn("Cannot reach %s using %s\n",
			    inet_ntoa(nif_list[i].router_addr),
			    nif_list[i].name);
			/* Clear this default router. */
			nif_list[i].router_addr.s_addr = 0;
		} else {
			num_found++;
		}
	}
	return (num_found);
}

/*
 * Get IP address of default routers for each interface.
 *
 * Param:
 *	mib_item_t *item: the mib info buffer.
 *	boolean_t *changed (referenced): set to B_TRUE if there is any change
 *		in router info.
 *
 * Return:
 *	-1 if there is no router found, 0 otherwise.
 */
static int
get_router_ip_addr(mib_item_t *item, boolean_t *changed)
{
	int found = 0;

	for (; item != NULL; item = item->next_item) {
		/* NCA does not support IPv6... */
		if (!(item->group == MIB2_IP && item->mib_id == MIB2_IP_ROUTE))
			continue;
		/* LINTED */
		found += ire_process((mib2_ipRouteEntry_t *)item->valp,
		    item->length, changed);
	}
	if (found == 0)
		return (-1);
	else
		return (0);
}

/*
 * Get Ethernet address for each default router from ARP.
 *
 * Param:
 *	mib_item_t *item: the mib info buffer.
 *	boolean_t *changed (referenced): set to B_TRUE if there is any change
 *		in ethernet address of router.
 *
 * Return:
 *	-1 if there is no ethernet address found, 0 otherwise.
 */
static int
get_router_ether_addr(mib_item_t *item, boolean_t *changed)
{
	int found = 0;

	for (; item != NULL; item = item->next_item) {
		/* NCA does not support IPv6... */
		if (!(item->group == MIB2_IP && item->mib_id == MIB2_IP_MEDIA))
			continue;
		/* LINTED */
		found += arp_process((mib2_ipNetToMediaEntry_t *)item->valp,
		    item->length, changed);
	}
	if (found == 0)
		return (-1);
	else
		return (0);
}

/*
 * Ping all default routers.  It just uses system(3F) to call
 * ping(1M) to do the job...
 */
static void
ping_them(void)
{
	int i;
	char ping_cmd[128];

	for (i = 0; i < num_nif; i++) {
		if (nif_list[i].router_addr.s_addr != 0) {
			(void) snprintf(ping_cmd, sizeof (ping_cmd),
			    "%s %s > /dev/null 2>&1",
			    ping_prog,
			    inet_ntoa(nif_list[i].router_addr));
			(void) system(ping_cmd);
		}
	}
}

/*
 * To get default router info (both IP address and ethernet address) for
 * each configured interface from IP.
 *
 * Param:
 *	boolean_t *changed (referenced): set to B_TRUE if there is any change
 *		of info.
 *
 * Return:
 *	-1 if there is any error, 0 if everything is fine.
 */
static int
get_if_info(boolean_t *changed)
{
	int mib_fd;
	mib_item_t *item;
	boolean_t ip_changed = B_FALSE;
	boolean_t ether_changed = B_FALSE;

	if ((mib_fd = open(IP_DEV_NAME, O_RDWR)) < 0) {
		logperror("cannot open ip to get router info");
		return (-1);
	}
	if (ioctl(mib_fd, I_PUSH, ARP_MOD_NAME) == -1) {
		logperror("cannot push arp");
		goto err;
	}

	if ((item = mibget(mib_fd)) == NULL) {
		goto err;
	}

	if (get_router_ip_addr(item, &ip_changed) < 0) {
		goto err;
	}
	/*
	 * Ping every routers to make sure that ARP has all their ethernet
	 * addresses.
	 */
	ping_them();
	/*
	 * If the router IP address is not changed, its ethernet address
	 * should not be changed.  But just in case there is some IP
	 * failover going on...
	 */
	if (get_router_ether_addr(item, &ether_changed) < 0) {
		goto err;
	}
	(void) close(mib_fd);
	*changed = ip_changed || ether_changed;
	return (0);
err:
	(void) close(mib_fd);
	return (-1);
}

/*
 * To remove the default router from an interface.
 *
 * Param:
 *	struct in_addr gw_addr: the IP address of the default router to be
 *	removed.
 */
static void
nca_del_nif(struct in_addr gw_addr)
{
	struct nca_set_ioctl nca_ioctl;
	struct strioctl strioc;
	int i;
	int udp_fd, fd;

	/* Search for the interface for this router. */
	for (i = 0; i < num_nif; i++) {
		if (nif_list[i].router_addr.s_addr == gw_addr.s_addr)
			break;
	}
	if (i == num_nif)
		return;

	if (ip_domux2fd(&udp_fd, &fd) < 0) {
		logwarn(gettext("Removing interface %s from the"
		    " configuration list.\n"), nif_list[i].name);
		nif_list[i].name[0] = 0;
		return;
	}
	if (ioctl(udp_fd, I_PUNLINK, lifr.lifr_ip_muxid) < 0) {
		logwarn(gettext("Removing interface %s from the"
		    " configuration list.\n"), nif_list[i].name);
		nif_list[i].name[0] = 0;
		(void) close(udp_fd);
		(void) close(fd);
		return;
	}

	strioc.ic_cmd = NCA_SET_IF;
	strioc.ic_timout = INFTIM;
	strioc.ic_len = sizeof (nca_ioctl);
	strioc.ic_dp = (char *)&nca_ioctl;

	nca_ioctl.local_addr = 0;
	(void) memset(nca_ioctl.router_ether_addr, 0, ETHERADDRL);
	nca_ioctl.action = DEL_DEF_ROUTE;

	if (ioctl(fd, I_STR, &strioc) < 0) {
		logperror("ioctl(NCA_SET_IF) failed");
	}
	ip_plink(udp_fd, fd);
	(void) close(udp_fd);
	(void) close(fd);

	/* Clear the fields for this interface. */
	nif_list[i].router_addr.s_addr = 0;
	(void) memset(nif_list[i].router_ether_addr, 0, ETHERADDRL);
}

/*
 * Wait for any changes in the routing table.  If there are changes to
 * IP address or router ethernet address, send down the info to NCA.
 */
static void
daemon_work(void)
{
	int n;
	int i;
	int udp_fd;
	int fd;
	int64_t msg[2048/8];
	struct rt_msghdr *rtm;
	boolean_t changed;
	struct sockaddr_in *sin;
	struct in_addr gw_addr;
	uchar_t *cp;

	/* Loop forever waiting for any routing changes. */
	for (;;) {
		if (debug) {
			logdebug("Waiting to read routing info...\n");
		}
		n = read(rt_fd, msg, sizeof (msg));
		/* Don't die...  Reinitialize socket and listen again. */
		if (n <= 0) {
			if (debug) {
				logdebug("Routing socket read error.\n");
			}
			(void) close(rt_fd);
			rt_fd = socket(PF_ROUTE, SOCK_RAW, AF_INET);
			i = 0;
			while (rt_fd < 0) {
				if (i++ == 0) {
					logperror(gettext("cannot reinitialize"
					    " routing socket"));
				} else if (i > 5) {
					logwarn(gettext("Give up on trying to"
					    " reinitializing routing"
					    " socket\n"));
					exit(1);
				}
				/* May be a transient error... */
				(void) sleep(10);
				rt_fd = socket(PF_ROUTE, SOCK_RAW, AF_INET);
			}
		} else {
			rtm = (struct rt_msghdr *)msg;
			if (rtm->rtm_version != RTM_VERSION) {
				logwarn(gettext("Do non understand routing"
				    " socket info.\n"));
				continue;
			}
			if (debug) {
				logdebug("Get routing info.\n");
			}
			switch (rtm->rtm_type) {
			case RTM_DELETE:
			case RTM_OLDDEL:
				sin = (struct sockaddr_in *)(rtm + 1);
				cp = (uchar_t *)sin;
				/* Only handle default route deletion. */
				if ((rtm->rtm_addrs & RTA_DST) &&
				    (sin->sin_addr.s_addr == 0)) {
					if (!(rtm->rtm_addrs & RTA_GATEWAY)) {
						break;
					}
					cp += sizeof (struct sockaddr_in);
					/* LINTED */
					sin = (struct sockaddr_in *)cp;
					gw_addr = sin->sin_addr;
					if (debug) {
						logdebug("Get default route "
						    "removal notice: gw %s\n",
						    inet_ntoa(gw_addr));
					}
					nca_del_nif(gw_addr);
				}
				break;
			case RTM_ADD:
			case RTM_OLDADD:
			case RTM_CHANGE:
				changed = B_FALSE;
				if (get_if_info(&changed) < 0) {
					/* May be a transient error... */
					(void) sleep(10);
					break;
				}
				/* Nothing is changed, do nothing. */
				if (!changed) {
					if (debug) {
						logdebug("Get route change "
						    "notice, but nothing is "
						    "changed for us!");
					}
					break;
				}
				lifr.lifr_addr.ss_family = AF_INET;
				for (i = 0; i < num_nif; i++) {
					int ret;

					/*
					 * If name is NULL, it means that
					 * we have encontered some problems
					 * when configurating the interface.
					 * So we remove it from the list.
					 */
					if (nif_list[i].name[0] == 0 ||
					    nif_list[i].local_addr.s_addr == 0)
						continue;
					(void) strlcpy(lifr.lifr_name,
					    nif_list[i].name,
					    sizeof (lifr.lifr_name));
					if (ip_domux2fd(&udp_fd, &fd) < 0) {
						logwarn(gettext("Removing"
						    " interface %s from the"
						    " configuration list.\n"),
						    nif_list[i].name);
						nif_list[i].name[0] = 0;
						continue;
					}
					if (ioctl(udp_fd, I_PUNLINK,
					    lifr.lifr_ip_muxid) < 0) {
						logwarn(gettext("Removing"
						    " interface %s from the"
						    " configuration list.\n"),
						    nif_list[i].name);
						nif_list[i].name[0] = 0;
						(void) close(udp_fd);
						(void) close(fd);
						continue;
					}
					if (debug) {
						logdebug("Configuring"
						    " %s\n", nif_list[i].name);
					}
					ret = nca_set_nif(fd,
					    nif_list[i].local_addr,
					    nif_list[i].router_ether_addr);
					ip_plink(udp_fd, fd);
					if (ret < 0) {
						/*
						 * This should not be possible
						 * since if NCA does not
						 * support the ioctl, the
						 * active flag should be
						 * cleared already and this
						 * function should not have
						 * been called at all!
						 */
						logwarn("Daemon dies\n");
						exit(1);
					}
					(void) close(udp_fd);
					(void) close(fd);
				}
				break;
			default:
				continue;
			}
		}
	}
}

/*
 * Make us a daemon.
 */
static void
daemon_init(void)
{
	pid_t pid;

	if ((pid = fork()) == -1) {
		/* Write directly to terminal, instead of syslog. */
		(void) fprintf(stderr, gettext("ncaconfd: cannot fork: %s\n"),
		    strerror(errno));
		exit(1);
	}
	if (pid != 0)
		exit(0);
	(void) setsid();
	/* Fork again so that we will never get a controlling terminal. */
	if ((pid = fork()) == -1) {
		/* Write directly to terminal, instead of syslog. */
		(void) fprintf(stderr, gettext("ncaconfd: cannot fork: %s\n"),
		    strerror(errno));
		exit(1);
	}
	if (pid != 0)
		exit(0);
	(void) chdir("/");
	(void) umask(0);
	(void) fclose(stdin);
	(void) fclose(stdout);
	(void) fclose(stderr);
}

int
main(int argc, char **argv)
{
	int i, j;
	int c;
	boolean_t active = B_FALSE;
	boolean_t as_daemon = B_TRUE;

	if (argc == 1) {
		(void) fprintf(stderr, gettext("Usage: %s [-al]"
		    " [interface1 interface2 ...]\n"), argv[0]);
		return (1);
	}

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);

	while ((c = getopt(argc, argv, "adcl")) != EOF) {
		switch (c) {
		case 'a':
			active = B_TRUE;
			break;
		case 'd':
			debug = B_TRUE;
			break;
		case 'c':
			/* Don't run as daemon. */
			as_daemon = B_FALSE;
			break;
		case 'l':
			logging = B_TRUE;
			break;
		default:
			/* -d and -c are "undocumented" options. */
			(void) fprintf(stderr, gettext("Usage: %s [-al]"
			    " [interface1 interface2 ...]\n"), argv[0]);
			return (1);
		}
	}
	num_nif = argc - optind;
	if (num_nif == 0) {
		/* No network interface to proces... */
		(void) fprintf(stderr, gettext("Usage: %s [-al]"
		    " [interface1 interface2 ...]\n"), argv[0]);
		return (0);
	}
	nif_list = calloc(num_nif, sizeof (nif_t));
	if (nif_list == NULL) {
		(void) fprintf(stderr, gettext("ncaconfd: Cannot malloc: %s\n"),
		    strerror(errno));
		return (1);
	}
	for (i = 0, j = optind; i < num_nif; i++, j++) {
		(void) strlcpy(nif_list[i].name, argv[j], LIFNAMSIZ+1);
	}

	/* Get IP address info for all the intefaces. */
	if (get_if_ip_addr() < 0) {
		if (debug) {
			(void) fprintf(stderr, "ncaconfd: Cannot get IP"
			    " addresses for interfaces.\n");
		}
		return (1);
	}
	if (logging)
		openlog("ncaconfd", LOG_PID, LOG_DAEMON);
	/* No need to run as daemon if NCA is not making active connections. */
	if (active && as_daemon)
		daemon_init();
	if (active) {
		boolean_t changed;

		/* NCA does not support IPv6... */
		if ((rt_fd = socket(PF_ROUTE, SOCK_RAW, AF_INET)) < 0) {
			logperror("Cannot open routing socket");
			return (1);
		}
		/*
		 * At boot up time, the default router may not have been
		 * found.  So ignore the error and check later.
		 */
		if (get_if_info(&changed) < 0) {
			if (debug) {
				(void) logwarn("Cannot get"
				    " information from network interface.\n");
			}
		}
	}
	/* Do the set up as daemon (if we are) to save time at boot up... */
	nca_setup(&active);
	if (active)
		daemon_work();
	return (0);
}