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

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/


/*
 * STREAMS Administrative Driver
 *
 * Currently only handles autopush and module name verification.
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/errno.h>
#include <sys/stream.h>
#include <sys/stropts.h>
#include <sys/strsubr.h>
#include <sys/strsun.h>
#include <sys/conf.h>
#include <sys/sad.h>
#include <sys/cred.h>
#include <sys/debug.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/stat.h>
#include <sys/cmn_err.h>
#include <sys/systm.h>
#include <sys/modctl.h>
#include <sys/priv_names.h>
#include <sys/sysmacros.h>
#include <sys/zone.h>

static int sadopen(queue_t *, dev_t *, int, int, cred_t *);
static int sadclose(queue_t *, int, cred_t *);
static int sadwput(queue_t *qp, mblk_t *mp);

static int sad_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int sad_attach(dev_info_t *, ddi_attach_cmd_t);

static void apush_ioctl(), apush_iocdata();
static void vml_ioctl(), vml_iocdata();
static int valid_major(major_t);

static dev_info_t *sad_dip;		/* private copy of devinfo pointer */

static struct module_info sad_minfo = {
	0x7361, "sad", 0, INFPSZ, 0, 0
};

static struct qinit sad_rinit = {
	NULL, NULL, sadopen, sadclose, NULL, &sad_minfo, NULL
};

static struct qinit sad_winit = {
	sadwput, NULL, NULL, NULL, NULL, &sad_minfo, NULL
};

struct streamtab sadinfo = {
	&sad_rinit, &sad_winit, NULL, NULL
};

DDI_DEFINE_STREAM_OPS(sad_ops, nulldev, nulldev, sad_attach,
    nodev, nodev, sad_info,
    D_MP | D_MTPERQ | D_MTOUTPERIM | D_MTOCEXCL, &sadinfo);

/*
 * Module linkage information for the kernel.
 */

static struct modldrv modldrv = {
	&mod_driverops, /* Type of module.  This one is a pseudo driver */
	"STREAMS Administrative Driver 'sad' %I%",
	&sad_ops,	/* driver ops */
};

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

int
_init(void)
{
	return (mod_install(&modlinkage));
}

int
_fini(void)
{
	return (mod_remove(&modlinkage));
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

static int
sad_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
	int instance = ddi_get_instance(devi);

	if (cmd != DDI_ATTACH)
		return (DDI_FAILURE);

	ASSERT(instance == 0);
	if (instance != 0)
		return (DDI_FAILURE);

	if (ddi_create_minor_node(devi, "user", S_IFCHR,
	    0, DDI_PSEUDO, NULL) == DDI_FAILURE) {
		return (DDI_FAILURE);
	}
	if (ddi_create_priv_minor_node(devi, "admin", S_IFCHR,
	    1, DDI_PSEUDO, PRIVONLY_DEV, PRIV_SYS_CONFIG,
	    PRIV_SYS_CONFIG, 0666) == DDI_FAILURE) {
		ddi_remove_minor_node(devi, NULL);
		return (DDI_FAILURE);
	}
	sad_dip = devi;
	return (DDI_SUCCESS);
}

/* ARGSUSED */
static int
sad_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
	int error;

	switch (infocmd) {
	case DDI_INFO_DEVT2DEVINFO:
		if (sad_dip == NULL) {
			error = DDI_FAILURE;
		} else {
			*result = sad_dip;
			error = DDI_SUCCESS;
		}
		break;
	case DDI_INFO_DEVT2INSTANCE:
		*result = (void *)0;
		error = DDI_SUCCESS;
		break;
	default:
		error = DDI_FAILURE;
	}
	return (error);
}


/*
 * sadopen() -
 * Allocate a sad device.  Only one
 * open at a time allowed per device.
 */
