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


/*
 * IP Policy Framework config driver
 */

#include <sys/types.h>
#include <sys/cmn_err.h>
#include <sys/kmem.h>
#include <sys/errno.h>
#include <sys/cpuvar.h>
#include <sys/open.h>
#include <sys/stat.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
#include <sys/stream.h>
#include <ipp/ipp.h>
#include <ipp/ippctl.h>
#include <sys/nvpair.h>
#include <sys/policy.h>

/*
 * Debug switch.
 */

#if	defined(DEBUG)
#define	IPPCTL_DEBUG
#endif

/*
 * Debug macros.
 */

#ifdef	IPPCTL_DEBUG

#define	DBG_MODLINK	0x00000001ull
#define	DBG_DEVOPS	0x00000002ull
#define	DBG_CBOPS	0x00000004ull

static	uint64_t	ippctl_debug_flags =
/*
 * DBG_MODLINK |
 * DBG_DEVOPS |
 * DBG_CBOPS |
 */
0;

static kmutex_t	debug_mutex[1];

/*PRINTFLIKE3*/
static void	ippctl_debug(uint64_t, char *, char *, ...)
	__PRINTFLIKE(3);

#define	DBG0(_type, _fmt)		    			\
	ippctl_debug((_type), __FN__, (_fmt));

#define	DBG1(_type, _fmt, _a1) 					\
	ippctl_debug((_type), __FN__, (_fmt), (_a1));

#define	DBG2(_type, _fmt, _a1, _a2)				\
	ippctl_debug((_type), __FN__, (_fmt), (_a1), (_a2));

#define	DBG3(_type, _fmt, _a1, _a2, _a3)			\
	ippctl_debug((_type), __FN__, (_fmt), (_a1), (_a2),	\
	    (_a3));

#define	DBG4(_type, _fmt, _a1, _a2, _a3, _a4)			\
	ippctl_debug((_type), __FN__, (_fmt), (_a1), (_a2),	\
	    (_a3), (_a4));

#define	DBG5(_type, _fmt, _a1, _a2, _a3, _a4, _a5)		\
	ippctl_debug((_type), __FN__, (_fmt), (_a1), (_a2),	\
	    (_a3), (_a4), (_a5));

#else	/* IPPCTL_DBG */

#define	DBG0(_type, _fmt)
#define	DBG1(_type, _fmt, _a1)
#define	DBG2(_type, _fmt, _a1, _a2)
#define	DBG3(_type, _fmt, _a1, _a2, _a3)
#define	DBG4(_type, _fmt, _a1, _a2, _a3, _a4)
#define	DBG5(_type, _fmt, _a1, _a2, _a3, _a4, _a5)

#endif	/* IPPCTL_DBG */

/*
 * cb_ops
 */

static int	ippctl_open(dev_t *, int, int, cred_t *);
static int	ippctl_close(dev_t, int, int, cred_t *);
static int	ippctl_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);

static	struct cb_ops	ippctl_cb_ops = {
	ippctl_open,	/* cb_open */
	ippctl_close,	/* cb_close */
	nodev,		/* cb_strategy */
	nodev,		/* cb_print */
	nodev,		/* cb_dump */
	nodev,		/* cb_read */
	nodev,		/* cb_write */
	ippctl_ioctl,	/* cb_ioctl */
	nodev,		/* cb_devmap */
	nodev,		/* cb_mmap */
	nodev,		/* cb_segmap */
	nochpoll,	/* cb_chpoll */
	ddi_prop_op,	/* cb_prop_op */
	0,		/* cb_str */
	D_NEW | D_MP,	/* cb_flag */
	CB_REV,		/* cb_rev */
	nodev,		/* cb_aread */
	nodev		/* cb_awrite */
};

/*
 * dev_ops
 */

static	int	ippctl_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
static	int	ippctl_attach(dev_info_t *, ddi_attach_cmd_t);
static	int	ippctl_detach(dev_info_t *, ddi_detach_cmd_t);

static	struct dev_ops	ippctl_dev_ops = {
	DEVO_REV,		/* devo_rev, */
	0,			/* devo_refcnt  */
	ippctl_info,		/* devo_getinfo */
	nulldev,		/* devo_identify */
	nulldev,		/* devo_probe */
	ippctl_attach,		/* devo_attach */
	ippctl_detach,		/* devo_detach */
	nodev,			/* devo_reset */
	&ippctl_cb_ops,		/* devo_cb_ops */
	(struct bus_ops *)0,	/* devo_bus_ops */
	NULL,			/* devo_power */
	ddi_quiesce_not_needed,		/* devo_quiesce */
};

static	struct modldrv modldrv = {
	&mod_driverops,
	"IP Policy Configuration Driver",
	&ippctl_dev_ops,
};

static	struct modlinkage modlinkage = {
	MODREV_1,
	&modldrv,
	NULL
};

/*
 * Local definitions, types and prototypes.
 */

#define	MAXUBUFLEN	(1 << 16)

#define	FREE_TEXT(_string)					\
	kmem_free((_string), strlen(_string) + 1)

#define	FREE_TEXT_ARRAY(_array, _nelt)				\
	{							\
		int	j;					\
								\
		for (j = 0; j < (_nelt); j++)			\
			if ((_array)[j] != NULL)		\
				FREE_TEXT((_array)[j]);		\
		kmem_free((_array), (_nelt) * sizeof (char *));	\
	}

typedef	struct ippctl_buf	ippctl_buf_t;

struct ippctl_buf {
	char	*buf;
	size_t	buflen;
};

