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

/*
 * varpd client interfaces
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <umem.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>
#include <door.h>

#include <libvarpd_impl.h>

typedef struct varpd_client {
	int vcl_doorfd;
} varpd_client_t;

typedef struct varpd_client_prop_info {
	varpd_client_t		*vcprop_client;
	uint64_t		vcprop_instance;
	uint_t			vcprop_propid;
	uint_t			vcprop_type;
	uint_t			vcprop_prot;
	uint32_t		vcprop_defsize;
	uint32_t		vcprop_psize;
	char			vcprop_name[LIBVARPD_PROP_NAMELEN];
	uint8_t			vcprop_default[LIBVARPD_PROP_SIZEMAX];
	uint8_t			vcprop_poss[LIBVARPD_PROP_SIZEMAX];
} varpd_client_prop_info_t;

static int
libvarpd_c_door_call(varpd_client_t *client, varpd_client_arg_t *argp,
    size_t altsize)
{
	int ret;
	door_arg_t darg;

	darg.data_ptr = (char *)argp;
	darg.desc_ptr = NULL;
	darg.desc_num = 0;
	darg.rbuf = (char *)argp;
	if (altsize != 0) {
		darg.data_size = altsize;
		darg.rsize = altsize;
	} else {
		darg.data_size = sizeof (varpd_client_arg_t);
		darg.rsize = sizeof (varpd_client_arg_t);
	}

	do {
		ret = door_call(client->vcl_doorfd, &darg);
	} while (ret != 0 && errno == EINTR);
	if (ret != 0) {
		switch (errno) {
		case E2BIG:
		case EFAULT:
		case EINVAL:
		case ENOTSUP:
		case EOVERFLOW:
		case ENFILE:
			libvarpd_panic("unhandleable errno from door_call: %d",
			    errno);
		}
		ret = errno;
	}

	return (ret);
}

int
libvarpd_c_create(varpd_client_handle_t **chpp, const char *doorname)
{
	varpd_client_t *client;

	client = umem_alloc(sizeof (varpd_client_t), UMEM_DEFAULT);
	if (client == NULL)
		return (ENOMEM);

	client->vcl_doorfd = open(doorname, O_RDWR);
	if (client->vcl_doorfd < 0) {
		int ret = errno;
		umem_free(client, sizeof (varpd_client_t));
		return (ret);
	}

	*chpp = (varpd_client_handle_t *)client;
	return (0);
}

void
libvarpd_c_destroy(varpd_client_handle_t *chp)
{
	varpd_client_t *client = (varpd_client_t *)chp;
	if (close(client->vcl_doorfd) != 0)
		libvarpd_panic("failed to close door fd %d: %d",
		    client->vcl_doorfd, errno);

	umem_free(chp, sizeof (varpd_client_t));
}

int
libvarpd_c_instance_create(varpd_client_handle_t *chp, datalink_id_t linkid,
    const char *search, uint64_t *cidp)
{
	int ret;
	varpd_client_t *client = (varpd_client_t *)chp;
	varpd_client_arg_t carg;
	varpd_client_create_arg_t *cap = &carg.vca_un.vca_create;

	if (strlen(search) >= LIBVARPD_PROP_NAMELEN)
		return (EINVAL);
	carg.vca_command = VARPD_CLIENT_CREATE;
	carg.vca_errno = 0;
	cap->vcca_linkid = linkid;
	(void) strlcpy(cap->vcca_plugin, search, LIBVARPD_PROP_NAMELEN);

	ret = libvarpd_c_door_call(client, &carg, 0);
	if (ret != 0)
		return (ret);

	if (carg.vca_errno != 0)
		return (carg.vca_errno);

	*cidp = cap->vcca_id;

	return (0);
}

int
libvarpd_c_instance_activate(varpd_client_handle_t *chp, uint64_t cid)
{
	int ret;
	varpd_client_t *client = (varpd_client_t *)chp;
	varpd_client_arg_t carg;
	varpd_client_instance_arg_t *vciap = &carg.vca_un.vca_instance;

	carg.vca_command = VARPD_CLIENT_ACTIVATE;
	carg.vca_errno = 0;
	vciap->vcia_id = cid;

	ret = libvarpd_c_door_call(client, &carg, 0);
	if (ret != 0)
		return (ret);

	if (carg.vca_errno != 0)
		return (carg.vca_errno);

	return (0);
}

int
libvarpd_c_instance_destroy(varpd_client_handle_t *chp, uint64_t cid)
{
	int ret;
	varpd_client_t *client = (varpd_client_t *)chp;
	varpd_client_arg_t carg;
	varpd_client_instance_arg_t *vciap = &carg.vca_un.vca_instance;

	carg.vca_command = VARPD_CLIENT_DESTROY;
	carg.vca_errno = 0;
	vciap->vcia_id = cid;

	ret = libvarpd_c_door_call(client, &carg, 0);
	if (ret != 0)
		return (ret);

	if (carg.vca_errno != 0)
		return (carg.vca_errno);

	return (0);
}

int
libvarpd_c_prop_nprops(varpd_client_handle_t *chp, uint64_t cid, uint_t *nprops)
{
	int ret;
	varpd_client_t *client = (varpd_client_t *)chp;
	varpd_client_arg_t carg;
	varpd_client_nprops_arg_t *vcnap = &carg.vca_un.vca_nprops;

	carg.vca_command = VARPD_CLIENT_NPROPS;
	carg.vca_errno = 0;
	vcnap->vcna_id = cid;
	vcnap->vcna_nprops = 0;

	ret = libvarpd_c_door_call(client, &carg, 0);
	if (ret != 0)
		return (ret);

	if (carg.vca_errno != 0)
		return (carg.vca_errno);
	*nprops = vcnap->vcna_nprops;
	return (0);
}

int
libvarpd_c_prop_handle_alloc(varpd_client_handle_t *chp, uint64_t cid,
    varpd_client_prop_handle_t **phdlp)
{
	varpd_client_prop_info_t *infop;

	infop = umem_alloc(sizeof (varpd_client_prop_info_t), UMEM_DEFAULT);
	if (infop == NULL)
		return (ENOMEM);

	bzero(infop, sizeof (varpd_client_prop_info_t));
	infop->vcprop_client = (varpd_client_t *)chp;
	infop->vcprop_instance = cid;
	infop->vcprop_propid = UINT_MAX;
	*phdlp = (varpd_client_prop_handle_t *)infop;
	return (0);
}

void
libvarpd_c_prop_handle_free(varpd_client_prop_handle_t *phdl)
{
	umem_free(phdl, sizeof (varpd_client_prop_info_t));
	phdl = NULL;
}

static void
libvarpd_c_prop_info_from_door(varpd_client_prop_info_t *infop,
    const varpd_client_propinfo_arg_t *vcfap)
{
	infop->vcprop_propid = vcfap->vcfa_propid;
	infop->vcprop_type = vcfap->vcfa_type;
	infop->vcprop_prot = vcfap->vcfa_prot;
	infop->vcprop_defsize = vcfap->vcfa_defsize;
	infop->vcprop_psize = vcfap->vcfa_psize;
	bcopy(vcfap->vcfa_name, infop->vcprop_name, LIBVARPD_PROP_NAMELEN);
	bcopy(vcfap->vcfa_default, infop->vcprop_default,
	    LIBVARPD_PROP_SIZEMAX);
	bcopy(vcfap->vcfa_poss, infop->vcprop_poss, LIBVARPD_PROP_SIZEMAX);
}

int
libvarpd_c_prop_info_fill_by_name(varpd_client_prop_handle_t *phdl,
    const char *name)
{
	int ret;
	varpd_client_arg_t carg;
	varpd_client_propinfo_arg_t *vcfap = &carg.vca_un.vca_info;
	varpd_client_prop_info_t *infop = (varpd_client_prop_info_t *)phdl;

	if (strlen(name) >= LIBVARPD_PROP_NAMELEN)
		return (EINVAL);
	bzero(&carg, sizeof (varpd_client_arg_t));
	carg.vca_command = VARPD_CLIENT_PROPINFO;
	carg.vca_errno = 0;
	vcfap->vcfa_id = infop->vcprop_instance;
	vcfap->vcfa_propid = UINT_MAX;
	(void) strlcpy(vcfap->vcfa_name, name, LIBVARPD_PROP_NAMELEN);

	ret = libvarpd_c_door_call(infop->vcprop_client, &carg, 0);
	if (ret != 0)
		return (ret);

	if (carg.vca_errno != 0)
		return (carg.vca_errno);

	libvarpd_c_prop_info_from_door(infop, vcfap);
	return (0);
}

int
libvarpd_c_prop_info_fill(varpd_client_prop_handle_t *phdl, uint_t propid)
{
	int ret;
	varpd_client_arg_t carg;
	varpd_client_propinfo_arg_t *vcfap = &carg.vca_un.vca_info;
	varpd_client_prop_info_t *infop = (varpd_client_prop_info_t *)phdl;

	bzero(&carg, sizeof (varpd_client_arg_t));
	carg.vca_command = VARPD_CLIENT_PROPINFO;
	carg.vca_errno = 0;
	vcfap->vcfa_id = infop->vcprop_instance;
	vcfap->vcfa_propid = propid;

	ret = libvarpd_c_door_call(infop->vcprop_client, &carg, 0);
	if (ret != 0)
		return (ret);

	if (carg.vca_errno != 0)
		return (carg.vca_errno);

	libvarpd_c_prop_info_from_door(infop, vcfap);
	return (0);
}

int
libvarpd_c_prop_info(varpd_client_prop_handle_t *phdl, const char **namep,
    uint_t *typep, uint_t *protp, const void **defp, uint32_t *defsizep,
    const mac_propval_range_t **possp)
{
	varpd_client_prop_info_t *infop = (varpd_client_prop_info_t *)phdl;
	if (infop->vcprop_propid == UINT_MAX)
		return (EINVAL);

	if (namep != NULL)
		*namep = infop->vcprop_name;
	if (typep != NULL)
		*typep = infop->vcprop_type;
	if (protp != NULL)
		*protp = infop->vcprop_prot;
	if (defp != NULL)
		*defp = infop->vcprop_default;
	if (defsizep != NULL)
		*defsizep = infop->vcprop_defsize;
	if (possp != NULL)
		*possp = (const mac_propval_range_t *)infop->vcprop_poss;
	return (0);
}

int
libvarpd_c_prop_get(varpd_client_prop_handle_t *phdl, void *buf, uint32_t *len)
{
	int ret;
	varpd_client_arg_t carg;
	varpd_client_prop_arg_t *vcpap = &carg.vca_un.vca_prop;
	varpd_client_prop_info_t *infop = (varpd_client_prop_info_t *)phdl;

	if (len == NULL || buf == NULL || infop->vcprop_propid == UINT_MAX)
		return (EINVAL);
	if (*len < LIBVARPD_PROP_SIZEMAX)
		return (EOVERFLOW);

	bzero(&carg, sizeof (varpd_client_arg_t));
	carg.vca_command = VARPD_CLIENT_GETPROP;
	carg.vca_errno = 0;
	vcpap->vcpa_id = infop->vcprop_instance;
	vcpap->vcpa_propid = infop->vcprop_propid;

	ret = libvarpd_c_door_call(infop->vcprop_client, &carg, 0);
	if (ret != 0)
		return (ret);

	if (carg.vca_errno != 0)
		return (carg.vca_errno);

	/*
	 * If the buffer size is too large then something odd has certainly
	 * happened here, it means that varpd has gone rogue. In such a case we
	 * return a rather odd errror, though we don't believe that this should
	 * generally happen.
	 */
	if (vcpap->vcpa_bufsize > LIBVARPD_PROP_SIZEMAX)
		return (E2BIG);

	bcopy(vcpap->vcpa_buf, buf, vcpap->vcpa_bufsize);
	*len = vcpap->vcpa_bufsize;
	return (0);
}

