/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (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

 */

/*

 */

#include <config.h>

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <alloca.h>

#include <errno.h>

#include <limits.h>

#include <string.h>

#include <strings.h>

#include <stropts.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <inet/ip.h>

#include <inet/ip6.h>

#include <arpa/inet.h>

#include <sys/sockio.h>

#include <libdlpi.h>

#include <libdladm.h>

#include <libdllink.h>

#include <zone.h>

#include <net/if_types.h>

#include <inet/arp.h>

#include <sys/socket.h>

#include <netdb.h>

#include <rad/radclient.h>

#include <rad/client/1/dlmgr.h>

#undef	IP_VERSION

#include "netlink-protocol.h"

#include "netlink.h"

#include "flow.h"

#include "packets.h"

#include "util-solaris.h"

#include "util.h"

#include "dpif-solaris.h"

static rc_conn_t *rad_conn = NULL;

static boolean_t b_true = B_TRUE;

typedef struct {

	uint_t		ifsp_ppa;	/* Physical Point of Attachment */

	uint_t		ifsp_lun;	/* Logical Unit number */

	boolean_t	ifsp_lunvalid;	/* TRUE if lun is valid */

	char		ifsp_devnm[LIFNAMSIZ]; /* only the device name */

} ifspec_t;

static int

extract_uint(const char *valstr, uint_t *val)

{

	char		*ep;

	unsigned long	ul;

	errno = 0;

	ul = strtoul(valstr, &ep, 10);

	if (errno != 0 || *ep != '\0' || ul > UINT_MAX)

		return (-1);

	*val = (uint_t)ul;

	return (0);

}

/*

 * Given a token with a logical unit spec, return the logical unit converted

 * to a uint_t.

 *

 * Returns: 0 for success, nonzero if an error occurred. errno is set if

 * necessary.

 */

static int

getlun(const char *bp, size_t bpsize, uint_t *lun)

{

	const char	*ep = &bp[bpsize - 1];

	const char	*tp;

	/* Lun must be all digits */

	for (tp = ep; tp > bp && isdigit(*tp); tp--)

		/* Null body */;

	if (tp == ep || tp != bp || extract_uint(bp + 1, lun) != 0) {

		errno = EINVAL;

		return (-1);

	}

	return (0);

}

/*

 * Given a single token ending with a ppa spec, return the ppa spec converted

 * to a uint_t.

 *

 * Returns: 0 for success, nonzero if an error occurred. errno is set if

 * necessary.

 */

static int

getppa(const char *bp, size_t bpsize, uint_t *ppa)

{

	const char	*ep = &bp[bpsize - 1];

	const char	*tp;

	for (tp = ep; tp >= bp && isdigit(*tp); tp--)

		/* Null body */;

	/*

	 * If the device name does not end with a digit or the device

	 * name is a sequence of numbers or a PPA contains a leading

	 * zero, return error.

	 */

	if (tp == ep || tp < bp || ((ep - tp) > 1 && *(tp + 1) == '0'))

		goto fail;

	if (extract_uint(tp + 1, ppa) != 0)

		goto fail;

	/* max value of PPA is 4294967294, which is (UINT_MAX - 1) */

	if (*ppa > UINT_MAX - 1)

		goto fail;

	return (0);

fail:

	errno = EINVAL;

	return (-1);

}

/*

 * Given a `linkname' of the form drv(ppa), parse it into `driver' and `ppa'.

 * If the `dsize' for the `driver' is not atleast MAXLINKNAMELEN then part of

 * the driver name will be copied to `driver'.

 *

 * This function also validates driver name and PPA and therefore callers can

 * call this function with `driver' and `ppa' set to NULL, to just verify the

 * linkname.

 */

boolean_t

dlparse_drvppa(const char *linknamep, char *driver, uint_t dsize, uint_t *ppa)

{

	char	*tp;

	char    linkname[MAXLINKNAMELEN];

	size_t	len;

	uint_t	lppa;

	if (linknamep == NULL || linknamep[0] == '\0')

		goto fail;

	len = strlcpy(linkname, linknamep, MAXLINKNAMELEN);

	if (len >= MAXLINKNAMELEN)

		goto fail;

	/* Get PPA */

	if (getppa(linkname, len, &lppa) != 0)

		return (_B_FALSE);

	/* strip the ppa off of the linkname, if present */

	for (tp = &linkname[len - 1]; tp >= linkname && isdigit(*tp); tp--)

		*tp = '\0';

	/*

	 * Now check for the validity of the device name. The legal characters

	 * in a device name are: alphanumeric (a-z,  A-Z,  0-9), underscore

	 * ('_'), hyphen ('-'), and period ('.'). The first character

	 * of the device name cannot be a digit and should be an alphabetic

	 * character.

	 */

	if (!isalpha(linkname[0]))

		goto fail;

	for (tp = linkname + 1; *tp != '\0'; tp++) {

		if (!isalnum(*tp) && *tp != '_' && *tp != '-' && *tp != '.')

			goto fail;

	}

	if (driver != NULL)

		(void) strlcpy(driver, linkname, dsize);

	if (ppa != NULL)

		*ppa = lppa;

	return (_B_TRUE);

fail:

	errno = EINVAL;

	return (_B_FALSE);

}

/*

 * Given an IP interface name, which is either a

 *	- datalink name (which is driver name plus PPA), for e.g. bge0 or

 *	- datalink name plus a logical interface identifier (delimited by ':'),

 *		for e.g. bge0:34

 * the following function validates its form and decomposes the contents into

 * ifspec_t.

 *

 * Returns _B_TRUE for success, otherwise _B_FALSE is returned.

 */

static boolean_t

ifparse_ifspec(const char *ifname, ifspec_t *ifsp)

{

	char	*lp;

	char	ifnamecp[LIFNAMSIZ];

	if (ifname == NULL || ifname[0] == '\0' ||

	    strlcpy(ifnamecp, ifname, LIFNAMSIZ) >= LIFNAMSIZ) {

		errno = EINVAL;

		return (_B_FALSE);

	}

	ifsp->ifsp_lunvalid = _B_FALSE;

	/* Any logical units? */

	lp = strchr(ifnamecp, ':');

	if (lp != NULL) {

		if (getlun(lp, strlen(lp), &ifsp->ifsp_lun) != 0)

			return (_B_FALSE);

		*lp = '\0';

		ifsp->ifsp_lunvalid = _B_TRUE;

	}

	return (dlparse_drvppa(ifnamecp, ifsp->ifsp_devnm,

	    sizeof (ifsp->ifsp_devnm), &ifsp->ifsp_ppa));

}

/*

 * Issues the ioctl SIOCSLIFNAME to kernel.

 */

static int

slifname(const char *ifname, uint64_t flags, int fd)

{

	struct lifreq	lifr;

	int		status = 0;

	ifspec_t	ifsp;

	boolean_t	valid_if;

	bzero(&lifr, sizeof (lifr));

	/* We should have already validated the interface name. */

	valid_if = ifparse_ifspec(ifname, &ifsp);

	ovs_assert(valid_if);

	lifr.lifr_ppa = ifsp.ifsp_ppa;

	lifr.lifr_flags = flags;

	(void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));

	if (ioctl(fd, SIOCSLIFNAME, &lifr) == -1) {

		status = errno;

	}

	return (status);

}

