/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright (c) 2015 Joyent, Inc.
 * Copyright 2020 OmniOS Community Edition (OmniOSce) Association.
 */

#include <libdladm_impl.h>
#include <libdllink.h>
#include <libdloverlay.h>
#include <sys/dld.h>
#include <sys/overlay.h>
#include <strings.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <limits.h>
#include <libscf.h>
#include <libvarpd_client.h>

#define	VARPD_PROPERTY_NAME	"varpd/id"
#define	VARPD_SERVICE		"network/varpd:default"

static const char *dladm_overlay_doorpath = "/var/run/varpd/varpd.door";

static boolean_t
varpd_svc_isonline(void)
{
	boolean_t isonline = B_FALSE;
	char *s;

	if ((s = smf_get_state(VARPD_SERVICE)) != NULL) {
		if (strcmp(s, SCF_STATE_STRING_ONLINE) == 0)
			isonline = B_TRUE;
		free(s);
	}

	return (isonline);
}

#define	MAX_WAIT_TIME	15

static dladm_status_t
varpd_enable_service(void)
{
	uint_t i;

	if (varpd_svc_isonline())
		return (DLADM_STATUS_OK);

	if (smf_enable_instance(VARPD_SERVICE, 0) == -1) {
		if (scf_error() == SCF_ERROR_PERMISSION_DENIED)
			return (DLADM_STATUS_DENIED);
		return (DLADM_STATUS_NOTFOUND);
	}

	/*
	 * Wait up to MAX_WAIT_TIME seconds for the service
	 */
	for (i = 0; i < MAX_WAIT_TIME; i++) {
		if (varpd_svc_isonline())
			return (DLADM_STATUS_OK);
		(void) sleep(1);
	}
	return (DLADM_STATUS_FAILED);
}

static int
dladm_overlay_count_cb(dladm_handle_t handle __unused,
    datalink_id_t linkid __unused, void *arg)
{
	(*(uint32_t *)arg)++;
	return (DLADM_WALK_CONTINUE);
}

/*
 * Disable the varpd service if there are no overlays left.
 */
static void
varpd_disable_service_when_no_overlays(dladm_handle_t handle)
{
	uint32_t cnt = 0;

	/*
	 * Get the number of the existing overlays. If there are no overlays
	 * left, disable the service.
	 */

	(void) dladm_walk_datalink_id(dladm_overlay_count_cb, handle,
	    &cnt, DATALINK_CLASS_OVERLAY, DATALINK_ANY_MEDIATYPE,
	    DLADM_OPT_ACTIVE);

	if (cnt == 0)
		(void) smf_disable_instance(VARPD_SERVICE, 0);
}

typedef struct dladm_overlay_propinfo {
	boolean_t dop_isvarpd;
	union {
		overlay_ioc_propinfo_t *dop_overlay;
		varpd_client_prop_handle_t *dop_varpd;
	} dop_un;
} dladm_overlay_propinfo_t;

dladm_status_t
dladm_overlay_prop_info(dladm_overlay_propinfo_handle_t phdl,
    const char **namep, uint_t *typep, uint_t *protp, const void **defp,
    uint32_t *sizep, const mac_propval_range_t **possp)
{
	dladm_overlay_propinfo_t *infop = (dladm_overlay_propinfo_t *)phdl;
	overlay_ioc_propinfo_t *oinfop = infop->dop_un.dop_overlay;

	if (infop->dop_isvarpd == B_FALSE) {
		if (namep != NULL)
			*namep = oinfop->oipi_name;
		if (typep != NULL)
			*typep = oinfop->oipi_type;
		if (protp != NULL)
			*protp = oinfop->oipi_prot;
		if (defp != NULL)
			*defp = oinfop->oipi_default;
		if (sizep != NULL)
			*sizep = oinfop->oipi_defsize;
		if (possp != NULL) {
			*possp = (const mac_propval_range_t *)oinfop->oipi_poss;
		}

	} else {
		int ret;
		ret = libvarpd_c_prop_info(infop->dop_un.dop_varpd, namep,
		    typep, protp, defp, sizep, possp);
		if (ret != 0)
			return (dladm_errno2status(ret));

	}

	return (DLADM_STATUS_OK);
}

static dladm_status_t
dladm_overlay_parse_prop(overlay_prop_type_t type, void *buf, uint32_t *sizep,
    const char *val)
{
	int ret;
	int64_t ival;
	uint64_t uval;
	char *eptr;
	struct in6_addr ipv6;
	struct in_addr ip;

	switch (type) {
	case OVERLAY_PROP_T_INT:
		errno = 0;
		ival = strtol(val, &eptr, 10);
		if ((ival == 0 && errno == EINVAL) ||
		    ((ival == LONG_MAX || ival == LONG_MIN) &&
		    errno == ERANGE))
			return (DLADM_STATUS_BADARG);
		bcopy(&ival, buf, sizeof (int64_t));
		*sizep = sizeof (int64_t);
		break;
	case OVERLAY_PROP_T_UINT:
		errno = 0;
		uval = strtol(val, &eptr, 10);
		if ((uval == 0 && errno == EINVAL) ||
		    (uval == ULONG_MAX && errno == ERANGE))
			return (DLADM_STATUS_BADARG);
		bcopy(&uval, buf, sizeof (uint64_t));
		*sizep = sizeof (uint64_t);
		break;
	case OVERLAY_PROP_T_STRING:
		ret = strlcpy((char *)buf, val, OVERLAY_PROP_SIZEMAX);
		if (ret >= OVERLAY_PROP_SIZEMAX)
			return (DLADM_STATUS_BADARG);
		*sizep = ret + 1;
		break;
	case OVERLAY_PROP_T_IP:
		/*
		 * Always try to parse the IP as an IPv6 address. If that fails,
		 * try to interpret it as an IPv4 address and transform it into
		 * an IPv6 mapped IPv4 address.
		 */
		if (inet_pton(AF_INET6, val, &ipv6) != 1) {
			if (inet_pton(AF_INET, val, &ip) != 1)
				return (DLADM_STATUS_BADARG);

			IN6_INADDR_TO_V4MAPPED(&ip, &ipv6);
		}
		bcopy(&ipv6, buf, sizeof (struct in6_addr));
		*sizep = sizeof (struct in6_addr);
		break;
	default:
		abort();
	}

	return (DLADM_STATUS_OK);
}

