/*
 * 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 2016 Joyent, Inc.
 */

/*
 * Point to point plug-in for varpd.
 *
 * This plugin implements a simple point to point plugin for a packet. It
 * represents the traditional tunnel, just in overlay form. As such, the only
 * properties it needs are those to determine where to send everything. At this
 * time, we don't allow a multicast address; however, there's no reason that the
 * direct plugin shouldn't in theory support multicast, though when implementing
 * it the best path will become clear.
 *
 * In general this module has been designed to make it easy to support a
 * destination of either IP or IP and port; however, we restrict it to the
 * latter as we don't currently have an implementation that would allow us to
 * test that.
 */

#include <libvarpd_provider.h>
#include <umem.h>
#include <errno.h>
#include <thread.h>
#include <synch.h>
#include <strings.h>
#include <assert.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <libnvpair.h>

typedef struct varpd_direct {
	overlay_plugin_dest_t	vad_dest;	/* RO */
	mutex_t			vad_lock;	/* Protects the rest */
	boolean_t		vad_hip;
	boolean_t		vad_hport;
	struct in6_addr		vad_ip;
	uint16_t		vad_port;
} varpd_direct_t;

static const char *varpd_direct_props[] = {
	"direct/dest_ip",
	"direct/dest_port"
};

static boolean_t
varpd_direct_valid_dest(overlay_plugin_dest_t dest)
{
	if (dest & ~(OVERLAY_PLUGIN_D_IP | OVERLAY_PLUGIN_D_PORT))
		return (B_FALSE);

	if (!(dest & (OVERLAY_PLUGIN_D_IP | OVERLAY_PLUGIN_D_PORT)))
		return (B_FALSE);

	return (B_TRUE);
}

/* ARGSUSED */
static int
varpd_direct_create(varpd_provider_handle_t *hdl, void **outp,
    overlay_plugin_dest_t dest)
{
	int ret;
	varpd_direct_t *vdp;

	if (varpd_direct_valid_dest(dest) == B_FALSE)
		return (ENOTSUP);

	vdp = umem_alloc(sizeof (varpd_direct_t), UMEM_DEFAULT);
	if (vdp == NULL)
		return (ENOMEM);

	if ((ret = mutex_init(&vdp->vad_lock, USYNC_THREAD | LOCK_ERRORCHECK,
	    NULL)) != 0) {
		umem_free(vdp, sizeof (varpd_direct_t));
		return (ret);
	}

	vdp->vad_dest = dest;
	vdp->vad_hip = B_FALSE;
	vdp->vad_hport = B_FALSE;
	*outp = vdp;
	return (0);
}

static int
varpd_direct_start(void *arg)
{
	varpd_direct_t *vdp = arg;

	mutex_enter(&vdp->vad_lock);
	if (vdp->vad_hip == B_FALSE ||((vdp->vad_dest & OVERLAY_PLUGIN_D_IP) &&
	    vdp->vad_hport == B_FALSE)) {
		mutex_exit(&vdp->vad_lock);
		return (EAGAIN);
	}
	mutex_exit(&vdp->vad_lock);

	return (0);
}

/* ARGSUSED */
static void
varpd_direct_stop(void *arg)
{
}

static void
varpd_direct_destroy(void *arg)
{
	varpd_direct_t *vdp = arg;

	if (mutex_destroy(&vdp->vad_lock) != 0)
		abort();
	umem_free(vdp, sizeof (varpd_direct_t));
}

static int
varpd_direct_default(void *arg, overlay_target_point_t *otp)
{
	varpd_direct_t *vdp = arg;

	mutex_enter(&vdp->vad_lock);
	bcopy(&vdp->vad_ip, &otp->otp_ip, sizeof (struct in6_addr));
	otp->otp_port = vdp->vad_port;
	mutex_exit(&vdp->vad_lock);

	return (VARPD_LOOKUP_OK);
}

static int
varpd_direct_nprops(void *arg, uint_t *nprops)
{
	const varpd_direct_t *vdp = arg;

	*nprops = 0;
	if (vdp->vad_dest & OVERLAY_PLUGIN_D_ETHERNET)
		*nprops += 1;

	if (vdp->vad_dest & OVERLAY_PLUGIN_D_IP)
		*nprops += 1;

	if (vdp->vad_dest & OVERLAY_PLUGIN_D_PORT)
		*nprops += 1;

	assert(*nprops == 1 || *nprops == 2);

	return (0);
}

