no longer allocate vnode table or name cache table

[unix-history] / usr / src / sys / kern / tty.c

diff --git a/usr/src/sys/kern/tty.c b/usr/src/sys/kern/tty.c
index f34580c..0b24a54 100644 (file)
--- a/usr/src/sys/kern/tty.c
+++ b/usr/src/sys/kern/tty.c
@@ -1,143 +1,151 @@
 /*
 /*

- * Copyright (c) 1982, 1986 Regents of the University of California.
+ * Copyright (c) 1982, 1986, 1990 Regents of the University of California.

  * All rights reserved.  The Berkeley software License Agreement
  * specifies the terms and conditions for redistribution.
  *
  * All rights reserved.  The Berkeley software License Agreement
  * specifies the terms and conditions for redistribution.
  *

- *     @(#)tty.c       7.3 (Berkeley) %G%
+ *     @(#)tty.c       7.21 (Berkeley) %G%

  */
 
  */
 

-#include "../machine/reg.h"
-

 #include "param.h"
 #include "systm.h"
 #include "param.h"
 #include "systm.h"

-#include "dir.h"

 #include "user.h"
 #include "ioctl.h"
 #include "user.h"
 #include "ioctl.h"

+#define TTYDEFCHARS

 #include "tty.h"
 #include "tty.h"

+#undef TTYDEFCHARS
+#define TTYDEFCHARS
+#include "ttydefaults.h"
+#undef TTYDEFCHARS
+#include "termios.h"

 #include "proc.h"
 #include "proc.h"

-#include "inode.h"

 #include "file.h"
 #include "conf.h"
 #include "file.h"
 #include "conf.h"

-#include "buf.h"

 #include "dkstat.h"
 #include "uio.h"
 #include "kernel.h"
 #include "dkstat.h"
 #include "uio.h"
 #include "kernel.h"

+#include "vnode.h"
+#include "syslog.h"
+
+#include "machine/reg.h"
+#include "syslog.h"
+
+/* symbolic sleep message strings */
+char ttyin[] = "ttyin";
+char ttyout[] = "ttyout";
+char ttopen[] = "ttopen";
+char ttclos[] = "ttclos";
+char ttybg[] = "ttybg";
+char ttybuf[] = "ttybuf";

 
 /*
  * Table giving parity for characters and indicating
 
 /*
  * Table giving parity for characters and indicating

- * character classes to tty driver.  In particular,
- * if the low 6 bits are 0, then the character needs
- * no special processing on output.
+ * character classes to tty driver. The 8th bit
+ * indicates parity, the 7th bit indicates the character
+ * is an alphameric or underscore (for ALTWERASE), and the 
+ * low 6 bits indicate delay type.  If the low 6 bits are 0
+ * then the character needs no special processing on output.

  */
 
 char partab[] = {
  */
 
 char partab[] = {

-       0001,0201,0201,0001,0201,0001,0001,0201,
-       0202,0004,0003,0201,0005,0206,0201,0001,
-       0201,0001,0001,0201,0001,0201,0201,0001,
-       0001,0201,0201,0001,0201,0001,0001,0201,
-       0200,0000,0000,0200,0000,0200,0200,0000,
-       0000,0200,0200,0000,0200,0000,0000,0200,
-       0000,0200,0200,0000,0200,0000,0000,0200,
-       0200,0000,0000,0200,0000,0200,0200,0000,
-       0200,0000,0000,0200,0000,0200,0200,0000,
-       0000,0200,0200,0000,0200,0000,0000,0200,
-       0000,0200,0200,0000,0200,0000,0000,0200,
-       0200,0000,0000,0200,0000,0200,0200,0000,
-       0000,0200,0200,0000,0200,0000,0000,0200,
-       0200,0000,0000,0200,0000,0200,0200,0000,
-       0200,0000,0000,0200,0000,0200,0200,0000,
-       0000,0200,0200,0000,0200,0000,0000,0201,
-
+       0001,0201,0201,0001,0201,0001,0001,0201,        /* nul - bel */
+       0202,0004,0003,0201,0005,0206,0201,0001,        /* bs - si */
+       0201,0001,0001,0201,0001,0201,0201,0001,        /* dle - etb */
+       0001,0201,0201,0001,0201,0001,0001,0201,        /* can - us */
+       0200,0000,0000,0200,0000,0200,0200,0000,        /* sp - ' */
+       0000,0200,0200,0000,0200,0000,0000,0200,        /* ( - / */
+       0100,0300,0300,0100,0300,0100,0100,0300,        /* 0 - 7 */
+       0300,0100,0000,0200,0000,0200,0200,0000,        /* 8 - ? */
+       0200,0100,0100,0300,0100,0300,0300,0100,        /* @ - G */
+       0100,0300,0300,0100,0300,0100,0100,0300,        /* H - O */
+       0100,0300,0300,0100,0300,0100,0100,0300,        /* P - W */
+       0300,0100,0100,0200,0000,0200,0200,0300,        /* X - _ */
+       0000,0300,0300,0100,0300,0100,0100,0300,        /* ` - g */
+       0300,0100,0100,0300,0100,0300,0300,0100,        /* h - o */
+       0300,0100,0100,0300,0100,0300,0300,0100,        /* p - w */
+       0100,0300,0300,0000,0200,0000,0000,0201,        /* x - del */

        /*
        /*

-        * 7 bit ascii ends with the last character above,
-        * but we contine through all 256 codes for the sake
-        * of the tty output routines which use special vax
-        * instructions which need a 256 character trt table.
+        * meta chars

         */
         */

-
-       0007,0007,0007,0007,0007,0007,0007,0007,
-       0007,0007,0007,0007,0007,0007,0007,0007,
-       0007,0007,0007,0007,0007,0007,0007,0007,
-       0007,0007,0007,0007,0007,0007,0007,0007,
-       0007,0007,0007,0007,0007,0007,0007,0007,
-       0007,0007,0007,0007,0007,0007,0007,0007,
-       0007,0007,0007,0007,0007,0007,0007,0007,
-       0007,0007,0007,0007,0007,0007,0007,0007,
-       0007,0007,0007,0007,0007,0007,0007,0007,
-       0007,0007,0007,0007,0007,0007,0007,0007,
-       0007,0007,0007,0007,0007,0007,0007,0007,
-       0007,0007,0007,0007,0007,0007,0007,0007,
-       0007,0007,0007,0007,0007,0007,0007,0007,
-       0007,0007,0007,0007,0007,0007,0007,0007,
-       0007,0007,0007,0007,0007,0007,0007,0007,
-       0007,0007,0007,0007,0007,0007,0007,0007
+       0001,0201,0201,0001,0201,0001,0001,0201,        /* nul - bel */
+       0202,0004,0003,0201,0005,0206,0201,0001,        /* bs - si */
+       0201,0001,0001,0201,0001,0201,0201,0001,        /* dle - etb */
+       0001,0201,0201,0001,0201,0001,0001,0201,        /* can - us */
+       0200,0000,0000,0200,0000,0200,0200,0000,        /* sp - ' */
+       0000,0200,0200,0000,0200,0000,0000,0200,        /* ( - / */
+       0100,0300,0300,0100,0300,0100,0100,0300,        /* 0 - 7 */
+       0300,0100,0000,0200,0000,0200,0200,0000,        /* 8 - ? */
+       0200,0100,0100,0300,0100,0300,0300,0100,        /* @ - G */
+       0100,0300,0300,0100,0300,0100,0100,0300,        /* H - O */
+       0100,0300,0300,0100,0300,0100,0100,0300,        /* P - W */
+       0300,0100,0100,0200,0000,0200,0200,0300,        /* X - _ */
+       0000,0300,0300,0100,0300,0100,0100,0300,        /* ` - g */
+       0300,0100,0100,0300,0100,0300,0300,0100,        /* h - o */
+       0300,0100,0100,0300,0100,0300,0300,0100,        /* p - w */
+       0100,0300,0300,0000,0200,0000,0000,0201,        /* x - del */

 };
 
 };
 

+extern struct tty *constty;            /* temporary virtual console */
+extern char partab[], maptab[];
+

 /*
 /*

- * Input mapping table-- if an entry is non-zero, when the
- * corresponding character is typed preceded by "\" the escape
- * sequence is replaced by the table value.  Mostly used for
- * upper-case only terminals.
+ * Is 'c' a line delimiter ("break" character)?

  */
  */

-char   maptab[] ={
-       000,000,000,000,000,000,000,000,
-       000,000,000,000,000,000,000,000,
-       000,000,000,000,000,000,000,000,
-       000,000,000,000,000,000,000,000,
-       000,'|',000,000,000,000,000,'`',
-       '{','}',000,000,000,000,000,000,
-       000,000,000,000,000,000,000,000,
-       000,000,000,000,000,000,000,000,
-       000,000,000,000,000,000,000,000,
-       000,000,000,000,000,000,000,000,
-       000,000,000,000,000,000,000,000,
-       000,000,000,000,000,000,'~',000,
-       000,'A','B','C','D','E','F','G',
-       'H','I','J','K','L','M','N','O',
-       'P','Q','R','S','T','U','V','W',
-       'X','Y','Z',000,000,000,000,000,
-};
+#define ttbreakc(c) ((c) == '\n' || ((c) == cc[VEOF] || \
+       (c) == cc[VEOL] || (c) == cc[VEOL2]) && (c) != _POSIX_VDISABLE)

 
 

-short  tthiwat[16] =
-   { 100,100,100,100,100,100,100,200,200,400,400,400,650,650,1300,2000 };
-short  ttlowat[16] =
-   {  30, 30, 30, 30, 30, 30, 30, 50, 50,120,120,120,125,125,125,125 };
+/*
+ * Debugging aids
+ */
+#define dprintf        if (tp->t_trace & TTRACE_IO)printf

 
 

