/*

 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*

 * Copyright (c) 1983 Regents of the University of California.

 * All rights reserved. The Berkeley software License Agreement

 * specifies the terms and conditions for redistribution.

 */

/*

 * PTY - Stream "pseudo-tty" device.

 * This is the "slave" side.

 */

#include <sys/param.h>

#include <sys/systm.h>

#include <sys/filio.h>

#include <sys/ioccom.h>

#include <sys/termios.h>

#include <sys/termio.h>

#include <sys/ttold.h>

#include <sys/stropts.h>

#include <sys/stream.h>

#include <sys/strsun.h>

#include <sys/tty.h>

#include <sys/user.h>

#include <sys/conf.h>

#include <sys/file.h>

#include <sys/vnode.h>	/* 1/0 on the vomit meter */

#include <sys/proc.h>

#include <sys/uio.h>

#include <sys/errno.h>

#include <sys/strsubr.h>

#include <sys/poll.h>

#include <sys/sysmacros.h>

#include <sys/debug.h>

#include <sys/procset.h>

#include <sys/cred.h>

#include <sys/ptyvar.h>

#include <sys/suntty.h>

#include <sys/stat.h>

#include <sys/policy.h>

#include <sys/conf.h>

#include <sys/ddi.h>

#include <sys/sunddi.h>

extern void gsignal(int pid, int sig);

extern	int npty;	/* number of pseudo-ttys configured in */

extern struct pty *pty_softc;

extern struct pollhead	ptcph;	/* poll head for ptcpoll() use */

#define	IFLAGS	(CS7|CREAD|PARENB)

/*

 * Most of these should be "void", but the people who defined the "streams"

 * data structure for S5 didn't understand data types.

 */

/*

 * Slave side.  This is a streams device.

 */

static int ptslopen(queue_t *, dev_t *, int flag, int, cred_t *);

static int ptslclose(queue_t *, int, cred_t *);

static int ptslrserv(queue_t *);

/*

 * To save instructions, since STREAMS ignores the return value

 * from this function, it is defined as void here. Kind of icky, but...

 */

static void ptslwput(queue_t *q, mblk_t *mp);

static struct module_info ptslm_info = {

	0,

	"ptys",

	0,

	INFPSZ,

	2048,

	200

};

static struct qinit ptslrinit = {

	putq,

	ptslrserv,

	ptslopen,

	ptslclose,

	NULL,

	&ptslm_info,

	NULL

};

static struct qinit ptslwinit = {

	(int (*)())ptslwput,

	NULL,

	NULL,

	NULL,

	NULL,

	&ptslm_info,

	NULL

};

struct	streamtab ptysinfo = {

	&ptslrinit,

	&ptslwinit,

	NULL,

	NULL

};

static void	ptslreioctl(void *);

static void	ptslioctl(struct pty *, queue_t *, mblk_t *);

static void	pt_sendstop(struct pty *);

static void	ptcpollwakeup(struct pty *, int);

static int ptsl_info(dev_info_t *, ddi_info_cmd_t, void *, void **);

static int ptsl_attach(dev_info_t *, ddi_attach_cmd_t);

static dev_info_t *ptsl_dip;	/* for dev-to-dip conversions */

DDI_DEFINE_STREAM_OPS(ptsl_ops, nulldev, nulldev,

    ptsl_attach, nodev, nodev, ptsl_info, D_MP, &ptysinfo,

    ddi_quiesce_not_supported);

#include <sys/types.h>

#include <sys/conf.h>

#include <sys/param.h>

#include <sys/systm.h>

#include <sys/errno.h>

#include <sys/modctl.h>

/*

 * Module linkage information for the kernel.

 */

static struct modldrv modldrv = {

	&mod_driverops, /* Type of module.  This one is a pseudo driver */

	"tty pseudo driver slave 'ptsl'",

	&ptsl_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 char	*tty_banks = PTY_BANKS;

static char	*tty_digits = PTY_DIGITS;

/* ARGSUSED */

static int

ptsl_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)

{

	char	name[8];

	int	tty_num;

	char	*tty_digit = tty_digits;

	char	*tty_bank = tty_banks;

	for (tty_num = 0; tty_num < npty; tty_num++) {

		(void) sprintf(name, "tty%c%c", *tty_bank, *tty_digit);

		if (ddi_create_minor_node(devi, name, S_IFCHR,

		    tty_num, DDI_PSEUDO, NULL) == DDI_FAILURE) {

			ddi_remove_minor_node(devi, NULL);

			return (-1);

		}

		if (*(++tty_digit) == '\0') {

			tty_digit = tty_digits;

			if (*(++tty_bank) == '\0')

				break;

		}

	}

	ptsl_dip = devi;

	return (DDI_SUCCESS);

}

/* ARGSUSED */

static int

ptsl_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,

    void **result)