static int	ippctl_copyin(caddr_t, int, char **, size_t *);
static int	ippctl_copyout(caddr_t, int, char *, size_t);
static int	ippctl_extract_op(nvlist_t *, uint8_t *);
static int	ippctl_extract_aname(nvlist_t *, char **);
static int	ippctl_extract_modname(nvlist_t *, char **);
static int	ippctl_attach_modname(nvlist_t *nvlp, char *val);
static int	ippctl_attach_modname_array(nvlist_t *nvlp, char **val, int);
static int	ippctl_attach_aname_array(nvlist_t *nvlp, char **val, int);
static int	ippctl_extract_flags(nvlist_t *, ipp_flags_t *);
static int	ippctl_cmd(char *, size_t, size_t *);
static int	ippctl_action_create(char *, char *, nvlist_t *, ipp_flags_t);
static int	ippctl_action_destroy(char *, ipp_flags_t);
static int	ippctl_action_modify(char *, nvlist_t *, ipp_flags_t);
static int	ippctl_action_info(char *, ipp_flags_t);
static int	ippctl_action_mod(char *);
static int	ippctl_list_mods(void);
static int	ippctl_mod_list_actions(char *);
static int	ippctl_data(char **, size_t *, size_t *);
static void	ippctl_flush(void);
static int	ippctl_add_nvlist(nvlist_t *, int);
static int	ippctl_callback(nvlist_t *, void *);
static int	ippctl_set_rc(int);
static void	ippctl_alloc(int);
static void	ippctl_realloc(void);
static void	ippctl_free(void);

/*
 * Global data
 */

static dev_info_t	*ippctl_dip = NULL;
static kmutex_t		ippctl_lock;
static boolean_t	ippctl_busy;
static ippctl_buf_t	*ippctl_array = NULL;
static int		ippctl_limit = -1;
static int		ippctl_rindex = -1;
static int		ippctl_windex = -1;

/*
 * Module linkage functions
 */

#define	__FN__	"_init"
int
_init(
	void)
{
	int	rc;

	if ((rc = mod_install(&modlinkage)) != 0) {
		DBG0(DBG_MODLINK, "mod_install failed\n");
		return (rc);
	}

	return (rc);
}
#undef	__FN__

#define	__FN__	"_fini"
int
_fini(
	void)
{
	int	rc;

	if ((rc = mod_remove(&modlinkage)) == 0) {
		return (rc);
	}

	DBG0(DBG_MODLINK, "mod_remove failed\n");
	return (rc);
}
#undef	__FN__

#define	__FN__	"_info"
int
_info(
	struct modinfo	*modinfop)
{
	DBG0(DBG_MODLINK, "calling mod_info\n");
	return (mod_info(&modlinkage, modinfop));
}
#undef	__FN__

/*
 * Driver interface functions (dev_ops and cb_ops)
 */

#define	__FN__	"ippctl_info"
/*ARGSUSED*/
static	int
ippctl_info(
	dev_info_t	*dip,
	ddi_info_cmd_t	cmd,
	void		*arg,
	void 		**result)
{
	int		rc = DDI_FAILURE;

	switch (cmd) {
	case DDI_INFO_DEVT2INSTANCE:
		*result = (void *)0;	/* Single instance driver */
		rc = DDI_SUCCESS;
		break;
	case DDI_INFO_DEVT2DEVINFO:
		*result = (void *)ippctl_dip;
		rc = DDI_SUCCESS;
		break;
	default:
		break;
	}

	return (rc);
}
#undef	__FN__

#define	__FN__	"ippctl_attach"
static	int
ippctl_attach(
	dev_info_t		*dip,
	ddi_attach_cmd_t	cmd)
{
	switch (cmd) {
	case DDI_ATTACH:
		break;
	case DDI_PM_RESUME:
		/*FALLTHRU*/
	case DDI_RESUME:
		/*FALLTHRU*/
	default:
		return (DDI_FAILURE);
	}

	DBG0(DBG_DEVOPS, "DDI_ATTACH\n");

	/*
	 * This is strictly a single instance driver.
	 */

	if (ippctl_dip != NULL)
		return (DDI_FAILURE);

	/*
	 * Create minor node.
	 */

	if (ddi_create_minor_node(dip, "ctl", S_IFCHR, 0,
	    DDI_PSEUDO, 0) != DDI_SUCCESS)
		return (DDI_FAILURE);

	/*
	 * No need for per-instance structure, just store vital data in
	 * globals.
	 */

	ippctl_dip = dip;
	mutex_init(&ippctl_lock, NULL, MUTEX_DRIVER, NULL);
	ippctl_busy = B_FALSE;

	return (DDI_SUCCESS);
}
#undef	__FN__

#define	__FN__	"ippctl_detach"
/*ARGSUSED*/
static	int
ippctl_detach(
	dev_info_t		*dip,
	ddi_detach_cmd_t	cmd)
{
	switch (cmd) {
	case DDI_DETACH:
		break;
	case DDI_PM_SUSPEND:
		/*FALLTHRU*/
	case DDI_SUSPEND:
		/*FALLTHRU*/
	default:
		return (DDI_FAILURE);
	}

	DBG0(DBG_DEVOPS, "DDI_DETACH\n");

	ASSERT(dip == ippctl_dip);

	ddi_remove_minor_node(dip, NULL);
	mutex_destroy(&ippctl_lock);
	ippctl_dip = NULL;

	return (DDI_SUCCESS);
}
#undef	__FN__

#define	__FN__	"ippctl_open"
/*ARGSUSED*/
static	int
ippctl_open(
	dev_t	*devp,
	int	flag,
	int	otyp,
	cred_t	*credp)
{
	minor_t	minor = getminor(*devp);
#define	LIMIT	4

	DBG0(DBG_CBOPS, "open\n");

	/*
	 * Only allow privileged users to open our device.
	 */

	if (secpolicy_net_config(credp, B_FALSE) != 0) {
		DBG0(DBG_CBOPS, "not privileged user\n");
		return (EPERM);
	}

	/*
	 * Sanity check other arguments.
	 */

	if (minor != 0) {
		DBG0(DBG_CBOPS, "bad minor\n");
		return (ENXIO);
	}

	if (otyp != OTYP_CHR) {
		DBG0(DBG_CBOPS, "bad device type\n");
		return (EINVAL);
	}

	/*
	 * This is also a single dev_t driver.
	 */

	mutex_enter(&ippctl_lock);
	if (ippctl_busy) {
		mutex_exit(&ippctl_lock);
		return (EBUSY);
	}
	ippctl_busy = B_TRUE;
	mutex_exit(&ippctl_lock);

	/*
	 * Allocate data buffer array (starting with length LIMIT, defined
	 * at the start of this function).
	 */

	ippctl_alloc(LIMIT);

	DBG0(DBG_CBOPS, "success\n");

	return (0);

#undef	LIMIT
}
#undef	__FN__

