/*
 * 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 2002 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

/*
 * Portions of this source code were derived from Berkeley 4.3 BSD
 * under license from the Regents of the University of California.
 */

#include "defs.h"

#define	IF_SEPARATOR	':'

struct interface	*ifnet;

static int		setup_listen_sock(int ifindex);
static void		addrouteforif(struct interface *ifp);
static void		resetup_listen_sock(struct interface *, int);

/*
 * This is called at startup and after that, every CHECK_INTERVAL seconds or
 * when a SIGHUP is received.
 */
void
initifs(void)
{
	static char *buf = NULL;
	static uint_t maxbufsize = 0;
	int bufsize;
	int numifs;
	struct lifnum lifn;
	struct lifconf lifc;
	struct lifreq lifr;
	struct lifreq *lifrp;
	int n;
	struct interface ifs;
	struct interface *ifp;
	int netmaskchange = 0;
	boolean_t changes = _B_FALSE;

	lifn.lifn_family = AF_INET6;
	lifn.lifn_flags = 0;
	if (ioctl(iocsoc, SIOCGLIFNUM, (char *)&lifn) < 0) {
		syslog(LOG_ERR, "initifs: ioctl (get interface numbers): %m");
		return;
	}
	numifs = lifn.lifn_count;
	bufsize = numifs * sizeof (struct lifreq);

	if (buf == NULL || bufsize > maxbufsize) {
		if (buf != NULL)
			free(buf);
		maxbufsize = bufsize;
		buf = (char *)malloc(maxbufsize);
		if (buf == NULL) {
			syslog(LOG_ERR, "initifs: out of memory");
			return;
		}
	}

	lifc.lifc_family = AF_INET6;
	lifc.lifc_flags = 0;
	lifc.lifc_len = bufsize;
	lifc.lifc_buf = buf;
	if (ioctl(iocsoc, SIOCGLIFCONF, (char *)&lifc) < 0) {
		syslog(LOG_ERR,
		    "initifs: ioctl (get interface configuration): %m");
		return;
	}

	/*
	 * Mark all of the currently known interfaces in order to determine
	 * which of the these interfaces no longer exist.
	 */
	for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next)
		ifp->int_flags |= RIP6_IFF_MARKED;
	lifrp = lifc.lifc_req;
	for (n = lifc.lifc_len / sizeof (struct lifreq); n > 0; n--, lifrp++) {
		bzero((char *)&ifs, sizeof (ifs));
		(void) strncpy(lifr.lifr_name, lifrp->lifr_name,
		    sizeof (lifr.lifr_name));
		if (ioctl(iocsoc, SIOCGLIFFLAGS, (char *)&lifr) < 0) {
			syslog(LOG_ERR,
			    "initifs: ioctl (get interface flags): %m");
			continue;
		}
		if (!(lifr.lifr_flags & IFF_IPV6) ||
		    !(lifr.lifr_flags & IFF_MULTICAST) ||
		    (lifr.lifr_flags & IFF_LOOPBACK))
			continue;

		ifp = if_ifwithname(lifr.lifr_name);
		if (ifp != NULL)
			ifp->int_flags &= ~RIP6_IFF_MARKED;
		if (lifr.lifr_flags & IFF_POINTOPOINT)
			ifs.int_flags |= RIP6_IFF_POINTOPOINT;
		if (lifr.lifr_flags & IFF_NORTEXCH)
			ifs.int_flags |= RIP6_IFF_NORTEXCH;
		if (lifr.lifr_flags & IFF_PRIVATE)
			ifs.int_flags |= RIP6_IFF_PRIVATE;
		if (lifr.lifr_flags & IFF_UP) {
			ifs.int_flags |= RIP6_IFF_UP;
		} else {
			if (ifp != NULL) {
				if (ifp->int_flags & RIP6_IFF_UP) {
					/*
					 * If there is an transition from up to
					 * down for an exisiting interface,
					 * increment the counter.
					 */
					ifp->int_transitions++;
					changes = _B_TRUE;
				}
				if_purge(ifp);
			}
			continue;
		}

		if (ifs.int_flags & RIP6_IFF_POINTOPOINT) {
			/*
			 * For point-to-point interfaces, retrieve both the
			 * local and the remote addresses.
			 */
			if (ioctl(iocsoc, SIOCGLIFADDR, (char *)&lifr) < 0) {
				syslog(LOG_ERR,
				    "initifs: ioctl (get interface address): "
				    "%m");
				continue;
			}
			ifs.int_addr =
			    ((struct sockaddr_in6 *)&lifr.lifr_addr)->sin6_addr;
			if (ioctl(iocsoc, SIOCGLIFDSTADDR, (char *)&lifr) < 0) {
				syslog(LOG_ERR,
				    "initifs: ioctl (get destination address): "
				    "%m");
				continue;
			}
			ifs.int_dstaddr = ((struct sockaddr_in6 *)
			    &lifr.lifr_dstaddr)->sin6_addr;
			ifs.int_prefix_length = IPV6_ABITS;
		} else {
			/*
			 * For other interfaces, retreieve the prefix (including
			 * the prefix length.
			 */
			if (ioctl(iocsoc, SIOCGLIFSUBNET, (char *)&lifr) < 0) {
				syslog(LOG_ERR,
				    "initifs: ioctl (get subnet prefix): %m");
				continue;
			}
			/*
			 * This should never happen but check for it in any case
			 * since the kernel stores it as an signed integer.
			 */
			if (lifr.lifr_addrlen < 0 ||
			    lifr.lifr_addrlen > IPV6_ABITS) {
				syslog(LOG_ERR,
				    "initifs: ioctl (get subnet prefix) "
				    "returned invalid prefix length of %d",
				    lifr.lifr_addrlen);
				continue;
			}
			ifs.int_prefix_length = lifr.lifr_addrlen;
			ifs.int_addr = ((struct sockaddr_in6 *)
			    &lifr.lifr_subnet)->sin6_addr;
		}

		if (ioctl(iocsoc, SIOCGLIFMETRIC, (char *)&lifr) < 0 ||
		    lifr.lifr_metric < 0)
			ifs.int_metric = 1;
		else
			ifs.int_metric = lifr.lifr_metric + 1;

		if (ioctl(iocsoc, SIOCGLIFINDEX, (char *)&lifr) < 0) {
			syslog(LOG_ERR, "initifs: ioctl (get index): %m");
			continue;
		}
		ifs.int_ifindex = lifr.lifr_index;

		if (ioctl(iocsoc, SIOCGLIFMTU, (char *)&lifr) < 0) {
			syslog(LOG_ERR, "initifs: ioctl (get mtu): %m");
			continue;
		}

		/*
		 * If the interface's recorded MTU doesn't make sense, use
		 * IPV6_MIN_MTU instead.
		 */
		if (lifr.lifr_mtu < IPV6_MIN_MTU)
			ifs.int_mtu = IPV6_MIN_MTU;
		else
			ifs.int_mtu = lifr.lifr_mtu;

		if (ifp != NULL) {
			/*
			 * RIP6_IFF_NORTEXCH flag change by itself shouldn't
			 * cause an if_purge() call, which also purges all the
			 * routes heard off this interface. So, let's suppress
			 * changes of RIP6_IFF_NORTEXCH	in the following
			 * comparisons.
			 */
			if (ifp->int_prefix_length == ifs.int_prefix_length &&
			    ((ifp->int_flags | RIP6_IFF_NORTEXCH) ==
			    (ifs.int_flags | RIP6_IFF_NORTEXCH)) &&
			    ifp->int_metric == ifs.int_metric &&
			    ifp->int_ifindex == ifs.int_ifindex) {
				/*
				 * Now let's make sure we capture the latest
				 * value of RIP6_IFF_NORTEXCH flag.
				 */
				if (ifs.int_flags & RIP6_IFF_NORTEXCH)
					ifp->int_flags |= RIP6_IFF_NORTEXCH;
				else
					ifp->int_flags &= ~RIP6_IFF_NORTEXCH;

				if (!(ifp->int_flags & RIP6_IFF_POINTOPOINT) &&
				    IN6_ARE_ADDR_EQUAL(&ifp->int_addr,
					&ifs.int_addr))
					continue;
				if ((ifp->int_flags & RIP6_IFF_POINTOPOINT) &&
				    IN6_ARE_ADDR_EQUAL(&ifp->int_dstaddr,
					&ifs.int_dstaddr))
					continue;
			}
			if_purge(ifp);
			if (ifp->int_prefix_length != ifs.int_prefix_length)
				netmaskchange = 1;
			ifp->int_addr = ifs.int_addr;
			ifp->int_dstaddr = ifs.int_dstaddr;
			ifp->int_metric = ifs.int_metric;
			/*
			 * If there is an transition from down to up for an
			 * exisiting interface, increment the counter.
			 */
			if (!(ifp->int_flags & RIP6_IFF_UP) &&
			    (ifs.int_flags & RIP6_IFF_UP))
				ifp->int_transitions++;
			ifp->int_flags |= ifs.int_flags;
			ifp->int_prefix_length = ifs.int_prefix_length;

			/*
			 * If the interface index has changed, we may need to
			 * set up the listen socket again.
			 */
			if (ifp->int_ifindex != ifs.int_ifindex) {
				if (ifp->int_sock != -1) {
					resetup_listen_sock(ifp,
					    ifs.int_ifindex);
				}
				ifp->int_ifindex = ifs.int_ifindex;
			}

			ifp->int_mtu = ifs.int_mtu;
		} else {
			char *cp;
			int log_num;

			ifp = (struct interface *)
			    malloc(sizeof (struct interface));
			if (ifp == NULL) {
				syslog(LOG_ERR, "initifs: out of memory");
				return;
			}
			*ifp = ifs;
			ifp->int_name = ifp->int_ifbase = NULL;
			ifp->int_name =
			    (char *)malloc((size_t)strlen(lifr.lifr_name) + 1);
			if (ifp->int_name == NULL) {
				free(ifp);
				syslog(LOG_ERR, "initifs: out of memory");
				return;
			}
			(void) strcpy(ifp->int_name, lifr.lifr_name);
			ifp->int_ifbase =
			    (char *)malloc((size_t)strlen(lifr.lifr_name) + 1);
			if (ifp->int_ifbase == NULL) {
				free(ifp->int_name);
				free(ifp);
				syslog(LOG_ERR, "initifs: out of memory");
				return;
			}
			(void) strcpy(ifp->int_ifbase, lifr.lifr_name);
			cp = (char *)index(ifp->int_ifbase, IF_SEPARATOR);
			if (cp != NULL) {
				/*
				 * Verify that the value following the separator
				 * is an integer greater than zero (the only
				 * possible value for a logical interface).
				 */
				log_num = atoi((char *)(cp + 1));
				if (log_num <= 0) {
					free(ifp->int_ifbase);
					free(ifp->int_name);
					free(ifp);
					syslog(LOG_ERR,
					    "initifs: interface name %s could "
					    "not be parsed", ifp->int_name);
					return;
				}
				*cp = '\0';
			} else {
				log_num = 0;
			}
			if (log_num == 0) {
				ifp->int_sock =
				    setup_listen_sock(ifp->int_ifindex);
			} else {
				ifp->int_sock = -1;
			}
			ifp->int_next = ifnet;
			ifnet = ifp;
			traceinit(ifp);
		}
		addrouteforif(ifp);
		changes = _B_TRUE;
	}

	/*
	 * Any remaining interfaces that are still marked and which were in an
	 * up state (RIP6_IFF_UP) need to removed from the routing table.
	 */
	for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next) {
		if ((ifp->int_flags & (RIP6_IFF_MARKED | RIP6_IFF_UP)) ==
		    (RIP6_IFF_MARKED | RIP6_IFF_UP)) {
			if_purge(ifp);
			ifp->int_flags &= ~RIP6_IFF_MARKED;
			changes = _B_TRUE;
		}
	}
	if (netmaskchange)
		rtchangeall();
	if (supplier & changes)
		dynamic_update((struct interface *)NULL);
}