/* ARGSUSED */
static int
sadopen(
	queue_t *qp,	/* pointer to read queue */
	dev_t *devp,	/* major/minor device of stream */
	int flag,	/* file open flags */
	int sflag,	/* stream open flags */
	cred_t *credp)	/* user credentials */
{
	int i;
	netstack_t *ns;
	str_stack_t *ss;

	if (sflag)		/* no longer called from clone driver */
		return (EINVAL);

	ns = netstack_find_by_cred(credp);
	ASSERT(ns != NULL);
	ss = ns->netstack_str;
	ASSERT(ss != NULL);

	/*
	 * Both USRMIN and ADMMIN are clone interfaces.
	 */
	for (i = 0; i < ss->ss_sadcnt; i++)
		if (ss->ss_saddev[i].sa_qp == NULL)
			break;
	if (i >= ss->ss_sadcnt) {		/* no such device */
		netstack_rele(ss->ss_netstack);
		return (ENXIO);
	}
	switch (getminor(*devp)) {
	case USRMIN:			/* mere mortal */
		ss->ss_saddev[i].sa_flags = 0;
		break;

	case ADMMIN:			/* privileged user */
		ss->ss_saddev[i].sa_flags = SADPRIV;
		break;

	default:
		netstack_rele(ss->ss_netstack);
		return (EINVAL);
	}

	ss->ss_saddev[i].sa_qp = qp;
	ss->ss_saddev[i].sa_ss = ss;
	qp->q_ptr = (caddr_t)&ss->ss_saddev[i];
	WR(qp)->q_ptr = (caddr_t)&ss->ss_saddev[i];

	/*
	 * NOTE: should the ADMMIN or USRMIN minors change
	 * then so should the offset of 2 below
	 * Both USRMIN and ADMMIN are clone interfaces and
	 * therefore their minor numbers (0 and 1) are reserved.
	 */
	*devp = makedevice(getemajor(*devp), i + 2);
	qprocson(qp);
	return (0);
}

/*
 * sadclose() -
 * Clean up the data structures.
 */
/* ARGSUSED */
static int
sadclose(
	queue_t *qp,	/* pointer to read queue */
	int flag,	/* file open flags */
	cred_t *credp)	/* user credentials */
{
	struct saddev *sadp;

	qprocsoff(qp);
	sadp = (struct saddev *)qp->q_ptr;
	sadp->sa_qp = NULL;
	sadp->sa_addr = NULL;
	netstack_rele(sadp->sa_ss->ss_netstack);
	sadp->sa_ss = NULL;
	qp->q_ptr = NULL;
	WR(qp)->q_ptr = NULL;
	return (0);
}

/*
 * sadwput() -
 * Write side put procedure.
 */
static int
sadwput(
	queue_t *qp,	/* pointer to write queue */
	mblk_t *mp)	/* message pointer */
{
	struct iocblk *iocp;

	switch (mp->b_datap->db_type) {
	case M_FLUSH:
		if (*mp->b_rptr & FLUSHR) {
			*mp->b_rptr &= ~FLUSHW;
			qreply(qp, mp);
		} else
			freemsg(mp);
		break;

	case M_IOCTL:
		iocp = (struct iocblk *)mp->b_rptr;
		switch (SAD_CMD(iocp->ioc_cmd)) {
		case SAD_CMD(SAD_SAP):
		case SAD_CMD(SAD_GAP):
			apush_ioctl(qp, mp);
			break;

		case SAD_VML:
			vml_ioctl(qp, mp);
			break;

		default:
			miocnak(qp, mp, 0, EINVAL);
			break;
		}
		break;

	case M_IOCDATA:
		iocp = (struct iocblk *)mp->b_rptr;
		switch (SAD_CMD(iocp->ioc_cmd)) {
		case SAD_CMD(SAD_SAP):
		case SAD_CMD(SAD_GAP):
			apush_iocdata(qp, mp);
			break;

		case SAD_VML:
			vml_iocdata(qp, mp);
			break;

		default:
			cmn_err(CE_WARN,
			    "sadwput: invalid ioc_cmd in case M_IOCDATA: %d",
			    iocp->ioc_cmd);
			freemsg(mp);
			break;
		}
		break;

	default:
		freemsg(mp);
		break;
	} /* switch (db_type) */
	return (0);
}

/*
 * apush_ioctl() -
 * Handle the M_IOCTL messages associated with
 * the autopush feature.
 */