#define	__FN__	"ippctl_close"
/*ARGSUSED*/
static	int
ippctl_close(
	dev_t	dev,
	int	flag,
	int	otyp,
	cred_t	*credp)
{
	minor_t	minor = getminor(dev);

	DBG0(DBG_CBOPS, "close\n");

	ASSERT(minor == 0);

	/*
	 * Free the data buffer array.
	 */

	ippctl_free();

	mutex_enter(&ippctl_lock);
	ippctl_busy = B_FALSE;
	mutex_exit(&ippctl_lock);

	DBG0(DBG_CBOPS, "success\n");

	return (0);
}
#undef	__FN__

#define	__FN__	"ippctl_ioctl"
static int
ippctl_ioctl(
	dev_t			dev,
	int			cmd,
	intptr_t		arg,
	int			mode,
	cred_t			*credp,
	int			*rvalp)
{
	minor_t			minor = getminor(dev);
	char			*cbuf;
	char			*dbuf;
	size_t			cbuflen;
	size_t			dbuflen;
	size_t			nextbuflen;
	int			rc;

	/*
	 * Paranoia check.
	 */

	if (secpolicy_net_config(credp, B_FALSE) != 0) {
		DBG0(DBG_CBOPS, "not privileged user\n");
		return (EPERM);
	}

	if (minor != 0) {
		DBG0(DBG_CBOPS, "bad minor\n");
		return (ENXIO);
	}

	switch (cmd) {
	case IPPCTL_CMD:
		DBG0(DBG_CBOPS, "command\n");

		/*
		 * Copy in the command buffer from user space.
		 */

		if ((rc = ippctl_copyin((caddr_t)arg, mode, &cbuf,
		    &cbuflen)) != 0)
			break;

		/*
		 * Execute the command.
		 */

		rc = ippctl_cmd(cbuf, cbuflen, &nextbuflen);

		/*
		 * Pass back the length of the first data buffer.
		 */

		DBG1(DBG_CBOPS, "nextbuflen = %lu\n", nextbuflen);
		*rvalp = nextbuflen;

		/*
		 * Free the kernel copy of the command buffer.
		 */

		kmem_free(cbuf, cbuflen);
		break;

	case IPPCTL_DATA:
		DBG0(DBG_CBOPS, "data\n");

		/*
		 * Grab the next data buffer from the array of pending
		 * buffers.
		 */

		if ((rc = ippctl_data(&dbuf, &dbuflen, &nextbuflen)) != 0)
			break;

		/*
		 * Copy it out to user space.
		 */

		rc = ippctl_copyout((caddr_t)arg, mode, dbuf, dbuflen);

		/*
		 * Pass back the length of the next data buffer.
		 */

		DBG1(DBG_CBOPS, "nextbuflen = %lu\n", nextbuflen);
		*rvalp = nextbuflen;
		break;

	default:
		DBG0(DBG_CBOPS, "unrecognized ioctl\n");
		rc = EINVAL;
		break;
	}

	DBG1(DBG_CBOPS, "rc = %d\n", rc);
	return (rc);
}
#undef	__FN__

/*
 * Local functions
 */

#define	__FN__	"ippctl_copyin"
static int
ippctl_copyin(
	caddr_t		arg,
	int		mode,
	char		**kbufp,
	size_t		*kbuflenp)
{
	ippctl_ioctl_t	iioc;
	caddr_t		ubuf;
	char		*kbuf;
	size_t		ubuflen;

	DBG0(DBG_CBOPS, "copying in ioctl structure\n");

	/*
	 * Copy in the ioctl structure from user-space, converting from 32-bit
	 * as necessary.
	 */

#ifdef	_MULTI_DATAMODEL
	switch (ddi_model_convert_from(mode & FMODELS)) {
	case DDI_MODEL_ILP32:
		{
			ippctl_ioctl32_t	iioc32;

			DBG0(DBG_CBOPS, "converting from 32-bit\n");

			if (ddi_copyin(arg, (caddr_t)&iioc32,
			    sizeof (ippctl_ioctl32_t), mode) != 0)
				return (EFAULT);

			ubuf = (caddr_t)(uintptr_t)iioc32.ii32_buf;
			ubuflen = (size_t)iioc32.ii32_buflen;
		}
		break;
	case DDI_MODEL_NONE:
		if (ddi_copyin(arg, (caddr_t)&iioc, sizeof (ippctl_ioctl_t),
		    mode) != 0)
			return (EFAULT);

		ubuf = iioc.ii_buf;
		ubuflen = iioc.ii_buflen;
		break;
	default:
		return (EFAULT);
	}
#else	/* _MULTI_DATAMODEL */
	if (ddi_copyin(arg, (caddr_t)&iioc, sizeof (ippctl_ioctl_t),
	    mode) != 0)
		return (EFAULT);

	ubuf = iioc.ii_buf;
	ubuflen = iioc.ii_buflen;
#endif	/* _MULTI_DATAMODEL */

	DBG1(DBG_CBOPS, "ubuf = 0x%p\n", (void *)ubuf);
	DBG1(DBG_CBOPS, "ubuflen = %lu\n", ubuflen);

	/*
	 * Sanity check the command buffer information.
	 */

	if (ubuflen == 0 || ubuf == NULL)
		return (EINVAL);
	if (ubuflen > MAXUBUFLEN)
		return (E2BIG);

	/*
	 * Allocate some memory for the command buffer and copy it in.
	 */

	kbuf = kmem_zalloc(ubuflen, KM_SLEEP);
	DBG0(DBG_CBOPS, "copying in nvlist\n");
	if (ddi_copyin(ubuf, (caddr_t)kbuf, ubuflen, mode) != 0) {
		kmem_free(kbuf, ubuflen);
		return (EFAULT);
	}

	*kbufp = kbuf;
	*kbuflenp = ubuflen;
	return (0);
}
#undef	__FN__