/*

 * Wrapper for sending a non-transparent I_STR ioctl().

 * Returns: Result from ioctl().

 */

static int

strioctl(int s, int cmd, char *buf, uint_t buflen)

{

	struct strioctl ioc;

	(void) memset(&ioc, 0, sizeof (ioc));

	ioc.ic_cmd = cmd;

	ioc.ic_timout = 0;

	ioc.ic_len = buflen;

	ioc.ic_dp = buf;

	return (ioctl(s, I_STR, (char *)&ioc));

}

/*

 * Issues the ioctl SIOCSLIFNAME to kernel on the given ARP stream fd.

 */

static int

slifname_arp(const char *ifname, uint64_t flags, int fd)

{

	struct lifreq	lifr;

	ifspec_t	ifsp;

	bzero(&lifr, sizeof (lifr));

	(void) ifparse_ifspec(ifname, &ifsp);

	lifr.lifr_ppa = ifsp.ifsp_ppa;

	lifr.lifr_flags = flags;

	(void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));

	/*

	 * Tell ARP the name and unit number for this interface.

	 * Note that arp has no support for transparent ioctls.

	 */

	if (strioctl(fd, SIOCSLIFNAME, (char *)&lifr,

	    sizeof (lifr)) == -1) {

		return (errno);

	}

	return (0);

}