int
libvarpd_c_prop_set(varpd_client_prop_handle_t *phdl, const void *buf,
    uint32_t len)
{
	int ret;
	varpd_client_arg_t carg;
	varpd_client_prop_arg_t *vcpap = &carg.vca_un.vca_prop;
	varpd_client_prop_info_t *infop = (varpd_client_prop_info_t *)phdl;

	if (len == 0 || buf == NULL || infop->vcprop_propid == UINT_MAX)
		return (EINVAL);
	if (len > LIBVARPD_PROP_SIZEMAX)
		return (EOVERFLOW);

	carg.vca_command = VARPD_CLIENT_SETPROP;
	carg.vca_errno = 0;
	vcpap->vcpa_id = infop->vcprop_instance;
	vcpap->vcpa_propid = infop->vcprop_propid;
	vcpap->vcpa_bufsize = len;
	bcopy(buf, vcpap->vcpa_buf, len);

	ret = libvarpd_c_door_call(infop->vcprop_client, &carg, 0);
	if (ret != 0)
		return (ret);

	if (carg.vca_errno != 0)
		return (carg.vca_errno);

	return (0);
}

int
libvarpd_c_instance_lookup(varpd_client_handle_t *chp, datalink_id_t linkid,
    uint64_t *instp)
{
	int ret;
	varpd_client_arg_t carg;
	varpd_client_lookup_arg_t *vclap = &carg.vca_un.vca_lookup;
	varpd_client_t *client = (varpd_client_t *)chp;

	carg.vca_command = VARPD_CLIENT_LOOKUP;
	carg.vca_errno = 0;
	vclap->vcla_linkid = linkid;
	ret = libvarpd_c_door_call(client, &carg, 0);
	if (ret != 0)
		return (ret);

	if (carg.vca_errno != 0)
		return (carg.vca_errno);
	if (instp != NULL)
		*instp = vclap->vcla_id;

	return (0);
}