-struct ttychars ttydefaults = {
-       CERASE, CKILL,  CINTR,  CQUIT,  CSTART, CSTOP,  CEOF,
-       CBRK,   CSUSP,  CDSUSP, CRPRNT, CFLUSH, CWERASE,CLNEXT
-};
+/*
+ * Is 'c' a line delimiter ("break" character)?
+ */
+#define ttbreakc(c) (c == '\n' || CCEQ(cc[VEOF], c) || \
+               CCEQ(cc[VEOL], c) || CCEQ(cc[VEOL2], c))

 
 ttychars(tp)
        struct tty *tp;
 {
 
 ttychars(tp)
        struct tty *tp;
 {

-
-       tp->t_chars = ttydefaults;
+       bcopy(ttydefchars, tp->t_cc, sizeof(ttydefchars));

 }
 
 /*
 }
 
 /*

+ *

  * Wait for output to drain, then flush input waiting.
  */
 ttywflush(tp)
  * Wait for output to drain, then flush input waiting.
  */
 ttywflush(tp)

-       register struct tty *tp;
+       struct tty *tp;

 {
 {

+       int error;

 
 

-       ttywait(tp);
-       ttyflush(tp, FREAD);
+       if ((error = ttywait(tp)) == 0)
+               ttyflush(tp, FREAD);
+       return (error);

 }
 
 }
 

+/*
+ * Wait for output to drain.
+ */
+/*
+ * Wait for output to drain.
+ */

 ttywait(tp)
        register struct tty *tp;
 {
 ttywait(tp)
        register struct tty *tp;
 {

-       register int s = spltty();
+       int error = 0, s = spltty();

 
        while ((tp->t_outq.c_cc || tp->t_state&TS_BUSY) &&
 
        while ((tp->t_outq.c_cc || tp->t_state&TS_BUSY) &&

-           tp->t_state&TS_CARR_ON) {
+           (tp->t_state&TS_CARR_ON || tp->t_cflag&CLOCAL) && 
+           tp->t_oproc) {

                (*tp->t_oproc)(tp);
                tp->t_state |= TS_ASLEEP;
                (*tp->t_oproc)(tp);
                tp->t_state |= TS_ASLEEP;

-               sleep((caddr_t)&tp->t_outq, TTOPRI);
+               if (error = tsleep((caddr_t)&tp->t_outq, TTOPRI | PCATCH,
+                   ttyout, 0))
+                       break;

        }
        splx(s);
        }
        splx(s);

+       return (error);

 }
 
 /*
 }
 
 /*


@@ -152,10 +160,10 @@ ttyflush(tp, rw)
        if (rw & FREAD) {
                while (getc(&tp->t_canq) >= 0)
                        ;
        if (rw & FREAD) {
                while (getc(&tp->t_canq) >= 0)
                        ;

-               wakeup((caddr_t)&tp->t_rawq);
+               ttwakeup(tp);

        }
        if (rw & FWRITE) {
        }
        if (rw & FWRITE) {

-               wakeup((caddr_t)&tp->t_outq);
+               wakeup((caddr_t)&tp->t_outq); /* XXX? what about selwakeup? */

                tp->t_state &= ~TS_TTSTOP;
                (*cdevsw[major(tp->t_dev)].d_stop)(tp, rw);
                while (getc(&tp->t_outq) >= 0)
                tp->t_state &= ~TS_TTSTOP;
                (*cdevsw[major(tp->t_dev)].d_stop)(tp, rw);
                while (getc(&tp->t_outq) >= 0)


@@ -189,8 +197,9 @@ ttyblock(tp)
         * Current input > threshold AND input is available to user program
         */
        if (x >= TTYHOG/2 && 
         * Current input > threshold AND input is available to user program
         */
        if (x >= TTYHOG/2 && 

-           ((tp->t_flags & (RAW|CBREAK)) || (tp->t_canq.c_cc > 0))) {
-               if (putc(tp->t_stopc, &tp->t_outq)==0) {
+           (!(tp->t_lflag&ICANON)) || (tp->t_canq.c_cc > 0) &&
+           tp->t_cc[VSTOP] != POSIX_V_DISABLE) {
+               if (putc(tp->t_cc[VSTOP], &tp->t_outq)==0) {

                        tp->t_state |= TS_TBLOCK;
                        ttstart(tp);
                }
                        tp->t_state |= TS_TBLOCK;
                        ttstart(tp);
                }


@@ -204,11 +213,13 @@ ttyblock(tp)
  * subroutine and it is called during a clock interrupt.
  */
 ttrstrt(tp)
  * subroutine and it is called during a clock interrupt.
  */
 ttrstrt(tp)

-       register struct tty *tp;
+       struct tty *tp;

 {
 
 {
 

+#ifdef DIAGNOSTIC

        if (tp == 0)
                panic("ttrstrt");
        if (tp == 0)
                panic("ttrstrt");

+#endif

        tp->t_state &= ~TS_TIMEOUT;
        ttstart(tp);
 }
        tp->t_state &= ~TS_TIMEOUT;
        ttstart(tp);
 }


@@ -220,15 +231,11 @@ ttrstrt(tp)
  * character, and after a timeout has finished.
  */
 ttstart(tp)
  * character, and after a timeout has finished.
  */
 ttstart(tp)

-       register struct tty *tp;
+       struct tty *tp;

 {
 {

-       register s;

 
 

-       s = spltty();
-       if ((tp->t_state & (TS_TIMEOUT|TS_TTSTOP|TS_BUSY)) == 0 &&
-           tp->t_oproc)                /* kludge for pty */
+       if (tp->t_oproc)                /* kludge for pty */

                (*tp->t_oproc)(tp);
                (*tp->t_oproc)(tp);

-       splx(s);

 }
 
 /*
 }
 
 /*


@@ -239,10 +246,9 @@ ttioctl(tp, com, data, flag)
        register struct tty *tp;
        caddr_t data;
 {
        register struct tty *tp;
        caddr_t data;
 {

-       int dev = tp->t_dev;

        extern int nldisp;
        extern int nldisp;

-       int s;
-       register int newflags;
+       int soft;
+       int s, error;

 
        /*
         * If the ioctl involves modification,
 
        /*
         * If the ioctl involves modification,


@@ -250,25 +256,37 @@ ttioctl(tp, com, data, flag)
         */
        switch (com) {
 
         */
        switch (com) {
 

-       case TIOCSETD:
+       case TIOCSETD: 
+       case TIOCFLUSH:
+       case TIOCSTI:
+       case TIOCSWINSZ:
+       case TIOCSETA:
+       case TIOCSETAW:
+       case TIOCSETAF:
+/**** these get removed ****
+       case TIOCSETAS:
+       case TIOCSETAWS:
+       case TIOCSETAFS:
+/***************************/
+#ifdef COMPAT_43

        case TIOCSETP:
        case TIOCSETN:
        case TIOCSETP:
        case TIOCSETN:

-       case TIOCFLUSH:

        case TIOCSETC:
        case TIOCSLTC:
        case TIOCSETC:
        case TIOCSLTC:

-       case TIOCSPGRP:

        case TIOCLBIS:
        case TIOCLBIC:
        case TIOCLSET:
        case TIOCLBIS:
        case TIOCLBIC:
        case TIOCLSET:

-       case TIOCSTI:
-       case TIOCSWINSZ:
-               while (tp->t_line == NTTYDISC &&
-                  u.u_procp->p_pgrp != tp->t_pgrp && tp == u.u_ttyp &&
+       case OTIOCSETD:
+#endif
+               while (isbackground(u.u_procp, tp) && 
+                  u.u_procp->p_pgrp->pg_jobc &&

                   (u.u_procp->p_flag&SVFORK) == 0 &&
                   (u.u_procp->p_flag&SVFORK) == 0 &&

-                  !(u.u_procp->p_sigignore & sigmask(SIGTTOU)) &&
-                  !(u.u_procp->p_sigmask & sigmask(SIGTTOU))) {
-                       gsignal(u.u_procp->p_pgrp, SIGTTOU);
-                       sleep((caddr_t)&lbolt, TTOPRI);
+                  (u.u_procp->p_sigignore & sigmask(SIGTTOU)) == 0 &&
+                  (u.u_procp->p_sigmask & sigmask(SIGTTOU)) == 0) {
+                       pgsignal(u.u_procp->p_pgrp, SIGTTOU);
+                       if (error = tsleep((caddr_t)&lbolt, TTOPRI | PCATCH,
+                           ttybg, 0))
+                               return (error);

                }
                break;
        }
                }
                break;
        }


@@ -286,22 +304,25 @@ ttioctl(tp, com, data, flag)
        /* set line discipline */
        case TIOCSETD: {
                register int t = *(int *)data;
        /* set line discipline */
        case TIOCSETD: {
                register int t = *(int *)data;

-               int error = 0;
+               dev_t dev = tp->t_dev;
+               dev_t dev = tp->t_dev;

 
 

-               if ((unsigned) t >= nldisp)
+               if ((unsigned)t >= nldisp)

                        return (ENXIO);
                if (t != tp->t_line) {
                        s = spltty();
                        (*linesw[tp->t_line].l_close)(tp);
                        error = (*linesw[t].l_open)(dev, tp);
                        if (error) {
                        return (ENXIO);
                if (t != tp->t_line) {
                        s = spltty();
                        (*linesw[tp->t_line].l_close)(tp);
                        error = (*linesw[t].l_open)(dev, tp);
                        if (error) {

-                               (void) (*linesw[tp->t_line].l_open)(dev, tp);
+                               (void)(*linesw[tp->t_line].l_open)(dev, tp);

                                splx(s);
                                return (error);
                        }
                        tp->t_line = t;
                        splx(s);
                }
                                splx(s);
                                return (error);
                        }
                        tp->t_line = t;
                        splx(s);
                }

+               if (tp->t_trace & TTRACE_STATE)
+                       ttytrace(com, tp);

                break;
        }
 
                break;
        }
 


@@ -314,9 +335,8 @@ ttioctl(tp, com, data, flag)
                tp->t_state &= ~TS_XCLUDE;
                break;
 
                tp->t_state &= ~TS_XCLUDE;
                break;
 

-       /* hang up line on last close */

        case TIOCHPCL:
        case TIOCHPCL:

-               tp->t_state |= TS_HUPCLS;
+               tp->t_cflag |= HUPCL;

                break;
 
        case TIOCFLUSH: {
                break;
 
        case TIOCFLUSH: {


@@ -330,6 +350,16 @@ ttioctl(tp, com, data, flag)
                break;
        }
 
                break;
        }
 

+       case FIOASYNC:
+               if (*(int *)data)
+                       tp->t_state |= TS_ASYNC;
+               else
+                       tp->t_state &= ~TS_ASYNC;
+               break;
+
+       case FIONBIO:
+               break;  /* XXX remove */
+

        /* return number of characters immediately available */
        case FIONREAD:
                *(off_t *)data = ttnread(tp);
        /* return number of characters immediately available */
        case FIONREAD:
                *(off_t *)data = ttnread(tp);


@@ -350,9 +380,9 @@ ttioctl(tp, com, data, flag)
 
        case TIOCSTART:
                s = spltty();
 
        case TIOCSTART:
                s = spltty();

-               if ((tp->t_state&TS_TTSTOP) || (tp->t_flags&FLUSHO)) {
+               if ((tp->t_state&TS_TTSTOP) || (tp->t_lflag&FLUSHO)) {

                        tp->t_state &= ~TS_TTSTOP;
                        tp->t_state &= ~TS_TTSTOP;

-                       tp->t_flags &= ~FLUSHO;
+                       tp->t_lflag &= ~FLUSHO;

                        ttstart(tp);
                }
                splx(s);
                        ttstart(tp);
                }
                splx(s);


@@ -364,139 +394,83 @@ ttioctl(tp, com, data, flag)
        case TIOCSTI:
                if (u.u_uid && (flag & FREAD) == 0)
                        return (EPERM);
        case TIOCSTI:
                if (u.u_uid && (flag & FREAD) == 0)
                        return (EPERM);

-               if (u.u_uid && u.u_ttyp != tp)
+               if (u.u_uid && !isctty(u.u_procp, tp))

                        return (EACCES);
                (*linesw[tp->t_line].l_rint)(*(char *)data, tp);
                break;
 
                        return (EACCES);
                (*linesw[tp->t_line].l_rint)(*(char *)data, tp);
                break;
 

-       case TIOCSETP:
-       case TIOCSETN: {
-               register struct sgttyb *sg = (struct sgttyb *)data;
-
-               tp->t_erase = sg->sg_erase;
-               tp->t_kill = sg->sg_kill;
-               tp->t_ispeed = sg->sg_ispeed;
-               tp->t_ospeed = sg->sg_ospeed;
-               newflags = (tp->t_flags&0xffff0000) | (sg->sg_flags&0xffff);
-               s = spltty();
-               if (tp->t_flags&RAW || newflags&RAW || com == TIOCSETP) {
-                       ttywait(tp);
-                       ttyflush(tp, FREAD);
-               } else if ((tp->t_flags&CBREAK) != (newflags&CBREAK)) {
-                       if (newflags&CBREAK) {
-                               struct clist tq;
-
-                               catq(&tp->t_rawq, &tp->t_canq);
-                               tq = tp->t_rawq;
-                               tp->t_rawq = tp->t_canq;
-                               tp->t_canq = tq;
-                       } else {
-                               tp->t_flags |= PENDIN;
-                               newflags |= PENDIN;
-                               ttwakeup(tp);
-                       }
-               }
-               tp->t_flags = newflags;
-               if (tp->t_flags&RAW) {
-                       tp->t_state &= ~TS_TTSTOP;
-                       ttstart(tp);
-               }
-               splx(s);
+       case TIOCGETA: {
+               struct termios *t = (struct termios *)data;
+               bcopy(&tp->t_termio, t, sizeof(struct termios));
+               if (tp->t_trace & TTRACE_STATE)
+                       ttytrace(com, tp);

                break;
        }
 
                break;
        }
 

-       /* send current parameters to user */
-       case TIOCGETP: {
-               register struct sgttyb *sg = (struct sgttyb *)data;
+               if (com == TIOCSETAF || com == TIOCSETAFS) 
+                       ttywflush(tp);
+               else {
+                       if (com == TIOCSETAW || com == TIOCSETAWS)
+                               ttywait(tp);
+                       if ((t->c_lflag&ICANON) != (tp->t_lflag&ICANON))
+                               if (t->c_lflag&ICANON) {        
+                                       tp->t_lflag |= PENDIN;
+                                       ttwakeup(tp);
+                               }
+                               else {
+                                       struct clist tq;

 
 

-               sg->sg_ispeed = tp->t_ispeed;
-               sg->sg_ospeed = tp->t_ospeed;
-               sg->sg_erase = tp->t_erase;
-               sg->sg_kill = tp->t_kill;
-               sg->sg_flags = tp->t_flags;
+                                       catq(&tp->t_rawq, &tp->t_canq);
+                                       tq = tp->t_rawq;
+                                       tp->t_rawq = tp->t_canq;
+                                       tp->t_canq = tq;
+                               }
+               }
+               tp->t_iflag = t->c_iflag;
+               tp->t_oflag = t->c_oflag;
+               tp->t_lflag = t->c_lflag;
+               bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
+               if (!soft) {
+                       tp->t_cflag = t->c_cflag;
+                       tp->t_ispeed = t->c_ispeed;
+                       tp->t_ospeed = t->c_ospeed;
+               }
+               tp->t_iflag = t->c_iflag;
+               tp->t_oflag = t->c_oflag;
+               tp->t_lflag = t->c_lflag;
+               bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
+               splx(s);
+               if (tp->t_trace & TTRACE_STATE)
+                       ttytrace(com, tp);

                break;
        }
 
                break;
        }
 

-       case FIONBIO:
-               if (*(int *)data)
-                       tp->t_state |= TS_NBIO;
-               else
-                       tp->t_state &= ~TS_NBIO;
-               break;
-
-       case FIOASYNC:
-               if (*(int *)data)
-                       tp->t_state |= TS_ASYNC;
-               else
-                       tp->t_state &= ~TS_ASYNC;
-               break;
-
-       case TIOCGETC:
-               bcopy((caddr_t)&tp->t_intrc, data, sizeof (struct tchars));
-               break;
-
-       case TIOCSETC:
-               bcopy(data, (caddr_t)&tp->t_intrc, sizeof (struct tchars));
-               break;
-
-       /* set/get local special characters */
-       case TIOCSLTC:
-               bcopy(data, (caddr_t)&tp->t_suspc, sizeof (struct ltchars));
-               break;
-
-       case TIOCGLTC:
-               bcopy((caddr_t)&tp->t_suspc, data, sizeof (struct ltchars));
-               break;
-

        /*
        /*

-        * Modify local mode word.
-        */
-       case TIOCLBIS:
-               tp->t_flags |= *(int *)data << 16;
-               break;
-
-       case TIOCLBIC:
-               tp->t_flags &= ~(*(int *)data << 16);
-               break;
-
-       case TIOCLSET:
-               tp->t_flags &= 0xffff;
-               tp->t_flags |= *(int *)data << 16;
-               break;
-
-       case TIOCLGET:
-               *(int *)data = ((unsigned)tp->t_flags) >> 16;
-               break;
-
-       /*
-        * Allow SPGRP only if tty is open for reading.
-        * Quick check: if we can find a process in the new pgrp,
-        * this user must own that process.
-        * SHOULD VERIFY THAT PGRP IS IN USE AND IS THIS USER'S.
+        * Set terminal process group.

         */
        case TIOCSPGRP: {
         */
        case TIOCSPGRP: {

-               struct proc *p;
-               int pgrp = *(int *)data;
+               register struct proc *p = u.u_procp;
+               register struct pgrp *pgrp = pgfind(*(int *)data);

 
 

-               if (u.u_uid && (flag & FREAD) == 0)
-                       return (EPERM);
-               p = pfind(pgrp);
-               if (p && p->p_pgrp == pgrp &&
-                   p->p_uid != u.u_uid && u.u_uid && !inferior(p))
+               if (!isctty(p, tp))
+                       return (ENOTTY);
+               else if (pgrp == NULL || pgrp->pg_session != p->p_session)

                        return (EPERM);
                tp->t_pgrp = pgrp;
                break;
        }
 
        case TIOCGPGRP:
                        return (EPERM);
                tp->t_pgrp = pgrp;
                break;
        }
 
        case TIOCGPGRP:

-               *(int *)data = tp->t_pgrp;
+               if (!isctty(u.u_procp, tp))
+                       return (ENOTTY);
+               *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0;

                break;
 
        case TIOCSWINSZ:
                if (bcmp((caddr_t)&tp->t_winsize, data,
                    sizeof (struct winsize))) {
                        tp->t_winsize = *(struct winsize *)data;
                break;
 
        case TIOCSWINSZ:
                if (bcmp((caddr_t)&tp->t_winsize, data,
                    sizeof (struct winsize))) {
                        tp->t_winsize = *(struct winsize *)data;

-                       gsignal(tp->t_pgrp, SIGWINCH);
+                       pgsignal(tp->t_pgrp, SIGWINCH);

                }
                break;
 
                }
                break;
 


@@ -504,21 +478,105 @@ ttioctl(tp, com, data, flag)
                *(struct winsize *)data = tp->t_winsize;
                break;
 
                *(struct winsize *)data = tp->t_winsize;
                break;
 

+       case TIOCCONS:
+               if (*(int *)data) {
+                       if (constty != NULL)
+                               return (EBUSY);
+#ifndef        UCONSOLE
+                       if (error = suser(u.u_cred, &u.u_acflag))
+                               return (error);
+#endif
+                       constty = tp;
+               } else if (tp == constty)
+                       constty = NULL;
+               break;
+
+#ifdef COMPAT_43
+       case TIOCGETP:
+       case TIOCSETP:
+       case TIOCSETN:
+       case TIOCGETC:
+       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
+
+       /* allow old ioctls for now */
+       case TIOCGETP:
+       case TIOCSETP:
+       case TIOCSETN:
+       case TIOCGETC:
+       case TIOCSETC:
+       case TIOCSLTC:
+       case TIOCGLTC:
+       case TIOCLBIS:
+       case TIOCLBIC:
+       case TIOCLSET:
+       case TIOCLGET:
+               return(ottioctl(tp, com, data, flag));
+

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

+/*
+ * DEBUG - to be removed
+ */
+ttytrace(ioc, tp)
+       struct tty *tp;
+{
+       register u_char *cc = tp->t_cc;
+       char comm[MAXCOMLEN+1];
+       static int seq = 0;
+       
+       bcopy(u.u_comm, comm, MAXCOMLEN+1);
+       comm[MAXCOMLEN] = '\0';
+
+       /* trace changes to line disciplines */
+       if (ioc == TIOCSETD) {
+               log(LOG_LOCAL4|LOG_DEBUG, "%s:%x:%x:%x:%x\n",
+                   comm, ioc, u.u_procp->p_pid, tp->t_dev, tp->t_line);
+               return;
+       }
+
+       /*
+        * format for the trace record is:
+        *
+        * u_comm:ioctl:pid:dev_t:ldisc:iflag:oflag:lflag:cflag:ispeed:
+        *    ospeed:cc's...:seq
+        *
+        * u_comm is a string and all other values are hex. "cc's..."
+        * stands for control chars 0 through NCC-1.  seq is a sequence #
+        * to force syslogd to log every entry (rather than hold them to
+        * print "last message repeated...".
+        */
+       log(LOG_LOCAL4|LOG_DEBUG, "%s:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x\n",
+               comm, ioc, u.u_procp->p_pid, tp->t_dev, tp->t_line,
+               tp->t_iflag, tp->t_oflag, tp->t_lflag, tp->t_cflag,
+               tp->t_ispeed, tp->t_ospeed, cc[0], cc[1], cc[2], cc[3],
+               cc[4], cc[5], cc[6], cc[7], cc[8], cc[9], cc[10], cc[11],
+               cc[12], cc[13], cc[14], cc[15], cc[16], cc[17], cc[18], 
+               cc[19], seq++);
+}
+

 ttnread(tp)
        struct tty *tp;
 {
        int nread = 0;
 
 ttnread(tp)
        struct tty *tp;
 {
        int nread = 0;
 

-       if (tp->t_flags & PENDIN)
+       if (tp->t_lflag & PENDIN)

                ttypend(tp);
        nread = tp->t_canq.c_cc;
                ttypend(tp);
        nread = tp->t_canq.c_cc;

-       if (tp->t_flags & (RAW|CBREAK))
+       if (tp->t_lflag & ICANON == 0)

                nread += tp->t_rawq.c_cc;
        return (nread);
 }
                nread += tp->t_rawq.c_cc;
        return (nread);
 }


@@ -535,7 +593,8 @@ ttselect(dev, rw)
 
        case FREAD:
                nread = ttnread(tp);
 
        case FREAD:
                nread = ttnread(tp);

-               if (nread > 0 || (tp->t_state & TS_CARR_ON) == 0)
+               if (nread > 0 || 
+                  ((tp->t_cflag&CLOCAL) == 0 && (tp->t_state&TS_CARR_ON) == 0))

                        goto win;
                if (tp->t_rsel && tp->t_rsel->p_wchan == (caddr_t)&selwait)
                        tp->t_state |= TS_RCOLL;
                        goto win;
                if (tp->t_rsel && tp->t_rsel->p_wchan == (caddr_t)&selwait)
                        tp->t_state |= TS_RCOLL;


@@ -544,7 +603,7 @@ ttselect(dev, rw)
                break;
 
        case FWRITE:
                break;
 
        case FWRITE:

-               if (tp->t_outq.c_cc <= TTLOWAT(tp))
+               if (tp->t_outq.c_cc <= tp->t_lowat)

                        goto win;
                if (tp->t_wsel && tp->t_wsel->p_wchan == (caddr_t)&selwait)
                        tp->t_state |= TS_WCOLL;
                        goto win;
                if (tp->t_wsel && tp->t_wsel->p_wchan == (caddr_t)&selwait)
                        tp->t_state |= TS_WCOLL;


@@ -561,30 +620,22 @@ win:
 
 /*
  * Initial open of tty, or (re)entry to line discipline.
 
 /*
  * Initial open of tty, or (re)entry to line discipline.

- * Establish a process group for distribution of
- * quits and interrupts from the tty.

  */
 ttyopen(dev, tp)
        dev_t dev;
        register struct tty *tp;
 {
  */
 ttyopen(dev, tp)
        dev_t dev;
        register struct tty *tp;
 {

-       register struct proc *pp;

 
 

-       pp = u.u_procp;

        tp->t_dev = dev;
        tp->t_dev = dev;

-       if (pp->p_pgrp == 0) {
-               u.u_ttyp = tp;
-               u.u_ttyd = dev;
-               if (tp->t_pgrp == 0)
-                       tp->t_pgrp = pp->p_pid;
-               pp->p_pgrp = tp->t_pgrp;
-       }
+

        tp->t_state &= ~TS_WOPEN;
        if ((tp->t_state & TS_ISOPEN) == 0) {
                tp->t_state |= TS_ISOPEN;
                bzero((caddr_t)&tp->t_winsize, sizeof(tp->t_winsize));
        tp->t_state &= ~TS_WOPEN;
        if ((tp->t_state & TS_ISOPEN) == 0) {
                tp->t_state |= TS_ISOPEN;
                bzero((caddr_t)&tp->t_winsize, sizeof(tp->t_winsize));

-               if (tp->t_line != NTTYDISC)
-                       ttywflush(tp);
+               /*
+                * CHANGE: used to do a ttywflush() if it was the
+                *  old (old) line discipline.
+                */

        }
        return (0);
 }
        }
        return (0);
 }


@@ -597,7 +648,6 @@ ttylclose(tp)
 {
 
        ttywflush(tp);
 {
 
        ttywflush(tp);

-       tp->t_line = 0;

 }
 
 /*
 }
 
 /*


@@ -606,10 +656,13 @@ ttylclose(tp)
 ttyclose(tp)
        register struct tty *tp;
 {
 ttyclose(tp)
        register struct tty *tp;
 {

-
+       if (constty == tp)
+               constty = NULL;

        ttyflush(tp, FREAD|FWRITE);
        ttyflush(tp, FREAD|FWRITE);

-       tp->t_pgrp = 0;
+       tp->t_session = NULL;
+       tp->t_pgrp = NULL;

        tp->t_state = 0;
        tp->t_state = 0;

+       return (0);

 }
 
 /*
 }
 
 /*


@@ -621,7 +674,7 @@ ttymodem(tp, flag)
        register struct tty *tp;
 {
 
        register struct tty *tp;
 {
 

-       if ((tp->t_state&TS_WOPEN) == 0 && (tp->t_flags & MDMBUF)) {
+       if ((tp->t_state&TS_WOPEN) == 0 && (tp->t_lflag & MDMBUF)) {

                /*
                 * MDMBUF: do flow control according to carrier flag
                 */
                /*
                 * MDMBUF: do flow control according to carrier flag
                 */


@@ -638,9 +691,9 @@ ttymodem(tp, flag)
                 */
                tp->t_state &= ~TS_CARR_ON;
                if (tp->t_state & TS_ISOPEN) {
                 */
                tp->t_state &= ~TS_CARR_ON;
                if (tp->t_state & TS_ISOPEN) {

-                       if ((tp->t_flags & NOHANG) == 0) {
-                               gsignal(tp->t_pgrp, SIGHUP);
-                               gsignal(tp->t_pgrp, SIGCONT);
+                       if ((tp->t_lflag & NOHANG) == 0) {
+                               pgsignal(tp->t_pgrp, SIGHUP);
+                               pgsignal(tp->t_pgrp, SIGCONT);

                                ttyflush(tp, FREAD|FWRITE);
                                return (0);
                        }
                                ttyflush(tp, FREAD|FWRITE);
                                return (0);
                        }


@@ -650,7 +703,7 @@ ttymodem(tp, flag)
                 * Carrier now on.
                 */
                tp->t_state |= TS_CARR_ON;
                 * Carrier now on.
                 */
                tp->t_state |= TS_CARR_ON;

-               wakeup((caddr_t)&tp->t_rawq);
+               ttwakeup(tp);

        }
        return (1);
 }
        }
        return (1);
 }


@@ -666,8 +719,11 @@ nullmodem(tp, flag)
        
        if (flag)
                tp->t_state |= TS_CARR_ON;
        
        if (flag)
                tp->t_state |= TS_CARR_ON;

-       else
+       else {

                tp->t_state &= ~TS_CARR_ON;
                tp->t_state &= ~TS_CARR_ON;

+               if ((tp->t_lflag & NOHANG) == 0)
+                       pgsignal(tp->t_pgrp, SIGHUP);
+       }

        return (flag);
 }
 
        return (flag);
 }
 


@@ -681,7 +737,7 @@ ttypend(tp)
        struct clist tq;
        register c;
 
        struct clist tq;
        register c;
 

-       tp->t_flags &= ~PENDIN;
+       tp->t_lflag &= ~PENDIN;

        tp->t_state |= TS_TYPEN;
        tq = tp->t_rawq;
        tp->t_rawq.c_cc = 0;
        tp->t_state |= TS_TYPEN;
        tq = tp->t_rawq;
        tp->t_rawq.c_cc = 0;


@@ -692,6 +748,8 @@ ttypend(tp)
 }
 
 /*
 }
 
 /*

+ *
+ *

  * Place a character on raw TTY input queue,
  * putting in delimiters and waking up top
  * half as needed.  Also echo if required.
  * Place a character on raw TTY input queue,
  * putting in delimiters and waking up top
  * half as needed.  Also echo if required.


@@ -702,52 +760,71 @@ ttyinput(c, tp)
        register c;
        register struct tty *tp;
 {
        register c;
        register struct tty *tp;
 {

-       register int t_flags = tp->t_flags;
-       int i;
+       register int iflag = tp->t_iflag;
+       register int lflag = tp->t_lflag;
+       register u_char *cc = tp->t_cc;
+       int i, err;

 
        /*
         * If input is pending take it first.
         */
 
        /*
         * If input is pending take it first.
         */