static int
varpd_direct_propinfo(void *arg, uint_t propid, varpd_prop_handle_t *vph)
{
	varpd_direct_t *vdp = arg;

	/*
	 * Because we only support IP + port combos right now, prop 0 should
	 * always be the IP. We don't support a port without an IP.
	 */
	assert(vdp->vad_dest & OVERLAY_PLUGIN_D_IP);
	if (propid == 0) {
		libvarpd_prop_set_name(vph, varpd_direct_props[0]);
		libvarpd_prop_set_prot(vph, OVERLAY_PROP_PERM_RRW);
		libvarpd_prop_set_type(vph, OVERLAY_PROP_T_IP);
		libvarpd_prop_set_nodefault(vph);
		return (0);
	}

	if (propid == 1 && vdp->vad_dest & OVERLAY_PLUGIN_D_PORT) {
		libvarpd_prop_set_name(vph, varpd_direct_props[1]);
		libvarpd_prop_set_prot(vph, OVERLAY_PROP_PERM_RRW);
		libvarpd_prop_set_type(vph, OVERLAY_PROP_T_UINT);
		libvarpd_prop_set_nodefault(vph);
		libvarpd_prop_set_range_uint32(vph, 1, UINT16_MAX);
		return (0);
	}

	return (EINVAL);
}

static int
varpd_direct_getprop(void *arg, const char *pname, void *buf, uint32_t *sizep)
{
	varpd_direct_t *vdp = arg;

	/* direct/dest_ip */
	if (strcmp(pname, varpd_direct_props[0]) == 0) {
		if (*sizep < sizeof (struct in6_addr))
			return (EOVERFLOW);
		mutex_enter(&vdp->vad_lock);
		if (vdp->vad_hip == B_FALSE) {
			*sizep = 0;
		} else {
			bcopy(&vdp->vad_ip, buf, sizeof (struct in6_addr));
			*sizep = sizeof (struct in6_addr);
		}
		mutex_exit(&vdp->vad_lock);
		return (0);
	}

	/* direct/dest_port */
	if (strcmp(pname, varpd_direct_props[1]) == 0) {
		uint64_t val;

		if (*sizep < sizeof (uint64_t))
			return (EOVERFLOW);
		mutex_enter(&vdp->vad_lock);
		if (vdp->vad_hport == B_FALSE) {
			*sizep = 0;
		} else {
			val = vdp->vad_port;
			bcopy(&val, buf, sizeof (uint64_t));
			*sizep = sizeof (uint64_t);
		}
		mutex_exit(&vdp->vad_lock);
		return (0);
	}

	return (EINVAL);
}

static int
varpd_direct_setprop(void *arg, const char *pname, const void *buf,
    const uint32_t size)
{
	varpd_direct_t *vdp = arg;

	/* direct/dest_ip */
	if (strcmp(pname, varpd_direct_props[0]) == 0) {
		const struct in6_addr *ipv6 = buf;

		if (size < sizeof (struct in6_addr))
			return (EOVERFLOW);

		if (IN6_IS_ADDR_V4COMPAT(ipv6))
			return (EINVAL);

		if (IN6_IS_ADDR_6TO4(ipv6))
			return (EINVAL);

		mutex_enter(&vdp->vad_lock);
		bcopy(buf, &vdp->vad_ip, sizeof (struct in6_addr));
		vdp->vad_hip = B_TRUE;
		mutex_exit(&vdp->vad_lock);
		return (0);
	}

	/* direct/dest_port */
	if (strcmp(pname, varpd_direct_props[1]) == 0) {
		const uint64_t *valp = buf;
		if (size < sizeof (uint64_t))
			return (EOVERFLOW);

		if (*valp == 0 || *valp > UINT16_MAX)
			return (EINVAL);

		mutex_enter(&vdp->vad_lock);
		vdp->vad_port = (uint16_t)*valp;
		vdp->vad_hport = B_TRUE;
		mutex_exit(&vdp->vad_lock);
		return (0);
	}

	return (EINVAL);
}