int
libvarpd_c_instance_target_mode(varpd_client_handle_t *chp, uint64_t cid,
    uint_t *dtype, uint_t *mtype)
{
	int ret;
	varpd_client_arg_t carg;
	varpd_client_target_mode_arg_t *vctmap = &carg.vca_un.vca_mode;
	varpd_client_t *client = (varpd_client_t *)chp;

	carg.vca_command = VARPD_CLIENT_TARGET_MODE;
	carg.vca_errno = 0;
	vctmap->vtma_id = cid;
	ret = libvarpd_c_door_call(client, &carg, 0);
	if (ret != 0)
		return (ret);

	if (carg.vca_errno != 0)
		return (carg.vca_errno);
	if (ret == 0) {
		if (mtype != NULL)
			*mtype = vctmap->vtma_mode;
		if (dtype != NULL)
			*dtype = vctmap->vtma_dest;
	}

	return (ret);
}

int
libvarpd_c_instance_cache_flush(varpd_client_handle_t *chp, uint64_t cid)
{
	int ret;
	varpd_client_arg_t carg;
	varpd_client_target_cache_arg_t *vctcap = &carg.vca_un.vca_cache;
	varpd_client_t *client = (varpd_client_t *)chp;

	carg.vca_command = VARPD_CLIENT_CACHE_FLUSH;
	carg.vca_errno = 0;

	vctcap->vtca_id = cid;
	ret = libvarpd_c_door_call(client, &carg, 0);
	if (ret != 0)
		return (ret);

	if (carg.vca_errno != 0)
		return (carg.vca_errno);

	return (0);
}