/*

 * Open "/dev/udp{,6}" for use as a multiplexor to PLINK the interface stream

 * under. We use "/dev/udp" instead of "/dev/ip" since STREAMS will not let

 * you PLINK a driver under itself, and "/dev/ip" is typically the driver at

 * the bottom of the stream for tunneling interfaces.

 */

static int

open_arp_on_udp(const char *udp_dev_name, int *fd)

{

	int err;

	if ((*fd = open(udp_dev_name, O_RDWR)) == -1)

		return (errno);

	/*

	 * Pop off all undesired modules (note that the user may have

	 * configured autopush to add modules above udp), and push the

	 * arp module onto the resulting stream. This is used to make

	 * IP+ARP be able to atomically track the muxid for the I_PLINKed

	 * STREAMS, thus it isn't related to ARP running the ARP protocol.

	 */

	while (ioctl(*fd, I_POP, 0) != -1)

		;

	if (errno == EINVAL && ioctl(*fd, I_PUSH, ARP_MOD_NAME) != -1)

		return (0);

	err = errno;

	(void) close(*fd);

	return (err);

}

static char *

solaris_proto2str(uint8_t protocol)

{

	if (protocol == IPPROTO_TCP)

		return ("tcp");

	if (protocol == IPPROTO_UDP)

		return ("udp");

	if (protocol == IPPROTO_SCTP)

		return ("sctp");

	if (protocol == IPPROTO_ICMPV6)

		return ("icmpv6");

	if (protocol == IPPROTO_ICMP)

		return ("icmp");

	else

		return ("");

}

static uint8_t

solaris_str2proto(const char *protostr)

{

	if (strcasecmp(protostr, "tcp") == 0)

		return (IPPROTO_TCP);

	else if (strcasecmp(protostr, "udp") == 0)

		return (IPPROTO_UDP);

	else if (strcasecmp(protostr, "sctp") == 0)

		return (IPPROTO_SCTP);

	else if (strcasecmp(protostr, "icmpv6") == 0)

		return (IPPROTO_ICMPV6);

	else if (strcasecmp(protostr, "icmp") == 0)

		return (IPPROTO_ICMP);

	return (0);

}

/*

 * Returns the flags value for the logical interface in `lifname'

 * in the buffer pointed to by `flags'.

 */

static int

solaris_get_flags(int sock, const char *lifname, uint64_t *flags)

{

	struct lifreq	lifr;

	bzero(&lifr, sizeof (lifr));

	(void) strlcpy(lifr.lifr_name, lifname, sizeof (lifr.lifr_name));

	if (ioctl(sock, SIOCGLIFFLAGS, (caddr_t)&lifr) < 0)

		return (errno);

	*flags = lifr.lifr_flags;

	return (0);

}

/*

 * For a given interface name, checks if IP interface exists.

 */

int

solaris_if_enabled(int sock, const char *ifname, uint64_t *flags)

{

	struct lifreq	lifr;

	int		error = 0;

	bzero(&lifr, sizeof (lifr));

	(void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));

	if (ioctl(sock, SIOCGLIFFLAGS, (caddr_t)&lifr) != 0)

		error = errno;

	if (error == 0 && flags != NULL)

		*flags = lifr.lifr_flags;

	return (error);

}