#define	__FN__	"ippctl_copyout"
static int
ippctl_copyout(
	caddr_t		arg,
	int		mode,
	char		*kbuf,
	size_t		kbuflen)
{
	ippctl_ioctl_t	iioc;
	caddr_t		ubuf;
	int		ubuflen;

	DBG0(DBG_CBOPS, "copying out ioctl structure\n");

	/*
	 * Copy in the ioctl structure from user-space, converting from 32-bit
	 * as necessary.
	 */

#ifdef	_MULTI_DATAMODEL
	switch (ddi_model_convert_from(mode & FMODELS)) {
	case DDI_MODEL_ILP32:
		{
			ippctl_ioctl32_t	iioc32;

			if (ddi_copyin(arg, (caddr_t)&iioc32,
			    sizeof (ippctl_ioctl32_t), mode) != 0)
				return (EFAULT);

			ubuf = (caddr_t)(uintptr_t)iioc32.ii32_buf;
			ubuflen = iioc32.ii32_buflen;
		}
		break;
	case DDI_MODEL_NONE:
		if (ddi_copyin(arg, (caddr_t)&iioc, sizeof (ippctl_ioctl_t),
		    mode) != 0)
			return (EFAULT);

		ubuf = iioc.ii_buf;
		ubuflen = iioc.ii_buflen;
		break;
	default:
		return (EFAULT);
	}
#else	/* _MULTI_DATAMODEL */
	if (ddi_copyin(arg, (caddr_t)&iioc, sizeof (ippctl_ioctl_t),
	    mode) != 0)
		return (EFAULT);

	ubuf = iioc.ii_buf;
	ubuflen = iioc.ii_buflen;
#endif	/* _MULTI_DATAMODEL */

	DBG1(DBG_CBOPS, "ubuf = 0x%p\n", (void *)ubuf);
	DBG1(DBG_CBOPS, "ubuflen = %d\n", ubuflen);

	/*
	 * Sanity check the data buffer details.
	 */

	if (ubuflen == 0 || ubuf == NULL)
		return (EINVAL);

	if (ubuflen < kbuflen)
		return (ENOSPC);
	if (ubuflen > MAXUBUFLEN)
		return (E2BIG);

	/*
	 * Copy out the data buffer to user space.
	 */

	DBG0(DBG_CBOPS, "copying out nvlist\n");
	if (ddi_copyout((caddr_t)kbuf, ubuf, kbuflen, mode) != 0)
		return (EFAULT);

	return (0);
}
#undef	__FN__

#define	__FN__	"ippctl_extract_op"
static int
ippctl_extract_op(
	nvlist_t	*nvlp,
	uint8_t		*valp)
{
	int		rc;

	/*
	 * Look-up and remove the opcode passed from libipp from the
	 * nvlist.
	 */

	if ((rc = nvlist_lookup_byte(nvlp, IPPCTL_OP, valp)) != 0)
		return (rc);

	(void) nvlist_remove_all(nvlp, IPPCTL_OP);
	return (0);
}
#undef	__FN__

#define	__FN__	"ippctl_extract_aname"
static int
ippctl_extract_aname(
	nvlist_t	*nvlp,
	char		**valp)
{
	int		rc;
	char		*ptr;

	/*
	 * Look-up and remove the action name passed from libipp from the
	 * nvlist.
	 */

	if ((rc = nvlist_lookup_string(nvlp, IPPCTL_ANAME, &ptr)) != 0)
		return (rc);

	*valp = kmem_alloc(strlen(ptr) + 1, KM_SLEEP);
	(void) strcpy(*valp, ptr);
	(void) nvlist_remove_all(nvlp, IPPCTL_ANAME);
	return (0);
}
#undef	__FN__

#define	__FN__	"ippctl_extract_modname"
static int
ippctl_extract_modname(
	nvlist_t	*nvlp,
	char		**valp)
{
	int		rc;
	char		*ptr;

	/*
	 * Look-up and remove the module name passed from libipp from the
	 * nvlist.
	 */

	if ((rc = nvlist_lookup_string(nvlp, IPPCTL_MODNAME, &ptr)) != 0)
		return (rc);

	*valp = kmem_alloc(strlen(ptr) + 1, KM_SLEEP);
	(void) strcpy(*valp, ptr);
	(void) nvlist_remove_all(nvlp, IPPCTL_MODNAME);
	return (0);
}
#undef	__FN__

#define	__FN__	"ippctl_attach_modname"
static int
ippctl_attach_modname(
	nvlist_t	*nvlp,
	char		*modname)
{
	/*
	 * Add a module name to an nvlist for passing back to user
	 * space.
	 */

	return (nvlist_add_string(nvlp, IPPCTL_MODNAME, modname));
}
#undef	__FN__

#define	__FN__	"ippctl_attach_modname_array"
static int
ippctl_attach_modname_array(
	nvlist_t	*nvlp,
	char		**modname_array,
	int		nelt)
{
	/*
	 * Add a module name array to an nvlist for passing back to user
	 * space.
	 */

	return (nvlist_add_string_array(nvlp, IPPCTL_MODNAME_ARRAY,
	    modname_array, nelt));
}
#undef	__FN__

#define	__FN__	"ippctl_attach_aname_array"
static int
ippctl_attach_aname_array(
	nvlist_t	*nvlp,
	char		**aname_array,
	int		nelt)
{
	/*
	 * Add an action name array to an nvlist for passing back to user
	 * space.
	 */

	return (nvlist_add_string_array(nvlp, IPPCTL_ANAME_ARRAY,
	    aname_array, nelt));
}
#undef	__FN__