-       if (t_flags&PENDIN)
+       if (lflag&PENDIN)

                ttypend(tp);
                ttypend(tp);

+       /*
+        * Gather stats.
+        */
+

        tk_nin++;
        tk_nin++;

-       c &= 0377;
+       if (lflag&ICANON) {
+               tk_cancc++;
+               tp->t_cancc++;
+       } else {
+               tk_rawcc++;
+               tp->t_rawcc++;
+       }
+       /*
+        * Handle exceptional conditions (break, parity, framing).
+        */
+       if (err = (c&TTY_ERRORMASK)) {
+               c &= TTY_CHARMASK;
+               if (err&TTY_FE && !c) {         /* break */
+                       if (iflag&IGNBRK)
+                               goto endcase;
+                       else if (iflag&BRKINT && lflag&ISIG && 
+                               (cc[VINTR] != POSIX_V_DISABLE))
+                               c = cc[VINTR];
+                       else
+                               c = 0;
+               } else if ((err&TTY_PE && iflag&INPCK) || err&TTY_FE) {
+                       if (iflag&IGNPAR)
+                               goto endcase;
+                       else if (iflag&PARMRK) {
+                               ttyinput(0377, tp);
+                               ttyinput(0, tp);
+                       } else
+                               c = 0;
+               }
+       }
+       dprintf("<%o>\n", c);

 
        /*
         * In tandem mode, check high water mark.
         */
 
        /*
         * In tandem mode, check high water mark.
         */