static void
apush_ioctl(
	queue_t *qp,	/* pointer to write queue */
	mblk_t *mp)	/* message pointer */
{
	struct iocblk	*iocp;
	struct saddev	*sadp;
	uint_t		size;

	iocp = (struct iocblk *)mp->b_rptr;
	if (iocp->ioc_count != TRANSPARENT) {
		miocnak(qp, mp, 0, EINVAL);
		return;
	}
	if (SAD_VER(iocp->ioc_cmd) > AP_VERSION) {
		miocnak(qp, mp, 0, EINVAL);
		return;
	}

	sadp = (struct saddev *)qp->q_ptr;
	switch (SAD_CMD(iocp->ioc_cmd)) {
	case SAD_CMD(SAD_SAP):
		if (!(sadp->sa_flags & SADPRIV)) {
			miocnak(qp, mp, 0, EPERM);
			break;
		}
		/* FALLTHRU */

	case SAD_CMD(SAD_GAP):
		sadp->sa_addr = (caddr_t)*(uintptr_t *)mp->b_cont->b_rptr;
		if (SAD_VER(iocp->ioc_cmd) == 1)
			size = STRAPUSH_V1_LEN;
		else
			size = STRAPUSH_V0_LEN;
		mcopyin(mp, (void *)GETSTRUCT, size, NULL);
		qreply(qp, mp);
		break;

	default:
		ASSERT(0);
		miocnak(qp, mp, 0, EINVAL);
		break;
	} /* switch (ioc_cmd) */
}

/*
 * apush_iocdata() -
 * Handle the M_IOCDATA messages associated with
 * the autopush feature.
 */