#define	__FN__	"ippctl_extract_flags"
static int
ippctl_extract_flags(
	nvlist_t	*nvlp,
	ipp_flags_t	*valp)
{
	int		rc;

	/*
	 * Look-up and remove the flags passed from libipp from the
	 * nvlist.
	 */

	if ((rc = nvlist_lookup_uint32(nvlp, IPPCTL_FLAGS,
	    (uint32_t *)valp)) != 0)
		return (rc);

	(void) nvlist_remove_all(nvlp, IPPCTL_FLAGS);
	return (0);
}
#undef	__FN__

#define	__FN__	"ippctl_cmd"
static int
ippctl_cmd(
	char		*cbuf,
	size_t		cbuflen,
	size_t		*nextbuflenp)
{
	nvlist_t	*nvlp = NULL;
	int		rc;
	char		*aname = NULL;
	char		*modname = NULL;
	ipp_flags_t	flags;
	uint8_t		op;

	/*
	 * Start a new command cycle by flushing any previous data buffers.
	 */

	ippctl_flush();
	*nextbuflenp = 0;

	/*
	 * Unpack the nvlist from the command buffer.
	 */

	if ((rc = nvlist_unpack(cbuf, cbuflen, &nvlp, KM_SLEEP)) != 0)
		return (rc);

	/*
	 * Extract the opcode to find out what we should do.
	 */

	if ((rc = ippctl_extract_op(nvlp, &op)) != 0) {
		nvlist_free(nvlp);
		return (rc);
	}

	switch (op) {
	case IPPCTL_OP_ACTION_CREATE:
		/*
		 * Create a new action.
		 */

		DBG0(DBG_CBOPS, "op = IPPCTL_OP_ACTION_CREATE\n");

		/*
		 * Extract the module name, action name and flags from the
		 * nvlist.
		 */

		if ((rc = ippctl_extract_modname(nvlp, &modname)) != 0) {
			nvlist_free(nvlp);
			return (rc);
		}

		if ((rc = ippctl_extract_aname(nvlp, &aname)) != 0) {
			FREE_TEXT(modname);
			nvlist_free(nvlp);
			return (rc);
		}

		if ((rc = ippctl_extract_flags(nvlp, &flags)) != 0) {
			FREE_TEXT(aname);
			FREE_TEXT(modname);
			nvlist_free(nvlp);
			return (rc);
		}


		rc = ippctl_action_create(modname, aname, nvlp, flags);
		break;

	case IPPCTL_OP_ACTION_MODIFY:

		/*
		 * Modify an existing action.
		 */

		DBG0(DBG_CBOPS, "op = IPPCTL_OP_ACTION_MODIFY\n");

		/*
		 * Extract the action name and flags from the nvlist.
		 */

		if ((rc = ippctl_extract_aname(nvlp, &aname)) != 0) {
			nvlist_free(nvlp);
			return (rc);
		}

		if ((rc = ippctl_extract_flags(nvlp, &flags)) != 0) {
			FREE_TEXT(aname);
			nvlist_free(nvlp);
			return (rc);
		}

		rc = ippctl_action_modify(aname, nvlp, flags);
		break;

	case IPPCTL_OP_ACTION_DESTROY:

		/*
		 * Destroy an action.
		 */

		DBG0(DBG_CBOPS, "op = IPPCTL_OP_ACTION_DESTROY\n");

		/*
		 * Extract the action name and flags from the nvlist.
		 */

		if ((rc = ippctl_extract_aname(nvlp, &aname)) != 0) {
			nvlist_free(nvlp);
			return (rc);
		}

		if ((rc = ippctl_extract_flags(nvlp, &flags)) != 0) {
			FREE_TEXT(aname);
			nvlist_free(nvlp);
			return (rc);
		}

		nvlist_free(nvlp);
		rc = ippctl_action_destroy(aname, flags);
		break;

	case IPPCTL_OP_ACTION_INFO:

		/*
		 * Retrive the configuration of an action.
		 */

		DBG0(DBG_CBOPS, "op = IPPCTL_OP_ACTION_INFO\n");

		/*
		 * Extract the action name and flags from the nvlist.
		 */

		if ((rc = ippctl_extract_aname(nvlp, &aname)) != 0) {
			nvlist_free(nvlp);
			return (rc);
		}

		if ((rc = ippctl_extract_flags(nvlp, &flags)) != 0) {
			nvlist_free(nvlp);
			FREE_TEXT(aname);
			return (rc);
		}

		nvlist_free(nvlp);
		rc = ippctl_action_info(aname, flags);
		break;

	case IPPCTL_OP_ACTION_MOD:

		/*
		 * Find the module that implements a given action.
		 */

		DBG0(DBG_CBOPS, "op = IPPCTL_OP_ACTION_MOD\n");

		/*
		 * Extract the action name from the nvlist.
		 */

		if ((rc = ippctl_extract_aname(nvlp, &aname)) != 0) {
			nvlist_free(nvlp);
			return (rc);
		}

		nvlist_free(nvlp);
		rc = ippctl_action_mod(aname);
		break;

	case IPPCTL_OP_LIST_MODS:

		/*
		 * List all the modules.
		 */

		DBG0(DBG_CBOPS, "op = IPPCTL_OP_LIST_MODS\n");

		nvlist_free(nvlp);
		rc = ippctl_list_mods();
		break;

	case IPPCTL_OP_MOD_LIST_ACTIONS:

		/*
		 * List all the actions for a given module.
		 */

		DBG0(DBG_CBOPS, "op = IPPCTL_OP_LIST_MODS\n");

		if ((rc = ippctl_extract_modname(nvlp, &modname)) != 0) {
			nvlist_free(nvlp);
			return (rc);
		}

		nvlist_free(nvlp);
		rc = ippctl_mod_list_actions(modname);
		break;

	default:

		/*
		 * Unrecognized opcode.
		 */

		nvlist_free(nvlp);
		rc = EINVAL;
		break;
	}

	/*
	 * The length of buffer that we need to notify back to libipp with
	 * the command ioctl's return is the length of the first data buffer
	 * in the array. We only expact to pass back data buffers if the
	 * operation succeeds (NOTE: this does not mean the kernel call has
	 * to succeed, merely that we successfully issued it and processed
	 * the results).
	 */

	if (rc == 0)
		*nextbuflenp = ippctl_array[0].buflen;

	return (rc);
}
#undef	__FN__

