/*
 * Copyright (c) 1982, 1986 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 *
 *	@(#)tty.c	7.18 (Berkeley) 10/27/89
 */

#include "param.h"
#include "systm.h"
#include "user.h"
#include "ioctl.h"

#define TTYDEFCHARS
#include "tty.h"
#undef TTYDEFCHARS

#include "proc.h"
#include "file.h"
#include "conf.h"
#include "dkstat.h"
#include "uio.h"
#include "kernel.h"
#include "vnode.h"

 */
/*ARGSUSED*/
ttioctl(tp, com, data, flag)
	register struct tty *tp;
	caddr_t data;
{
	extern int nldisp;

	int s, error;


	/*
	 * If the ioctl involves modification,
	 * hang if in the background.
	 */
	switch (com) {

	case TIOCSETD: 
	case TIOCFLUSH:
	/*case TIOCSPGRP:*/
	case TIOCSTI:
	case TIOCSWINSZ:
	case TIOCSETA:
	case TIOCSETAW:
	case TIOCSETAF:
/**** these get removed ****
	case TIOCSETAS:
	case TIOCSETAWS:
	case TIOCSETAFS:
/***************************/
		while (u.u_procp->p_pgid != tp->t_pgid &&
		   tp == u.u_ttyp &&
		   u.u_procp->p_pgrp->pg_jobc &&
		   (u.u_procp->p_flag&SVFORK) == 0 &&
		   !(u.u_procp->p_sigignore & sigmask(SIGTTOU)) &&
		   !(u.u_procp->p_sigmask & sigmask(SIGTTOU))) {
			pgsignal(u.u_procp->p_pgrp, SIGTTOU);

	case TIOCGETA: {
		struct termios *t = (struct termios *)data;

		bcopy(&tp->t_termios, t, sizeof(struct termios));
		break;
	}

	/*** THIS ALL GETS REMOVED ***/
	case JUNK_TIOCSETAS:
	case JUNK_TIOCSETAWS:
	case JUNK_TIOCSETAFS:
		((struct termios *)data)->c_cflag |= CIGNORE;
		switch(com) {
		case JUNK_TIOCSETAS:
			com = TIOCSETA;
			break;
		case JUNK_TIOCSETAWS:
			com = TIOCSETAW;
			break;
		case JUNK_TIOCSETAFS:
			com = TIOCSETAF;
			break;
		}
	/*******************************/
		/*FALLTHROGH*/
	case TIOCSETA:
	case TIOCSETAW:
	case TIOCSETAF: {
		register struct termios *t = (struct termios *)data;
		s = spltty();
		if (com == TIOCSETAW || com == TIOCSETAF) {
			ttywait(tp);
			if (com == TIOCSETAF);
				ttyflush(tp, FREAD);
		}

		if (!(t->c_cflag&CIGNORE)) {
			/*
			 * set device hardware
			 */
			if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
				splx(s);
				return (error);
			} else {
				if (!(tp->t_state&TS_CARR_ON) &&
				    (tp->t_cflag&CLOCAL) &&
				    !(t->c_cflag&CLOCAL)) {
					tp->t_state &= ~TS_ISOPEN;
					tp->t_state |= TS_WOPEN;
					ttwakeup(tp);
				}
				tp->t_cflag = t->c_cflag;
				tp->t_ispeed = t->c_ispeed;
				tp->t_ospeed = t->c_ospeed;
			}
			ttsetwater(tp);
		}
		if (com != TIOCSETAF) {




			if ((t->c_lflag&ICANON) != (tp->t_lflag&ICANON))
				if (t->c_lflag&ICANON) {	
					tp->t_lflag |= PENDIN;
					ttwakeup(tp);
				}
				else {
					struct clist tq;

		/* RETHINK - whether non-session leader
		 * can allocate a new ctty for a session.
		 */
		if (u.u_ttyp || 
		    (tp->t_session && tp->t_session != p->p_session) ||
		    (!tp->t_session && !SESS_LEADER(p)))
			return (EPERM);
		u.u_ttyp = tp;
		u.u_ttyd = tp->t_dev;
		if (tp->t_pgid == 0)
			tp->t_pgid = p->p_pgrp->pg_id;
		tp->t_session = p->p_session;
		break;
	}

	case TIOCSETC:
	case TIOCSLTC:
	case TIOCGLTC:
	case TIOCLBIS:
	case TIOCLBIC:
	case TIOCLSET:
	case TIOCLGET:
	case OTIOCGETD:
	case OTIOCSETD:
		return(ttcompat(tp, com, data, flag));
#endif

	default:
		return (-1);
	}
	return (0);

nullmodem(tp, flag)
	register struct tty *tp;
	int flag;
{
	
	if (flag)
		tp->t_state |= TS_CARR_ON;
	else {
		tp->t_state &= ~TS_CARR_ON;
		if ((tp->t_lflag & NOHANG) == 0)
			gsignal(tp->t_pgid, SIGHUP);
	}
	return (flag);
}

/*
 * reinput pending characters after state switch
 * call at spltty().
 */

	 * case statement is labeled ``endcase'', so goto
	 * it after a case match, or similar.
	 */
	/*
	 * Control chars which aren't controlled
	 * by ICANON, ISIG, or IXON.
	 */
	if (lflag&IEXTEN) {
		if (CCEQ(cc[VLNEXT],c)) {
			if (lflag&ECHO) {
				if (lflag&ECHOE)
					ttyout("^\b", tp);
				else
					ttyecho(c, tp);
			}

		}
		if (CCEQ(cc[VSUSP],c)) {
			if ((lflag&NOFLSH) == 0)
				ttyflush(tp, FREAD);
			ttyecho(c, tp);
			gsignal(tp->t_pgid, SIGTSTP);
			goto endcase;
		}
		if (CCEQ(cc[VINFO],c)) {
			ttyinfo(tp);
			goto endcase;
		}
	}
	/*
	 * Handle start/stop characters.
	 */
	if (iflag&IXON) {
		if (CCEQ(cc[VSTOP],c)) {

	/*
	 * From here on down canonical mode character
	 * processing takes place.
	 */
	/*
	 * erase (^H / ^?)
	 */
	if (CCEQ(cc[VERASE], c)) {
		if (tp->t_rawq.c_cc)
			ttyrub(unputc(&tp->t_rawq), tp);
		goto endcase;
	}
	/*
	 * kill (^U)
	 */

			}
			s = spltty();
			savecol = tp->t_col;
			tp->t_state |= TS_CNTTB;
			tp->t_lflag |= FLUSHO;
			tp->t_col = tp->t_rocol;
			cp = tp->t_rawq.c_cf;
			if (cp)
				c = *cp;	/* XXX FIX NEXTC */
			for (; cp; cp = nextc(&tp->t_rawq, cp, &c))
				ttyecho(c, tp);
			tp->t_lflag &= ~FLUSHO;
			tp->t_state &= ~TS_CNTTB;
			splx(s);
			/*
			 * savecol will now be length of the tab

	register int i;

	for (i = 0; table[i].sp_speed != -1; i++)
		if (table[i].sp_speed == speed)
			return(table[i].sp_code);
	return(-1);
}

/*
 * (^T)
 * Report on state of foreground process group.
 */
ttyinfo(tp)
	struct tty *tp;
{
	register struct proc *p;
	struct pgrp *pg = pgfind(tp->t_pgid);

	if (ttycheckoutq(tp,0) == 0) 
		return;
	if (pg == NULL)
		ttyprintf(tp, "kernel: no foreground process group\n");
	else if ((p = pg->pg_mem) == NULL)
		ttyprintf(tp, "kernel: empty process group: %d\n", 
			tp->t_pgid);
	else {
		int i = 0;
		for (; p != NULL; p = p->p_pgrpnxt) {
			ttyprintf(tp, 
			 "kernel: pid: %d state: %x wchan: %x ticks: %d\n",
				p->p_pid, p->p_stat, p->p_wchan, p->p_cpticks);
			if (++i > 6) {
				ttyprintf(tp, "kernel: more...\n");
				break;
			}
		}
	}
}

#define TOTTY	0x2	/* XXX should be in header */
/*VARARGS2*/
ttyprintf(tp, fmt, x1)
	register struct tty *tp;
	char *fmt;
	unsigned x1;
{
	prf(fmt, &x1, TOTTY, tp);
}