int
libvarpd_c_instance_cache_delete(varpd_client_handle_t *chp, uint64_t cid,
    const struct ether_addr *key)
{
	int ret;
	varpd_client_arg_t carg;
	varpd_client_target_cache_arg_t *vctcap = &carg.vca_un.vca_cache;
	varpd_client_t *client = (varpd_client_t *)chp;

	if (key == NULL)
		return (EINVAL);

	carg.vca_command = VARPD_CLIENT_CACHE_DELETE;
	carg.vca_errno = 0;
	vctcap->vtca_id = cid;
	bcopy(key, vctcap->vtca_key, ETHERADDRL);

	ret = libvarpd_c_door_call(client, &carg, 0);
	if (ret != 0)
		return (ret);

	if (carg.vca_errno != 0)
		return (carg.vca_errno);

	return (0);
}

int
libvarpd_c_instance_cache_get(varpd_client_handle_t *chp, uint64_t cid,
    const struct ether_addr *key, varpd_client_cache_entry_t *entry)
{
	int ret;
	varpd_client_arg_t carg;
	varpd_client_target_cache_arg_t *vctcap = &carg.vca_un.vca_cache;
	varpd_client_t *client = (varpd_client_t *)chp;

	if (key == NULL || entry == NULL)
		return (EINVAL);

	carg.vca_command = VARPD_CLIENT_CACHE_GET;
	carg.vca_errno = 0;
	vctcap->vtca_id = cid;
	bcopy(key, vctcap->vtca_key, ETHERADDRL);
	bzero(&vctcap->vtca_entry, sizeof (varpd_client_cache_entry_t));

	ret = libvarpd_c_door_call(client, &carg, 0);
	if (ret != 0)
		return (ret);

	if (carg.vca_errno != 0)
		return (carg.vca_errno);

	bcopy(&vctcap->vtca_entry, entry, sizeof (varpd_client_cache_entry_t));
	return (0);
}