#define	__FN__	"ippctl_action_create"
static int
ippctl_action_create(
	char		*modname,
	char		*aname,
	nvlist_t	*nvlp,
	ipp_flags_t	flags)
{
	int		ipp_rc;
	int		rc;
	ipp_mod_id_t	mid;
	ipp_action_id_t	aid;

	/*
	 * Look up the module id from the name and create the new
	 * action.
	 */

	mid = ipp_mod_lookup(modname);
	FREE_TEXT(modname);

	ipp_rc = ipp_action_create(mid, aname, &nvlp, flags, &aid);
	FREE_TEXT(aname);

	/*
	 * Add an nvlist containing the kernel return code to the
	 * set of nvlists to pass back to libipp.
	 */

	if ((rc = ippctl_set_rc(ipp_rc)) != 0) {
		if (nvlp != NULL) {
			nvlist_free(nvlp);
			if (ipp_action_destroy(aid, 0) != 0) {
				cmn_err(CE_PANIC,
				    "ippctl: unrecoverable error (aid = %d)",
				    aid);
				/*NOTREACHED*/
			}
		}
		return (rc);
	}

	/*
	 * If the module passed back an nvlist, add this as
	 * well.
	 */

	if (nvlp != NULL) {
		rc = ippctl_callback(nvlp, NULL);
		nvlist_free(nvlp);
	} else
		rc = 0;

	return (rc);
}
#undef	__FN__

#define	__FN__	"ippctl_action_destroy"
static int
ippctl_action_destroy(
	char		*aname,
	ipp_flags_t	flags)
{
	ipp_action_id_t	aid;
	int		ipp_rc;
	int		rc;

	/*
	 * Look up the action id and destroy the action.
	 */

	aid = ipp_action_lookup(aname);
	FREE_TEXT(aname);

	ipp_rc = ipp_action_destroy(aid, flags);

	/*
	 * Add an nvlist containing the kernel return code to the
	 * set of nvlists to pass back to libipp.
	 */

	if ((rc = ippctl_set_rc(ipp_rc)) != 0)
		return (rc);

	/*
	 * There's no more information to pass back.
	 */

	return (0);
}
#undef	__FN__

#define	__FN__	"ippctl_action_modify"
static int
ippctl_action_modify(
	char		*aname,
	nvlist_t	*nvlp,
	ipp_flags_t	flags)
{
	ipp_action_id_t	aid;
	int		ipp_rc;
	int		rc;

	/*
	 * Look up the action id and modify the action.
	 */

	aid = ipp_action_lookup(aname);
	FREE_TEXT(aname);

	ipp_rc = ipp_action_modify(aid, &nvlp, flags);

	/*
	 * Add an nvlist containing the kernel return code to the
	 * set of nvlists to pass back to libipp.
	 */

	if ((rc = ippctl_set_rc(ipp_rc)) != 0) {
		nvlist_free(nvlp);
		return (rc);
	}

	/*
	 * If the module passed back an nvlist, add this as
	 * well.
	 */

	if (nvlp != NULL) {
		rc = ippctl_callback(nvlp, NULL);
		nvlist_free(nvlp);
	} else
		rc = 0;

	return (rc);
}
#undef	__FN__

#define	__FN__	"ippctl_action_info"
static int
ippctl_action_info(
	char		*aname,
	ipp_flags_t	flags)
{
	ipp_action_id_t	aid;
	int		ipp_rc;
	int		rc;

	/*
	 * Look up the action and call the information retrieval
	 * entry point.
	 *
	 * NOTE: The callback function that is passed in packs and
	 * stores each of the nvlists it is called with in the array
	 * that will be passed back to libipp.
	 */

	aid = ipp_action_lookup(aname);
	FREE_TEXT(aname);

	ipp_rc = ipp_action_info(aid, ippctl_callback, NULL, flags);

	/*
	 * Add an nvlist containing the kernel return code to the
	 * set of nvlists to pass back to libipp.
	 */

	if ((rc = ippctl_set_rc(ipp_rc)) != 0)
		return (rc);

	/*
	 * There's no more information to pass back.
	 */

	return (0);
}
#undef	__FN__

#define	__FN__	"ippctl_action_mod"
static int
ippctl_action_mod(
	char		*aname)
{
	ipp_mod_id_t	mid;
	ipp_action_id_t	aid;
	char		*modname;
	nvlist_t	*nvlp;
	int		ipp_rc;
	int		rc;

	/*
	 * Look up the action id and get the id of the module that
	 * implements the action. If that succeeds then look up the
	 * name of the module.
	 */

	aid = ipp_action_lookup(aname);
	FREE_TEXT(aname);

	if ((ipp_rc = ipp_action_mod(aid, &mid)) == 0)
		ipp_rc = ipp_mod_name(mid, &modname);

	/*
	 * Add an nvlist containing the kernel return code to the
	 * set of nvlists to pass back to libipp.
	 */

	if ((rc = ippctl_set_rc(ipp_rc)) != 0)
		return (rc);

	/*
	 * If everything succeeded add an nvlist containing the
	 * module name to the set of nvlists to pass back to libipp.
	 */

	if (ipp_rc == 0) {
		if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, KM_SLEEP)) != 0)
			return (rc);

		if ((rc = ippctl_attach_modname(nvlp, modname)) != 0) {
			nvlist_free(nvlp);
			return (rc);
		}

		FREE_TEXT(modname);

		rc = ippctl_callback(nvlp, NULL);
		nvlist_free(nvlp);
	} else
		rc = 0;

	return (rc);
}
#undef	__FN__