-       if (t_flags&TANDEM)
+       if (iflag&IXOFF)

                ttyblock(tp);
 
                ttyblock(tp);
 

-       if (t_flags&RAW) {
-               /*
-                * Raw mode, just put character
-                * in input q w/o interpretation.
-                */
-               if (tp->t_rawq.c_cc > TTYHOG) 
-                       ttyflush(tp, FREAD|FWRITE);
-               else {
-                       if (putc(c, &tp->t_rawq) >= 0)
-                               ttwakeup(tp);
-                       ttyecho(c, tp);
-               }
-               goto endcase;
-       }
-

        /*
        /*

-        * Ignore any high bit added during
-        * previous ttyinput processing.
+        * In tandem mode, check high water mark.

         */
         */

-       if ((tp->t_state&TS_TYPEN) == 0 && (t_flags&PASS8) == 0)
+       if ((tp->t_state&TS_TYPEN) == 0 && (iflag&ISTRIP))

                c &= 0177;
        /*
         * Check for literal nexting very first
         */
        if (tp->t_state&TS_LNCH) {
                c &= 0177;
        /*
         * Check for literal nexting very first
         */
        if (tp->t_state&TS_LNCH) {

-               c |= 0200;
+               c |= TTY_QUOTE;

                tp->t_state &= ~TS_LNCH;
        }
                tp->t_state &= ~TS_LNCH;
        }

-

        /*
         * Scan for special characters.  This code
         * is really just a big case statement with
        /*
         * Scan for special characters.  This code
         * is really just a big case statement with


@@ -755,112 +832,140 @@ ttyinput(c, tp)
         * case statement is labeled ``endcase'', so goto
         * it after a case match, or similar.
         */
         * case statement is labeled ``endcase'', so goto
         * it after a case match, or similar.
         */

-       if (tp->t_line == NTTYDISC) {
-               if (c == tp->t_lnextc) {
-                       if (t_flags&ECHO)
-                               ttyout("^\b", tp);
+
+       /*
+        * Extensions to POSIX input modes which aren't controlled
+        * by ICANON, ISIG, or IXON.
+        */
+       if (iflag&IEXTEN) {
+               if (CCEQ(cc[VLNEXT],c) && (iflag&ISTRIP)) {
+                       if (lflag&ECHO)
+                               ttyout("^\b", tp); /*XXX - presumes too much */

                        tp->t_state |= TS_LNCH;
                        goto endcase;
                }
                        tp->t_state |= TS_LNCH;
                        goto endcase;
                }

-               if (c == tp->t_flushc) {
-                       if (t_flags&FLUSHO)
-                               tp->t_flags &= ~FLUSHO;
+               if (CCEQ(cc[VFLUSHO],c)) {
+                       if (lflag&FLUSHO)
+                               tp->t_lflag &= ~FLUSHO;

                        else {
                                ttyflush(tp, FWRITE);
                                ttyecho(c, tp);
                                if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
                                        ttyretype(tp);
                        else {
                                ttyflush(tp, FWRITE);
                                ttyecho(c, tp);
                                if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
                                        ttyretype(tp);

-                               tp->t_flags |= FLUSHO;
+                               tp->t_lflag |= FLUSHO;

                        }
                        goto startoutput;
                }
                        }
                        goto startoutput;
                }

-               if (c == tp->t_suspc) {
-                       if ((t_flags&NOFLSH) == 0)
+       }
+
+       /*
+        * Signals.
+        */
+       if (lflag&ISIG) {
+               if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
+                       if ((lflag&NOFLSH) == 0)
+                               ttyflush(tp, FREAD|FWRITE);
+                       ttyecho(c, tp);
+                       gsignal(tp->t_pgrp, CCEQ(cc[VINTR],c) ? 
+                               SIGINT : SIGQUIT);
+                       goto endcase;
+               }
+               if (CCEQ(cc[VSUSP],c)) {
+                       if ((lflag&NOFLSH) == 0)

                                ttyflush(tp, FREAD);
                        ttyecho(c, tp);
                                ttyflush(tp, FREAD);
                        ttyecho(c, tp);

-                       gsignal(tp->t_pgrp, SIGTSTP);
+                       pgsignal(tp->t_pgrp, SIGTSTP);
+                       goto endcase;
+               }
+               if (CCEQ(cc[VINFO], c)) {
+                       pgsignal(tp->t_pgrp, SIGINFO);
+                       if ((lflag&NOKERNINFO) == 0)
+                               ttyinfo(tp);

                        goto endcase;
                }
        }
                        goto endcase;
                }
        }

-

        /*
         * Handle start/stop characters.
         */
        /*
         * Handle start/stop characters.
         */