static dladm_status_t
i_dladm_overlay_setprop_db(dladm_handle_t handle, datalink_id_t linkid,
    const char *name, char *const *valp, uint_t cnt)
{
	dladm_conf_t	conf;
	dladm_status_t	status;

	if (linkid == DATALINK_INVALID_LINKID ||
	    name == NULL || valp == NULL || cnt != 1) {
		return (DLADM_STATUS_BADARG);
	}

	status = dladm_open_conf(handle, linkid, &conf);
	if (status != DLADM_STATUS_OK)
		return (status);

	status = dladm_set_conf_field(handle, conf, name, DLADM_TYPE_STR,
	    valp[0]);
	if (status == DLADM_STATUS_OK)
		status = dladm_write_conf(handle, conf);

	dladm_destroy_conf(handle, conf);
	return (status);
}

static dladm_status_t
dladm_overlay_varpd_setprop(dladm_handle_t handle __unused,
    varpd_client_handle_t *chdl, uint64_t inst, datalink_id_t linkid __unused,
    const char *name, char *const *valp, uint_t cnt __unused)
{
	int ret;
	uint32_t size;
	uint8_t buf[LIBVARPD_PROP_SIZEMAX];
	varpd_client_prop_handle_t *phdl;
	uint_t type;
	dladm_status_t status;

	if ((ret = libvarpd_c_prop_handle_alloc(chdl, inst, &phdl)) != 0)
		return (dladm_errno2status(ret));

	if ((ret = libvarpd_c_prop_info_fill_by_name(phdl, name)) != 0) {
		libvarpd_c_prop_handle_free(phdl);
		return (dladm_errno2status(ret));
	}

	if ((ret = libvarpd_c_prop_info(phdl, NULL, &type, NULL, NULL, NULL,
	    NULL)) != 0) {
		libvarpd_c_prop_handle_free(phdl);
		return (dladm_errno2status(ret));
	}

	if ((status = dladm_overlay_parse_prop(type, buf, &size, valp[0])) !=
	    DLADM_STATUS_OK) {
		libvarpd_c_prop_handle_free(phdl);
		return (status);
	}

	status = DLADM_STATUS_OK;
	ret = libvarpd_c_prop_set(phdl, buf, size);
	libvarpd_c_prop_handle_free(phdl);
	if (ret != 0)
		status = dladm_errno2status(ret);

	if (status != DLADM_STATUS_OK)
		return (status);

	return (status);
}

static dladm_status_t
dladm_overlay_setprop(dladm_handle_t handle, datalink_id_t linkid,
    const char *name, char *const *valp, uint_t cnt)
{
	int			ret;
	dladm_status_t		status;
	overlay_ioc_propinfo_t	info;
	overlay_ioc_prop_t	prop;

	if (linkid == DATALINK_INVALID_LINKID ||
	    name == NULL || valp == NULL || cnt != 1)
		return (DLADM_STATUS_BADARG);

	bzero(&info, sizeof (overlay_ioc_propinfo_t));
	info.oipi_linkid = linkid;
	info.oipi_id = -1;
	if (strlcpy(info.oipi_name, name, OVERLAY_PROP_NAMELEN) >=
	    OVERLAY_PROP_NAMELEN)
		return (DLADM_STATUS_BADARG);

	status = DLADM_STATUS_OK;
	ret = ioctl(dladm_dld_fd(handle), OVERLAY_IOC_PROPINFO, &info);
	if (ret != 0)
		status = dladm_errno2status(errno);

	if (status != DLADM_STATUS_OK)
		return (status);

	prop.oip_linkid = linkid;
	prop.oip_id = info.oipi_id;
	prop.oip_name[0] = '\0';
	if ((status = dladm_overlay_parse_prop(info.oipi_type, prop.oip_value,
	    &prop.oip_size, valp[0])) != DLADM_STATUS_OK)
		return (status);

	status = DLADM_STATUS_OK;
	ret = ioctl(dladm_dld_fd(handle), OVERLAY_IOC_SETPROP, &prop);
	if (ret != 0)
		status = dladm_errno2status(errno);

	if (status != DLADM_STATUS_OK)
		return (status);

	return (status);
}

/*
 * Tell the user about any unset required properties.
 */
static int
dladm_overlay_activate_cb(dladm_handle_t handle, datalink_id_t linkid,
    dladm_overlay_propinfo_handle_t phdl, void *arg)
{
	dladm_status_t status;
	uint8_t buf[DLADM_OVERLAY_PROP_SIZEMAX];
	uint_t prot;
	size_t size = sizeof (buf);
	const char *name;
	dladm_errlist_t *errs = arg;

	if ((status = dladm_overlay_prop_info(phdl, &name, NULL, &prot, NULL,
	    NULL, NULL)) != DLADM_STATUS_OK)
		return (status);

	if ((prot & OVERLAY_PROP_PERM_REQ) == 0)
		return (DLADM_WALK_CONTINUE);

	if (dladm_overlay_get_prop(handle, linkid, phdl, buf, &size) !=
	    DLADM_STATUS_OK)
		return (DLADM_WALK_CONTINUE);

	if (size == 0)
		(void) dladm_errlist_append(errs, "unset required property: %s",
		    name);

	return (DLADM_WALK_CONTINUE);
}

/*
 * We need to clean up the world here. The problem is that we may or may not
 * actually have everything created. While in the normal case, we'd always have
 * an overlay device, assigned datalink id, and a varpd instance, we might not
 * have any of those, except for the datalink instance. Therefore, as long as
 * the id refers to a valid overlay, we should try to clean up as much of the
 * state as possible and most importantly, we need to make sure we delete the
 * datalink id. If we fail to do that, then that name will become lost to time.
 */