int
libvarpd_c_instance_cache_set(varpd_client_handle_t *chp, uint64_t cid,
    const struct ether_addr *key, const varpd_client_cache_entry_t *entry)
{
	int ret;
	varpd_client_arg_t carg;
	varpd_client_target_cache_arg_t *vctcap = &carg.vca_un.vca_cache;
	varpd_client_t *client = (varpd_client_t *)chp;

	if (key == NULL || entry == NULL)
		return (EINVAL);

	carg.vca_command = VARPD_CLIENT_CACHE_SET;
	carg.vca_errno = 0;
	vctcap->vtca_id = cid;
	bcopy(key, vctcap->vtca_key, ETHERADDRL);
	bcopy(entry, &vctcap->vtca_entry, sizeof (varpd_client_cache_entry_t));

	ret = libvarpd_c_door_call(client, &carg, 0);
	if (ret != 0)
		return (ret);

	if (carg.vca_errno != 0)
		return (carg.vca_errno);

	return (0);
}

int
libvarpd_c_instance_cache_walk(varpd_client_handle_t *chp, uint64_t cid,
    varpd_client_cache_f func, void *arg)
{
	int ret = 0;
	size_t bufsize = sizeof (varpd_client_arg_t) +
	    100 * sizeof (varpd_client_cache_entry_t);
	varpd_client_t *client = (varpd_client_t *)chp;
	varpd_client_arg_t *cargp;
	varpd_client_target_walk_arg_t *vctwap;

	/*
	 * Because the number of entries involved in a walk may be large, we
	 * dynamically allocate a number of queries to make at a single time.
	 * This also means that the average door request doesn't inflate by the
	 * number of entries we want. For now, let's always grab 100 entries in
	 * a request.
	 */
	cargp = umem_zalloc(bufsize, UMEM_DEFAULT);
	if (cargp == NULL)
		return (errno);
	vctwap = &cargp->vca_un.vca_walk;
	for (;;) {
		int i;

		cargp->vca_command = VARPD_CLIENT_CACHE_WALK;
		cargp->vca_errno = 0;
		vctwap->vtcw_id = cid;
		vctwap->vtcw_count = 100;

		ret = libvarpd_c_door_call(client, cargp, bufsize);
		if (ret != 0)
			break;

		if (cargp->vca_errno != 0) {
			ret = cargp->vca_errno;
			break;
		}

		if (vctwap->vtcw_count == 0) {
			ret = 0;
			break;
		}

		for (i = 0; i < vctwap->vtcw_count; i++) {
			varpd_client_cache_entry_t ent;

			ent.vcp_flags = vctwap->vtcw_ents[i].otce_flags;
			bcopy(vctwap->vtcw_ents[i].otce_dest.otp_mac,
			    &ent.vcp_mac, ETHERADDRL);
			ent.vcp_ip = vctwap->vtcw_ents[i].otce_dest.otp_ip;
			ent.vcp_port = vctwap->vtcw_ents[i].otce_dest.otp_port;
			ret = func(chp, cid,
			    (struct ether_addr *)vctwap->vtcw_ents[i].otce_mac,
			    &ent, arg);
			if (ret != 0) {
				ret = 0;
				goto done;
			}
		}
	}

done:
	umem_free(cargp, bufsize);
	return (ret);
}