static void
addrouteforif(struct interface *ifp)
{
	struct rt_entry *rt;
	struct in6_addr *dst;

	if (ifp->int_flags & RIP6_IFF_POINTOPOINT)
		dst = &ifp->int_dstaddr;
	else
		dst = &ifp->int_addr;

	rt = rtlookup(dst, ifp->int_prefix_length);

	if (rt != NULL) {
		if (rt->rt_state & RTS_INTERFACE)
			return;
		rtdelete(rt);
	}
	rtadd(dst, &ifp->int_addr, ifp->int_prefix_length, ifp->int_metric, 0,
	    _B_TRUE, ifp);
}

static int
setup_listen_sock(int ifindex)
{
	int sock;
	struct sockaddr_in6 sin6;
	uint_t hops;
	struct ipv6_mreq allrouters_mreq;
	int on = 1;
	int off = 0;
	int recvsize;

	sock = socket(AF_INET6, SOCK_DGRAM, 0);
	if (sock == -1)
		goto sock_fail;

	if (setsockopt(sock, IPPROTO_IPV6, IPV6_BOUND_IF, (char *)&ifindex,
	    sizeof (ifindex)) < 0) {
		syslog(LOG_ERR,
		    "setup_listen_sock: setsockopt: IPV6_BOUND_IF: %m");
		goto sock_fail;
	}

	hops = IPV6_MAX_HOPS;
	if (setsockopt(sock, IPPROTO_IPV6, IPV6_UNICAST_HOPS, (char *)&hops,
	    sizeof (hops)) < 0) {
		syslog(LOG_ERR,
		    "setup_listen_sock: setsockopt: IPV6_UNICAST_HOPS: %m");
		goto sock_fail;
	}

	if (setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *)&hops,
	    sizeof (hops)) < 0) {
		syslog(LOG_ERR,
		    "setup_listen_sock: setsockopt: IPV6_MULTICAST_HOPS: %m");
		goto sock_fail;
	}

	if (setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *)&off,
	    sizeof (off)) < 0) {
		syslog(LOG_ERR,
		    "setup_listen_sock: setsockopt: IPV6_MULTICAST_LOOP: %m");
		goto sock_fail;
	}

	allrouters_mreq.ipv6mr_multiaddr = allrouters_in6;
	allrouters_mreq.ipv6mr_interface = ifindex;
	if (setsockopt(sock, IPPROTO_IPV6, IPV6_JOIN_GROUP,
	    (char *)&allrouters_mreq, sizeof (allrouters_mreq)) < 0) {
		if (errno != EADDRINUSE) {
			syslog(LOG_ERR,
			    "setup_listen_sock: setsockopt: "
			    "IPV6_JOIN_GROUP: %m");
			goto sock_fail;
		}
	}

	if (setsockopt(sock, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, (char *)&on,
	    sizeof (off)) < 0) {
		syslog(LOG_ERR,
		    "setup_listen_sock: setsockopt: IPV6_RECVHOPLIMIT: %m");
		goto sock_fail;
	}

	if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&on,
	    sizeof (on)) < 0) {
		syslog(LOG_ERR,
		    "setup_listen_sock: setsockopt: SO_REUSEADDR: %m");
		goto sock_fail;
	}

	recvsize = RCVBUFSIZ;
	if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *)&recvsize,
	    sizeof (int)) < 0) {
		syslog(LOG_ERR, "setup_listen_sock: setsockopt: SO_RCVBUF: %m");
		goto sock_fail;
	}

	bzero((char *)&sin6, sizeof (sin6));
	sin6.sin6_family = AF_INET6;
	sin6.sin6_port = rip6_port;
	if (bind(sock, (struct sockaddr *)&sin6, sizeof (sin6)) < 0) {
		syslog(LOG_ERR, "setup_listen_sock: bind: %m");
		goto sock_fail;
	}

	poll_ifs_num++;
	if (poll_ifs == NULL) {
		poll_ifs = (struct pollfd *)
		    malloc(max_poll_ifs * sizeof (struct pollfd));
	} else if (poll_ifs_num > max_poll_ifs) {
		max_poll_ifs *= 2;
		poll_ifs = (struct pollfd *)realloc((char *)poll_ifs,
		    max_poll_ifs * sizeof (struct pollfd));
	}
	if (poll_ifs == NULL) {
		syslog(LOG_ERR, "setup_listen_sock: out of memory");
		goto sock_fail;
	}

	poll_ifs[poll_ifs_num - 1].fd = sock;
	poll_ifs[poll_ifs_num - 1].events = POLLIN;
	return (sock);