dladm_status_t
dladm_overlay_delete(dladm_handle_t handle, datalink_id_t linkid,
    uint32_t flags)
{
	datalink_class_t class;
	overlay_ioc_delete_t oid;
	varpd_client_handle_t *chdl;
	int ret;
	uint64_t varpdid;

	if (dladm_datalink_id2info(handle, linkid, NULL, &class, NULL,
	    NULL, 0) != DLADM_STATUS_OK) {
		return (DLADM_STATUS_BADARG);
	}

	if (class != DATALINK_CLASS_OVERLAY)
		return (DLADM_STATUS_BADARG);

	oid.oid_linkid = linkid;
	ret = ioctl(dladm_dld_fd(handle), OVERLAY_IOC_DELETE, &oid);
	if (ret != 0 && errno != ENOENT) {
		return (dladm_errno2status(errno));
	}

	if ((ret = libvarpd_c_create(&chdl, dladm_overlay_doorpath)) != 0) {
		return (dladm_errno2status(ret));
	}

	if ((ret = libvarpd_c_instance_lookup(chdl, linkid, &varpdid)) != 0) {
		if (ret == ENOENT) {
			goto finish;
		}
		(void) libvarpd_c_destroy(chdl);
		return (dladm_errno2status(ret));
	}

	ret = libvarpd_c_instance_destroy(chdl, varpdid);
finish:
	(void) libvarpd_c_destroy(chdl);
	if ((flags & DLADM_OPT_PERSIST) != 0) {
		(void) dladm_remove_conf(handle, linkid);
		(void) dladm_destroy_datalink_id(handle, linkid, flags);
	}

	(void) varpd_disable_service_when_no_overlays(handle);

	return (dladm_errno2status(ret));
}

dladm_status_t
dladm_overlay_get_prop(dladm_handle_t handle, datalink_id_t linkid,
    dladm_overlay_propinfo_handle_t infohdl, void *buf, size_t *sizep)
{
	int ret;
	overlay_ioc_prop_t oip;
	dladm_overlay_propinfo_t *infop = (dladm_overlay_propinfo_t *)infohdl;

	/*
	 * It'd be nice if we had a better or more specific error for this. If
	 * this kind of error becomes common place, let's get a better dladm
	 * error.
	 */
	if (*sizep < DLADM_OVERLAY_PROP_SIZEMAX)
		return (dladm_errno2status(ERANGE));

	if (infop->dop_isvarpd == B_FALSE) {
		bzero(&oip, sizeof (overlay_ioc_prop_t));
		oip.oip_linkid = linkid;
		oip.oip_id = infop->dop_un.dop_overlay->oipi_id;
		ret = ioctl(dladm_dld_fd(handle), OVERLAY_IOC_GETPROP, &oip);
		if (ret != 0)
			return (dladm_errno2status(errno));
		bcopy(oip.oip_value, buf, DLADM_OVERLAY_PROP_SIZEMAX);
		*sizep = oip.oip_size;
	} else {
		uint32_t size = *sizep;

		ret = libvarpd_c_prop_get(infop->dop_un.dop_varpd, buf, &size);
		if (ret != 0)
			return (dladm_errno2status(errno));
		*sizep = size;
	}

	return (DLADM_STATUS_OK);
}

static dladm_status_t
dladm_overlay_walk_varpd_prop(dladm_handle_t handle, datalink_id_t linkid,
    uint64_t varpdid, dladm_overlay_prop_f func, void *arg)
{
	int ret;
	varpd_client_handle_t *chdl;
	varpd_client_prop_handle_t *phdl;
	uint_t i, nprops;
	dladm_status_t status;

	if ((ret = libvarpd_c_create(&chdl, dladm_overlay_doorpath)) != 0)
		return (dladm_errno2status(ret));

	if ((ret = libvarpd_c_prop_handle_alloc(chdl, varpdid, &phdl)) != 0) {
		(void) libvarpd_c_destroy(chdl);
		return (dladm_errno2status(ret));
	}

	if ((ret = libvarpd_c_prop_nprops(chdl, varpdid, &nprops)) != 0) {
		libvarpd_c_prop_handle_free(phdl);
		(void) libvarpd_c_destroy(chdl);
		return (dladm_errno2status(ret));
	}

	status = DLADM_STATUS_OK;
	for (i = 0; i < nprops; i++) {
		dladm_overlay_propinfo_t dop;

		bzero(&dop, sizeof (dop));
		dop.dop_isvarpd = B_TRUE;
		dop.dop_un.dop_varpd = phdl;

		if ((ret = libvarpd_c_prop_info_fill(phdl, i)) != 0) {
			status = dladm_errno2status(ret);
			break;
		}

		ret = func(handle, linkid,
		    (dladm_overlay_propinfo_handle_t)&dop, arg);
		if (ret == DLADM_WALK_TERMINATE)
			break;
	}

	libvarpd_c_prop_handle_free(phdl);
	libvarpd_c_destroy(chdl);

	return (status);
}

