+ /*
+ * 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.
+ */
+ qp = t_flags&CBREAK ? &tp->t_rawq : &tp->t_canq;
+
+ /*
+ * No input, sleep on rawq awaiting hardware
+ * receipt and notification.
+ */
+ s = spltty();
+ if (qp->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);
+
+ /*
+ * Input present, perform input mapping
+ * and processing (we're not in raw mode).
+ */
+ first = 1;
+ while ((c = getc(qp)) >= 0) {
+ if (t_flags&CRMOD && c == '\r')
+ c = '\n';
+ /*
+ * Check for delayed suspend character.
+ */
+ if (tp->t_line == NTTYDISC && c == tp->t_dsuspc) {
+ gsignal(tp->t_pgrp, SIGTSTP);
+ if (first) {
+ sleep((caddr_t)&lbolt, TTIPRI);
+ goto loop;
+ }
+ break;
+ }
+ /*
+ * Interpret EOF only in cooked mode.
+ */
+ if (c == tp->t_eofc && (t_flags&CBREAK) == 0)
+ break;
+ /*
+ * Give user character.
+ */
+ error = ureadc(t_flags&PASS8 ? c : c & 0177, uio);
+ if (error)
+ break;
+ if (uio->uio_resid == 0)
+ break;
+ /*
+ * In cooked mode check for a "break character"
+ * marking the end of a "line of input".
+ */
+ if ((t_flags&CBREAK) == 0 && ttbreakc(c, tp))
+ break;
+ first = 0;
+ }
+
+checktandem:
+ /*
+ * 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) {
+ tp->t_state &= ~TS_TBLOCK;
+ ttstart(tp);
+ }
+ return (error);
+}
+
+/*
+ * Check the output queue on tp for space for a kernel message
+ * (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.
+ */
+ttycheckoutq(tp, wait)
+ register struct tty *tp;
+ int wait;
+{
+ int hiwat, s;
+
+ hiwat = TTHIWAT(tp);
+ s = spltty();
+ if (tp->t_outq.c_cc > hiwat + 200)
+ while (tp->t_outq.c_cc > hiwat) {
+ ttstart(tp);
+ if (wait == 0) {
+ splx(s);
+ return (0);
+ }
+ tp->t_state |= TS_ASLEEP;
+ sleep((caddr_t)&tp->t_outq, TTOPRI);
+ }
+ splx(s);
+ return (1);
+}
+
+/*
+ * Called from the device's write routine after it has
+ * calculated the tty-structure given as argument.
+ */
+ttwrite(tp, uio)
+ register struct tty *tp;
+ register struct uio *uio;
+{
+ register char *cp;
+ register int cc, ce, c;
+ int i, hiwat, cnt, error, s;
+ char obuf[OBUFSIZ];
+
+ hiwat = TTHIWAT(tp);
+ cnt = uio->uio_resid;
+ error = 0;
+loop:
+ if ((tp->t_state&TS_CARR_ON) == 0)
+ return (EIO);
+ /*
+ * 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);
+ goto loop;
+ }
+
+ /*
+ * 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.
+ */
+ 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;
+ }
+ 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_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...
+ */
+ 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;
+ }
+ continue;
+ }
+ /*
+ * If nothing fancy need be done, grab those characters we
+ * can handle without any of ttyoutput's processing and
+ * just transfer them to the output q. For those chars
+ * which require special processing (as indicated by the
+ * bits in partab), call ttyoutput. After processing
+ * a hunk of data, look for FLUSHO so ^O's will take effect
+ * immediately.
+ */
+ while (cc > 0) {
+ if (tp->t_flags & (RAW|LITOUT))
+ ce = cc;
+ else {
+ ce = cc - scanc((unsigned)cc, (caddr_t)cp,
+ (caddr_t)partab, 077);
+ /*
+ * If ce is zero, then we're processing
+ * a special character through ttyoutput.
+ */
+ if (ce == 0) {
+ tp->t_rocount = 0;
+ 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;
+ }
+ goto loop;
+ }
+ cp++, cc--;
+ if (tp->t_flags&FLUSHO ||
+ tp->t_outq.c_cc > hiwat)
+ goto ovhiwat;
+ continue;
+ }
+ }
+ /*
+ * A bunch of normal characters have been found,
+ * transfer them en masse to the output queue and
+ * continue processing at the top of the loop.
+ * If there are any further characters in this
+ * <= OBUFSIZ chunk, the first should be a character
+ * requiring special handling by ttyoutput.
+ */
+ tp->t_rocount = 0;
+ i = b_to_q(cp, ce, &tp->t_outq);
+ ce -= i;
+ tp->t_col += ce;
+ cp += ce, cc -= ce, tk_nout += ce;
+ 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;
+ goto loop;
+ }
+ if (tp->t_flags&FLUSHO || tp->t_outq.c_cc > hiwat)
+ goto ovhiwat;
+ }
+ }
+ ttstart(tp);
+ return (error);
+
+ovhiwat:
+ 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.
+ */
+ if (tp->t_outq.c_cc <= hiwat) {
+ splx(s);
+ goto loop;
+ }
+ ttstart(tp);
+ if (tp->t_state&TS_NBIO) {
+ splx(s);
+ if (uio->uio_resid == cnt)
+ return (EWOULDBLOCK);
+ return (0);
+ }
+ tp->t_state |= TS_ASLEEP;
+ sleep((caddr_t)&tp->t_outq, TTOPRI);
+ splx(s);
+ goto loop;
+}
+
+/*
+ * Rubout one character from the rawq of tp
+ * as cleanly as possible.
+ */
+ttyrub(c, tp)
+ register c;
+ register struct tty *tp;
+{
+ register char *cp;
+ register int savecol;
+ int s;
+ char *nextc();
+
+ if ((tp->t_flags&ECHO) == 0)
+ return;
+ tp->t_flags &= ~FLUSHO;
+ c &= 0377;
+ if (tp->t_flags&CRTBS) {
+ if (tp->t_rocount == 0) {
+ /*
+ * Screwed by ttwrite; retype
+ */
+ ttyretype(tp);
+ return;
+ }
+ if (c == ('\t'|0200) || c == ('\n'|0200))
+ ttyrubo(tp, 2);
+ else switch (partab[c&=0177]&0177) {
+
+ case ORDINARY:
+ if (tp->t_flags&LCASE && c >= 'A' && c <= 'Z')
+ ttyrubo(tp, 2);
+ else
+ ttyrubo(tp, 1);
+ break;
+
+ case VTAB:
+ case BACKSPACE:
+ case CONTROL:
+ case RETURN:
+ if (tp->t_flags&CTLECH)
+ ttyrubo(tp, 2);
+ break;
+
+ case TAB:
+ if (tp->t_rocount < tp->t_rawq.c_cc) {
+ ttyretype(tp);
+ return;
+ }
+ s = spltty();
+ savecol = tp->t_col;
+ tp->t_state |= TS_CNTTB;
+ tp->t_flags |= FLUSHO;
+ 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_state &= ~TS_CNTTB;
+ splx(s);
+ /*
+ * savecol will now be length of the tab
+ */
+ savecol -= tp->t_col;
+ tp->t_col += savecol;
+ if (savecol > 8)
+ savecol = 8; /* overflow screw */
+ while (--savecol >= 0)
+ (void) ttyoutput('\b', tp);
+ break;
+
+ default:
+ panic("ttyrub");
+ }
+ } else if (tp->t_flags&PRTERA) {
+ if ((tp->t_state&TS_ERASE) == 0) {
+ (void) ttyoutput('\\', tp);
+ tp->t_state |= TS_ERASE;
+ }
+ ttyecho(c, tp);
+ } else
+ ttyecho(tp->t_erase, tp);
+ tp->t_rocount--;
+}
+
+/*
+ * Crt back over cnt chars perhaps
+ * erasing them.
+ */
+ttyrubo(tp, cnt)
+ register struct tty *tp;
+ int cnt;
+{
+ register char *rubostring = tp->t_flags&CRTERA ? "\b \b" : "\b";
+
+ while (--cnt >= 0)
+ ttyout(rubostring, tp);
+}
+
+/*
+ * Reprint the rawq line.
+ * We assume c_cc has already been checked.
+ */
+ttyretype(tp)
+ register struct tty *tp;
+{
+ register char *cp;
+ char *nextc();
+ int s;
+
+ if (tp->t_rprntc != 0377)
+ ttyecho(tp->t_rprntc, tp);
+ (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);
+ tp->t_state &= ~TS_ERASE;
+ splx(s);
+ tp->t_rocount = tp->t_rawq.c_cc;
+ tp->t_rocol = 0;
+}
+
+/*
+ * Echo a typed character to the terminal
+ */
+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;
+ if (tp->t_flags&RAW) {
+ (void) ttyoutput(c, tp);
+ 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) {
+ (void) ttyoutput('^', tp);
+ c &= 0177;
+ if (c == 0177)
+ c = '?';
+ else if (tp->t_flags&LCASE)
+ 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));
+}
+
+/*
+ * send string cp to tp
+ */
+ttyout(cp, tp)
+ register char *cp;
+ register struct tty *tp;
+{
+ register char c;
+
+ while (c = *cp++)
+ (void) ttyoutput(c, tp);
+}
+
+ttwakeup(tp)
+ struct tty *tp;
+{
+
+ if (tp->t_rsel) {
+ selwakeup(tp->t_rsel, tp->t_state&TS_RCOLL);
+ tp->t_state &= ~TS_RCOLL;
+ tp->t_rsel = 0;