#define	__FN__	"ippctl_list_mods"
static int
ippctl_list_mods(
	void)
{
	nvlist_t	*nvlp;
	int		ipp_rc;
	int		rc = 0;
	ipp_mod_id_t	*mid_array;
	char		**modname_array = NULL;
	int		nelt;
	int		length;
	int		i;

	/*
	 * Get a list of all the module ids. If that succeeds,
	 * translate the ids into names.
	 *
	 * NOTE: This translation may fail if a module is
	 * unloaded during this operation. If this occurs, EAGAIN
	 * will be passed back to libipp note that a transient
	 * problem occured.
	 */

	if ((ipp_rc = ipp_list_mods(&mid_array, &nelt)) == 0) {

		/*
		 * It is possible that there are no modules
		 * registered.
		 */

		if (nelt > 0) {
			length = nelt * sizeof (char *);
			modname_array = kmem_zalloc(length, KM_SLEEP);

			for (i = 0; i < nelt; i++) {
				if (ipp_mod_name(mid_array[i],
				    &modname_array[i]) != 0) {
					kmem_free(mid_array, nelt *
					    sizeof (ipp_mod_id_t));
					FREE_TEXT_ARRAY(modname_array, nelt);
					ipp_rc = EAGAIN;
					goto done;
				}
			}

			kmem_free(mid_array, nelt * sizeof (ipp_mod_id_t));

			if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME,
			    KM_SLEEP)) != 0) {
				FREE_TEXT_ARRAY(modname_array, nelt);
				return (rc);
			}

			if ((rc = ippctl_attach_modname_array(nvlp,
			    modname_array, nelt)) != 0) {
				FREE_TEXT_ARRAY(modname_array, nelt);
				nvlist_free(nvlp);
				return (rc);
			}

			FREE_TEXT_ARRAY(modname_array, nelt);

			if ((rc = ippctl_callback(nvlp, NULL)) != 0) {
				nvlist_free(nvlp);
				return (rc);
			}

			nvlist_free(nvlp);
		}
	}

done:
	/*
	 * Add an nvlist containing the kernel return code to the
	 * set of nvlists to pass back to libipp.
	 */

	if ((rc = ippctl_set_rc(ipp_rc)) != 0)
		return (rc);

	return (0);
}
#undef	__FN__

#define	__FN__	"ippctl_mod_list_actions"
static int
ippctl_mod_list_actions(
	char		*modname)
{
	ipp_mod_id_t	mid;
	nvlist_t	*nvlp;
	int		ipp_rc;
	int		rc = 0;
	ipp_action_id_t	*aid_array;
	char		**aname_array = NULL;
	int		nelt;
	int		length;
	int		i;

	/*
	 * Get the module id.
	 */

	mid = ipp_mod_lookup(modname);
	FREE_TEXT(modname);

	/*
	 * Get a list of all the action ids for the module. If that succeeds,
	 * translate the ids into names.
	 *
	 * NOTE: This translation may fail if an action is
	 * destroyed during this operation. If this occurs, EAGAIN
	 * will be passed back to libipp note that a transient
	 * problem occured.
	 */

	if ((ipp_rc = ipp_mod_list_actions(mid, &aid_array, &nelt)) == 0) {

		/*
		 * It is possible that there are no actions defined.
		 * (This is unlikely though as the module would normally
		 * be auto-unloaded fairly quickly)
		 */

		if (nelt > 0) {
			length = nelt * sizeof (char *);
			aname_array = kmem_zalloc(length, KM_SLEEP);

			for (i = 0; i < nelt; i++) {
				if (ipp_action_name(aid_array[i],
				    &aname_array[i]) != 0) {
					kmem_free(aid_array, nelt *
					    sizeof (ipp_action_id_t));
					FREE_TEXT_ARRAY(aname_array, nelt);
					ipp_rc = EAGAIN;
					goto done;
				}
			}

			kmem_free(aid_array, nelt * sizeof (ipp_action_id_t));

			if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME,
			    KM_SLEEP)) != 0) {
				FREE_TEXT_ARRAY(aname_array, nelt);
				return (rc);
			}

			if ((rc = ippctl_attach_aname_array(nvlp, aname_array,
			    nelt)) != 0) {
				FREE_TEXT_ARRAY(aname_array, nelt);
				nvlist_free(nvlp);
				return (rc);
			}

			FREE_TEXT_ARRAY(aname_array, nelt);

			if ((rc = ippctl_callback(nvlp, NULL)) != 0) {
				nvlist_free(nvlp);
				return (rc);
			}

			nvlist_free(nvlp);
		}
	}

done:
	/*
	 * Add an nvlist containing the kernel return code to the
	 * set of nvlists to pass back to libipp.
	 */

	if ((rc = ippctl_set_rc(ipp_rc)) != 0)
		return (rc);

	return (0);
}
#undef	__FN__

#define	__FN__	"ippctl_data"
static int
ippctl_data(
	char	**dbufp,
	size_t	*dbuflenp,
	size_t	*nextbuflenp)
{
	int	i;

	DBG0(DBG_CBOPS, "called\n");

	/*
	 * Get the next data buffer from the array by looking at the
	 * 'read index'. If this is the same as the 'write index' then
	 * there's no more buffers in the array.
	 */

	i = ippctl_rindex;
	if (i == ippctl_windex)
		return (ENOENT);

	/*
	 * Extract the buffer details. It is a pre-packed nvlist.
	 */

	*dbufp = ippctl_array[i].buf;
	*dbuflenp = ippctl_array[i].buflen;

	DBG2(DBG_CBOPS, "accessing nvlist[%d], length %lu\n", i, *dbuflenp);
	ASSERT(*dbufp != NULL);

	/*
	 * Advance the 'read index' and check if there's another buffer.
	 * If there is then we need to pass back its length to libipp so that
	 * another data ioctl will be issued.
	 */

	i++;
	if (i < ippctl_windex)
		*nextbuflenp = ippctl_array[i].buflen;
	else
		*nextbuflenp = 0;

	ippctl_rindex = i;
	return (0);
}
#undef	__FN__