static int
varpd_direct_save(void *arg, nvlist_t *nvp)
{
	int ret;
	varpd_direct_t *vdp = arg;

	mutex_enter(&vdp->vad_lock);
	if (vdp->vad_hport == B_TRUE) {
		if ((ret = nvlist_add_uint16(nvp, varpd_direct_props[1],
		    vdp->vad_port)) != 0) {
			mutex_exit(&vdp->vad_lock);
			return (ret);
		}
	}

	if (vdp->vad_hip == B_TRUE) {
		char buf[INET6_ADDRSTRLEN];

		if (inet_ntop(AF_INET6, &vdp->vad_ip, buf, sizeof (buf)) ==
		    NULL)
			abort();
		if ((ret = nvlist_add_string(nvp, varpd_direct_props[0],
		    buf)) != 0) {
			mutex_exit(&vdp->vad_lock);
			return (ret);
		}
	}
	mutex_exit(&vdp->vad_lock);

	return (0);
}

/* ARGSUSED */
static int
varpd_direct_restore(nvlist_t *nvp, varpd_provider_handle_t *hdl,
    overlay_plugin_dest_t dest, void **outp)
{
	int ret;
	char *ipstr;
	varpd_direct_t *vdp;

	if (varpd_direct_valid_dest(dest) == B_FALSE)
		return (ENOTSUP);

	vdp = umem_alloc(sizeof (varpd_direct_t), UMEM_DEFAULT);
	if (vdp == NULL)
		return (ENOMEM);

	if ((ret = mutex_init(&vdp->vad_lock, USYNC_THREAD | LOCK_ERRORCHECK,
	    NULL)) != 0) {
		umem_free(vdp, sizeof (varpd_direct_t));
		return (ret);
	}

	if ((ret = nvlist_lookup_uint16(nvp, varpd_direct_props[1],
	    &vdp->vad_port)) != 0) {
		if (ret != ENOENT) {
			if (mutex_destroy(&vdp->vad_lock) != 0)
				abort();
			umem_free(vdp, sizeof (varpd_direct_t));
			return (ret);
		}
		vdp->vad_hport = B_FALSE;
	} else {
		vdp->vad_hport = B_TRUE;
	}

	if ((ret = nvlist_lookup_string(nvp, varpd_direct_props[0],
	    &ipstr)) != 0) {
		if (ret != ENOENT) {
			if (mutex_destroy(&vdp->vad_lock) != 0)
				abort();
			umem_free(vdp, sizeof (varpd_direct_t));
			return (ret);
		}
		vdp->vad_hip = B_FALSE;
	} else {
		ret = inet_pton(AF_INET6, ipstr, &vdp->vad_ip);
		/*
		 * inet_pton is only defined to return -1 with errno set to
		 * EAFNOSUPPORT, which really, shouldn't happen.
		 */
		if (ret == -1) {
			assert(errno == EAFNOSUPPORT);
			abort();
		}
		if (ret == 0) {
			if (mutex_destroy(&vdp->vad_lock) != 0)
				abort();
			umem_free(vdp, sizeof (varpd_direct_t));
			return (EINVAL);
		}
	}

	*outp = vdp;
	return (0);
}

static const varpd_plugin_ops_t varpd_direct_ops = {
	0,
	varpd_direct_create,
	varpd_direct_start,
	varpd_direct_stop,
	varpd_direct_destroy,
	varpd_direct_default,
	NULL,
	varpd_direct_nprops,
	varpd_direct_propinfo,
	varpd_direct_getprop,
	varpd_direct_setprop,
	varpd_direct_save,
	varpd_direct_restore
};

#pragma init(varpd_direct_init)
static void
varpd_direct_init(void)
{
	int err;
	varpd_plugin_register_t *vpr;

	vpr = libvarpd_plugin_alloc(VARPD_CURRENT_VERSION, &err);
	if (vpr == NULL)
		return;

	vpr->vpr_mode = OVERLAY_TARGET_POINT;
	vpr->vpr_name = "direct";
	vpr->vpr_ops = &varpd_direct_ops;
	(void) libvarpd_plugin_register(vpr);
	libvarpd_plugin_free(vpr);
}