int

solaris_unplumb_if(int sock, const char *ifname, sa_family_t af)

{

	int		ip_muxid;

	int		arp_muxid;

	int		mux_fd = -1;

	int		muxid_fd = -1;

	char		*udp_dev_name;

	uint64_t	ifflags = 0;

	boolean_t	changed_arp_muxid = B_FALSE;

	struct lifreq	lifr;

	int		ret = 0;

	boolean_t	v6 = (af == AF_INET6);

	/*

	 * We used /dev/udp or udp6 to set up the mux. So we have to use

	 * the same now for PUNLINK also.

	 */

	udp_dev_name = (v6 ?  UDP6_DEV_NAME : UDP_DEV_NAME);

	if ((muxid_fd = open(udp_dev_name, O_RDWR)) == -1) {

		ret = errno;

		goto done;

	}

	ret = open_arp_on_udp(udp_dev_name, &mux_fd);

	if (ret != 0)

		goto done;

	bzero(&lifr, sizeof (lifr));

	(void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));

	if (ioctl(muxid_fd, SIOCGLIFMUXID, (caddr_t)&lifr) < 0) {

		ret = errno;

		goto done;

	}

	arp_muxid = lifr.lifr_arp_muxid;

	ip_muxid = lifr.lifr_ip_muxid;

	ret = solaris_get_flags(sock, ifname, &ifflags);

	if (ret != 0)

		goto done;

	/*

	 * We don't have a good way of knowing whether the arp stream is

	 * plumbed. We can't rely on IFF_NOARP because someone could

	 * have turned it off later using "ifconfig xxx -arp".

	 */

	if (arp_muxid != 0) {

		if (ioctl(mux_fd, I_PUNLINK, arp_muxid) < 0) {

			if ((errno == EINVAL) &&

			    (ifflags & (IFF_NOARP | IFF_IPV6))) {

				/*

				 * Some plumbing utilities set the muxid to

				 * -1 or some invalid value to signify that

				 * there is no arp stream. Set the muxid to 0

				 * before trying to unplumb the IP stream.

				 * IP does not allow the IP stream to be

				 * unplumbed if it sees a non-null arp muxid,

				 * for consistency of IP-ARP streams.

				 */

				lifr.lifr_arp_muxid = 0;

				(void) ioctl(muxid_fd, SIOCSLIFMUXID,

				    (caddr_t)&lifr);

				changed_arp_muxid = B_TRUE;

			}

		}

	}

	if (ioctl(mux_fd, I_PUNLINK, ip_muxid) < 0) {

		if (changed_arp_muxid) {

			/*

			 * Some error occurred, and we need to restore

			 * everything back to what it was.

			 */

			ret = errno;

			lifr.lifr_arp_muxid = arp_muxid;

			lifr.lifr_ip_muxid = ip_muxid;

			(void) ioctl(muxid_fd, SIOCSLIFMUXID, (caddr_t)&lifr);

		}

	}

done:

	if (muxid_fd != -1)

		(void) close(muxid_fd);

	if (mux_fd != -1)

		(void) close(mux_fd);

	return (ret);

}

/*

 * Plumbs the interface `ifname'.

 */

int

solaris_plumb_if(int sock, const char *ifname, sa_family_t af)

{

	int		ip_muxid;

	int		mux_fd = -1, ip_fd, arp_fd;

	char		*udp_dev_name;

	dlpi_handle_t	dh_arp = NULL, dh_ip = NULL;

	uint64_t	ifflags;

	uint_t		dlpi_flags;

	int		status = 0;

	const char	*linkname;

	int		ret;

	if (solaris_if_enabled(sock, ifname, NULL) == 0) {

		status = EEXIST;

		goto done;

	}

	dlpi_flags = DLPI_NOATTACH;

	linkname = ifname;

	/*

	 * We use DLPI_NOATTACH because the ip module will do the attach

	 * itself for DLPI style-2 devices.