{

	int error;

	switch (infocmd) {

	case DDI_INFO_DEVT2DEVINFO:

		if (ptsl_dip == NULL) {

			error = DDI_FAILURE;

		} else {

			*result = (void *)ptsl_dip;

			error = DDI_SUCCESS;

		}

		break;

	case DDI_INFO_DEVT2INSTANCE:

		*result = (void *)0;

		error = DDI_SUCCESS;

		break;

	default:

		error = DDI_FAILURE;

	}

	return (error);

}

/*

 * Open the slave side of a pty.

 */

/*ARGSUSED*/

static int

ptslopen(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *cred)

{

	minor_t unit;

	dev_t dev = *devp;

	struct pty *pty;

	unit = getminor(dev);

	if (unit >= npty)

		return (ENXIO);

	pty = &pty_softc[unit];

	mutex_enter(&pty->ptc_lock);

	/*

	 * Block waiting for controller to open, unless this is a no-delay

	 * open.

	 */

again:

	if (pty->pt_ttycommon.t_writeq == NULL) {

		pty->pt_ttycommon.t_iflag = 0;

		pty->pt_ttycommon.t_cflag = (B38400 << IBSHIFT)|B38400|IFLAGS;

		pty->pt_ttycommon.t_iocpending = NULL;

		pty->pt_wbufcid = 0;

		pty->pt_ttycommon.t_size.ws_row = 0;

		pty->pt_ttycommon.t_size.ws_col = 0;

		pty->pt_ttycommon.t_size.ws_xpixel = 0;

		pty->pt_ttycommon.t_size.ws_ypixel = 0;

	} else if ((pty->pt_ttycommon.t_flags & TS_XCLUDE) &&

	    secpolicy_excl_open(cred) != 0) {

		mutex_exit(&pty->ptc_lock);

		return (EBUSY);

	}

	if (!(flag & (FNONBLOCK|FNDELAY)) &&

	    !(pty->pt_ttycommon.t_cflag & CLOCAL)) {

		if (!(pty->pt_flags & PF_CARR_ON)) {

			pty->pt_flags |= PF_WOPEN;

			if (!cv_wait_sig(&pty->pt_cv_flags, &pty->ptc_lock)) {

				pty->pt_flags &= ~PF_WOPEN;

				mutex_exit(&pty->ptc_lock);

				return (EINTR);

			}

			goto again;

		}

	}

	pty->pt_sdev = dev;

	q->q_ptr = WR(q)->q_ptr = pty;

	pty->pt_flags &= ~PF_SLAVEGONE;

	pty->pt_ttycommon.t_readq = pty->pt_ttycommon.t_writeq = NULL;

	/*

	 * Slave is ready to accept messages but master still can't send

	 * messages to the slave queue since it is not plumbed

	 * yet. So do qprocson() and finish slave initialization.

	 */

	mutex_exit(&pty->ptc_lock);

	qprocson(q);

	/*

	 * Now it is safe to send messages to q, so wakeup master possibly

	 * waiting for slave queue to finish open.

	 */

	mutex_enter(&pty->ptc_lock);

	/*

	 * queue has already been setup with a pointer to

	 * the stream head that is being referenced

	 */

	pty->pt_vnode = strq2vp(q);

	VN_RELE(pty->pt_vnode);

	pty->pt_ttycommon.t_readq = q;

	pty->pt_ttycommon.t_writeq = WR(q);

	/* tell master device that slave is ready for writing */

	if (pty->pt_flags & PF_CARR_ON)

		cv_broadcast(&pty->pt_cv_readq);

	mutex_exit(&pty->ptc_lock);

	return (0);

}

static int

ptslclose(queue_t *q, int flag, cred_t *cred)

{

	struct pty *pty;

	bufcall_id_t pt_wbufcid = 0;

#ifdef lint

	flag = flag;

	cred = cred;

#endif

	if ((pty = (struct pty *)q->q_ptr) == NULL)

		return (ENODEV);	/* already been closed once */

	/*

	 * Prevent the queues from being uses by master device.

	 * This should be done before qprocsoff or writer may attempt

	 * to use the slave queue after qprocsoff removed it from the stream and

	 * before entering mutex_enter().

	 */

	mutex_enter(&pty->ptc_lock);

	pty->pt_ttycommon.t_readq = NULL;

	pty->pt_ttycommon.t_writeq = NULL;

	while (pty->pt_flags & PF_IOCTL) {

		pty->pt_flags |= PF_WAIT;

		cv_wait(&pty->pt_cv_flags, &pty->ptc_lock);

	}

	pty->pt_vnode = NULL;

	mutex_exit(&pty->ptc_lock);

	qprocsoff(q);

	mutex_enter(&pty->ptc_lock);

	/*

	 * ptc_lock mutex is not dropped across

	 * the call to the routine ttycommon_close

	 */

	ttycommon_close(&pty->pt_ttycommon);

	/*

	 * Cancel outstanding "bufcall" request.

	 */

	if (pty->pt_wbufcid) {

		pt_wbufcid = pty->pt_wbufcid;

		pty->pt_wbufcid = 0;

	}

	/*

	 * Clear out all the slave-side state.

	 */

	pty->pt_flags &= ~(PF_WOPEN|PF_STOPPED|PF_NOSTOP);

	if (pty->pt_flags & PF_CARR_ON) {

		pty->pt_flags |= PF_SLAVEGONE;	/* let the controller know */

		ptcpollwakeup(pty, 0);	/* wake up readers/selectors */

		ptcpollwakeup(pty, FWRITE);	/* wake up writers/selectors */

		cv_broadcast(&pty->pt_cv_flags);

	}

	pty->pt_sdev = 0;

	q->q_ptr = WR(q)->q_ptr = NULL;

	mutex_exit(&pty->ptc_lock);

	if (pt_wbufcid)

		unbufcall(pt_wbufcid);

	return (0);

}