dladm_status_t
dladm_overlay_walk_prop(dladm_handle_t handle, datalink_id_t linkid,
    dladm_overlay_prop_f func, void *arg, dladm_errlist_t *errs)
{
	int i, ret;
	char buf[MAXLINKNAMELEN];
	char errmsg[DLADM_STRSIZE];
	datalink_class_t class;
	dladm_status_t info_status;
	overlay_ioc_nprops_t oin;
	overlay_ioc_propinfo_t oipi;
	dladm_overlay_propinfo_t dop;
	uint64_t varpdid = UINT64_MAX;

	if ((info_status = dladm_datalink_id2info(handle, linkid, NULL, &class,
	    NULL, buf, MAXLINKNAMELEN)) != DLADM_STATUS_OK) {
		(void) dladm_errlist_append(errs, "failed to get info for "
		    "datalink id %u: %s",
		    linkid, dladm_status2str(info_status, errmsg));
		return (DLADM_STATUS_BADARG);
	}

	if (class != DATALINK_CLASS_OVERLAY) {
		(void) dladm_errlist_append(errs, "%s is not an overlay", buf);
		return (DLADM_STATUS_BADARG);
	}

	bzero(&oin, sizeof (overlay_ioc_nprops_t));
	oin.oipn_linkid = linkid;
	ret = ioctl(dladm_dld_fd(handle), OVERLAY_IOC_NPROPS, &oin);
	if (ret != 0) {
		(void) dladm_errlist_append(errs, "failed to get "
		    "overlay properties for overlay %s: %s",
		    buf, strerror(errno));
		return (dladm_errno2status(errno));
	}

	for (i = 0; i < oin.oipn_nprops; i++) {
		bzero(&dop, sizeof (dladm_overlay_propinfo_t));
		bzero(&oipi, sizeof (overlay_ioc_propinfo_t));
		oipi.oipi_linkid = linkid;
		oipi.oipi_id = i;
		ret = ioctl(dladm_dld_fd(handle), OVERLAY_IOC_PROPINFO, &oipi);
		if (ret != 0) {
			(void) dladm_errlist_append(errs, "failed to get "
			    "propinfo for overlay %s, property %d: %s",
			    buf, i, strerror(errno));
			return (dladm_errno2status(errno));
		}

		dop.dop_isvarpd = B_FALSE;
		dop.dop_un.dop_overlay = &oipi;
		ret = func(handle, linkid,
		    (dladm_overlay_propinfo_handle_t)&dop, arg);
		if (ret == DLADM_WALK_TERMINATE)
			break;

		if (strcmp(oipi.oipi_name, VARPD_PROPERTY_NAME) == 0) {
			uint8_t buf[DLADM_OVERLAY_PROP_SIZEMAX];
			size_t bufsize = sizeof (buf);
			uint64_t *vp;

			if (dladm_overlay_get_prop(handle, linkid,
			    (dladm_overlay_propinfo_handle_t)&dop, buf,
			    &bufsize) != DLADM_STATUS_OK)
				continue;

			vp = (uint64_t *)buf;
			varpdid = *vp;
		}
	}

	/* Should this really be possible? */
	if (varpdid == UINT64_MAX)
		return (DLADM_STATUS_OK);

	ret = dladm_overlay_walk_varpd_prop(handle, linkid, varpdid, func,
	    arg);
	if (ret != DLADM_STATUS_OK) {
		(void) dladm_errlist_append(errs,
		    "failed to get varpd props for "
		    "overlay %s, varpd id %llu: %s",
		    buf, varpdid, dladm_status2str(info_status, errmsg));
	}
	return (ret);
}

static dladm_status_t
dladm_overlay_persist_config(dladm_handle_t handle, dladm_overlay_attr_t *attr)
{
	dladm_conf_t conf;
	dladm_status_t status;

	if ((status = dladm_create_conf(handle, attr->oa_name, attr->oa_linkid,
	    DATALINK_CLASS_OVERLAY, DL_ETHER, &conf)) != DLADM_STATUS_OK) {
		return (status);
	}

	status = dladm_set_conf_field(handle, conf, FVNETID,
	    DLADM_TYPE_UINT64, &attr->oa_vid);
	if (status != DLADM_STATUS_OK)
		goto done;

	status = dladm_set_conf_field(handle, conf, FENCAP,
	    DLADM_TYPE_STR, attr->oa_encap);
	if (status != DLADM_STATUS_OK)
		goto done;

	status = dladm_set_conf_field(handle, conf, FSEARCH,
	    DLADM_TYPE_STR, attr->oa_search);
	if (status != DLADM_STATUS_OK)
		goto done;

	status = dladm_write_conf(handle, conf);

done:
	dladm_destroy_conf(handle, conf);
	return (status);
}

static dladm_status_t
i_dladm_overlay_create_sys(dladm_handle_t handle, dladm_overlay_attr_t *attr)
{
	overlay_ioc_create_t oic;
	dladm_status_t status;
	int ret;

	bzero(&oic, sizeof (oic));
	oic.oic_linkid = attr->oa_linkid;
	oic.oic_vnetid = attr->oa_vid;
	(void) strlcpy(oic.oic_encap, attr->oa_encap, MAXLINKNAMELEN);

	status = DLADM_STATUS_OK;
	ret = ioctl(dladm_dld_fd(handle), OVERLAY_IOC_CREATE, &oic);
	if (ret != 0) {
		/*
		 * It'd be nice if we had private errors so we could better
		 * distinguish between different classes of errors.
		 */
		status = dladm_errno2status(errno);
	}

	return (status);
}