-       if (c == tp->t_stopc) {
-               if ((tp->t_state&TS_TTSTOP) == 0) {
-                       tp->t_state |= TS_TTSTOP;
-                       (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
-                       return;
+       if (iflag&IXON) {
+               if (CCEQ(cc[VSTOP],c)) {
+                       if ((tp->t_state&TS_TTSTOP) == 0) {
+                               tp->t_state |= TS_TTSTOP;
+                               (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
+                               return;
+                       }
+                       if (!CCEQ(cc[VSTART], c))
+                               return;
+                       /* 
+                        * if VSTART == VSTOP we toggle 
+                        */
+                       goto endcase;

                }
                }

-               if (c != tp->t_startc)
-                       return;
-               goto endcase;
+               if (CCEQ(cc[VSTART], c))
+                       goto restartoutput;

        }
        }

-       if (c == tp->t_startc)
-               goto restartoutput;
-

        /*
        /*

-        * Look for interrupt/quit chars.
+        * IGNCR, ICRNL, & INLCR

         */
         */

-       if (c == tp->t_intrc || c == tp->t_quitc) {
-               if ((t_flags&NOFLSH) == 0)
-                       ttyflush(tp, FREAD|FWRITE);
-               ttyecho(c, tp);
-               gsignal(tp->t_pgrp, c == tp->t_intrc ? SIGINT : SIGQUIT);
-               goto endcase;
-       }
-
-       if (tp->t_flags & LCASE && c <= 0177) {
-               if (tp->t_state&TS_BKSL) {
-                       ttyrub(unputc(&tp->t_rawq), tp);
-                       if (maptab[c])
-                               c = maptab[c];
-                       c |= 0200;
-                       tp->t_state &= ~(TS_BKSL|TS_QUOT);
-               } else if (c >= 'A' && c <= 'Z')
-                       c += 'a' - 'A';
-               else if (c == '\\')
-                       tp->t_state |= TS_BKSL;
+       if (c == '\r') {
+               if (iflag&IGNCR)
+                       goto endcase;
+               else if (iflag&ICRNL)
+                       c = '\n';

        }
        }

-
+       else if (c == '\n' && iflag&INLCR)
+               c = '\r';
+       else if (c == '\n' && iflag&INLCR)
+               c = '\r';

        /*
        /*

-        * Cbreak mode, don't process line editing
+        * Non canonical mode, don't process line editing

         * characters; check high water mark for wakeup.
         * characters; check high water mark for wakeup.

+        * 
+        * 

         */
         */

-       if (t_flags&CBREAK) {
+       if (!(lflag&ICANON)) {

                if (tp->t_rawq.c_cc > TTYHOG) {
                if (tp->t_rawq.c_cc > TTYHOG) {

-                       if (tp->t_outq.c_cc < TTHIWAT(tp) &&
-                           tp->t_line == NTTYDISC)
-                               (void) ttyoutput(CTRL(g), tp);
-               } else if (putc(c, &tp->t_rawq) >= 0) {
-                       ttwakeup(tp);
-                       ttyecho(c, tp);
+                       if (iflag&IMAXBEL) {
+                               if (tp->t_outq.c_cc < tp->t_hiwat)
+                                       (void) ttyoutput(CTRL('g'), tp);
+                       } else
+                               ttyflush(tp, FREAD | FWRITE);
+               } else {
+                       if (putc(c, &tp->t_rawq) >= 0) {
+                               ttwakeup(tp);
+                               ttyecho(c, tp);
+                       }

                }
                goto endcase;
        }
                }
                goto endcase;
        }

-

        /*
        /*

-        * From here on down cooked mode character
+        * From here on down canonical mode character

         * processing takes place.
         */
         * processing takes place.
         */

-       if ((tp->t_state&TS_QUOT) &&
-           (c == tp->t_erase || c == tp->t_kill)) {
-               ttyrub(unputc(&tp->t_rawq), tp);
-               c |= 0200;
-       }
-       if (c == tp->t_erase) {
+
+       /* 
+        * Oldstyle quoting of erase, kill, and eof chars.
+        *
+        * Historically is '\' , but can be changed (read: disabled)
+        * with the VQUOTE subscript.
+        */
+
+       /*
+        * erase (^H / ^?)
+        */
+       if (CCEQ(cc[VERASE], c)) {

                if (tp->t_rawq.c_cc)
                        ttyrub(unputc(&tp->t_rawq), tp);
                goto endcase;
        }
                if (tp->t_rawq.c_cc)
                        ttyrub(unputc(&tp->t_rawq), tp);
                goto endcase;
        }

-       if (c == tp->t_kill) {
-               if (t_flags&CRTKIL &&
-                   tp->t_rawq.c_cc == tp->t_rocount) {
+               if (lflag&ECHOKE && tp->t_rawq.c_cc == tp->t_rocount &&
+                   (lflag&ECHOPRT) == 0) {

                        while (tp->t_rawq.c_cc)
                                ttyrub(unputc(&tp->t_rawq), tp);
                } else {
                        ttyecho(c, tp);
                        while (tp->t_rawq.c_cc)
                                ttyrub(unputc(&tp->t_rawq), tp);
                } else {
                        ttyecho(c, tp);

-                       ttyecho('\n', tp);
+                       if (lflag&ECHOK || lflag&ECHOKE)
+                               ttyecho('\n', tp);

                        while (getc(&tp->t_rawq) > 0)
                                ;
                        tp->t_rocount = 0;
                        while (getc(&tp->t_rawq) > 0)
                                ;
                        tp->t_rocount = 0;


@@ -868,68 +973,68 @@ ttyinput(c, tp)
                tp->t_state &= ~TS_LOCAL;
                goto endcase;
        }
                tp->t_state &= ~TS_LOCAL;
                goto endcase;
        }

-

        /*
        /*

-        * New line discipline,
-        * check word erase/reprint line.
+        * word erase (^W)

         */
         */

-       if (tp->t_line == NTTYDISC) {
-               if (c == tp->t_werasc) {
-                       if (tp->t_rawq.c_cc == 0)
-                               goto endcase;
-                       do {
-                               c = unputc(&tp->t_rawq);
-                               if (c != ' ' && c != '\t')
-                                       goto erasenb;
-                               ttyrub(c, tp);
-                       } while (tp->t_rawq.c_cc);
-                       goto endcase;
-       erasenb:
-                       do {
-                               ttyrub(c, tp);
-                               if (tp->t_rawq.c_cc == 0)
-                                       goto endcase;
-                               c = unputc(&tp->t_rawq);
-                       } while (c != ' ' && c != '\t');
-                       (void) putc(c, &tp->t_rawq);
-                       goto endcase;
-               }
-               if (c == tp->t_rprntc) {
-                       ttyretype(tp);
-                       goto endcase;
-               }
+                       c = unputc(&tp->t_rawq);
+               } while (c != ' ' && c != '\t');
+               (void) putc(c, &tp->t_rawq);
+               goto endcase;
+       }
+       /*
+        * reprint line (^R)
+        */
+       if (CCEQ(cc[VREPRINT], c)) {
+               ttyretype(tp);
+               goto endcase;
+       }
+       /*
+        * reprint line (^R)
+        */
+       if (CCEQ(cc[VREPRINT], c)) {
+               ttyretype(tp);
+               goto endcase;

        }
        }

-

        /*
         * Check for input buffer overflow
         */
        if (tp->t_rawq.c_cc+tp->t_canq.c_cc >= TTYHOG) {
        /*
         * Check for input buffer overflow
         */
        if (tp->t_rawq.c_cc+tp->t_canq.c_cc >= TTYHOG) {

-               if (tp->t_line == NTTYDISC)
-                       (void) ttyoutput(CTRL(g), tp);
+               if (iflag&IMAXBEL) {
+                       if (tp->t_outq.c_cc < TTHIWAT(tp))
+                               (void) ttyoutput(CTRL('g'), tp);
+               } else
+                       ttyflush(tp, FREAD | FWRITE);

                goto endcase;
        }
                goto endcase;
        }

-

        /*
         * Put data char in q for user and
         * wakeup on seeing a line delimiter.
         */
        if (putc(c, &tp->t_rawq) >= 0) {
        /*
         * Put data char in q for user and
         * wakeup on seeing a line delimiter.
         */
        if (putc(c, &tp->t_rawq) >= 0) {

-               if (ttbreakc(c, tp)) {
+               if (ttbreakc(c)) {

                        tp->t_rocount = 0;
                        catq(&tp->t_rawq, &tp->t_canq);
                        ttwakeup(tp);
                } else if (tp->t_rocount++ == 0)
                        tp->t_rocol = tp->t_col;
                        tp->t_rocount = 0;
                        catq(&tp->t_rawq, &tp->t_canq);
                        ttwakeup(tp);
                } else if (tp->t_rocount++ == 0)
                        tp->t_rocol = tp->t_col;

-               tp->t_state &= ~TS_QUOT;
-               if (c == '\\')
-                       tp->t_state |= TS_QUOT;
+               if (CCEQ(cc[VQUOTE], c) && (iflag&ISTRIP))
+                       tp->t_state |= TS_QUOT; /* '\' escape */

                if (tp->t_state&TS_ERASE) {
                if (tp->t_state&TS_ERASE) {

+                       /*
+                        * end of prterase \.../
+                        */
+                       /*
+                        * end of prterase \.../
+                        */

                        tp->t_state &= ~TS_ERASE;
                        (void) ttyoutput('/', tp);
                }
                i = tp->t_col;
                ttyecho(c, tp);
                        tp->t_state &= ~TS_ERASE;
                        (void) ttyoutput('/', tp);
                }
                i = tp->t_col;
                ttyecho(c, tp);

-               if (c == tp->t_eofc && t_flags&ECHO) {
+               if (CCEQ(cc[VEOF], c) && lflag&ECHO) {
+                       /*
+                        * Place the cursor over the '^' of the ^D.
+                        */

                        i = MIN(2, tp->t_col - i);
                        while (i > 0) {
                                (void) ttyoutput('\b', tp);
                        i = MIN(2, tp->t_col - i);
                        while (i > 0) {
                                (void) ttyoutput('\b', tp);


@@ -939,15 +1044,15 @@ ttyinput(c, tp)
        }
 endcase:
        /*
        }
 endcase:
        /*

-        * If DEC-style start/stop is enabled don't restart
-        * output until seeing the start character.
+        * IXANY means allow any character to restart output.

         */
         */

-       if (t_flags&DECCTQ && tp->t_state&TS_TTSTOP &&
-           tp->t_startc != tp->t_stopc)
+       if (tp->t_state&TS_TTSTOP && (iflag&IXANY == 0) 
+           && cc[VSTART] != cc[VSTOP])

                return;
                return;

+       

 restartoutput:
        tp->t_state &= ~TS_TTSTOP;
 restartoutput:
        tp->t_state &= ~TS_TTSTOP;

-       tp->t_flags &= ~FLUSHO;
+       tp->t_lflag &= ~FLUSHO;

 startoutput:
        ttstart(tp);
 }
 startoutput:
        ttstart(tp);
 }


@@ -967,79 +1072,54 @@ ttyoutput(c, tp)
 {
        register char *colp;
        register ctype;
 {
        register char *colp;
        register ctype;

-
-       if (tp->t_flags & (RAW|LITOUT)) {
-               if (tp->t_flags&FLUSHO)
+       if (!(tp->t_oflag&OPOST)) {
+               if (tp->t_lflag&FLUSHO) 

                        return (-1);
                if (putc(c, &tp->t_outq))
                        return (c);
                tk_nout++;
                        return (-1);
                if (putc(c, &tp->t_outq))
                        return (c);
                tk_nout++;

+               tp->t_outcc++;

                return (-1);
        }
                return (-1);
        }

-
-       /*
-        * Ignore EOT in normal mode to avoid
-        * hanging up certain terminals.
-        */
-       c &= 0177;
-       if (c == CEOT && (tp->t_flags&CBREAK) == 0)
-               return (-1);
+       c &= 0377;

        /*
         * Turn tabs to spaces as required
         */
        /*
         * Turn tabs to spaces as required
         */

-       if (c == '\t' && (tp->t_flags&TBDELAY) == XTABS) {
+       if (c == '\t' && tp->t_oflag&OXTABS ) {

                register int s;
 
                c = 8 - (tp->t_col&7);
                register int s;
 
                c = 8 - (tp->t_col&7);

-               if ((tp->t_flags&FLUSHO) == 0) {
+               if ((tp->t_lflag&FLUSHO) == 0) {

                        s = spltty();           /* don't interrupt tabs */
                        c -= b_to_q("        ", c, &tp->t_outq);
                        tk_nout += c;
                        s = spltty();           /* don't interrupt tabs */
                        c -= b_to_q("        ", c, &tp->t_outq);
                        tk_nout += c;

+                       tp->t_outcc += c;

                        splx(s);
                }
                tp->t_col += c;
                return (c ? -1 : '\t');
        }
                        splx(s);
                }
                tp->t_col += c;
                return (c ? -1 : '\t');
        }

+       if (c == CEOT && oflag&ONOEOT)
+               return(-1);

        tk_nout++;
        tk_nout++;

-       /*
-        * for upper-case-only terminals,
-        * generate escapes.
-        */
-       if (tp->t_flags&LCASE) {
-               colp = "({)}!|^~'`";
-               while (*colp++)
-                       if (c == *colp++) {
-                               if (ttyoutput('\\', tp) >= 0)
-                                       return (c);
-                               c = colp[-2];
-                               break;
-                       }
-               if ('A' <= c && c <= 'Z') {
-                       if (ttyoutput('\\', tp) >= 0)
-                               return (c);
-               } else if ('a' <= c && c <= 'z')
-                       c += 'A' - 'a';
-       }
-
+       tp->t_outcc++;
+#ifdef notdef

        /*
         * turn <nl> to <cr><lf> if desired.
         */
        /*
         * turn <nl> to <cr><lf> if desired.
         */

-       if (c == '\n' && tp->t_flags&CRMOD)
-               if (ttyoutput('\r', tp) >= 0)
-                       return (c);
-       if (c == '~' && tp->t_flags&TILDE)
-               c = '`';
-       if ((tp->t_flags&FLUSHO) == 0 && putc(c, &tp->t_outq))
+#endif
+       if ((tp->t_lflag&FLUSHO) == 0 && putc(c, &tp->t_outq))
+               return (c);
+       if ((tp->t_lflag&FLUSHO) == 0 && putc(c, &tp->t_outq))

                return (c);
        /*
         * Calculate delays.
         * The numbers here represent clock ticks
         * and are not necessarily optimal for all terminals.
                return (c);
        /*
         * Calculate delays.
         * The numbers here represent clock ticks
         * and are not necessarily optimal for all terminals.

-        * The delays are indicated by characters above 0200.
-        * In raw mode there are no delays and the
-        * transmission path is 8 bits wide.

         *
         * SHOULD JUST ALLOW USER TO SPECIFY DELAYS
         *
         * SHOULD JUST ALLOW USER TO SPECIFY DELAYS

+        *
+        * (actually, should THROW AWAY terminals which need delays)

         */
        colp = &tp->t_col;
        ctype = partab[c];
         */
        colp = &tp->t_col;
        ctype = partab[c];


@@ -1107,8 +1187,8 @@ ttyoutput(c, tp)
                }
                *colp = 0;
        }
                }
                *colp = 0;
        }

-       if (c && (tp->t_flags&FLUSHO) == 0)
-               (void) putc(c|0200, &tp->t_outq);
+       if (c && (tp->t_lflag&FLUSHO) == 0)
+               (void) putc(c|TTY_QUOTE, &tp->t_outq);

        return (-1);
 }
 #undef mstohz
        return (-1);
 }
 #undef mstohz


