![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tty.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / kernel / USRSRC / ttydrv|
Return to tty.c CVS log | Up to [MW Coherent from dump] / coherent / d / kernel / USRSRC / ttydrv |
1.1 ! root 1: /* ! 2: * File: $USRSRC/ttydrv/tty.c ! 3: * ! 4: * Purpose: COHERENT line discipline module. ! 5: * This is the common part of typewriter service. It handles all device- ! 6: * independent aspects of a typewriter, including tandem flow control, ! 7: * erase and kill, stop and start, and common ioctl functions. ! 8: * ! 9: * $Log: tty.c,v $ ! 10: * Revision 1.9 91/09/17 06:06:42 bin ! 11: * updated by hal ! 12: * ! 13: * Revision 1.8 91/09/13 18:01:39 piggy ! 14: * Only do XON/XOFF flow control if TANDEM is set. ! 15: * ! 16: * Revision 1.7 91/09/13 17:58:00 hal ! 17: * Drop 3rd arg (was writing PSW directly from it!) for ttread/ttwrite. ! 18: * General face lift. ! 19: * ! 20: * ! 21: * Bug: no support for 8-bit characters. ! 22: * Fix: don't strip keyboard input. 01/22/91. (norm) ! 23: * ! 24: * Bug: Switching modes between cooked and CBREAK/RAW left buffered input ! 25: * in the input buffer until returning to cooked mode. 05/13/91 norm ! 26: * ! 27: * Bug: setting speed to default in ttopen() was conditioned to ! 28: * use hard constants. 90/08/28. hws ! 29: * ! 30: * Revision 1.5 91/06/06 18:28:53 norm ! 31: * Restore 8-bit fix. ! 32: * ! 33: * Revision 1.2 89/07/17 11:51:20 src ! 34: * Bug: Terminal could lock up when setting it to RAWIN mode, if ! 35: * output was suspended due to X-OFF, and output data was present. ! 36: * Fix: Setting terminal to RAWIN mode now clears X-OFF, starts output ! 37: * BEFORE waiting for output to drain. Received signals now cause ! 38: * operation to complete without waiting for drain. (ABC) ! 39: * ! 40: * Revision 1.1 88/03/24 16:18:12 src ! 41: * Initial revision ! 42: * ! 43: * 86/12/12 Allan Cornish /usr/src/sys/drv/tty.c ! 44: * Added 3rd argument to ttpoll() to support non-blocking polls. ! 45: * ! 46: * 86/11/19 Allan Cornish /usr/src/sys/drv/tty.c ! 47: * Made ttread() and ttwrite() recognize the IONDLY flag in iop->io_flag. ! 48: * wakeup() and pollwake() now have delayed invocation by defer(). ! 49: * Added poll [System V.3] capability. ! 50: * ! 51: * 85/06/28 Allan Cornish ! 52: * made ttioctl() clear T_STOP flag if ISRIN. ! 53: * ! 54: * 85/03/04 Allan Cornish ! 55: * made ttread() interruptible. ! 56: * ! 57: * 85/03/01 Allan Cornish ! 58: * made ttclose() interruptible. ! 59: */ ! 60: ! 61: /* ! 62: * Includes. ! 63: */ ! 64: #include <sys/clist.h> ! 65: #include <sys/coherent.h> ! 66: #include <sys/con.h> ! 67: #include <sys/deftty.h> ! 68: #include <sys/io.h> ! 69: #include <sys/proc.h> ! 70: #include <sys/sched.h> ! 71: #include <sys/stat.h> ! 72: #include <sys/tty.h> ! 73: #include <sys/uproc.h> ! 74: #include <errno.h> ! 75: ! 76: /* ! 77: * Definitions. ! 78: * Constants. ! 79: * Macros with argument lists. ! 80: * Typedefs. ! 81: * Enums. ! 82: */ ! 83: ! 84: /* NEAR_OR_FAR_CALL is for invoking t_param and t_start */ ! 85: #define NEAR_OR_FAR_CALL(tp_fn) {\ ! 86: if (tp->t_cs_sel) \ ! 87: ld_call(tp->t_cs_sel, tp->tp_fn, tp); \ ! 88: else \ ! 89: (*tp->tp_fn)(tp); } ! 90: ! 91: /* ! 92: * Functions. ! 93: * Import Functions. ! 94: * Export Functions. ! 95: * Local Functions. ! 96: */ ! 97: void ttclose(); ! 98: void ttflush(); ! 99: void tthup(); ! 100: void ttin(); ! 101: void ttioctl(); ! 102: void ttopen(); ! 103: int ttout(); ! 104: int ttpoll(); ! 105: void ttread(); ! 106: void ttsetgrp(); ! 107: void ttsignal(); ! 108: void ttstart(); ! 109: void ttstash(); ! 110: void ttwrite(); ! 111: ! 112: /* ! 113: * Global Data. ! 114: * Import Variables. ! 115: * Export Variables. ! 116: * Local Variables. ! 117: */ ! 118: extern int wakeup(); ! 119: extern void pollwake(); ! 120: ! 121: /* ! 122: * ttopen() ! 123: * ! 124: * Called by driver on first open. ! 125: * Set up defaults. ! 126: */ ! 127: void ttopen(tp) ! 128: register TTY *tp; ! 129: { ! 130: tp->t_escape = 0; ! 131: tp->t_sgttyb.sg_ispeed = tp->t_dispeed; ! 132: tp->t_sgttyb.sg_ospeed = tp->t_dospeed; ! 133: tp->t_sgttyb.sg_erase = DEF_SG_ERASE; ! 134: tp->t_sgttyb.sg_kill = DEF_SG_KILL; ! 135: tp->t_sgttyb.sg_flags = DEF_SG_FLAGS; ! 136: tp->t_tchars.t_intrc = DEF_T_INTRC; ! 137: tp->t_tchars.t_quitc = DEF_T_QUITC; ! 138: tp->t_tchars.t_startc = DEF_T_STARTC; ! 139: tp->t_tchars.t_stopc = DEF_T_STOPC; ! 140: tp->t_tchars.t_eofc = DEF_T_EOFC; ! 141: tp->t_tchars.t_brkc = DEF_T_BRKC; ! 142: if (tp->t_param != NULL) { ! 143: NEAR_OR_FAR_CALL(t_param) ! 144: } ! 145: } ! 146: ! 147: /* ! 148: * ttsetgrp() ! 149: * ! 150: * Set process group when process does not have one. ! 151: * Also set up process's controlling terminal. ! 152: */ ! 153: void ttsetgrp(tp, ctdev) ! 154: register TTY *tp; ! 155: dev_t ctdev; ! 156: { ! 157: register PROC *pp; ! 158: ! 159: pp = SELF; ! 160: if (pp->p_group == 0) { ! 161: if (tp->t_group == 0) ! 162: tp->t_group = pp->p_pid; ! 163: pp->p_group = tp->t_group; ! 164: } ! 165: if (pp->p_ttdev == NODEV) ! 166: pp->p_ttdev = ctdev; ! 167: } ! 168: ! 169: /* ! 170: * ttyclose() ! 171: * ! 172: * Called by driver on the last close. ! 173: * Wait for all pending output to go out. ! 174: * Kill input. ! 175: */ ! 176: void ttclose(tp) ! 177: register TTY *tp; ! 178: { ! 179: register int s; ! 180: ! 181: while (tp->t_oq.cq_cc != 0) { ! 182: s = sphi(); ! 183: if (tp->t_oq.cq_cc != 0) { ! 184: tp->t_flags |= T_DRAIN; ! 185: sleep((char *)&tp->t_oq, CVTTOUT, IVTTOUT, SVTTOUT); ! 186: } ! 187: spl(s); ! 188: if (SELF->p_ssig && nondsig()) ! 189: break; ! 190: } ! 191: ttflush(tp); ! 192: tp->t_flags = tp->t_group = 0; ! 193: } ! 194: ! 195: /* ! 196: * ttread() ! 197: * ! 198: * The read routine for a tty device driver will call this function. ! 199: * ! 200: * Move data from tp->t_iq to io segment iop. ! 201: * Number of characters to copy is in iop->ioc. ! 202: * ! 203: * In cooked mode, copy up to the first newline or break character, or ! 204: * until the count runs out. ! 205: * In CBREAK or RAW modes, return when count runs out or when input clist ! 206: * is empty and we're returning at least one byte. ! 207: */ ! 208: void ttread(tp, iop) ! 209: register TTY *tp; ! 210: register IO *iop; ! 211: { ! 212: register c; ! 213: int o; ! 214: int sioc = iop->io_ioc; /* number of bytes to read */ ! 215: ! 216: while (iop->io_ioc) { ! 217: o = sphi(); ! 218: while ((c = getq(&tp->t_iq)) < 0) { ! 219: if ((tp->t_flags & T_CARR) == 0) { ! 220: u.u_error = EIO; /* error since no carrier */ ! 221: spl(o); ! 222: return; ! 223: } ! 224: ! 225: /* If we're in CBREAK or RAW mode, and we don't */ ! 226: /* have the special "blocking read" bit set for */ ! 227: /* these modes, and we read at least one byte */ ! 228: /* of input, return immediately, since we have */ ! 229: /* run out of characters from the clist. */ ! 230: ! 231: if (ISBBYB && ((tp->t_flags & T_BRD) == 0) ! 232: && iop->io_ioc < sioc) { ! 233: spl(o); ! 234: return; ! 235: } ! 236: ! 237: /* ! 238: * Non-blocking reads. ! 239: * Tell user process to try again later. ! 240: */ ! 241: if ( iop->io_flag & IONDLY ) { ! 242: u.u_error = EAGAIN; ! 243: spl(o); ! 244: return; ! 245: } ! 246: ! 247: tp->t_flags |= T_INPUT; /* wait for more data */ ! 248: sleep((char *)&tp->t_iq, CVTTIN, IVTTIN, SVTTIN); ! 249: ! 250: if (SELF->p_ssig && nondsig()) { ! 251: if (iop->io_ioc == sioc) ! 252: u.u_error = EINTR; ! 253: spl(o); ! 254: return; ! 255: } ! 256: } ! 257: /* ! 258: * Flow control - can we turn on input from the driver yet? ! 259: */ ! 260: if (tp->t_iq.cq_cc <= ILOLIM) { ! 261: if ((tp->t_flags&T_ISTOP) != 0) ! 262: tp->t_flags &= ~T_ISTOP; ! 263: if ((tp->t_flags&T_TSTOP) != 0) { ! 264: tp->t_flags &= ~T_TSTOP; ! 265: while (putq(&tp->t_oq, startc) < 0) { ! 266: ttstart(tp); ! 267: waitq(); ! 268: } ! 269: ttstart(tp); ! 270: } ! 271: } ! 272: spl(o); ! 273: if (!ISBBYB && ISEOF) ! 274: return; ! 275: if (ioputc(c, iop) < 0) ! 276: return; ! 277: if (!ISBBYB && (c=='\n' || ISBRK)) ! 278: return; ! 279: } ! 280: } ! 281: ! 282: /* ! 283: * ttwrite() ! 284: * ! 285: * Write routine. ! 286: * Transfer stuff to the character list. ! 287: */ ! 288: void ttwrite(tp, iop) ! 289: register TTY *tp; ! 290: register IO *iop; ! 291: { ! 292: register c; ! 293: int o; ! 294: ! 295: /* ! 296: * Non-blocking writes which can fit. ! 297: * NOTE: exhaustion of clists can still cause blocking writes. ! 298: */ ! 299: if ( (iop->io_flag & IONDLY) && (OHILIM >= iop->io_ioc) ) { ! 300: ! 301: /* ! 302: * No room. ! 303: */ ! 304: if ( tp->t_oq.cq_cc >= OHILIM-iop->io_ioc ) { ! 305: u.u_error = EAGAIN; ! 306: return; ! 307: } ! 308: } ! 309: ! 310: while ((c = iogetc(iop)) >= 0) { ! 311: if ((tp->t_flags & T_CARR) == 0) { ! 312: u.u_error = EIO; /* error since no carrier */ ! 313: return; ! 314: } ! 315: o = sphi(); ! 316: while (tp->t_oq.cq_cc >= OHILIM) { ! 317: ttstart(tp); ! 318: if (tp->t_oq.cq_cc < OHILIM) ! 319: break; ! 320: tp->t_flags |= T_HILIM; ! 321: sleep((char *)&tp->t_oq, CVTTOUT, IVTTOUT, SVTTOUT); ! 322: if (SELF->p_ssig && nondsig()) { ! 323: u.u_error = EINTR; ! 324: spl(o); ! 325: return; ! 326: } ! 327: } ! 328: while (putq(&tp->t_oq, c) < 0) { ! 329: ttstart(tp); ! 330: waitq(); ! 331: } ! 332: spl(o); ! 333: } ! 334: o = sphi(); ! 335: ttstart(tp); ! 336: spl(o); ! 337: } ! 338: ! 339: /* ! 340: * ttioctl() ! 341: * ! 342: * This routine handles common typewriter ioctl functions. ! 343: * Note that flushing the stream now means drain the output ! 344: * and clear the input. ! 345: */ ! 346: void ttioctl(tp, com, vec) ! 347: register TTY *tp; ! 348: register struct sgttyb *vec; ! 349: { ! 350: register int flush = 0; ! 351: register int drain = 0; ! 352: register char *p1, *p2; ! 353: int rload = 0; ! 354: int was_bbyb = 0; ! 355: ! 356: switch (com) { ! 357: case TIOCQUERY: ! 358: kucopy(&tp->t_iq.cq_cc, vec, sizeof(int)); ! 359: break; ! 360: case TIOCGETP: ! 361: kucopy(&tp->t_sgttyb, vec, sizeof (struct sgttyb)); ! 362: break; ! 363: case TIOCSETP: ! 364: ++flush; /* flush input */ ! 365: ++drain; /* delay for output */ ! 366: ++rload; ! 367: ukcopy(vec, &tp->t_sgttyb, sizeof (struct sgttyb)); ! 368: break; ! 369: case TIOCSETN: ! 370: was_bbyb = ISBBYB; /* previous mode */ ! 371: ++rload; ! 372: ukcopy(vec, &tp->t_sgttyb, sizeof (struct sgttyb)); ! 373: if (!was_bbyb && ISBBYB && tp->t_ibx != 0) { ! 374: p1 = &tp->t_ib[0]; ! 375: p2 = &tp->t_ib[tp->t_ibx]; ! 376: while (p1 < p2) ! 377: #if NOT_8_BIT ! 378: putq(&tp->t_iq, (*p1++) & 0177); ! 379: #else ! 380: putq(&tp->t_iq, (*p1++)); ! 381: #endif ! 382: tp->t_ibx = 0; ! 383: } ! 384: break; ! 385: case TIOCGETC: ! 386: kucopy(&tp->t_tchars, vec, sizeof (struct tchars)); ! 387: break; ! 388: case TIOCSETC: ! 389: ++rload; ! 390: ++drain; ! 391: ukcopy(vec, &tp->t_tchars, sizeof (struct tchars)); ! 392: break; ! 393: case TIOCEXCL: ! 394: tp->t_flags |= T_EXCL; ! 395: break; ! 396: case TIOCNXCL: ! 397: tp->t_flags &= ~T_EXCL; ! 398: break; ! 399: case TIOCHPCL: /* set hangup on last close */ ! 400: tp->t_flags |= T_HPCL; ! 401: break; ! 402: case TIOCCHPCL: /* don't hangup on last close */ ! 403: if (!super()) /* only superuser may do this */ ! 404: u.u_error = EPERM; /* not su */ ! 405: else ! 406: tp->t_flags &= ~T_HPCL; /* turn off hangup bit */ ! 407: break; ! 408: case TIOCGETTF: /* get tty flag word */ ! 409: kucopy(&tp->t_flags, (unsigned *) vec, sizeof(unsigned)); ! 410: break; ! 411: case TIOCFLUSH: ! 412: ++flush; /* flush both input and output */ ! 413: ++drain; ! 414: break; ! 415: case TIOCBREAD: /* blocking read for CBREAK/RAW mode */ ! 416: tp->t_flags |= T_BRD; ! 417: break; ! 418: case TIOCCBREAD: /* turn off CBREAK/RAW blocking read mode */ ! 419: tp->t_flags &= ~T_BRD; ! 420: break; ! 421: default: ! 422: u.u_error = EINVAL; ! 423: } ! 424: ! 425: /* ! 426: * Ensure output is enabled BEFORE waiting for output to drain. ! 427: */ ! 428: if ( (ISRIN) && (tp->t_flags & T_STOP) ) { ! 429: tp->t_flags &= ~T_STOP; ! 430: ttstart( tp ); ! 431: } ! 432: ! 433: /* ! 434: * Wait for output to drain, or signal to arrive. ! 435: */ ! 436: if (drain != 0) { ! 437: while (tp->t_oq.cq_cc != 0) { ! 438: tp->t_flags |= T_DRAIN; ! 439: sleep((char *)&tp->t_oq, CVTTOUT, IVTTOUT, SVTTOUT); ! 440: if (SELF->p_ssig && nondsig()) ! 441: break; ! 442: } ! 443: } ! 444: ! 445: /* ! 446: * Flush input. ! 447: */ ! 448: if (flush != 0) ! 449: ttflush(tp); ! 450: ! 451: /* ! 452: * Re-initialize hardware. ! 453: */ ! 454: if ( (rload != 0) && (tp->t_param != NULL) ) ! 455: NEAR_OR_FAR_CALL(t_param) ! 456: } ! 457: ! 458: /* ! 459: * ttpoll() ! 460: * ! 461: * Polling routine. ! 462: * [System V.3 Compatible] ! 463: */ ! 464: int ttpoll( tp, ev, msec ) ! 465: register TTY * tp; ! 466: int ev; ! 467: int msec; ! 468: { ! 469: /* ! 470: * Priority polls not supported. ! 471: */ ! 472: ev &= ~POLLPRI; ! 473: ! 474: /* ! 475: * Input poll with no data present. ! 476: */ ! 477: if ( (ev & POLLIN) && (tp->t_iq.cq_cc == 0) ) { ! 478: ! 479: /* ! 480: * Blocking input poll. ! 481: */ ! 482: if ( msec != 0 ) ! 483: pollopen( &tp->t_ipolls ); ! 484: ! 485: /* ! 486: * Second look to avoid interrupt race. ! 487: */ ! 488: if ( tp->t_iq.cq_cc == 0 ) ! 489: ev &= ~POLLIN; ! 490: } ! 491: ! 492: /* ! 493: * Output poll with no space. ! 494: */ ! 495: if ( (ev & POLLOUT) && (tp->t_oq.cq_cc >= OLOLIM) ) { ! 496: ! 497: /* ! 498: * Blocking output poll. ! 499: */ ! 500: if ( msec != 0 ) ! 501: pollopen( &tp->t_opolls ); ! 502: ! 503: /* ! 504: * Second look to avoid interrupt race. ! 505: */ ! 506: if ( tp->t_oq.cq_cc >= OLOLIM ) ! 507: ev &= ~POLLIN; ! 508: } ! 509: ! 510: if ( ((ev & POLLIN) == 0) && ((tp->t_flags & T_CARR) == 0) ) ! 511: ev |= POLLHUP; ! 512: ! 513: return ev; ! 514: } ! 515: ! 516: /* ! 517: * ttout() ! 518: * ! 519: * Pull a character from the output queues of the typewriter. ! 520: * Doing fills, newline insert, tab expansion, etc. ! 521: * ! 522: * If the stream is empty return a -1. ! 523: * Called at high priority. ! 524: */ ! 525: int ttout(tp) ! 526: register TTY *tp; ! 527: { ! 528: register c; ! 529: ! 530: if (tp->t_nfill) { ! 531: --tp->t_nfill; ! 532: c = tp->t_fillb; ! 533: } else if ((tp->t_flags&T_INL) != 0) { ! 534: tp->t_flags &= ~T_INL; ! 535: c = '\n'; ! 536: } else { ! 537: if ((c=getq(&tp->t_oq)) < 0) ! 538: return -1; ! 539: if (!ISROUT) { ! 540: if (c=='\n' && ISCRMOD) { ! 541: tp->t_flags |= T_INL; ! 542: c = '\r'; ! 543: } else if (c=='\t' && ISXTABS) { ! 544: tp->t_nfill = ~(tp->t_hpos|~07); ! 545: tp->t_fillb = ' '; ! 546: c = ' '; ! 547: } ! 548: } ! 549: } ! 550: if (!ISROUT) { ! 551: if (c == '\b') { ! 552: if (tp->t_hpos) ! 553: --tp->t_hpos; ! 554: } else if (c == '\r') ! 555: tp->t_hpos = 0; ! 556: else if (c == '\t') ! 557: tp->t_hpos = (tp->t_hpos|07) + 1; ! 558: #if NOT_8_BIT ! 559: else if (c >= ' ' && c <= '~') ! 560: #else ! 561: else if ((c >= ' ' && c <= '~') || (c >= 0200 && c <= 0376)) ! 562: #endif ! 563: ++tp->t_hpos; ! 564: } ! 565: return c; ! 566: } ! 567: ! 568: /* ! 569: * ttin() ! 570: * ! 571: * Pass a character to the device independent typewriter routines. ! 572: * Handle erase and kill, tandem flow control, and other magic. ! 573: * Called at high priority from the driver's interrupt processor. ! 574: */ ! 575: void ttin(tp, c) ! 576: register TTY *tp; ! 577: register c; ! 578: { ! 579: int dc, i, n; ! 580: ! 581: if (!ISRIN) { ! 582: #if NOT_8_BIT ! 583: c &= 0177; ! 584: #endif ! 585: if (ISINTR) { ! 586: ttsignal(tp, SIGINT); ! 587: return; ! 588: } ! 589: if (ISQUIT) { ! 590: ttsignal(tp, SIGQUIT); ! 591: return; ! 592: } ! 593: ! 594: /* ! 595: * Only do flow control if TANDEM is set. ! 596: */ ! 597: if (ISTAND) { ! 598: if (ISSTOP) { ! 599: if ((tp->t_flags&T_STOP) == 0) ! 600: tp->t_flags |= T_STOP; ! 601: return; ! 602: } ! 603: if (ISSTART) { ! 604: tp->t_flags &= ~T_STOP; ! 605: ttstart(tp); ! 606: return; ! 607: } ! 608: } ! 609: } ! 610: if ((tp->t_flags&T_ISTOP) != 0) ! 611: return; ! 612: if (!ISRIN) { ! 613: if (c=='\r' && ISCRMOD) ! 614: c = '\n'; ! 615: if (tp->t_escape != 0) { ! 616: if (c == ESC) ! 617: ++tp->t_escape; ! 618: else { ! 619: if (ISERASE || ISKILL) { ! 620: c |= 0200; ! 621: --tp->t_escape; ! 622: } ! 623: while (tp->t_escape!=0 && tp->t_ibx<NCIB-1) { ! 624: tp->t_ib[tp->t_ibx++] = ESC; ! 625: --tp->t_escape; ! 626: } ! 627: ttstash(tp, c); ! 628: } ! 629: if (ISECHO) { ! 630: #if NOT_8_BIT ! 631: putq(&tp->t_oq, c&0177); ! 632: #else ! 633: putq(&tp->t_oq, c); /* no strip for 8-bit */ ! 634: #endif ! 635: ttstart(tp); ! 636: } ! 637: return; ! 638: } ! 639: if (ISERASE && !ISCBRK) { ! 640: while (tp->t_escape!=0 && tp->t_ibx<NCIB-1) { ! 641: tp->t_ib[tp->t_ibx++] = ESC; ! 642: --tp->t_escape; ! 643: } ! 644: if (tp->t_ibx == 0) ! 645: return; ! 646: dc = tp->t_ib[--tp->t_ibx]; ! 647: if (ISECHO) { ! 648: if (!ISCRT) ! 649: putq(&tp->t_oq, c); ! 650: /* don't erase for bell, null, or rubout */ ! 651: #if NOT_8_BIT ! 652: else if (((c = dc&0177) == '\007') ! 653: || c == 0 || c == 0177) ! 654: #else ! 655: else if (((c = dc) == '\007') ! 656: || c == 0 || c == 0177 || c == 0377) ! 657: #endif ! 658: return; ! 659: else if (c != '\b' && c != '\t') { ! 660: putq(&tp->t_oq, '\b'); ! 661: putq(&tp->t_oq, ' '); ! 662: putq(&tp->t_oq, '\b'); ! 663: } else if (c == '\t') { ! 664: n = tp->t_opos + tp->t_escape; ! 665: for (i=0; i<tp->t_ibx; ++i) { ! 666: c = tp->t_ib[i]; ! 667: #if NOT_8_BIT ! 668: if ((c&0200) != 0) { ! 669: ++n; ! 670: c &= 0177; ! 671: } ! 672: #endif ! 673: if (c == '\b') ! 674: --n; ! 675: else { ! 676: if (c == '\t') ! 677: n |= 07; ! 678: ++n; ! 679: } ! 680: } ! 681: while (n++ < tp->t_hpos) ! 682: putq(&tp->t_oq, '\b'); ! 683: } ! 684: #if NOT_8_BIT ! 685: if ((dc&0200) != 0) { ! 686: if ((dc&0177) != '\b') ! 687: putq(&tp->t_oq, '\b'); ! 688: putq(&tp->t_oq, ' '); ! 689: putq(&tp->t_oq, '\b'); ! 690: } ! 691: #endif ! 692: ttstart(tp); ! 693: } ! 694: return; ! 695: } ! 696: if (ISKILL && !ISCBRK) { ! 697: tp->t_ibx = 0; ! 698: tp->t_escape = 0; ! 699: if (ISECHO) { ! 700: if (c < 0x20) { ! 701: putq(&tp->t_oq, '^'); ! 702: c += 0x40; ! 703: } ! 704: putq(&tp->t_oq, c); ! 705: putq(&tp->t_oq, '\n'); ! 706: ttstart(tp); ! 707: } ! 708: return; ! 709: } ! 710: } ! 711: if (ISBBYB) { ! 712: putq(&tp->t_iq, c); ! 713: if ((tp->t_flags&T_INPUT) != 0) { ! 714: tp->t_flags &= ~T_INPUT; ! 715: defer( wakeup, (char *) &tp->t_iq ); ! 716: } ! 717: if ( tp->t_ipolls.e_procp ) { ! 718: tp->t_ipolls.e_procp = 0; ! 719: defer( pollwake, (char *) &tp->t_ipolls ); ! 720: } ! 721: } else { ! 722: if (tp->t_ibx == 0) ! 723: tp->t_opos = tp->t_hpos; ! 724: if (c == ESC) ! 725: ++tp->t_escape; ! 726: else ! 727: ttstash(tp, c); ! 728: } ! 729: if (ISECHO) { ! 730: if (ISRIN || !ISEOF) { ! 731: putq(&tp->t_oq, c); ! 732: ttstart(tp); ! 733: } ! 734: } ! 735: if ((n=tp->t_iq.cq_cc)>=IHILIM) ! 736: tp->t_flags |= T_ISTOP; ! 737: else if (ISTAND && (tp->t_flags&T_TSTOP)==0 && n>=ITSLIM) { ! 738: tp->t_flags |= T_TSTOP; ! 739: putq(&tp->t_oq, stopc); ! 740: ttstart(tp); ! 741: } ! 742: } ! 743: ! 744: /* ! 745: * ttstash() ! 746: * ! 747: * Cooked mode. ! 748: * Put character in the buffer and check for end of line. ! 749: * Only a legal end of line can take the last character position. ! 750: */ ! 751: void ttstash(tp, c) ! 752: register TTY *tp; ! 753: { ! 754: register char *p1, *p2; ! 755: ! 756: if (c=='\n' || ISEOF || ISBRK) { ! 757: p1 = &tp->t_ib[0]; ! 758: p2 = &tp->t_ib[tp->t_ibx]; ! 759: *p2++ = c; /* Always room */ ! 760: while (p1 < p2) ! 761: #if NOT_8_BIT ! 762: putq(&tp->t_iq, (*p1++)&0177); ! 763: #else ! 764: putq(&tp->t_iq, (*p1++)); ! 765: #endif ! 766: tp->t_ibx = 0; ! 767: tp->t_escape = 0; ! 768: ! 769: if ( tp->t_flags & T_INPUT ) { ! 770: tp->t_flags &= ~T_INPUT; ! 771: defer( wakeup, (char *) &tp->t_iq ); ! 772: } ! 773: ! 774: if ( tp->t_ipolls.e_procp ) { ! 775: tp->t_ipolls.e_procp = 0; ! 776: defer( pollwake, (char *) &tp->t_ipolls ); ! 777: } ! 778: ! 779: } else if (tp->t_ibx < NCIB-1) ! 780: tp->t_ib[tp->t_ibx++] = c; ! 781: } ! 782: ! 783: /* ! 784: * ttstart() ! 785: * ! 786: * Start output on a tty. ! 787: * Duck out if stopped. Do wakeups. ! 788: */ ! 789: void ttstart(tp) ! 790: register TTY *tp; ! 791: { ! 792: register int n; ! 793: ! 794: n = tp->t_flags; ! 795: if ( n & T_STOP ) ! 796: return; ! 797: ! 798: if ((n&T_DRAIN)!=0 && tp->t_oq.cq_cc==0 ! 799: && (n&T_INL)==0 && tp->t_nfill==0) ! 800: { tp->t_flags &= ~T_DRAIN; ! 801: defer( wakeup, (char *) &tp->t_oq ); ! 802: return; ! 803: } ! 804: ! 805: NEAR_OR_FAR_CALL(t_start) ! 806: ! 807: if ( tp->t_oq.cq_cc > OLOLIM ) ! 808: return; ! 809: ! 810: if ( n & T_HILIM ) { ! 811: tp->t_flags &= ~T_HILIM; ! 812: defer( wakeup, (char *) &tp->t_oq ); ! 813: } ! 814: ! 815: if ( tp->t_opolls.e_procp ) { ! 816: tp->t_opolls.e_procp = 0; ! 817: defer( pollwake, (char *) &tp->t_opolls ); ! 818: } ! 819: } ! 820: ! 821: /* ! 822: * ttflush() ! 823: * ! 824: * Flush a tty. ! 825: * Called to clear out queues. ! 826: */ ! 827: void ttflush(tp) ! 828: register TTY *tp; ! 829: { ! 830: clrq(&tp->t_iq); ! 831: clrq(&tp->t_oq); ! 832: ! 833: if ( tp->t_flags & T_INPUT ) ! 834: defer( wakeup, (char *) &tp->t_iq ); ! 835: ! 836: if ( tp->t_flags & (T_DRAIN|T_HILIM) ) ! 837: defer( wakeup, (char *) &tp->t_oq ); ! 838: ! 839: if ( tp->t_ipolls.e_procp != 0 ) { ! 840: tp->t_ipolls.e_procp = 0; ! 841: defer( pollwake, (char *) &tp->t_ipolls ); ! 842: } ! 843: ! 844: if ( tp->t_opolls.e_procp != 0 ) { ! 845: tp->t_opolls.e_procp = 0; ! 846: defer( pollwake, (char *) &tp->t_opolls ); ! 847: } ! 848: ! 849: tp->t_ibx = 0; ! 850: tp->t_escape = 0; ! 851: tp->t_flags &= T_SAVE; /* reset most flag bits */ ! 852: } ! 853: ! 854: /* ! 855: * ttsignal() ! 856: * ! 857: * Send a signal to every process in the given process group. ! 858: */ ! 859: void ttsignal(tp, sig) ! 860: TTY *tp; ! 861: int sig; ! 862: { ! 863: register int g; ! 864: register PROC *pp; ! 865: ! 866: g = tp->t_group; ! 867: if (g == 0) ! 868: return; ! 869: ttflush(tp); ! 870: pp = &procq; ! 871: while ((pp=pp->p_nforw) != &procq) ! 872: if (pp->p_group == g) ! 873: sendsig(sig, pp); ! 874: } ! 875: ! 876: /* ! 877: * tthup() ! 878: * ! 879: * Flag hangup internally to force errors on tty read/write, flush tty, ! 880: * then send hangup signal. ! 881: */ ! 882: void tthup(tp) ! 883: register TTY *tp; ! 884: { ! 885: tp->t_flags &= ~T_CARR; /* indicate no carrier */ ! 886: ttflush(tp); ! 887: ttsignal(tp, SIGHUP); ! 888: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.