static dladm_status_t
i_dladm_overlay_commit_sys(dladm_handle_t handle, dladm_overlay_attr_t *attr,
    dladm_arg_list_t *props, dladm_errlist_t *errs)
{
	overlay_ioc_activate_t oia;
	varpd_client_handle_t *vch;
	dladm_status_t status;
	size_t slen;
	uint64_t id;
	int ret;
	uint_t i;

	slen = strlen(attr->oa_search);
	for (i = 0; props != NULL && i < props->al_count; i++) {
		dladm_arg_info_t	*aip = &props->al_info[i];

		/*
		 * If it's a property for the search plugin, eg. it has the
		 * prefix '<search>/', then we don't set the property on the
		 * overlay device and instead set it on the varpd instance.
		 */
		if (strncmp(aip->ai_name, attr->oa_search, slen) == 0 &&
		    aip->ai_name[slen] == '/')
			continue;
		status = dladm_overlay_setprop(handle, attr->oa_linkid,
		    aip->ai_name, aip->ai_val, aip->ai_count);
		if (status != DLADM_STATUS_OK) {
			(void) dladm_errlist_append(errs,
			    "failed to set property %s", aip->ai_name);
			return (status);
		}

		if (attr->oa_flags & DLADM_OPT_PERSIST) {
			status = i_dladm_overlay_setprop_db(handle,
			    attr->oa_linkid, aip->ai_name, aip->ai_val,
			    aip->ai_count);
			if (status != DLADM_STATUS_OK) {
				(void) dladm_errlist_append(errs,
				    "failed to persistently set property %s",
				    aip->ai_name);
				return (status);
			}
		}
	}

	if ((ret = libvarpd_c_create(&vch, dladm_overlay_doorpath)) != 0) {
		(void) dladm_errlist_append(errs,
		    "failed to create libvarpd handle: %s", strerror(ret));
		return (dladm_errno2status(ret));
	}

	if ((ret = libvarpd_c_instance_create(vch, attr->oa_linkid,
	    attr->oa_search, &id)) != 0) {
		(void) dladm_errlist_append(errs,
		    "failed to create varpd instance: %s", strerror(ret));
		libvarpd_c_destroy(vch);
		return (dladm_errno2status(ret));
	}

	for (i = 0; props != NULL && i < props->al_count; i++) {
		dladm_arg_info_t	*aip = &props->al_info[i];

		/*
		 * Skip arguments we've processed already.
		 */
		if (strncmp(aip->ai_name, attr->oa_search, slen) != 0 ||
		    aip->ai_name[slen] != '/')
			continue;

		ret = dladm_overlay_varpd_setprop(handle, vch, id,
		    attr->oa_linkid, aip->ai_name, aip->ai_val, aip->ai_count);
		if (ret != 0) {
			(void) dladm_errlist_append(errs,
			    "failed to set varpd prop: %s\n", aip->ai_name);
			(void) libvarpd_c_instance_destroy(vch, id);
			libvarpd_c_destroy(vch);
			return (dladm_errno2status(ret));
		}

		if (attr->oa_flags & DLADM_OPT_PERSIST) {
			status = i_dladm_overlay_setprop_db(handle,
			    attr->oa_linkid, aip->ai_name, aip->ai_val,
			    aip->ai_count);
			if (status != DLADM_STATUS_OK) {
				(void) dladm_errlist_append(errs, "failed to "
				    "persistently set varpd prop: %s\n",
				    aip->ai_name);
				(void) libvarpd_c_instance_destroy(vch, id);
				libvarpd_c_destroy(vch);
				return (status);
			}
		}
	}

	if ((ret = libvarpd_c_instance_activate(vch, id)) != 0) {
		(void) dladm_errlist_append(errs,
		    "failed to activate varpd instance: %s", strerror(ret));
		(void) dladm_overlay_walk_varpd_prop(handle, attr->oa_linkid,
		    id, dladm_overlay_activate_cb, errs);
		(void) libvarpd_c_instance_destroy(vch, id);
		libvarpd_c_destroy(vch);
		return (dladm_errno2status(ret));

	}

	bzero(&oia, sizeof (oia));
	oia.oia_linkid = attr->oa_linkid;
	status = DLADM_STATUS_OK;
	ret = ioctl(dladm_dld_fd(handle), OVERLAY_IOC_ACTIVATE, &oia);
	if (ret != 0) {
		ret = errno;
		(void) dladm_errlist_append(errs, "failed to activate "
		    "device: %s", strerror(ret));
		(void) libvarpd_c_instance_destroy(vch, id);
		(void) dladm_overlay_walk_prop(handle, attr->oa_linkid,
		    dladm_overlay_activate_cb, errs, errs);
		status = dladm_errno2status(ret);
	}

	libvarpd_c_destroy(vch);

	return (status);
}

dladm_status_t
dladm_overlay_create(dladm_handle_t handle, const char *name,
    const char *encap, const char *search, uint64_t vid,
    dladm_arg_list_t *props, dladm_errlist_t *errs, uint32_t flags)
{
	dladm_status_t status;
	datalink_id_t linkid;
	dladm_overlay_attr_t attr;
	char errmsg[DLADM_STRSIZE];

	if (strlcpy(attr.oa_name, name, sizeof (attr.oa_name)) >=
	    sizeof (attr.oa_name)) {
		return (DLADM_STATUS_BADARG);
	}
	if (strlcpy(attr.oa_encap, encap, sizeof (attr.oa_encap)) >=
	    sizeof (attr.oa_encap)) {
		return (DLADM_STATUS_BADARG);
	}
	if (strlcpy(attr.oa_search, search, sizeof (attr.oa_search)) >=
	    sizeof (attr.oa_search)) {
		return (DLADM_STATUS_BADARG);
	}

	status = varpd_enable_service();
	if (status != DLADM_STATUS_OK)
		return (status);

	status = dladm_create_datalink_id(handle, name, DATALINK_CLASS_OVERLAY,
	    DL_ETHER, flags, &linkid);
	if (status != DLADM_STATUS_OK)
		return (status);

	attr.oa_linkid = linkid;
	attr.oa_vid = vid;
	attr.oa_flags = flags;

	status = i_dladm_overlay_create_sys(handle, &attr);

	if (status != DLADM_STATUS_OK) {
		(void) dladm_destroy_datalink_id(handle, linkid, flags);
		return (status);
	}

	if ((flags & DLADM_OPT_PERSIST) != 0) {
		status = dladm_overlay_persist_config(handle, &attr);
		if (status != DLADM_STATUS_OK) {
			(void) dladm_errlist_append(errs, "failed to create "
			    "persistent configuration for %s: %s",
			    attr.oa_name, dladm_status2str(status, errmsg));
		}
	}

	if (status == DLADM_STATUS_OK)
		status = i_dladm_overlay_commit_sys(handle, &attr, props, errs);

	if (status != DLADM_STATUS_OK) {
		(void) dladm_overlay_delete(handle, linkid, flags);
		(void) dladm_destroy_datalink_id(handle, linkid, flags);
	}

	return (status);
}