static void
apush_iocdata(
	queue_t *qp,	/* pointer to write queue */
	mblk_t *mp)	/* message pointer */
{
	int i, ret;
	struct copyresp *csp;
	struct strapush *sap = NULL;
	struct autopush *ap, *ap_tmp;
	struct saddev *sadp;
	uint_t size;
	dev_t dev;
	str_stack_t *ss;

	sadp = (struct saddev *)qp->q_ptr;
	ss = sadp->sa_ss;

	csp = (struct copyresp *)mp->b_rptr;
	if (csp->cp_rval) {	/* if there was an error */
		freemsg(mp);
		return;
	}
	if (mp->b_cont) {
		/*
		 * sap needed only if mp->b_cont is set.  figure out the
		 * size of the expected sap structure and make sure
		 * enough data was supplied.
		 */
		if (SAD_VER(csp->cp_cmd) == 1)
			size = STRAPUSH_V1_LEN;
		else
			size = STRAPUSH_V0_LEN;
		if (MBLKL(mp->b_cont) < size) {
			miocnak(qp, mp, 0, EINVAL);
			return;
		}
		sap = (struct strapush *)mp->b_cont->b_rptr;
		dev = makedevice(sap->sap_major, sap->sap_minor);
	}
	switch (SAD_CMD(csp->cp_cmd)) {
	case SAD_CMD(SAD_SAP):

		/* currently we only support one SAD_SAP command */
		if (((long)csp->cp_private) != GETSTRUCT) {
			cmn_err(CE_WARN,
			    "apush_iocdata: cp_private bad in SAD_SAP: %p",
			    (void *)csp->cp_private);
			miocnak(qp, mp, 0, EINVAL);
			return;
		}

		switch (sap->sap_cmd) {
		default:
			miocnak(qp, mp, 0, EINVAL);
			return;
		case SAP_ONE:
		case SAP_RANGE:
		case SAP_ALL:
			/* allocate and initialize a new config */
			ap = sad_ap_alloc();
			ap->ap_common = sap->sap_common;
			if (SAD_VER(csp->cp_cmd) > 0)
				ap->ap_anchor = sap->sap_anchor;
			for (i = 0; i < MIN(sap->sap_npush, MAXAPUSH); i++)
				(void) strncpy(ap->ap_list[i],
				    sap->sap_list[i], FMNAMESZ);

			/* sanity check the request */
			if (((ret = sad_ap_verify(ap)) != 0) ||
			    ((ret = valid_major(ap->ap_major)) != 0)) {
				sad_ap_rele(ap, ss);
				miocnak(qp, mp, 0, ret);
				return;
			}

			/* check for overlapping configs */
			mutex_enter(&ss->ss_sad_lock);
			ap_tmp = sad_ap_find(&ap->ap_common, ss);
			if (ap_tmp != NULL) {
				/* already configured */
				mutex_exit(&ss->ss_sad_lock);
				sad_ap_rele(ap_tmp, ss);
				sad_ap_rele(ap, ss);
				miocnak(qp, mp, 0, EEXIST);
				return;
			}

			/* add the new config to our hash */
			sad_ap_insert(ap, ss);
			mutex_exit(&ss->ss_sad_lock);
			miocack(qp, mp, 0, 0);
			return;

		case SAP_CLEAR:
			/* sanity check the request */
			if (ret = valid_major(sap->sap_major)) {
				miocnak(qp, mp, 0, ret);
				return;
			}

			/* search for a matching config */
			if ((ap = sad_ap_find_by_dev(dev, ss)) == NULL) {
				/* no config found */
				miocnak(qp, mp, 0, ENODEV);
				return;
			}

			/*
			 * If we matched a SAP_RANGE config
			 * the minor passed in must match the
			 * beginning of the range exactly.
			 */
			if ((ap->ap_type == SAP_RANGE) &&
			    (ap->ap_minor != sap->sap_minor)) {
				sad_ap_rele(ap, ss);
				miocnak(qp, mp, 0, ERANGE);
				return;
			}

			/*
			 * If we matched a SAP_ALL config
			 * the minor passed in must be 0.
			 */
			if ((ap->ap_type == SAP_ALL) &&
			    (sap->sap_minor != 0)) {
				sad_ap_rele(ap, ss);
				miocnak(qp, mp, 0, EINVAL);
				return;
			}

			/*
			 * make sure someone else hasn't already
			 * removed this config from the hash.
			 */
			mutex_enter(&ss->ss_sad_lock);
			ap_tmp = sad_ap_find(&ap->ap_common, ss);
			if (ap_tmp != ap) {
				mutex_exit(&ss->ss_sad_lock);
				sad_ap_rele(ap_tmp, ss);
				sad_ap_rele(ap, ss);
				miocnak(qp, mp, 0, ENODEV);
				return;
			}

			/* remove the config from the hash and return */
			sad_ap_remove(ap, ss);
			mutex_exit(&ss->ss_sad_lock);

			/*
			 * Release thrice, once for sad_ap_find_by_dev(),
			 * once for sad_ap_find(), and once to free.
			 */
			sad_ap_rele(ap, ss);
			sad_ap_rele(ap, ss);
			sad_ap_rele(ap, ss);
			miocack(qp, mp, 0, 0);
			return;
		} /* switch (sap_cmd) */
		/*NOTREACHED*/

	case SAD_CMD(SAD_GAP):
		switch ((long)csp->cp_private) {

		case GETSTRUCT:
			/* sanity check the request */
			if (ret = valid_major(sap->sap_major)) {
				miocnak(qp, mp, 0, ret);
				return;
			}

			/* search for a matching config */
			if ((ap = sad_ap_find_by_dev(dev, ss)) == NULL) {
				/* no config found */
				miocnak(qp, mp, 0, ENODEV);
				return;
			}

			/* copy out the contents of the config */
			sap->sap_common = ap->ap_common;
			if (SAD_VER(csp->cp_cmd) > 0)
				sap->sap_anchor = ap->ap_anchor;
			for (i = 0; i < ap->ap_npush; i++)
				(void) strcpy(sap->sap_list[i], ap->ap_list[i]);
			for (; i < MAXAPUSH; i++)
				bzero(sap->sap_list[i], FMNAMESZ + 1);

			/* release our hold on the config */
			sad_ap_rele(ap, ss);

			/* copyout the results */
			if (SAD_VER(csp->cp_cmd) == 1)
				size = STRAPUSH_V1_LEN;
			else
				size = STRAPUSH_V0_LEN;

			mcopyout(mp, (void *)GETRESULT, size, sadp->sa_addr,
			    NULL);
			qreply(qp, mp);
			return;
		case GETRESULT:
			miocack(qp, mp, 0, 0);
			return;

		default:
			cmn_err(CE_WARN,
			    "apush_iocdata: cp_private bad case SAD_GAP: %p",
			    (void *)csp->cp_private);
			freemsg(mp);
			return;
		} /* switch (cp_private) */
		/*NOTREACHED*/
	default:	/* can't happen */
		ASSERT(0);
		freemsg(mp);
		return;
	} /* switch (cp_cmd) */
}