/*

 * Put procedure for write queue.

 * Respond to M_STOP, M_START, M_IOCTL, and M_FLUSH messages here;

 * queue up M_DATA messages for processing by the controller "read"

 * routine; discard everything else.

 */

static void

ptslwput(queue_t *q, mblk_t *mp)

{

	struct pty *pty;

	mblk_t *bp;

	pty = (struct pty *)q->q_ptr;

	mutex_enter(&pty->ptc_lock);

	switch (mp->b_datap->db_type) {

	case M_STOP:

		if (!(pty->pt_flags & PF_STOPPED)) {

			pty->pt_flags |= PF_STOPPED;

			pty->pt_send |= TIOCPKT_STOP;

			ptcpollwakeup(pty, 0);

		}

		freemsg(mp);

		break;

	case M_START:

		if (pty->pt_flags & PF_STOPPED) {

			pty->pt_flags &= ~PF_STOPPED;

			pty->pt_send = TIOCPKT_START;

			ptcpollwakeup(pty, 0);

		}

		ptcpollwakeup(pty, FREAD);	/* permit controller to read */

		freemsg(mp);

		break;

	case M_IOCTL:

		ptslioctl(pty, q, mp);

		break;

	case M_FLUSH:

		if (*mp->b_rptr & FLUSHW) {

			/*

			 * Set the "flush write" flag, so that we

			 * notify the controller if they're in packet

			 * or user control mode.

			 */

			if (!(pty->pt_send & TIOCPKT_FLUSHWRITE)) {

				pty->pt_send |= TIOCPKT_FLUSHWRITE;

				ptcpollwakeup(pty, 0);

			}

			/*

			 * Flush our write queue.

			 */

			flushq(q, FLUSHDATA);	/* XXX doesn't flush M_DELAY */

			*mp->b_rptr &= ~FLUSHW;	/* it has been flushed */

		}

		if (*mp->b_rptr & FLUSHR) {

			/*

			 * Set the "flush read" flag, so that we

			 * notify the controller if they're in packet

			 * mode.

			 */

			if (!(pty->pt_send & TIOCPKT_FLUSHREAD)) {

				pty->pt_send |= TIOCPKT_FLUSHREAD;

				ptcpollwakeup(pty, 0);

			}

			flushq(RD(q), FLUSHDATA);

			mutex_exit(&pty->ptc_lock);

			qreply(q, mp);	/* give the read queues a crack at it */

			return;

		} else

			freemsg(mp);

		break;

	case M_DATA:

		/*

		 * Throw away any leading zero-length blocks, and queue it up

		 * for the controller to read.

		 */

		if (pty->pt_flags & PF_CARR_ON) {

			bp = mp;

			while ((bp->b_wptr - bp->b_rptr) == 0) {

				mp = bp->b_cont;

				freeb(bp);

				if (mp == NULL) {

					mutex_exit(&pty->ptc_lock);

					return;	/* damp squib of a message */

				}

				bp = mp;

			}

			(void) putq(q, mp);

			ptcpollwakeup(pty, FREAD);	/* soup's on! */

		} else

			freemsg(mp);	/* nobody listening */

		break;

	case M_CTL:

		if ((*(int *)mp->b_rptr) == MC_CANONQUERY) {

			/*

			 * We're being asked whether we do canonicalization

			 * or not.  Send a reply back up indicating whether

			 * we do or not.

			 */

			(void) putctl1(RD(q), M_CTL,

			    (pty->pt_flags & PF_REMOTE) ?

			    MC_NOCANON : MC_DOCANON);

		}

		freemsg(mp);

		break;

	default:

		/*

		 * "No, I don't want a subscription to Chain Store Age,

		 * thank you anyway."

		 */

		freemsg(mp);

		break;

	}

	mutex_exit(&pty->ptc_lock);

}

/*

 * Retry an "ioctl", now that "bufcall" claims we may be able to allocate

 * the buffer we need.

 */

static void

ptslreioctl(void *arg)

{

	struct pty *pty = arg;

	queue_t *q;

	mblk_t *mp;

	mutex_enter(&pty->ptc_lock);

	/*

	 * The bufcall is no longer pending.

	 */

	if (pty->pt_wbufcid == 0) {

		mutex_exit(&pty->ptc_lock);

		return;

	}

	pty->pt_wbufcid = 0;

	if ((q = pty->pt_ttycommon.t_writeq) == NULL) {

		mutex_exit(&pty->ptc_lock);