typedef struct overlay_walk_cb {
	dladm_handle_t		owc_handle;
	datalink_id_t		owc_linkid;
	void			*owc_arg;
	dladm_overlay_cache_f	owc_func;
	uint_t			owc_mode;
	uint_t			owc_dest;
} overlay_walk_cb_t;

static int
dladm_overlay_walk_cache_cb(varpd_client_handle_t *chdl __unused,
    uint64_t varpdid __unused, const struct ether_addr *key,
    const varpd_client_cache_entry_t *entry, void *arg)
{
	overlay_walk_cb_t *owc = arg;
	dladm_overlay_point_t point;

	bzero(&point, sizeof (dladm_overlay_point_t));
	point.dop_dest = owc->owc_dest;
	point.dop_mac = entry->vcp_mac;
	point.dop_flags = entry->vcp_flags;
	point.dop_ip = entry->vcp_ip;
	point.dop_port = entry->vcp_port;

	if (owc->owc_mode == OVERLAY_TARGET_POINT)
		point.dop_flags |= DLADM_OVERLAY_F_DEFAULT;

	if (owc->owc_func(owc->owc_handle, owc->owc_linkid, key, &point,
	    owc->owc_arg) == DLADM_WALK_TERMINATE)
		return (1);
	return (0);
}

dladm_status_t
dladm_overlay_walk_cache(dladm_handle_t handle, datalink_id_t linkid,
    dladm_overlay_cache_f func, void *arg)
{
	int ret;
	uint_t mode, dest;
	uint64_t varpdid;
	varpd_client_handle_t *chdl;
	overlay_walk_cb_t cbarg;

	if ((ret = libvarpd_c_create(&chdl, dladm_overlay_doorpath)) != 0)
		return (dladm_errno2status(ret));

	if ((ret = libvarpd_c_instance_lookup(chdl, linkid, &varpdid)) != 0) {
		libvarpd_c_destroy(chdl);
		return (dladm_errno2status(ret));
	}

	if ((ret = libvarpd_c_instance_target_mode(chdl, varpdid,
	    &dest, &mode)) != 0) {
		libvarpd_c_destroy(chdl);
		return (dladm_errno2status(ret));
	}

	cbarg.owc_handle = handle;
	cbarg.owc_linkid = linkid;
	cbarg.owc_arg = arg;
	cbarg.owc_func = func;
	cbarg.owc_dest = dest;
	cbarg.owc_mode = mode;
	ret = libvarpd_c_instance_cache_walk(chdl, varpdid,
	    dladm_overlay_walk_cache_cb, &cbarg);
	libvarpd_c_destroy(chdl);

	return (dladm_errno2status(ret));
}

dladm_status_t
dladm_overlay_cache_flush(dladm_handle_t handle __unused, datalink_id_t linkid)
{
	int ret;
	uint64_t varpdid;
	varpd_client_handle_t *chdl;

	if ((ret = libvarpd_c_create(&chdl, dladm_overlay_doorpath)) != 0)
		return (dladm_errno2status(ret));

	if ((ret = libvarpd_c_instance_lookup(chdl, linkid, &varpdid)) != 0) {
		libvarpd_c_destroy(chdl);
		return (dladm_errno2status(ret));
	}

	ret = libvarpd_c_instance_cache_flush(chdl, varpdid);
	libvarpd_c_destroy(chdl);

	return (dladm_errno2status(ret));
}

dladm_status_t
dladm_overlay_cache_delete(dladm_handle_t handle __unused, datalink_id_t linkid,
    const struct ether_addr *key)
{
	int ret;
	uint64_t varpdid;
	varpd_client_handle_t *chdl;

	if ((ret = libvarpd_c_create(&chdl, dladm_overlay_doorpath)) != 0)
		return (dladm_errno2status(ret));

	if ((ret = libvarpd_c_instance_lookup(chdl, linkid, &varpdid)) != 0) {
		libvarpd_c_destroy(chdl);
		return (dladm_errno2status(ret));
	}

	ret = libvarpd_c_instance_cache_delete(chdl, varpdid, key);
	libvarpd_c_destroy(chdl);

	return (dladm_errno2status(ret));
}