#define	__FN__	"ippctl_flush"
static void
ippctl_flush(
	void)
{
	int	i;
	char	*buf;
	size_t	buflen;

	/*
	 * Free any buffers left in the array.
	 */

	for (i = 0; i < ippctl_limit; i++) {
		if ((buflen = ippctl_array[i].buflen) > 0) {
			buf = ippctl_array[i].buf;
			ASSERT(buf != NULL);
			kmem_free(buf, buflen);
		}
	}

	/*
	 * NULL all the entries.
	 */

	bzero(ippctl_array, ippctl_limit * sizeof (ippctl_buf_t));

	/*
	 * Reset the indexes.
	 */

	ippctl_rindex = 0;
	ippctl_windex = 1;
}
#undef	__FN__

#define	__FN__	"ippctl_add_nvlist"
static int
ippctl_add_nvlist(
	nvlist_t	*nvlp,
	int		i)
{
	char		*buf;
	size_t		buflen;
	int		rc;

	/*
	 * NULL the buffer pointer so that a buffer is automatically
	 * allocated for us.
	 */

	buf = NULL;

	/*
	 * Pack the nvlist and get back the buffer pointer and length.
	 */

	if ((rc = nvlist_pack(nvlp, &buf, &buflen, NV_ENCODE_NATIVE,
	    KM_SLEEP)) != 0) {
		ippctl_array[i].buf = NULL;
		ippctl_array[i].buflen = 0;
		return (rc);
	}

	DBG2(DBG_CBOPS, "added nvlist[%d]: length %lu\n", i, buflen);

	/*
	 * Store the pointer an length in the array at the given index.
	 */

	ippctl_array[i].buf = buf;
	ippctl_array[i].buflen = buflen;

	return (0);
}
#undef	__FN__

#define	__FN__	"ippctl_callback"
/*ARGSUSED*/
static int
ippctl_callback(
	nvlist_t	*nvlp,
	void		*arg)
{
	int		i;
	int		rc;

	/*
	 * Check the 'write index' to see if there's space in the array for
	 * a new entry.
	 */

	i = ippctl_windex;
	ASSERT(i != 0);

	/*
	 * If there's no space, re-allocate the array (see comments in
	 * ippctl_realloc() for details).
	 */

	if (i == ippctl_limit)
		ippctl_realloc();

	/*
	 * Add the nvlist to the array.
	 */

	if ((rc = ippctl_add_nvlist(nvlp, i)) == 0)
		ippctl_windex++;

	return (rc);
}
#undef	__FN__

#define	__FN__	"ippctl_set_rc"
static int
ippctl_set_rc(
	int		val)
{
	nvlist_t	*nvlp;
	int		rc;

	/*
	 * Create an nvlist to store the return code,
	 */

	if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, KM_SLEEP)) != 0)
		return (ENOMEM);

	if ((rc = nvlist_add_int32(nvlp, IPPCTL_RC, val)) != 0) {
		nvlist_free(nvlp);
		return (rc);
	}

	/*
	 * Add it at the beginning of the array.
	 */

	rc = ippctl_add_nvlist(nvlp, 0);

	nvlist_free(nvlp);
	return (rc);
}
#undef	__FN__

#define	__FN__	"ippctl_alloc"
static void
ippctl_alloc(
	int	limit)
{
	/*
	 * Allocate the data buffer array and initialize the indexes.
	 */

	ippctl_array = kmem_zalloc(limit * sizeof (ippctl_buf_t), KM_SLEEP);
	ippctl_limit = limit;
	ippctl_rindex = 0;
	ippctl_windex = 1;
}
#undef	__FN__

#define	__FN__	"ippctl_realloc"
static void
ippctl_realloc(
	void)
{
	ippctl_buf_t	*array;
	int		limit;
	int		i;

	/*
	 * Allocate a new array twice the size of the old one.
	 */

	limit = ippctl_limit << 1;
	array = kmem_zalloc(limit * sizeof (ippctl_buf_t), KM_SLEEP);

	/*
	 * Copy across the information from the old array into the new one.
	 */

	for (i = 0; i < ippctl_limit; i++)
		array[i] = ippctl_array[i];

	/*
	 * Free the old array.
	 */

	kmem_free(ippctl_array, ippctl_limit * sizeof (ippctl_buf_t));

	ippctl_array = array;
	ippctl_limit = limit;
}
#undef	__FN__

#define	__FN__	"ippctl_free"
static void
ippctl_free(
	void)
{
	/*
	 * Flush the array prior to freeing it to make sure no buffers are
	 * leaked.
	 */

	ippctl_flush();

	/*
	 * Free the array.
	 */

	kmem_free(ippctl_array, ippctl_limit * sizeof (ippctl_buf_t));
	ippctl_array = NULL;
	ippctl_limit = -1;
	ippctl_rindex = -1;
	ippctl_windex = -1;
}
#undef	__FN__

#ifdef	IPPCTL_DEBUG
static void
ippctl_debug(
	uint64_t	type,
	char		*fn,
	char		*fmt,
			...)
{
	char		buf[255];
	va_list		adx;

	if ((type & ippctl_debug_flags) == 0)
		return;

	mutex_enter(debug_mutex);
	va_start(adx, fmt);
	(void) vsnprintf(buf, 255, fmt, adx);
	va_end(adx);

	printf("%s: %s", fn, buf);
	mutex_exit(debug_mutex);
}
#endif	/* IPPCTL_DBG */