/*
 * vml_ioctl() -
 * Handle the M_IOCTL message associated with a request
 * to validate a module list.
 */
static void
vml_ioctl(
	queue_t *qp,	/* pointer to write queue */
	mblk_t *mp)	/* message pointer */
{
	struct iocblk *iocp;

	iocp = (struct iocblk *)mp->b_rptr;
	if (iocp->ioc_count != TRANSPARENT) {
		miocnak(qp, mp, 0, EINVAL);
		return;
	}
	ASSERT(SAD_CMD(iocp->ioc_cmd) == SAD_VML);
	mcopyin(mp, (void *)GETSTRUCT,
	    SIZEOF_STRUCT(str_list, iocp->ioc_flag), NULL);
	qreply(qp, mp);
}

/*
 * vml_iocdata() -
 * Handle the M_IOCDATA messages associated with
 * a request to validate a module list.
 */
static void
vml_iocdata(
	queue_t *qp,	/* pointer to write queue */
	mblk_t *mp)	/* message pointer */
{
	long i;
	int	nmods;
	struct copyresp *csp;
	struct str_mlist *lp;
	STRUCT_HANDLE(str_list, slp);
	struct saddev *sadp;

	csp = (struct copyresp *)mp->b_rptr;
	if (csp->cp_rval) {	/* if there was an error */
		freemsg(mp);
		return;
	}

	ASSERT(SAD_CMD(csp->cp_cmd) == SAD_VML);
	sadp = (struct saddev *)qp->q_ptr;
	switch ((long)csp->cp_private) {
	case GETSTRUCT:
		STRUCT_SET_HANDLE(slp, csp->cp_flag,
		    (struct str_list *)mp->b_cont->b_rptr);
		nmods = STRUCT_FGET(slp, sl_nmods);
		if (nmods <= 0) {
			miocnak(qp, mp, 0, EINVAL);
			break;
		}
		sadp->sa_addr = (caddr_t)(uintptr_t)nmods;

		mcopyin(mp, (void *)GETLIST, nmods * sizeof (struct str_mlist),
		    STRUCT_FGETP(slp, sl_modlist));
		qreply(qp, mp);
		break;

	case GETLIST:
		lp = (struct str_mlist *)mp->b_cont->b_rptr;
		for (i = 0; i < (long)sadp->sa_addr; i++, lp++) {
			lp->l_name[FMNAMESZ] = '\0';
			if (fmodsw_find(lp->l_name, FMODSW_LOAD) == NULL) {
				miocack(qp, mp, 0, 1);
				return;
			}
		}
		miocack(qp, mp, 0, 0);
		break;

	default:
		cmn_err(CE_WARN, "vml_iocdata: invalid cp_private value: %p",
		    (void *)csp->cp_private);
		freemsg(mp);
		break;
	} /* switch (cp_private) */
}

/*
 * Validate a major number and also verify if
 * it is a STREAMS device.
 * Return values: 0 if a valid STREAMS dev
 *		  error code otherwise
 */
static int
valid_major(major_t major)
{
	int ret = 0;

	if (etoimajor(major) == -1)
		return (EINVAL);

	/*
	 * attempt to load the driver 'major' and verify that
	 * it is a STREAMS driver.
	 */
	if (ddi_hold_driver(major) == NULL)
		return (EINVAL);

	if (!STREAMSTAB(major))
		ret = ENOSTR;

	ddi_rele_driver(major);

	return (ret);
}