dladm_status_t
dladm_overlay_cache_set(dladm_handle_t handle __unused, datalink_id_t linkid,
    const struct ether_addr *key, char *val)
{
	int ret;
	uint_t dest;
	uint64_t varpdid;
	char *ip, *port = NULL;
	varpd_client_handle_t *chdl;
	varpd_client_cache_entry_t vcp;


	if ((ret = libvarpd_c_create(&chdl, dladm_overlay_doorpath)) != 0)
		return (dladm_errno2status(ret));

	if ((ret = libvarpd_c_instance_lookup(chdl, linkid, &varpdid)) != 0) {
		libvarpd_c_destroy(chdl);
		return (dladm_errno2status(ret));
	}

	if ((ret = libvarpd_c_instance_target_mode(chdl, varpdid,
	    &dest, NULL)) != 0) {
		libvarpd_c_destroy(chdl);
		return (dladm_errno2status(ret));
	}

	/*
	 * Mode tells us what we should expect in val. It we have more than one
	 * thing listed, the canonical format of it right now is mac,ip:port.
	 */
	bzero(&vcp, sizeof (varpd_client_cache_entry_t));

	if (strcasecmp(val, "drop") == 0) {
		vcp.vcp_flags = OVERLAY_TARGET_CACHE_DROP;
		goto send;
	}

	if (dest & OVERLAY_PLUGIN_D_ETHERNET) {
		if (ether_aton_r(val, &vcp.vcp_mac) == NULL) {
			libvarpd_c_destroy(chdl);
			return (dladm_errno2status(EINVAL));
		}
	}

	if (dest & OVERLAY_PLUGIN_D_IP) {
		if (dest & OVERLAY_PLUGIN_D_ETHERNET) {
			if ((ip = strchr(val, ',')) == NULL) {
				libvarpd_c_destroy(chdl);
				return (dladm_errno2status(ret));
			}
			ip++;
		} else {
			ip = val;
		}

		if (dest & OVERLAY_PLUGIN_D_PORT) {
			if ((port = strchr(val, ':')) == NULL) {
				libvarpd_c_destroy(chdl);
				return (dladm_errno2status(ret));
			}
			*port = '\0';
			port++;
		}

		/* Try v6, then fall back to v4 */
		ret = inet_pton(AF_INET6, ip, &vcp.vcp_ip);
		if (ret == -1)
			abort();
		if (ret == 0) {
			struct in_addr v4;

			ret = inet_pton(AF_INET, ip, &v4);
			if (ret == -1)
				abort();
			if (ret == 0) {
				libvarpd_c_destroy(chdl);
				return (dladm_errno2status(ret));
			}
			IN6_INADDR_TO_V4MAPPED(&v4, &vcp.vcp_ip);
		}
	}

	if (dest & OVERLAY_PLUGIN_D_PORT) {
		char *eptr;
		unsigned long l;
		if (port == NULL && (dest & OVERLAY_PLUGIN_D_ETHERNET)) {
			if ((port = strchr(val, ',')) == NULL) {
				libvarpd_c_destroy(chdl);
				return (dladm_errno2status(EINVAL));
			}
		} else if (port == NULL)
			port = val;

		errno = 0;
		l = strtoul(port, &eptr, 10);
		if (errno != 0 || *eptr != '\0') {
			libvarpd_c_destroy(chdl);
			return (dladm_errno2status(EINVAL));
		}
		if (l == 0 || l > UINT16_MAX) {
			libvarpd_c_destroy(chdl);
			return (dladm_errno2status(EINVAL));
		}
		vcp.vcp_port = l;
	}

send:
	ret = libvarpd_c_instance_cache_set(chdl, varpdid, key, &vcp);

	libvarpd_c_destroy(chdl);
	return (dladm_errno2status(ret));
}

dladm_status_t
dladm_overlay_cache_get(dladm_handle_t handle __unused, datalink_id_t linkid,
    const struct ether_addr *key, dladm_overlay_point_t *point)
{
	int ret;
	uint_t dest, mode;
	uint64_t varpdid;
	varpd_client_handle_t *chdl;
	varpd_client_cache_entry_t entry;

	if ((ret = libvarpd_c_create(&chdl, dladm_overlay_doorpath)) != 0)
		return (dladm_errno2status(ret));

	if ((ret = libvarpd_c_instance_lookup(chdl, linkid, &varpdid)) != 0) {
		libvarpd_c_destroy(chdl);
		return (dladm_errno2status(ret));
	}

	if ((ret = libvarpd_c_instance_target_mode(chdl, varpdid,
	    &dest, &mode)) != 0) {
		libvarpd_c_destroy(chdl);
		return (dladm_errno2status(ret));
	}

	ret = libvarpd_c_instance_cache_get(chdl, varpdid, key, &entry);
	if (ret == 0) {
		point->dop_dest = dest;
		point->dop_mac = entry.vcp_mac;
		point->dop_flags = entry.vcp_flags;
		point->dop_ip = entry.vcp_ip;
		point->dop_port = entry.vcp_port;
		if (mode == OVERLAY_TARGET_POINT)
			point->dop_flags |= DLADM_OVERLAY_F_DEFAULT;
	}

	libvarpd_c_destroy(chdl);
	return (dladm_errno2status(ret));
}

dladm_status_t
dladm_overlay_status(dladm_handle_t handle, datalink_id_t linkid,
    dladm_overlay_status_f func, void *arg)
{
	int ret;
	dladm_status_t status;
	overlay_ioc_status_t ois;
	dladm_overlay_status_t dos;

	ois.ois_linkid = linkid;
	status = DLADM_STATUS_OK;
	ret = ioctl(dladm_dld_fd(handle), OVERLAY_IOC_STATUS, &ois);
	if (ret != 0)
		status = dladm_errno2status(errno);
	if (status != DLADM_STATUS_OK)
		return (status);

	dos.dos_degraded = ois.ois_status == OVERLAY_I_DEGRADED ? B_TRUE :
	    B_FALSE;
	(void) strlcpy(dos.dos_fmamsg, ois.ois_message,
	    sizeof (dos.dos_fmamsg));
	func(handle, linkid, &dos, arg);
	return (DLADM_STATUS_OK);
}

/*
 * dladm_parse_args() usually creates a dladm_arg_list_t by tokenising a
 * delimited string and storing pointers to pieces of that string in the
 * dladm_arg_info_t structure. Those pointers do not need to be individually
 * freed.
 *
 * This function deals with property lists which have instead been built from
 * the persistent datalink configuration database, in order to bring up an
 * overlay at boot time. In this case, the properties have been retrieved
 * one-by-one, duplicated with strdup(), and added to the list. When the list
 * is finished with, this function takes care of freeing the memory.
 */
static void
i_dladm_overlay_props_free(dladm_handle_t handle __unused,
    dladm_arg_list_t *props)
{
	uint_t i, j;

	for (i = 0; props != NULL && i < props->al_count; i++) {
		dladm_arg_info_t *aip = &props->al_info[i];

		/* For ai_name, we need to cast away the 'const' qualifier. */
		free((char *)aip->ai_name);
		for (j = 0; j < aip->ai_count; j++)
			free(aip->ai_val[j]);
	}
	free(props);
}