sock_fail:
	if (sock > 0)
		(void) close(sock);
	return (-1);
}

/*
 * resetup_listen_sock is primarily used in the case where a tunnel was
 * plumbed, unplumbed, then plumbed again.  This would cause the binding set by
 * IPV6_BOUND_IF to be useless, and sends to the associated socket will be
 * transmitted on the wrong interface.  resetup_listen_sock
 *	closes the socket,
 *	removes the socket from poll_ifs[]
 *	plugs the hole in poll_ifs[]
 *	calls setup_listen_sock to set up the socket again
 */
void
resetup_listen_sock(struct interface *ifp, int newindex)
{
	int i;

	(void) close(ifp->int_sock);

	/* Remove socket from poll_ifs[]. */
	for (i = poll_ifs_num - 1; i >= 0; i--) {

		if (poll_ifs[i].fd == ifp->int_sock) {

			poll_ifs[i].fd = 0;
			poll_ifs[i].events = 0;

			/*
			 * Remove hole in poll_ifs.  Possibly exchange
			 * poll_ifs[i] with poll_ifs[poll_ifs_num-1].
			 */
			if (i != poll_ifs_num - 1) {
				poll_ifs[i] = poll_ifs[poll_ifs_num - 1];
				poll_ifs[poll_ifs_num - 1].fd = 0;
				poll_ifs[poll_ifs_num - 1].events = 0;
			}
			poll_ifs_num--;

			/* Now set everything up again. */
			ifp->int_sock = setup_listen_sock(newindex);
			break;
		}
	}
}