@@ -1117,137 +1197,126 @@ ttyoutput(c, tp)
  * Called from device's read routine after it has
  * calculated the tty-structure given as argument.
  */
  * Called from device's read routine after it has
  * calculated the tty-structure given as argument.
  */

-ttread(tp, uio)
+ttread(tp, uio, flag)

        register struct tty *tp;
        struct uio *uio;
 {
        register struct clist *qp;
        register struct tty *tp;
        struct uio *uio;
 {
        register struct clist *qp;

-       register c, t_flags;
+       register int c, t_flags;
+       register long lflag = tp->t_lflag;
+       register long iflag = tp->t_iflag;
+       register u_char *cc = tp->t_cc;

        int s, first, error = 0;
 
        int s, first, error = 0;
 

+

 loop:
 loop:

+       s = spltty();

        /*
        /*

-        * Take any pending input first.
+        * take pending input first 

         */
         */

-       s = spltty();
-       if (tp->t_flags&PENDIN)
+       if (tp->t_lflag&PENDIN)

                ttypend(tp);
        splx(s);
 
                ttypend(tp);
        splx(s);
 

-       if ((tp->t_state&TS_CARR_ON)==0)
-               return (EIO);
-

        /*
         * Hang process if it's in the background.
         */
        /*
         * Hang process if it's in the background.
         */

-       if (tp == u.u_ttyp && u.u_procp->p_pgrp != tp->t_pgrp) {
+       if (isbackground(u.u_procp, tp)) {

                if ((u.u_procp->p_sigignore & sigmask(SIGTTIN)) ||
                   (u.u_procp->p_sigmask & sigmask(SIGTTIN)) ||
                if ((u.u_procp->p_sigignore & sigmask(SIGTTIN)) ||
                   (u.u_procp->p_sigmask & sigmask(SIGTTIN)) ||

-                   u.u_procp->p_flag&SVFORK)
+                   u.u_procp->p_flag&SVFORK || u.u_procp->p_pgrp->pg_jobc == 0)

                        return (EIO);
                        return (EIO);

-               gsignal(u.u_procp->p_pgrp, SIGTTIN);
-               sleep((caddr_t)&lbolt, TTIPRI);
+               pgsignal(u.u_procp->p_pgrp, SIGTTIN);
+               if (error = tsleep((caddr_t)&lbolt, TTIPRI | PCATCH, ttybg, 0))
+                       return (error);

                goto loop;
        }
                goto loop;
        }

-       t_flags = tp->t_flags;
-
-       /*
-        * In raw mode take characters directly from the
-        * raw queue w/o processing.  Interlock against
-        * device interrupts when interrogating rawq.
-        */
-       if (t_flags&RAW) {
-               s = spltty();
-               if (tp->t_rawq.c_cc <= 0) {
-                       if ((tp->t_state&TS_CARR_ON) == 0 ||
-                           (tp->t_state&TS_NBIO)) {
-                               splx(s);
-                               return (EWOULDBLOCK);
-                       }
-                       sleep((caddr_t)&tp->t_rawq, TTIPRI);
-                       splx(s);
-                       goto loop;
-               }
-               splx(s);
-               while (!error && tp->t_rawq.c_cc && uio->uio_resid)
-                       error = ureadc(getc(&tp->t_rawq), uio);
-               goto checktandem;
-       }

 
        /*
 
        /*

-        * In cbreak mode use the rawq, otherwise
-        * take characters from the canonicalized q.
+        * If canonical, use the canonical queue,
+        * else use the raw queue.

         */
         */

-       qp = t_flags&CBREAK ? &tp->t_rawq : &tp->t_canq;
+       qp = lflag&ICANON ? &tp->t_canq : &tp->t_rawq;

 
        /*
 
        /*

-        * No input, sleep on rawq awaiting hardware
-        * receipt and notification.
+        * If there is no input, sleep on rawq
+        * awaiting hardware receipt and notification.
+        * If we have data, we don't need to check for carrier.

         */
        s = spltty();
        if (qp->c_cc <= 0) {
         */
        s = spltty();
        if (qp->c_cc <= 0) {

-               if ((tp->t_state&TS_CARR_ON) == 0 ||
-                   (tp->t_state&TS_NBIO)) {
+               int carrier;
+
+               carrier = (tp->t_state&TS_CARR_ON) || (tp->t_cflag&CLOCAL);
+               if (!carrier && tp->t_state&TS_ISOPEN) {
+                       splx(s);
+                       return (0);     /* EOF */
+               }
+               if (flag & IO_NDELAY) {

                        splx(s);
                        return (EWOULDBLOCK);
                }
                        splx(s);
                        return (EWOULDBLOCK);
                }

-               sleep((caddr_t)&tp->t_rawq, TTIPRI);
+               error = tsleep((caddr_t)&tp->t_rawq, TTIPRI | PCATCH,
+                   carrier ? ttyin : ttopen, 0);

                splx(s);
                splx(s);

+               if (error)
+                       return (error);

                goto loop;
        }
        splx(s);
 
        /*
                goto loop;
        }
        splx(s);
 
        /*

-        * Input present, perform input mapping
-        * and processing (we're not in raw mode).
+        * Input present, check for input mapping and processing.

         */
        first = 1;
        while ((c = getc(qp)) >= 0) {
         */
        first = 1;
        while ((c = getc(qp)) >= 0) {

-               if (t_flags&CRMOD && c == '\r')
-                       c = '\n';

                /*
                /*

-                * Check for delayed suspend character.
+                * delayed suspend (^Y)

                 */
                 */

-               if (tp->t_line == NTTYDISC && c == tp->t_dsuspc) {
-                       gsignal(tp->t_pgrp, SIGTSTP);
+               if (CCEQ(cc[VDSUSP], c) && lflag&ISIG) {
+                       pgsignal(tp->t_pgrp, SIGTSTP);

                        if (first) {
                        if (first) {

-                               sleep((caddr_t)&lbolt, TTIPRI);
+                               if (error = tsleep((caddr_t)&lbolt,
+                                   TTIPRI | PCATCH, ttybg, 0))
+                                       break;

                                goto loop;
                        }
                        break;
                }
                /*
                                goto loop;
                        }
                        break;
                }
                /*

-                * Interpret EOF only in cooked mode.
+                * Interpret EOF only in canonical mode.

                 */
                 */

-               if (c == tp->t_eofc && (t_flags&CBREAK) == 0)
+               if (CCEQ(cc[VEOF], c) && lflag&ICANON)

                        break;
                /*
                 * Give user character.
                 */
                        break;
                /*
                 * Give user character.
                 */

-               error = ureadc(t_flags&PASS8 ? c : c & 0177, uio);
+               error = ureadc(iflag&ISTRIP ? c & 0177 : c , uio);

                if (error)
                        break;
                if (uio->uio_resid == 0)
                        break;
                /*
                if (error)
                        break;
                if (uio->uio_resid == 0)
                        break;
                /*

-                * In cooked mode check for a "break character"
+                * In canonical mode check for a "break character"

                 * marking the end of a "line of input".
                 */
                 * marking the end of a "line of input".
                 */

-               if ((t_flags&CBREAK) == 0 && ttbreakc(c, tp))
+               if (lflag&ICANON && ttbreakc(c)) {

                        break;
                        break;

+               }

                first = 0;
        }
                first = 0;
        }

-
-checktandem:

        /*
         * Look to unblock output now that (presumably)
         * the input queue has gone down.
         */
        /*
         * Look to unblock output now that (presumably)
         * the input queue has gone down.
         */

-       if (tp->t_state&TS_TBLOCK && tp->t_rawq.c_cc < TTYHOG/5)
-               if (putc(tp->t_startc, &tp->t_outq) == 0) {
+       if (tp->t_state&TS_TBLOCK && tp->t_rawq.c_cc < TTYHOG/5) {
+               if (cc[VSTART] != POSIX_V_DISABLE 
+                  && putc(cc[VSTART], &tp->t_outq) == 0) {

                        tp->t_state &= ~TS_TBLOCK;
                        ttstart(tp);
                }
                        tp->t_state &= ~TS_TBLOCK;
                        ttstart(tp);
                }

+       }
+       }

        return (error);
 }
 
        return (error);
 }
 


@@ -1256,24 +1325,28 @@ checktandem:
  * (from uprintf/tprintf).  Allow some space over the normal
  * hiwater mark so we don't lose messages due to normal flow
  * control, but don't let the tty run amok.
  * (from uprintf/tprintf).  Allow some space over the normal
  * hiwater mark so we don't lose messages due to normal flow
  * control, but don't let the tty run amok.

+ * Sleeps here are not interruptible, but we return prematurely
+ * if new signals come in.

  */
 ttycheckoutq(tp, wait)
        register struct tty *tp;
        int wait;
 {
  */
 ttycheckoutq(tp, wait)
        register struct tty *tp;
        int wait;
 {

-       int hiwat, s;
+       int hiwat, s, oldsig;

 
 

-       hiwat = TTHIWAT(tp);
+       hiwat = tp->t_hiwat;

        s = spltty();
        s = spltty();

+       oldsig = u.u_procp->p_sig;

        if (tp->t_outq.c_cc > hiwat + 200)
                while (tp->t_outq.c_cc > hiwat) {
                        ttstart(tp);
        if (tp->t_outq.c_cc > hiwat + 200)
                while (tp->t_outq.c_cc > hiwat) {
                        ttstart(tp);

-                       if (wait == 0) {
+                       if (wait == 0 || u.u_procp->p_sig != oldsig) {

                                splx(s);
                                return (0);
                        }
                                splx(s);
                                return (0);
                        }

+                       timeout(wakeup, (caddr_t)&tp->t_outq, hz);

                        tp->t_state |= TS_ASLEEP;
                        tp->t_state |= TS_ASLEEP;

-                       sleep((caddr_t)&tp->t_outq, TTOPRI);
+                       sleep((caddr_t)&tp->t_outq, PZERO - 1);

                }
        splx(s);
        return (1);
                }
        splx(s);
        return (1);


@@ -1283,90 +1356,80 @@ ttycheckoutq(tp, wait)
  * Called from the device's write routine after it has
  * calculated the tty-structure given as argument.
  */
  * Called from the device's write routine after it has
  * calculated the tty-structure given as argument.
  */

-ttwrite(tp, uio)
+ttwrite(tp, uio, flag)

        register struct tty *tp;
        register struct uio *uio;
 {
        register char *cp;
        register struct tty *tp;
        register struct uio *uio;
 {
        register char *cp;

-       register int cc, ce, c;
+       register int cc = 0, ce;

        int i, hiwat, cnt, error, s;
        char obuf[OBUFSIZ];
 
        int i, hiwat, cnt, error, s;
        char obuf[OBUFSIZ];
 

-       hiwat = TTHIWAT(tp);
+       hiwat = tp->t_hiwat;

        cnt = uio->uio_resid;
        error = 0;
 loop:
        cnt = uio->uio_resid;
        error = 0;
 loop:

-       if ((tp->t_state&TS_CARR_ON) == 0)
-               return (EIO);
+       s = spltty();
+       if ((tp->t_state&TS_CARR_ON) == 0 && (tp->t_cflag&CLOCAL) == 0) {
+               if (tp->t_state&TS_ISOPEN) {
+                       splx(s);
+                       return (EIO);
+               } else if (flag & IO_NDELAY) {
+                       splx(s);
+                       error = EWOULDBLOCK;
+                       goto out;
+               } else {
+                       /*
+                        * sleep awaiting carrier
+                        */
+                       error = tsleep((caddr_t)&tp->t_rawq, TTIPRI | PCATCH,
+                           ttopen, 0);
+                       splx(s);
+                       if (error)
+                               goto out;
+                       goto loop;
+               }
+       }
+       splx(s);

        /*
         * Hang the process if it's in the background.
         */
        /*
         * Hang the process if it's in the background.
         */

-       if (u.u_procp->p_pgrp != tp->t_pgrp && tp == u.u_ttyp &&
-           (tp->t_flags&TOSTOP) && (u.u_procp->p_flag&SVFORK)==0 &&
-           !(u.u_procp->p_sigignore & sigmask(SIGTTOU)) &&
-           !(u.u_procp->p_sigmask & sigmask(SIGTTOU))) {
-               gsignal(u.u_procp->p_pgrp, SIGTTOU);
-               sleep((caddr_t)&lbolt, TTIPRI);
+           (tp->t_lflag&TOSTOP) && (u.u_procp->p_flag&SVFORK)==0 &&
+           (u.u_procp->p_sigignore & sigmask(SIGTTOU)) == 0 &&
+           (u.u_procp->p_sigmask & sigmask(SIGTTOU)) == 0 &&
+            u.u_procp->p_pgrp->pg_jobc) {
+               pgsignal(u.u_procp->p_pgrp, SIGTTOU);
+               if (error = tsleep((caddr_t)&lbolt, TTIPRI | PCATCH, ttybg, 0))
+                       goto out;

                goto loop;
        }
                goto loop;
        }

-

        /*
         * Process the user's data in at most OBUFSIZ
        /*
         * Process the user's data in at most OBUFSIZ

-        * chunks.  Perform lower case simulation and
-        * similar hacks.  Keep track of high water
-        * mark, sleep on overflow awaiting device aid
-        * in acquiring new space.
+        * chunks.  Perform any output translation.
+        * Keep track of high water mark, sleep on overflow
+        * awaiting device aid in acquiring new space.

         */
         */

-       while (uio->uio_resid > 0) {
-               /*
-                * Grab a hunk of data from the user.
-                */
-               cc = uio->uio_iov->iov_len;
-               if (cc == 0) {
-                       uio->uio_iovcnt--;
-                       uio->uio_iov++;
-                       if (uio->uio_iovcnt <= 0)
-                               panic("ttwrite");
-                       continue;
+       while (uio->uio_resid > 0 || cc > 0) {
+               if (tp->t_lflag&FLUSHO) {
+                       uio->uio_resid = 0;
+                       return (0);

                }
                }

-               if (cc > OBUFSIZ)
-                       cc = OBUFSIZ;
-               cp = obuf;
-               error = uiomove(cp, cc, UIO_WRITE, uio);
-               if (error)
-                       break;

                if (tp->t_outq.c_cc > hiwat)
                        goto ovhiwat;
                if (tp->t_outq.c_cc > hiwat)
                        goto ovhiwat;

-               if (tp->t_flags&FLUSHO)
-                       continue;

                /*
                /*

-                * If we're mapping lower case or kludging tildes,
-                * then we've got to look at each character, so
-                * just feed the stuff to ttyoutput...
+                * Grab a hunk of data from the user,
+                * unless we have some leftover from last time.

                 */
                 */

-               if (tp->t_flags & (LCASE|TILDE)) {
-                       while (cc > 0) {
-                               c = *cp++;
-                               tp->t_rocount = 0;
-                               while ((c = ttyoutput(c, tp)) >= 0) {
-                                       /* out of clists, wait a bit */
-                                       ttstart(tp);
-                                       sleep((caddr_t)&lbolt, TTOPRI);
-                                       tp->t_rocount = 0;
-                                       if (cc != 0) {
-                                               uio->uio_iov->iov_base -= cc;
-                                               uio->uio_iov->iov_len += cc;
-                                               uio->uio_resid += cc;
-                                               uio->uio_offset -= cc;
-                                       }
-                                       goto loop;
-                               }
-                               --cc;
-                               if (tp->t_outq.c_cc > hiwat)
-                                       goto ovhiwat;
+               if (cc == 0) {
+                       cc = min(uio->uio_resid, OBUFSIZ);
+                       cp = obuf;
+                       error = uiomove(cp, cc, uio);
+                       if (error) {
+                               cc = 0;
+                               break;

                        }
                        }

-                       continue;

                }
                }

+#ifdef notdef

                /*
                 * If nothing fancy need be done, grab those characters we
                 * can handle without any of ttyoutput's processing and
                /*
                 * If nothing fancy need be done, grab those characters we
                 * can handle without any of ttyoutput's processing and


@@ -1377,11 +1440,11 @@ loop:
                 * immediately.
                 */
                while (cc > 0) {
                 * immediately.
                 */
                while (cc > 0) {

-                       if (tp->t_flags & (RAW|LITOUT))
+                       if (!(tp->t_oflag&OPOST))

                                ce = cc;
                        else {
                                ce = cc;
                        else {

-                               ce = cc - scanc((unsigned)cc, (caddr_t)cp,
-                                  (caddr_t)partab, 077);
+                               ce = cc - scanc((unsigned)cc, (u_char *)cp,
+                                  (u_char *)partab, 077);

                                /*
                                 * If ce is zero, then we're processing
                                 * a special character through ttyoutput.
                                /*
                                 * If ce is zero, then we're processing
                                 * a special character through ttyoutput.


@@ -1391,17 +1454,13 @@ loop:
                                        if (ttyoutput(*cp, tp) >= 0) {
                                            /* no c-lists, wait a bit */
                                            ttstart(tp);
                                        if (ttyoutput(*cp, tp) >= 0) {
                                            /* no c-lists, wait a bit */
                                            ttstart(tp);

-                                           sleep((caddr_t)&lbolt, TTOPRI);
-                                           if (cc != 0) {
-                                               uio->uio_iov->iov_base -= cc;
-                                               uio->uio_iov->iov_len += cc;
-                                               uio->uio_resid += cc;
-                                               uio->uio_offset -= cc;
-                                           }
+                                           if (error = tsleep((caddr_t)&lbolt,
+                                               TTOPRI | PCATCH, ttybuf, 0))
+                                                   break;

                                            goto loop;
                                        }
                                        cp++, cc--;
                                            goto loop;
                                        }
                                        cp++, cc--;

-                                       if (tp->t_flags&FLUSHO ||
+                                       if (tp->t_lflag&FLUSHO ||

                                            tp->t_outq.c_cc > hiwat)
                                                goto ovhiwat;
                                        continue;
                                            tp->t_outq.c_cc > hiwat)
                                                goto ovhiwat;
                                        continue;


@@ -1420,49 +1479,54 @@ loop:
                        ce -= i;
                        tp->t_col += ce;
                        cp += ce, cc -= ce, tk_nout += ce;
                        ce -= i;
                        tp->t_col += ce;
                        cp += ce, cc -= ce, tk_nout += ce;

+                       tp->t_outcc += ce;

                        if (i > 0) {
                                /* out of c-lists, wait a bit */
                                ttstart(tp);
                        if (i > 0) {
                                /* out of c-lists, wait a bit */
                                ttstart(tp);

-                               sleep((caddr_t)&lbolt, TTOPRI);
-                               uio->uio_iov->iov_base -= cc;
-                               uio->uio_iov->iov_len += cc;
-                               uio->uio_resid += cc;
-                               uio->uio_offset -= cc;
+                               if (error = tsleep((caddr_t)&lbolt,
+                                   TTOPRI | PCATCH, ttybuf, 0))
+                                       break;

                                goto loop;
                        }
                                goto loop;
                        }

-                       if (tp->t_flags&FLUSHO || tp->t_outq.c_cc > hiwat)
-                               goto ovhiwat;
+                       if (tp->t_lflag&FLUSHO || tp->t_outq.c_cc > hiwat)
+                               break;

                }
                }

+               ttstart(tp);
+               ttstart(tp);

        }
        }

-       ttstart(tp);
+out:
+       /*
+        * If cc is nonzero, we leave the uio structure inconsistent,
+        * as the offset and iov pointers have moved forward,
+        * but it doesn't matter (the call will either return short
+        * or restart with a new uio).
+        */
+       uio->uio_resid += cc;

        return (error);
 
 ovhiwat:
        return (error);
 
 ovhiwat:

+       ttstart(tp);

        s = spltty();
        s = spltty();

-       if (cc != 0) {
-               uio->uio_iov->iov_base -= cc;
-               uio->uio_iov->iov_len += cc;
-               uio->uio_resid += cc;
-               uio->uio_offset -= cc;
-       }

        /*
        /*

-        * This can only occur if FLUSHO
-        * is also set in t_flags.
+        * This can only occur if FLUSHO is set in t_lflag,
+        * or if ttstart/oproc is synchronous (or very fast).

         */
        if (tp->t_outq.c_cc <= hiwat) {
                splx(s);
                goto loop;
        }
         */
        if (tp->t_outq.c_cc <= hiwat) {
                splx(s);
                goto loop;
        }

-       ttstart(tp);
-       if (tp->t_state&TS_NBIO) {
+       if (flag & IO_NDELAY) {

                splx(s);
                splx(s);

+               uio->uio_resid += cc;

                if (uio->uio_resid == cnt)
                        return (EWOULDBLOCK);
                return (0);
        }
        tp->t_state |= TS_ASLEEP;
                if (uio->uio_resid == cnt)
                        return (EWOULDBLOCK);
                return (0);
        }
        tp->t_state |= TS_ASLEEP;

-       sleep((caddr_t)&tp->t_outq, TTOPRI);
+       error = tsleep((caddr_t)&tp->t_outq, TTOPRI | PCATCH, ttyout, 0);

        splx(s);
        splx(s);

+       if (error)
+               goto out;

        goto loop;
 }
 
        goto loop;
 }
 


@@ -1479,11 +1543,9 @@ ttyrub(c, tp)
        int s;
        char *nextc();
 
        int s;
        char *nextc();
 

-       if ((tp->t_flags&ECHO) == 0)
+       if ((tp->t_lflag&ECHO) == 0)

                return;
                return;

-       tp->t_flags &= ~FLUSHO;
-       c &= 0377;
-       if (tp->t_flags&CRTBS) {
+       if (tp->t_lflag&ECHOE) {

                if (tp->t_rocount == 0) {
                        /*
                         * Screwed by ttwrite; retype
                if (tp->t_rocount == 0) {
                        /*
                         * Screwed by ttwrite; retype


@@ -1491,26 +1553,27 @@ ttyrub(c, tp)
                        ttyretype(tp);
                        return;
                }
                        ttyretype(tp);
                        return;
                }

-               if (c == ('\t'|0200) || c == ('\n'|0200))
+               /* if tab or newline was escaped  - XXX - not 8bit */
+               if (c == ('\t'|TTY_QUOTE) || c == ('\n'|TTY_QUOTE))

                        ttyrubo(tp, 2);
                        ttyrubo(tp, 2);

-               else switch (partab[c&=0177]&0177) {
+               else switch (partab[c&=0377]&077) {

 
                case ORDINARY:
 
                case ORDINARY:

-                       if (tp->t_flags&LCASE && c >= 'A' && c <= 'Z')
-                               ttyrubo(tp, 2);
-                       else
-                               ttyrubo(tp, 1);
+#ifdef notdef
+                       ttyrubo(tp, 1);

                        break;
 
                case VTAB:
                case BACKSPACE:
                case CONTROL:
                case RETURN:
                        break;
 
                case VTAB:
                case BACKSPACE:
                case CONTROL:
                case RETURN:

-                       if (tp->t_flags&CTLECH)
+                       if (tp->t_lflag&ECHOCTL)

                                ttyrubo(tp, 2);
                        break;
 
                                ttyrubo(tp, 2);
                        break;
 

-               case TAB:
+               case TAB: {
+                       int c;
+

                        if (tp->t_rocount < tp->t_rawq.c_cc) {
                                ttyretype(tp);
                                return;
                        if (tp->t_rocount < tp->t_rawq.c_cc) {
                                ttyretype(tp);
                                return;


@@ -1518,12 +1581,10 @@ ttyrub(c, tp)
                        s = spltty();
                        savecol = tp->t_col;
                        tp->t_state |= TS_CNTTB;
                        s = spltty();
                        savecol = tp->t_col;
                        tp->t_state |= TS_CNTTB;

-                       tp->t_flags |= FLUSHO;
+                       tp->t_lflag |= FLUSHO;

                        tp->t_col = tp->t_rocol;
                        cp = tp->t_rawq.c_cf;
                        tp->t_col = tp->t_rocol;
                        cp = tp->t_rawq.c_cf;

-                       for (; cp; cp = nextc(&tp->t_rawq, cp))
-                               ttyecho(*cp, tp);
-                       tp->t_flags &= ~FLUSHO;
+                       tp->t_lflag &= ~FLUSHO;

                        tp->t_state &= ~TS_CNTTB;
                        splx(s);
                        /*
                        tp->t_state &= ~TS_CNTTB;
                        splx(s);
                        /*


@@ -1536,18 +1597,22 @@ ttyrub(c, tp)
                        while (--savecol >= 0)
                                (void) ttyoutput('\b', tp);
                        break;
                        while (--savecol >= 0)
                                (void) ttyoutput('\b', tp);
                        break;

+               }

 
                default:
 
                default:

-                       panic("ttyrub");
+                       /* XXX */
+                       printf("ttyrub: would panic c = %d, val = %d\n",
+                               c, partab[c&=0377]&077);
+                       /*panic("ttyrub");*/

                }
                }

-       } else if (tp->t_flags&PRTERA) {
+       } else if (tp->t_lflag&ECHOPRT) {

                if ((tp->t_state&TS_ERASE) == 0) {
                        (void) ttyoutput('\\', tp);
                        tp->t_state |= TS_ERASE;
                }
                ttyecho(c, tp);
        } else
                if ((tp->t_state&TS_ERASE) == 0) {
                        (void) ttyoutput('\\', tp);
                        tp->t_state |= TS_ERASE;
                }
                ttyecho(c, tp);
        } else

-               ttyecho(tp->t_erase, tp);
+               ttyecho(tp->t_cc[VERASE], tp);

        tp->t_rocount--;
 }
 
        tp->t_rocount--;
 }
 


@@ -1559,10 +1624,10 @@ ttyrubo(tp, cnt)
        register struct tty *tp;
        int cnt;
 {
        register struct tty *tp;
        int cnt;
 {

-       register char *rubostring = tp->t_flags&CRTERA ? "\b \b" : "\b";
+       register char *rubostring = tp->t_lflag&ECHOE ? "\b \b" : "\b";

 
        while (--cnt >= 0)
 
        while (--cnt >= 0)

-               ttyout(rubostring, tp);
+               ttyoutstr("\b \b", tp);

 }
 
 /*
 }
 
 /*


@@ -1574,16 +1639,20 @@ ttyretype(tp)
 {
        register char *cp;
        char *nextc();
 {
        register char *cp;
        char *nextc();

-       int s;
+       int s, c;

 
 

-       if (tp->t_rprntc != 0377)
-               ttyecho(tp->t_rprntc, tp);
+       if (tp->t_cc[VREPRINT] != POSIX_V_DISABLE)
+               ttyecho(tp->t_cc[VREPRINT], tp);

        (void) ttyoutput('\n', tp);
        s = spltty();
        (void) ttyoutput('\n', tp);
        s = spltty();

-       for (cp = tp->t_canq.c_cf; cp; cp = nextc(&tp->t_canq, cp))
-               ttyecho(*cp, tp);
-       for (cp = tp->t_rawq.c_cf; cp; cp = nextc(&tp->t_rawq, cp))
-               ttyecho(*cp, tp);
+       /*** XXX *** FIX *** NEXTC IS BROKEN - DOESN'T CHECK QUOTE
+         BIT OF FIRST CHAR ****/
+       for (cp = tp->t_canq.c_cf, c=(cp?*cp:0); cp; cp = nextc(&tp->t_canq, cp, &c)) {
+               ttyecho(c, tp);
+       }
+       for (cp = tp->t_rawq.c_cf, c=(cp?*cp:0); cp; cp = nextc(&tp->t_rawq, cp, &c)) {
+               ttyecho(c, tp);
+       }

        tp->t_state &= ~TS_ERASE;
        splx(s);
        tp->t_rocount = tp->t_rawq.c_cc;
        tp->t_state &= ~TS_ERASE;
        splx(s);
        tp->t_rocount = tp->t_rawq.c_cc;


@@ -1591,54 +1660,34 @@ ttyretype(tp)
 }
 
 /*
 }
 
 /*

- * Echo a typed character to the terminal
+ * Echo a typed character to the terminal.

  */
 ttyecho(c, tp)
        register c;
        register struct tty *tp;
 {
  */
 ttyecho(c, tp)
        register c;
        register struct tty *tp;
 {

-
-       if ((tp->t_state&TS_CNTTB) == 0)
-               tp->t_flags &= ~FLUSHO;
-       if ((tp->t_flags&ECHO) == 0)
-               return;

        c &= 0377;
        c &= 0377;

-       if (tp->t_flags&RAW) {
-               (void) ttyoutput(c, tp);
+       if ((tp->t_state&TS_CNTTB) == 0)
+               tp->t_lflag &= ~FLUSHO;
+       if ((tp->t_lflag&ECHO) == 0 && !(tp->t_lflag&ECHONL && c == '\n'))

                return;
                return;

-       }
-       if (c == '\r' && tp->t_flags&CRMOD)
-               c = '\n';
-       if (tp->t_flags&CTLECH) {
-               if ((c&0177) <= 037 && c!='\t' && c!='\n' || (c&0177)==0177) {
+       if (tp->t_lflag&ECHOCTL) {
+               if ((c&TTY_CHARMASK) <= 037 && c != '\t' && c != '\n' ||
+                   c == 0177) {

                        (void) ttyoutput('^', tp);
                        (void) ttyoutput('^', tp);

-                       c &= 0177;
+                       c &= TTY_CHARMASK;

                        if (c == 0177)
                                c = '?';
                        if (c == 0177)
                                c = '?';

-                       else if (tp->t_flags&LCASE)
-                               c += 'a' - 1;
+#ifdef notdef
+#endif

                        else
                                c += 'A' - 1;
                }
        }
                        else
                                c += 'A' - 1;
                }
        }

-       (void) ttyoutput(c&0177, tp);
-}
-
-/*
- * Is c a break char for tp?
- */
-ttbreakc(c, tp)
-       register c;
-       register struct tty *tp;
-{
-       return (c == '\n' || c == tp->t_eofc || c == tp->t_brkc ||
-               c == '\r' && (tp->t_flags&CRMOD));
-}
-
-/*
+       (void) ttyoutput(c, tp);

  * send string cp to tp
  */
  * send string cp to tp
  */

-ttyout(cp, tp)
+ttyoutstr(cp, tp)

        register char *cp;
        register struct tty *tp;
 {
        register char *cp;
        register struct tty *tp;
 {


@@ -1658,6 +1707,101 @@ ttwakeup(tp)
                tp->t_rsel = 0;
        }
        if (tp->t_state & TS_ASYNC)
                tp->t_rsel = 0;
        }
        if (tp->t_state & TS_ASYNC)

-               gsignal(tp->t_pgrp, SIGIO); 
+               pgsignal(tp->t_pgrp, SIGIO); 

        wakeup((caddr_t)&tp->t_rawq);
 }
        wakeup((caddr_t)&tp->t_rawq);
 }

+
+/*
+ * set tty hi and low water marks
+ *
+ * Try to arrange the dynamics so there's about one second
+ * from hi to low water.
+ * 
+ */
+ttsetwater(tp)
+       struct tty *tp;
+{
+       register cps = tp->t_ospeed / 10;
+       register x;
+
+#define clamp(x, h, l) ((x)>h ? h : ((x)<l) ? l : (x))
+       tp->t_lowat = x = clamp(cps/2, TTMAXLOWAT, TTMINLOWAT);
+       x += cps;
+       x = clamp(x, TTMAXHIWAT, TTMINHIWAT);
+       tp->t_hiwat = roundup(x, CBSIZE);
+#undef clamp
+}
+
+ttspeedtab(speed, table)
+       struct speedtab table[];
+{
+       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;
+
+       if (ttycheckoutq(tp,0) == 0) 
+               return;
+       if (tp->t_session == NULL)
+               ttyprintf(tp, "kernel: not a controlling terminal\n");
+       else if (tp->t_pgrp == NULL || 
+               (p = tp->t_pgrp->pg_mem) == NULL)
+               ttyprintf(tp, "kernel: no foreground process group\n");
+       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)
+       struct tty *tp;
+       char *fmt;
+       unsigned x1;
+{
+       prf(fmt, &x1, TOTTY, (caddr_t)tp);
+}
+
+/*
+ * Output char to tty; console putchar style.
+ */
+tputchar(c, tp)
+       int c;
+       struct tty *tp;
+{
+       register s = spltty();
+
+       if ((tp->t_state & (TS_CARR_ON | TS_ISOPEN)) 
+           == (TS_CARR_ON | TS_ISOPEN)) {
+               if (c == '\n')
+                       (void) ttyoutput('\r', tp);
+               (void) ttyoutput(c, tp);
+               ttstart(tp);
+               splx(s);
+               return (0);
+       }
+       splx(s);
+       return (-1);
+}