static dladm_status_t
i_dladm_overlay_fetch_persistent_config(dladm_handle_t handle,
    datalink_id_t linkid, dladm_overlay_attr_t *attrp,
    dladm_arg_list_t **props)
{
	dladm_conf_t conf;
	dladm_status_t status;
	char attr[MAXLINKATTRLEN], last_attr[MAXLINKATTRLEN];
	char attrval[OVERLAY_PROP_SIZEMAX];
	size_t attrsz;
	dladm_arg_list_t *list = NULL;

	*props = NULL;

	if ((status = dladm_getsnap_conf(handle, linkid, &conf)) !=
	    DLADM_STATUS_OK) {
		return (status);
	}

	attrp->oa_linkid = linkid;

	status = dladm_get_conf_field(handle, conf, FVNETID, &attrp->oa_vid,
	    sizeof (attrp->oa_vid));
	if (status != DLADM_STATUS_OK)
		goto done;

	status = dladm_get_conf_field(handle, conf, FENCAP,
	    attrp->oa_encap, sizeof (attrp->oa_encap));
	if (status != DLADM_STATUS_OK)
		goto done;

	status = dladm_get_conf_field(handle, conf, FSEARCH,
	    attrp->oa_search, sizeof (attrp->oa_search));
	if (status != DLADM_STATUS_OK)
		goto done;

	list = calloc(1, sizeof (dladm_arg_list_t));

	*last_attr = '\0';
	while (dladm_getnext_conf_linkprop(handle, conf, last_attr,
	    attr, attrval, sizeof (attrval), &attrsz) == DLADM_STATUS_OK) {
		dladm_arg_info_t *aip;

		(void) strlcpy(last_attr, attr, sizeof (last_attr));
		if (strchr(attr, '/') == NULL)
			continue;

		aip = &list->al_info[list->al_count];
		bzero(aip, sizeof (dladm_arg_info_t));
		if ((aip->ai_name = strdup(attr)) == NULL) {
			status = dladm_errno2status(errno);
			break;
		}
		if ((aip->ai_val[0] = strdup(attrval)) == NULL) {
			status = dladm_errno2status(errno);
			break;
		}
		aip->ai_count = 1;
		list->al_count++;
		if (list->al_count >= DLADM_MAX_ARG_CNT) {
			status = DLADM_STATUS_TOOMANYELEMENTS;
			break;
		}
	}

done:

	dladm_destroy_conf(handle, conf);

	if (status != DLADM_STATUS_OK) {
		if (list != NULL)
			i_dladm_overlay_props_free(handle, list);
		return (status);
	}

	*props = list;
	return (DLADM_STATUS_OK);
}

typedef struct dladm_overlay_up_arg_s {
	dladm_errlist_t	*errlist;
} dladm_overlay_up_arg_t;

static int
i_dladm_overlay_up(dladm_handle_t handle, datalink_id_t linkid, void *arg)
{
	dladm_overlay_up_arg_t *argp = arg;
	dladm_errlist_t *errs = argp->errlist;
	datalink_class_t class;
	dladm_status_t status;
	dladm_overlay_attr_t attr;
	dladm_arg_list_t *props;
	char errmsg[DLADM_STRSIZE];

	bzero(&attr, sizeof (attr));

	status = dladm_datalink_id2info(handle, linkid, NULL, &class,
	    NULL, attr.oa_name, sizeof (attr.oa_name));
	if (status != DLADM_STATUS_OK) {
		(void) dladm_errlist_append(errs, "failed to get info for "
		    "datalink id %u: %s",
		    linkid, dladm_status2str(status, errmsg));
		return (DLADM_STATUS_BADARG);
	}

	if (class != DATALINK_CLASS_OVERLAY) {
		(void) dladm_errlist_append(errs, "%s is not an overlay",
		    attr.oa_name);
		return (DLADM_STATUS_BADARG);
	}

	status = varpd_enable_service();
	if (status != DLADM_STATUS_OK) {
		(void) dladm_errlist_append(errs, "failed to enable svc:/%s",
		    VARPD_SERVICE);
		return (DLADM_WALK_TERMINATE);
	}

	status = i_dladm_overlay_fetch_persistent_config(handle, linkid,
	    &attr, &props);
	if (status != DLADM_STATUS_OK) {
		(void) dladm_errlist_append(errs, "failed to retrieve "
		    "persistent configuration for %s: %s",
		    attr.oa_name, dladm_status2str(status, errmsg));
		return (DLADM_WALK_CONTINUE);
	}

	status = i_dladm_overlay_create_sys(handle, &attr);
	if (status != DLADM_STATUS_OK) {
		(void) dladm_errlist_append(errs,
		    "failed to create overlay device %s: %s",
		    attr.oa_name, dladm_status2str(status, errmsg));
		goto out;
	}

	status = i_dladm_overlay_commit_sys(handle, &attr, props, errs);
	if (status != DLADM_STATUS_OK) {
		(void) dladm_errlist_append(errs,
		    "failed to set properties for overlay device %s: %s",
		    attr.oa_name, dladm_status2str(status, errmsg));
		dladm_overlay_delete(handle, linkid, 0);
		goto out;
	}

	status = dladm_up_datalink_id(handle, linkid);
	if (status != DLADM_STATUS_OK) {
		(void) dladm_errlist_append(errs,
		    "failed to bring datalink up for overlay device %s: %s",
		    attr.oa_name, dladm_status2str(status, errmsg));
		dladm_overlay_delete(handle, linkid, 0);
		goto out;
	}

out:
	i_dladm_overlay_props_free(handle, props);

	return (DLADM_WALK_CONTINUE);
}

dladm_status_t
dladm_overlay_up(dladm_handle_t handle, datalink_id_t linkid,
    dladm_errlist_t *errs)
{
	dladm_overlay_up_arg_t overlay_arg = {
		.errlist	= errs
	};

	if (linkid == DATALINK_ALL_LINKID) {
		(void) dladm_walk_datalink_id(i_dladm_overlay_up, handle,
		    &overlay_arg, DATALINK_CLASS_OVERLAY,
		    DATALINK_ANY_MEDIATYPE, DLADM_OPT_PERSIST);
	} else {
		(void) i_dladm_overlay_up(handle, linkid, &overlay_arg);
	}

	if (dladm_errlist_count(errs) == 0)
		return (DLADM_STATUS_OK);

	return (DLADM_STATUS_FAILED);
}