![[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 / b / kernel / io.386|
Return to tty.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / io.386 |
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: */ ! 10: ! 11: /* ! 12: * About STOP flag bits: ! 13: * T_ISTOP is set when the tty module's input queue is in danger of ! 14: * overflow. It is up to the device driver to check this flag ! 15: * and do something about it. If ttin() is called with a ! 16: * character from the device while T_ISTOP is set, the character ! 17: * is discarded. T_ISTOP is cleared when the input queue is ! 18: * sufficiently empty. The device driver can monitor this bit for ! 19: * hardware flow control. ! 20: * T_TSTOP is the "Tandem" flow control flag for input. If TANDEM is set ! 21: * and the input queue is in danger of overflow, t_stopc is sent ! 22: * and T_TSTOP is set. When the input queue is empty enough, ! 23: * t_startc is sent and T_TSTOP is cleared. ! 24: * T_STOP is the flow control bit for output. No output will be ! 25: * written to the output queue while this bit is true. ! 26: * Except for initialization of flags in the TTY struct, by ! 27: * ttopen(), this bit is not written by tty.c. ! 28: * 91/09/15 - hal ! 29: */ ! 30: /* ! 31: * About VMIN and VTIME: ! 32: * These parameters only apply when ICANON is zero. ! 33: * If VMIN > 0 and VTIME = 0, block until VMIN characters are received. ! 34: * If VMIN > 0 and VTIME > 0, block until the first character is received, ! 35: * then return after VMIN characters are received or VTIME/10 seconds ! 36: * have elapsed since last character, whichever comes first. ! 37: * If VMIN = 0, return after first character or after VTIME/10 seconds. ! 38: * (may return with read count of zero - but will return one character ! 39: * if it is available, even if VTIME is zero). ! 40: */ ! 41: ! 42: /* ! 43: * Includes. ! 44: */ ! 45: #include <sys/coherent.h> ! 46: #include <sys/clist.h> ! 47: #include <sys/con.h> ! 48: #include <sys/deftty.h> ! 49: #include <sys/io.h> ! 50: #include <sys/proc.h> ! 51: #include <sys/sched.h> ! 52: #include <sys/stat.h> ! 53: #include <sys/tty.h> ! 54: #include <errno.h> ! 55: #ifdef _I386 ! 56: #include <termio.h> ! 57: #include <sys/inode.h> ! 58: #include <sys/ascii.h> ! 59: #else ! 60: #define kucopyS(k, u, n) kucopy(k, u, n) ! 61: #define ukcopyS(u, k, n) ukcopy(u, k, n) ! 62: #endif ! 63: ! 64: #ifdef TRACER ! 65: #define DUMPSGTTY(sp) dumpsgtty(sp) ! 66: ! 67: static void dumpsgtty(sp) ! 68: struct sgttyb * sp; ! 69: { ! 70: T_HAL(2, printf("S:%x:%x ", sp->sg_ispeed, sp->sg_flags)); ! 71: } ! 72: #else ! 73: #define DUMPSGTTY(sp) ! 74: #endif ! 75: ! 76: /* ! 77: * Definitions. ! 78: * Constants. ! 79: * Macros with argument lists. ! 80: * Typedefs. ! 81: * Enums. ! 82: */ ! 83: ! 84: #define SGTTY_CPY_LEN (sizeof (struct sgttyb)) ! 85: ! 86: /* NEAR_OR_FAR_CALL is for invoking t_param and t_start */ ! 87: #ifdef _I386 ! 88: #define NEAR_OR_FAR_CALL(tp_fn) { (*tp->tp_fn)(tp); } ! 89: #define SET_HPCL { \ ! 90: if (tp->t_termio.c_cflag & HUPCL) \ ! 91: tp->t_flags |= T_HPCL; \ ! 92: else \ ! 93: tp->t_flags &= ~T_HPCL; } ! 94: #else ! 95: #define NEAR_OR_FAR_CALL(tp_fn) {\ ! 96: if (tp->t_cs_sel) \ ! 97: ld_call(tp->t_cs_sel, tp->tp_fn, tp); \ ! 98: else \ ! 99: (*tp->tp_fn)(tp); } ! 100: #define SET_HPCL ! 101: #endif ! 102: ! 103: /* ! 104: * Functions. ! 105: * Import Functions. ! 106: * Export Functions. ! 107: * Local Functions. ! 108: */ ! 109: void ttclose(); ! 110: void ttflush(); ! 111: void tthup(); ! 112: void ttin(); ! 113: void ttinflush(); ! 114: int ttinp(); ! 115: void ttioctl(); ! 116: void ttopen(); ! 117: int ttout(); ! 118: void ttoutflush(); ! 119: int ttoutp(); ! 120: int ttpoll(); ! 121: void ttread(); ! 122: void ttread0(); ! 123: void ttsetgrp(); ! 124: void ttsignal(); ! 125: void ttstart(); ! 126: void ttwrite(); ! 127: void ttwrite0(); ! 128: ! 129: static void ttstash(); ! 130: static void ttrtp(); ! 131: ! 132: #ifdef _I386 ! 133: static void make_termio(); ! 134: static void make_sg(); ! 135: #else ! 136: #define make_termio(a1,a2,a3) ! 137: #define make_sg(a1,a2,a3) ! 138: #endif ! 139: ! 140: /* ! 141: * Global Data. ! 142: * Import Variables. ! 143: * Export Variables. ! 144: * Local Variables. ! 145: */ ! 146: extern int wakeup(); ! 147: extern void pollwake(); ! 148: ! 149: /* ! 150: * ttopen() ! 151: * ! 152: * Called by driver on first open. ! 153: * Set up defaults. ! 154: */ ! 155: void ! 156: ttopen(tp) ! 157: register TTY *tp; ! 158: { ! 159: tp->t_escape = 0; ! 160: tp->t_sgttyb.sg_ispeed = tp->t_dispeed; ! 161: tp->t_sgttyb.sg_ospeed = tp->t_dospeed; ! 162: tp->t_sgttyb.sg_erase = DEF_SG_ERASE; ! 163: tp->t_sgttyb.sg_kill = DEF_SG_KILL; ! 164: tp->t_sgttyb.sg_flags = DEF_SG_FLAGS; ! 165: tp->t_tchars.t_intrc = DEF_T_INTRC; ! 166: tp->t_tchars.t_quitc = DEF_T_QUITC; ! 167: tp->t_tchars.t_startc = DEF_T_STARTC; ! 168: tp->t_tchars.t_stopc = DEF_T_STOPC; ! 169: tp->t_tchars.t_eofc = DEF_T_EOFC; ! 170: tp->t_tchars.t_brkc = DEF_T_BRKC; ! 171: ! 172: #ifdef _I386 ! 173: tp->t_termio.c_lflag |= ICANON; ! 174: tp->t_termio.c_cc[VEOL] = A_NL; ! 175: tp->t_termio.c_cc[VEOF] = A_EOT; ! 176: make_termio(&tp->t_sgttyb, &tp->t_tchars, &tp->t_termio); ! 177: if (tp->t_flags & T_HPCL) ! 178: tp->t_termio.c_cflag |= HUPCL; ! 179: else ! 180: tp->t_termio.c_cflag &= ~HUPCL; ! 181: tp->t_termio.c_cflag |= (CS8|CREAD); ! 182: #endif ! 183: ! 184: if (tp->t_param) ! 185: NEAR_OR_FAR_CALL(t_param) ! 186: } ! 187: ! 188: /* ! 189: * ttsetgrp() ! 190: * ! 191: * If process is a group leader without a control terminal, ! 192: * make its control terminal this device. ! 193: * ! 194: * If process is a group leader and this device does not have ! 195: * a process group, give it the group of the current process. ! 196: */ ! 197: void ttsetgrp(tp, ctdev, mode) ! 198: register TTY *tp; ! 199: dev_t ctdev; ! 200: int mode; ! 201: { ! 202: register PROC *pp; ! 203: ! 204: pp = SELF; ! 205: #ifdef _I386 ! 206: if (pp->p_group == pp->p_pid && 0 == (mode & IPNOCTTY)) { ! 207: #else ! 208: if (pp->p_group == pp->p_pid) { ! 209: #endif ! 210: if (pp->p_ttdev == NODEV) ! 211: pp->p_ttdev = ctdev; ! 212: if (tp->t_group == 0) ! 213: tp->t_group = pp->p_pid; ! 214: } ! 215: } ! 216: ! 217: /* ! 218: * ttyclose() ! 219: * ! 220: * Called by driver on the last close. ! 221: * Wait for all pending output to go out. ! 222: * Kill input. ! 223: */ ! 224: void ttclose(tp) ! 225: register TTY *tp; ! 226: { ! 227: register int s; ! 228: ! 229: while (tp->t_oq.cq_cc) { ! 230: s = sphi(); ! 231: if (tp->t_oq.cq_cc) { ! 232: tp->t_flags |= T_DRAIN; ! 233: #ifdef _I386 ! 234: x_sleep((char *)&tp->t_oq, pritty, slpriSigCatch, ! 235: "ttydrain"); ! 236: #else ! 237: v_sleep((char *)&tp->t_oq, CVTTOUT, IVTTOUT, SVTTOUT, ! 238: "ttydrain"); ! 239: #endif ! 240: /* The line discipline is waiting for the tty to drain. */ ! 241: } ! 242: spl(s); ! 243: if (SELF->p_ssig && nondsig()) ! 244: break; ! 245: } ! 246: ttflush(tp); ! 247: tp->t_flags = tp->t_group = 0; ! 248: } ! 249: ! 250: /* ! 251: * ttread() ! 252: * ! 253: * The read routine for a tty device driver will call this function. ! 254: * ! 255: * Move data from tp->t_iq to io segment iop. ! 256: * Number of characters to copy is in iop->ioc. ! 257: * ! 258: * In cooked mode, copy up to the first newline or break character, or ! 259: * until the count runs out. ! 260: * In CBREAK or RAW modes, return when count runs out or when input clist ! 261: * is empty and we're returning at least one byte. ! 262: */ ! 263: ! 264: void ttread(tp, iop) ! 265: register TTY *tp; ! 266: register IO *iop; ! 267: { ! 268: ttread0(tp, iop, 0, 0, 0, 0); ! 269: } ! 270: ! 271: /* VTIME value is in 10ths of a second */ ! 272: /* VTICKS is number of cpu ticks per VTIME unit */ ! 273: #define VTICKS (HZ/10) ! 274: ! 275: /* ! 276: * ttread0() ! 277: * ! 278: * Move data from user (in IO struct) to clists. ! 279: * Do wakeups on functions supplied when read is blocked or completed. ! 280: */ ! 281: void ttread0(tp, iop, func1, arg1, func2, arg2) ! 282: register TTY *tp; ! 283: register IO *iop; ! 284: int (*func1)(), arg1, (*func2)(), arg2; ! 285: { ! 286: register int c; ! 287: int o; ! 288: int sioc = iop->io_ioc; /* number of bytes to read */ ! 289: ! 290: #ifdef _I386 ! 291: int time0 = lbolt; ! 292: int timing = 0; /* a boolean flag */ ! 293: int got_ch = 0; /* a boolean flag */ ! 294: unsigned char vtime = tp->t_termio.c_cc[VTIME]; ! 295: unsigned char vmin = tp->t_termio.c_cc[VMIN]; ! 296: #endif ! 297: ! 298: while (iop->io_ioc) { ! 299: #ifdef _I386 ! 300: /* ! 301: * Start VTIME timer if we got a character or vmin is zero. ! 302: */ ! 303: if (ISBBYB && vtime) { ! 304: if (got_ch || vmin == 0) { ! 305: timing = 1; ! 306: time0 = lbolt; ! 307: timeout(&tp->t_vtime, vtime*VTICKS, wakeup, ! 308: &tp->t_iq); ! 309: } ! 310: } ! 311: #endif ! 312: ! 313: o = sphi(); ! 314: while ((c = cltgetq(&tp->t_iq)) < 0) { ! 315: if ((tp->t_flags & T_CARR) == 0) { ! 316: u.u_error = EIO; /* error since no carrier */ ! 317: spl(o); ! 318: goto read_done; ! 319: } ! 320: ! 321: #ifdef _I386 ! 322: /* ! 323: * [T_BRD handling in COH 286 is replaced by ! 324: * VMIN/VTIME handling in COH 386.] ! 325: * ! 326: * If vmin is nonzero, and at least vmin characters ! 327: * have been received, return. ! 328: * ! 329: * If vmin is zero and vtime is zero, return ! 330: * whether characters have been received or not. ! 331: * ! 332: * If vmin is zero, and we got a char, return. ! 333: * ! 334: * If vtime is nonzero, and vtime 10th seconds have ! 335: * elapsed, return. ! 336: * ! 337: * Otherwise, go to sleep until more input arrives. ! 338: */ ! 339: if (ISBBYB) { ! 340: if (vmin) { ! 341: /* received vmin or more characters? */ ! 342: if ((sioc - iop->io_ioc) >= vmin) { ! 343: spl(o); ! 344: goto read_done; ! 345: } ! 346: } else { ! 347: if (got_ch || vtime == 0) { ! 348: spl(o); ! 349: goto read_done; ! 350: } ! 351: } ! 352: } ! 353: if (timing && ((lbolt - time0)/VTICKS) >= vtime) { ! 354: spl(o); ! 355: goto read_done; ! 356: } ! 357: #else ! 358: /* If we're in CBREAK or RAW mode, and we don't */ ! 359: /* have the special "blocking read" bit set for */ ! 360: /* these modes, and we read at least one byte */ ! 361: /* of input, return immediately, since we have */ ! 362: /* run out of characters from the clist. */ ! 363: ! 364: if (ISBBYB && ((tp->t_flags & T_BRD) == 0) ! 365: && iop->io_ioc < sioc) { ! 366: spl(o); ! 367: goto read_done; ! 368: } ! 369: #endif ! 370: /* ! 371: * Non-blocking reads. ! 372: * Tell user process to try again later. ! 373: */ ! 374: if (iop->io_flag & IONDLY) { ! 375: u.u_error = EAGAIN; ! 376: spl(o); ! 377: goto read_done; ! 378: } ! 379: ! 380: tp->t_flags |= T_INPUT; /* wait for more data */ ! 381: if (func1) ! 382: (*func1)(arg1); ! 383: if (func2) ! 384: (*func2)(arg2); ! 385: #ifdef _I386 ! 386: x_sleep((char *)&tp->t_iq, pritty, slpriSigLjmp, ! 387: "ttywait"); ! 388: #else ! 389: v_sleep((char *)&tp->t_iq, CVTTIN, IVTTIN, SVTTIN, ! 390: "ttywait"); ! 391: #endif ! 392: /* The line discipline is waiting for more data. */ ! 393: ! 394: if (SELF->p_ssig && nondsig()) { ! 395: if (iop->io_ioc == sioc) ! 396: u.u_error = EINTR; ! 397: spl(o); ! 398: goto read_done; ! 399: } ! 400: } ! 401: ! 402: /* Got a character "c" from the input queue. */ ! 403: got_ch = 1; ! 404: ! 405: /* ! 406: * Flow control - can we turn on input from the driver yet? ! 407: */ ! 408: if (tp->t_iq.cq_cc <= ILOLIM) { ! 409: if (tp->t_flags & T_ISTOP) ! 410: tp->t_flags &= ~T_ISTOP; ! 411: if (ISTAND && (tp->t_flags&T_TSTOP)) { ! 412: tp->t_flags &= ~T_TSTOP; ! 413: while (cltputq(&tp->t_oq, startc) < 0) { ! 414: ttstart(tp); ! 415: waitq(); ! 416: } ! 417: ttstart(tp); ! 418: } ! 419: } ! 420: spl(o); ! 421: if (!ISBBYB && ISEOF) ! 422: goto read_done; ! 423: if (ioputc(c, iop) < 0) ! 424: goto read_done; ! 425: if (!ISBBYB && (c=='\n' || ISBRK)) ! 426: goto read_done; ! 427: #ifdef _I386 ! 428: if (ISBBYB && vtime) ! 429: timing = 1; ! 430: #endif ! 431: } ! 432: ! 433: read_done: ! 434: ! 435: #ifdef _I386 ! 436: if (timing) /* turn off the VTIME timer */ ! 437: timeout(&tp->t_vtime, 0, 0, 0); ! 438: #endif ! 439: ! 440: if (func1) ! 441: (*func1)(arg1); ! 442: if (func2) ! 443: (*func2)(arg2); ! 444: return; ! 445: } ! 446: ! 447: /* ! 448: * ttwrite() ! 449: * ! 450: * Write routine. ! 451: */ ! 452: void ! 453: ttwrite(tp, iop) ! 454: register TTY *tp; ! 455: register IO *iop; ! 456: { ! 457: ttwrite0(tp, iop, 0, 0, 0, 0); ! 458: } ! 459: ! 460: /* ! 461: * ttwrite0() ! 462: * ! 463: * Move data from user (in IO struct) to clists. ! 464: * Do wakeups on functions supplied when write is blocked or completed. ! 465: */ ! 466: void ! 467: ttwrite0(tp, iop, func1, arg1, func2, arg2) ! 468: register TTY *tp; ! 469: register IO *iop; ! 470: int (*func1)(), arg1, (*func2)(), arg2; ! 471: { ! 472: register int c; ! 473: int o; ! 474: ! 475: /* ! 476: * Non-blocking writes which can fit. ! 477: * NOTE: exhaustion of clists can still cause blocking writes. ! 478: */ ! 479: if ((iop->io_flag & IONDLY) && (OHILIM >= iop->io_ioc)) { ! 480: ! 481: /* ! 482: * No room. ! 483: */ ! 484: if (tp->t_oq.cq_cc >= OHILIM-iop->io_ioc) { ! 485: u.u_error = EAGAIN; ! 486: return; ! 487: } ! 488: } ! 489: ! 490: while ((c = iogetc(iop)) >= 0) { ! 491: if ((tp->t_flags & T_CARR) == 0) { ! 492: u.u_error = EIO; /* error since no carrier */ ! 493: return; ! 494: } ! 495: o = sphi(); ! 496: while (tp->t_oq.cq_cc >= OHILIM) { ! 497: ttstart(tp); ! 498: if (tp->t_oq.cq_cc < OHILIM) ! 499: break; ! 500: tp->t_flags |= T_HILIM; ! 501: if (func1) ! 502: (*func1)(arg1); ! 503: if (func2) ! 504: (*func2)(arg2); ! 505: #ifdef _I386 ! 506: x_sleep((char *)&tp->t_oq, pritty, slpriSigCatch, "ttyoq"); ! 507: #else ! 508: v_sleep((char *)&tp->t_oq, CVTTOUT, IVTTOUT, SVTTOUT, ! 509: "ttyoq"); ! 510: #endif ! 511: /* ! 512: * The line discipline is waiting for an output ! 513: * queue to drain. ! 514: */ ! 515: if (SELF->p_ssig && nondsig()) { ! 516: u.u_error = EINTR; ! 517: spl(o); ! 518: return; ! 519: } ! 520: } ! 521: while (cltputq(&tp->t_oq, c) < 0) { ! 522: ttstart(tp); ! 523: waitq(); ! 524: } ! 525: spl(o); ! 526: } ! 527: o = sphi(); ! 528: ttstart(tp); ! 529: spl(o); ! 530: if (func1) ! 531: (*func1)(arg1); ! 532: if (func2) ! 533: (*func2)(arg2); ! 534: } ! 535: ! 536: /* ! 537: * ttioctl() ! 538: * ! 539: * This routine handles common typewriter ioctl functions. ! 540: * Note that flushing the stream now means drain the output ! 541: * and clear the input. ! 542: */ ! 543: void ! 544: ttioctl(tp, com, vec) ! 545: register TTY *tp; ! 546: int com; ! 547: register struct sgttyb *vec; ! 548: { ! 549: register int outDrain = 0; ! 550: int s; ! 551: int rload = 0; ! 552: int was_bbyb; ! 553: int inFlush = 0, outFlush = 0; ! 554: ! 555: /* ! 556: * Keep sgttyb, t_chars, AND termio structs for each tty device. ! 557: * ! 558: * TCSET* writes a new termio and converts so as to update ! 559: * sgttyb and t_chars as well. ! 560: * ! 561: * TIOCSET[NP] writes new sgttyb and converts so as to update termio. ! 562: * ! 563: * TIOCSETC writes new t_chars and converts so as to update termio. ! 564: */ ! 565: switch (com) { ! 566: #ifdef _I386 ! 567: case TCGETA: ! 568: if (!kucopyS(&tp->t_termio, vec, sizeof(struct termio))) ! 569: return; ! 570: break; ! 571: case TCSETA: ! 572: was_bbyb = ISBBYB; /* previous mode */ ! 573: if(!ukcopyS(vec, &tp->t_termio, sizeof(struct termio))) ! 574: return; ! 575: make_sg(vec, &tp->t_sgttyb, &tp->t_tchars); ! 576: SET_HPCL; ! 577: ++rload; ! 578: if (!was_bbyb && ISBBYB) ! 579: ttrtp(tp); ! 580: break; ! 581: case TCSETAW: ! 582: was_bbyb = ISBBYB; /* previous mode */ ! 583: if(!ukcopyS(vec, &tp->t_termio, sizeof(struct termio))) ! 584: return; ! 585: make_sg(vec, &tp->t_sgttyb, &tp->t_tchars); ! 586: SET_HPCL; ! 587: ++outDrain; /* delay for output */ ! 588: ++rload; ! 589: if (!was_bbyb && ISBBYB) ! 590: ttrtp(tp); ! 591: break; ! 592: case TCSETAF: ! 593: if(!ukcopyS(vec, &tp->t_termio, sizeof(struct termio))) ! 594: return; ! 595: make_sg(vec, &tp->t_sgttyb, &tp->t_tchars); ! 596: SET_HPCL; ! 597: ++inFlush; /* flush input */ ! 598: ++outDrain; /* delay for output */ ! 599: ++rload; ! 600: break; ! 601: #endif ! 602: case TIOCQUERY: ! 603: kucopyS(&tp->t_iq.cq_cc, vec, sizeof(int)); ! 604: break; ! 605: case TIOCGETP: ! 606: if (XMODE_386 && !useracc(vec, sizeof(struct sgttyb), 1)) { ! 607: u.u_error = EFAULT; ! 608: return; ! 609: } ! 610: kucopy(&tp->t_sgttyb, vec, SGTTY_CPY_LEN); ! 611: break; ! 612: case TIOCSETP: ! 613: if (XMODE_386 && !useracc(vec, sizeof(struct sgttyb), 0)) { ! 614: u.u_error = EFAULT; ! 615: return; ! 616: } ! 617: DUMPSGTTY(&tp->t_sgttyb); ! 618: ++inFlush; /* flush input */ ! 619: ++outDrain; /* delay for output */ ! 620: ++rload; ! 621: ukcopy(vec, &tp->t_sgttyb, SGTTY_CPY_LEN); ! 622: make_termio(&tp->t_sgttyb, &tp->t_tchars, &tp->t_termio); ! 623: break; ! 624: case TIOCSETN: ! 625: was_bbyb = ISBBYB; /* previous mode */ ! 626: DUMPSGTTY(&tp->t_sgttyb); ! 627: ++rload; ! 628: if (XMODE_386 && !useracc(vec, sizeof(struct sgttyb), 0)) { ! 629: u.u_error = EFAULT; ! 630: return; ! 631: } ! 632: ukcopy(vec, &tp->t_sgttyb, SGTTY_CPY_LEN); ! 633: make_termio(&tp->t_sgttyb, &tp->t_tchars, &tp->t_termio); ! 634: if (!was_bbyb && ISBBYB) ! 635: ttrtp(tp); ! 636: break; ! 637: case TIOCGETC: ! 638: kucopyS(&tp->t_tchars, vec, sizeof (struct tchars)); ! 639: break; ! 640: case TIOCSETC: ! 641: ++rload; ! 642: ++outDrain; ! 643: if(!ukcopyS(vec, &tp->t_tchars, sizeof (struct tchars))) ! 644: return; ! 645: make_termio(&tp->t_sgttyb, &tp->t_tchars, &tp->t_termio); ! 646: break; ! 647: case TIOCEXCL: ! 648: s = sphi(); ! 649: tp->t_flags |= T_EXCL; ! 650: spl(s); ! 651: break; ! 652: case TIOCNXCL: ! 653: s = sphi(); ! 654: tp->t_flags &= ~T_EXCL; ! 655: spl(s); ! 656: break; ! 657: case TIOCHPCL: /* set hangup on last close */ ! 658: s = sphi(); ! 659: tp->t_flags |= T_HPCL; ! 660: spl(s); ! 661: #ifdef _I386 ! 662: tp->t_termio.c_cflag |= HUPCL; ! 663: #endif ! 664: break; ! 665: case TIOCCHPCL: /* don't hangup on last close */ ! 666: if (!super()) /* only superuser may do this */ ! 667: u.u_error = EPERM; /* not su */ ! 668: else { ! 669: s = sphi(); ! 670: tp->t_flags &= ~T_HPCL; /* turn off hangup bit */ ! 671: spl(s); ! 672: #ifdef _I386 ! 673: tp->t_termio.c_cflag &= ~HUPCL; ! 674: #endif ! 675: } ! 676: break; ! 677: case TIOCGETTF: /* get tty flag word */ ! 678: kucopyS(&tp->t_flags, (unsigned *) vec, sizeof(unsigned)); ! 679: break; ! 680: #ifdef _I386 ! 681: case TCFLSH: ! 682: switch ((int)vec) { ! 683: case 0: inFlush++; break; ! 684: case 1: outFlush++; break; ! 685: case 2: inFlush++; outFlush++; break; ! 686: default: u.u_error = EINVAL; ! 687: } ! 688: break; ! 689: case TCSBRK: ! 690: ++outDrain; ! 691: break; ! 692: #endif ! 693: case TIOCFLUSH: ! 694: ++inFlush; /* flush both input and output */ ! 695: ++outFlush; ! 696: /* ++outDrain; Why? - hws - 91/11/22 */ ! 697: break; ! 698: #ifndef _I386 ! 699: case TIOCBREAD: /* blocking read for CBREAK/RAW mode */ ! 700: s = sphi(); ! 701: tp->t_flags |= T_BRD; ! 702: spl(s); ! 703: break; ! 704: case TIOCCBREAD: /* turn off CBREAK/RAW blocking read mode */ ! 705: s = sphi(); ! 706: tp->t_flags &= ~T_BRD; ! 707: spl(s); ! 708: break; ! 709: #endif ! 710: /* ! 711: * The following is a hack so that the process group for /dev/console ! 712: * contains the current login shell running on it. ! 713: * Only expect /etc/init to use this ugliness. ! 714: */ ! 715: case TIOCSETG: ! 716: if (super()) ! 717: tp->t_group = SELF->p_group; ! 718: break; ! 719: default: ! 720: u.u_error = EINVAL; ! 721: } ! 722: ! 723: /* ! 724: * T_STOP is set under two conditions: ! 725: * - a modem control device is awaiting carrier ! 726: * - a stopc (usually Ctrl-S) character was received. ! 727: * ! 728: * If ioctl just put device into RAWIN mode, make sure device ! 729: * is not still waiting for startc. ! 730: */ ! 731: #if _I386 ! 732: /* Is XON/XOFF flow control off *and* we are waiting for startc? */ ! 733: if ((!ISIXON) && (tp->t_flags & T_XSTOP)) { ! 734: s = sphi(); ! 735: tp->t_flags &= ~(T_STOP | T_XSTOP); ! 736: ttstart(tp); ! 737: spl(s); ! 738: } ! 739: #else ! 740: if ((!ISIXON) && (tp->t_flags & T_STOP) && !(tp->t_flags & T_HOPEN)) { ! 741: s = sphi(); ! 742: tp->t_flags &= ~T_STOP; ! 743: ttstart(tp); ! 744: spl(s); ! 745: } ! 746: #endif ! 747: ! 748: /* ! 749: * Wait for output to drain, or signal to arrive. ! 750: * ! 751: * NOTE: This stuff is properly done within the device driver, ! 752: * *before* ttioctl() is called. This paragraph should disappear ! 753: * from tty.c, with maybe an entry point added for the driver to ! 754: * drain the queue while draining the peripheral device. -hws- ! 755: */ ! 756: if (outDrain) { ! 757: while (tp->t_oq.cq_cc) { ! 758: s = sphi(); ! 759: tp->t_flags |= T_DRAIN; ! 760: spl(s); ! 761: #ifdef _I386 ! 762: x_sleep((char *)&tp->t_oq, pritty, slpriSigCatch, ! 763: "ttyiodrn"); ! 764: #else ! 765: v_sleep((char *)&tp->t_oq, CVTTOUT, IVTTOUT, SVTTOUT, ! 766: "ttyiodrn"); ! 767: #endif ! 768: /* A TIOC has asked for tty output to drain. */ ! 769: if (SELF->p_ssig && nondsig()) ! 770: break; ! 771: } ! 772: } ! 773: ! 774: /* ! 775: * Flush. ! 776: */ ! 777: if (inFlush) ! 778: ttinflush(tp); ! 779: if (outFlush) ! 780: ttoutflush(tp); ! 781: ! 782: /* ! 783: * Re-initialize hardware. ! 784: */ ! 785: if (rload) { ! 786: if (tp->t_param) ! 787: NEAR_OR_FAR_CALL(t_param) ! 788: } ! 789: } ! 790: ! 791: /* ! 792: * ttpoll() ! 793: * ! 794: * Polling routine. ! 795: * [System V.3 Compatible] ! 796: */ ! 797: int ttpoll(tp, ev, msec) ! 798: register TTY * tp; ! 799: int ev; ! 800: int msec; ! 801: { ! 802: /* ! 803: * Priority polls not supported. ! 804: */ ! 805: ev &= ~POLLPRI; ! 806: ! 807: /* ! 808: * Input poll with no data present. ! 809: */ ! 810: if ((ev & POLLIN) && (tp->t_iq.cq_cc == 0)) { ! 811: ! 812: /* ! 813: * Blocking input poll. ! 814: */ ! 815: if (msec) ! 816: pollopen(&tp->t_ipolls); ! 817: ! 818: /* ! 819: * Second look to avoid interrupt race. ! 820: */ ! 821: if (tp->t_iq.cq_cc == 0) ! 822: ev &= ~POLLIN; ! 823: } ! 824: ! 825: /* ! 826: * Output poll with no space. ! 827: */ ! 828: if ((ev & POLLOUT) && (tp->t_oq.cq_cc >= OLOLIM)) { ! 829: ! 830: /* ! 831: * Blocking output poll. ! 832: */ ! 833: if (msec) ! 834: pollopen(&tp->t_opolls); ! 835: ! 836: /* ! 837: * Second look to avoid interrupt race. ! 838: */ ! 839: if (tp->t_oq.cq_cc >= OLOLIM) ! 840: ev &= ~POLLOUT; ! 841: } ! 842: ! 843: if (((ev & POLLIN) == 0) && ((tp->t_flags & T_CARR) == 0)) ! 844: ev |= POLLHUP; ! 845: ! 846: return ev; ! 847: } ! 848: ! 849: /* ! 850: * ttout() ! 851: * ! 852: * Pull a character from the output queues of the typewriter. ! 853: * Doing fills, newline insert, tab expansion, etc. ! 854: * ! 855: * If the stream is empty return a -1. ! 856: * Called at high priority. ! 857: */ ! 858: int ttout(tp) ! 859: register TTY *tp; ! 860: { ! 861: register int c; ! 862: ! 863: if (tp->t_nfill) { ! 864: --tp->t_nfill; ! 865: c = tp->t_fillb; ! 866: } else if (tp->t_flags & T_INL) { ! 867: tp->t_flags &= ~T_INL; ! 868: c = '\n'; ! 869: } else { ! 870: if ((c=cltgetq(&tp->t_oq)) < 0) ! 871: return -1; ! 872: if (!ISROUT) { ! 873: if (c=='\n' && ISONLCR) { ! 874: tp->t_flags |= T_INL; ! 875: c = '\r'; ! 876: } else if (c=='\r' && ISOCRNL) { ! 877: c = '\n'; ! 878: } else if (c=='\t' && ISXTABS) { ! 879: tp->t_nfill = ~(tp->t_hpos|~07); ! 880: tp->t_fillb = ' '; ! 881: c = ' '; ! 882: } ! 883: } ! 884: } ! 885: if (!ISROUT) { ! 886: if (c == '\b') { ! 887: if (tp->t_hpos) ! 888: --tp->t_hpos; ! 889: } else if (c == '\r') ! 890: tp->t_hpos = 0; ! 891: else if (c == '\t') ! 892: tp->t_hpos = (tp->t_hpos|07) + 1; ! 893: #if NOT_8_BIT ! 894: else if (c >= ' ' && c <= '~') ! 895: #else ! 896: else if ((c >= ' ' && c <= '~') || (c >= 0200 && c <= 0376)) ! 897: #endif ! 898: ++tp->t_hpos; ! 899: } ! 900: return c; ! 901: } ! 902: ! 903: /* ! 904: * ttin() ! 905: * ! 906: * Pass a character to the device independent typewriter routines. ! 907: * Handle erase and kill, tandem flow control, and other magic. ! 908: * Often called at high priority from the driver's interrupt routine. ! 909: */ ! 910: void ! 911: ttin(tp, c) ! 912: register TTY *tp; ! 913: register int c; ! 914: { ! 915: int dc, i, n; ! 916: int s; ! 917: ! 918: if (ISISTRIP) ! 919: c &= 0x7F; ! 920: ! 921: if (ISISIG && ISQUIT) { ! 922: ttsignal(tp, SIGQUIT); ! 923: goto ttin_ret; ! 924: } ! 925: ! 926: if (ISISIG && ISINTR) { ! 927: ttsignal(tp, SIGINT); ! 928: goto ttin_ret; ! 929: } ! 930: ! 931: if (tp->t_flags & T_ISTOP) ! 932: goto ttin_ret; ! 933: ! 934: if (ISICRNL && !ISIGNCR) { ! 935: if (c=='\r') ! 936: c = '\n'; ! 937: } ! 938: ! 939: if (!ISRIN) { ! 940: if (tp->t_escape) { ! 941: if (c == ESC) ! 942: ++tp->t_escape; ! 943: else { ! 944: if (ISERASE || ISKILL) { ! 945: c |= 0200; ! 946: --tp->t_escape; ! 947: } ! 948: while (tp->t_escape && tp->t_ibx<NCIB-1) { ! 949: tp->t_ib[tp->t_ibx++] = ESC; ! 950: --tp->t_escape; ! 951: } ! 952: ttstash(tp, c); ! 953: } ! 954: if (ISECHO) { ! 955: #if NOT_8_BIT ! 956: cltputq(&tp->t_oq, c&0177); ! 957: #else ! 958: cltputq(&tp->t_oq, c); /* no strip for 8-bit */ ! 959: #endif ! 960: ttstart(tp); ! 961: } ! 962: goto ttin_ret; ! 963: } ! 964: if (ISERASE && !ISCBRK) { ! 965: while (tp->t_escape && tp->t_ibx<NCIB-1) { ! 966: tp->t_ib[tp->t_ibx++] = ESC; ! 967: --tp->t_escape; ! 968: } ! 969: if (tp->t_ibx == 0) ! 970: goto ttin_ret; ! 971: dc = tp->t_ib[--tp->t_ibx]; ! 972: if (ISECHO) { ! 973: if (!ISCRT) ! 974: cltputq(&tp->t_oq, c); ! 975: /* don't erase for bell, null, or rubout */ ! 976: #if NOT_8_BIT ! 977: else if (((c = dc&0177) == '\007') ! 978: || c == 0 || c == 0177) ! 979: #else ! 980: else if (((c = dc) == '\007') ! 981: || c == 0 || c == 0177 || c == 0377) ! 982: #endif ! 983: goto ttin_ret; ! 984: else if (c != '\b' && c != '\t') { ! 985: cltputq(&tp->t_oq, '\b'); ! 986: cltputq(&tp->t_oq, ' '); ! 987: cltputq(&tp->t_oq, '\b'); ! 988: } else if (c == '\t') { ! 989: n = tp->t_opos + tp->t_escape; ! 990: for (i=0; i<tp->t_ibx; ++i) { ! 991: c = tp->t_ib[i]; ! 992: #if NOT_8_BIT ! 993: if (c & 0200) { ! 994: ++n; ! 995: c &= 0177; ! 996: } ! 997: #endif ! 998: if (c == '\b') ! 999: --n; ! 1000: else { ! 1001: if (c == '\t') ! 1002: n |= 07; ! 1003: ++n; ! 1004: } ! 1005: } ! 1006: while (n++ < tp->t_hpos) ! 1007: cltputq(&tp->t_oq, '\b'); ! 1008: } ! 1009: #if NOT_8_BIT ! 1010: if (dc & 0200) { ! 1011: if ((dc&0177) != '\b') ! 1012: cltputq(&tp->t_oq, '\b'); ! 1013: cltputq(&tp->t_oq, ' '); ! 1014: cltputq(&tp->t_oq, '\b'); ! 1015: } ! 1016: #endif ! 1017: ttstart(tp); ! 1018: } ! 1019: goto ttin_ret; ! 1020: } ! 1021: if (ISKILL && !ISCBRK) { ! 1022: tp->t_ibx = 0; ! 1023: tp->t_escape = 0; ! 1024: if (ISECHO) { ! 1025: if (c < 0x20) { ! 1026: cltputq(&tp->t_oq, '^'); ! 1027: c += 0x40; ! 1028: } ! 1029: cltputq(&tp->t_oq, c); ! 1030: cltputq(&tp->t_oq, '\n'); ! 1031: ttstart(tp); ! 1032: } ! 1033: goto ttin_ret; ! 1034: } ! 1035: } ! 1036: if (ISBBYB) { ! 1037: cltputq(&tp->t_iq, c); ! 1038: if (tp->t_flags & T_INPUT) { ! 1039: s = sphi(); ! 1040: tp->t_flags &= ~T_INPUT; ! 1041: spl(s); ! 1042: wakeup(&tp->t_iq); ! 1043: } ! 1044: if (tp->t_ipolls.e_procp) { ! 1045: tp->t_ipolls.e_procp = 0; ! 1046: pollwake((char *) &tp->t_ipolls); ! 1047: } ! 1048: } else { ! 1049: if (tp->t_ibx == 0) ! 1050: tp->t_opos = tp->t_hpos; ! 1051: if (c == ESC) ! 1052: ++tp->t_escape; ! 1053: else ! 1054: ttstash(tp, c); ! 1055: } ! 1056: if (ISECHO) { ! 1057: if (ISRIN || !ISEOF) { ! 1058: cltputq(&tp->t_oq, c); ! 1059: ttstart(tp); ! 1060: } ! 1061: } ! 1062: if ((n=tp->t_iq.cq_cc)>=IHILIM) { ! 1063: s = sphi(); ! 1064: tp->t_flags |= T_ISTOP; ! 1065: spl(s); ! 1066: } else if (ISTAND && (tp->t_flags&T_TSTOP)==0 && n>=ITSLIM) { ! 1067: s = sphi(); ! 1068: tp->t_flags |= T_TSTOP; ! 1069: spl(s); ! 1070: cltputq(&tp->t_oq, stopc); ! 1071: ttstart(tp); ! 1072: } ! 1073: ! 1074: ttin_ret: ! 1075: return; ! 1076: } ! 1077: ! 1078: /* ! 1079: * ttstash() ! 1080: * ! 1081: * Cooked mode. ! 1082: * Put character in the buffer and check for end of line. ! 1083: * Only a legal end of line can take the last character position. ! 1084: * ! 1085: * Only called from ttin(), and ttin() is called at high priority. ! 1086: */ ! 1087: static void ttstash(tp, c) ! 1088: register TTY *tp; ! 1089: { ! 1090: register char *p1, *p2; ! 1091: ! 1092: if (c=='\n' || ISEOF || ISBRK) { ! 1093: p1 = &tp->t_ib[0]; ! 1094: p2 = &tp->t_ib[tp->t_ibx]; ! 1095: *p2++ = c; /* Always room */ ! 1096: while (p1 < p2) ! 1097: #if NOT_8_BIT ! 1098: cltputq(&tp->t_iq, (*p1++)&0177); ! 1099: #else ! 1100: cltputq(&tp->t_iq, (*p1++)); ! 1101: #endif ! 1102: tp->t_ibx = 0; ! 1103: tp->t_escape = 0; ! 1104: ! 1105: if (tp->t_flags & T_INPUT) { ! 1106: tp->t_flags &= ~T_INPUT; ! 1107: wakeup(&tp->t_iq); ! 1108: } ! 1109: ! 1110: if (tp->t_ipolls.e_procp) { ! 1111: tp->t_ipolls.e_procp = 0; ! 1112: pollwake((char *) &tp->t_ipolls); ! 1113: } ! 1114: ! 1115: } else if (tp->t_ibx < NCIB-1) ! 1116: tp->t_ib[tp->t_ibx++] = c; ! 1117: } ! 1118: ! 1119: /* ! 1120: * ttstart() ! 1121: * ! 1122: * Start output on a tty. ! 1123: * Duck out if stopped. Do wakeups. ! 1124: */ ! 1125: void ttstart(tp) ! 1126: register TTY *tp; ! 1127: { ! 1128: register int n; ! 1129: int s; ! 1130: ! 1131: n = tp->t_flags; ! 1132: if (n & T_STOP) ! 1133: goto stdone; ! 1134: ! 1135: if ((n&T_DRAIN) && tp->t_oq.cq_cc==0 ! 1136: && (n&T_INL)==0 && tp->t_nfill==0) { ! 1137: s = sphi(); ! 1138: tp->t_flags &= ~T_DRAIN; ! 1139: spl(s); ! 1140: wakeup(&tp->t_oq); ! 1141: goto stdone; ! 1142: } ! 1143: ! 1144: NEAR_OR_FAR_CALL(t_start) ! 1145: ! 1146: if (tp->t_oq.cq_cc > OLOLIM) ! 1147: goto stdone; ! 1148: ! 1149: if (n & T_HILIM) { ! 1150: s = sphi(); ! 1151: tp->t_flags &= ~T_HILIM; ! 1152: spl(s); ! 1153: wakeup(&tp->t_oq); ! 1154: } ! 1155: ! 1156: if (tp->t_opolls.e_procp) { ! 1157: tp->t_opolls.e_procp = 0; ! 1158: pollwake((char *) &tp->t_opolls); ! 1159: } ! 1160: stdone: ! 1161: return; ! 1162: } ! 1163: ! 1164: /* ! 1165: * ttflush() ! 1166: * ! 1167: * Flush tty input and output queues. ! 1168: */ ! 1169: void ! 1170: ttflush(tp) ! 1171: register TTY *tp; ! 1172: { ! 1173: ttinflush(tp); ! 1174: ttoutflush(tp); ! 1175: } ! 1176: ! 1177: /* ! 1178: * ttinflush() ! 1179: * ! 1180: * Flush input queues. ! 1181: */ ! 1182: void ! 1183: ttinflush(tp) ! 1184: register TTY *tp; ! 1185: { ! 1186: clrq(&tp->t_iq); ! 1187: ! 1188: if (tp->t_flags & T_INPUT) { ! 1189: wakeup(&tp->t_iq); ! 1190: } ! 1191: ! 1192: if (tp->t_ipolls.e_procp) { ! 1193: tp->t_ipolls.e_procp = 0; ! 1194: pollwake((char *) &tp->t_ipolls); ! 1195: } ! 1196: ! 1197: tp->t_ibx = 0; ! 1198: tp->t_escape = 0; ! 1199: } ! 1200: ! 1201: /* ! 1202: * ttoutflush() ! 1203: * ! 1204: * Flush tty output queues. ! 1205: */ ! 1206: void ! 1207: ttoutflush(tp) ! 1208: register TTY *tp; ! 1209: { ! 1210: clrq(&tp->t_oq); ! 1211: ! 1212: if (tp->t_flags & (T_DRAIN|T_HILIM)) { ! 1213: wakeup(&tp->t_oq); ! 1214: } ! 1215: ! 1216: if (tp->t_opolls.e_procp) { ! 1217: tp->t_opolls.e_procp = 0; ! 1218: pollwake((char *) &tp->t_opolls); ! 1219: } ! 1220: } ! 1221: ! 1222: /* ! 1223: * ttsignal() ! 1224: * ! 1225: * Send a signal to every process in the given process group. ! 1226: */ ! 1227: void ! 1228: ttsignal(tp, sig) ! 1229: TTY *tp; ! 1230: int sig; ! 1231: { ! 1232: register int g; ! 1233: register PROC *pp; ! 1234: ! 1235: g = tp->t_group; ! 1236: if (g == 0) ! 1237: goto sigdone; ! 1238: ttflush(tp); ! 1239: pp = &procq; ! 1240: while ((pp=pp->p_nforw) != &procq) ! 1241: if (pp->p_group == g) { ! 1242: sendsig(sig, pp); ! 1243: } ! 1244: sigdone: ! 1245: return; ! 1246: } ! 1247: ! 1248: /* ! 1249: * tthup() ! 1250: * ! 1251: * Flag hangup internally to force errors on tty read/write, flush tty, ! 1252: * then send hangup signal. ! 1253: */ ! 1254: void tthup(tp) ! 1255: register TTY *tp; ! 1256: { ! 1257: ttflush(tp); ! 1258: ttsignal(tp, SIGHUP); ! 1259: } ! 1260: ! 1261: #ifdef _I386 ! 1262: /* ! 1263: * Convert from sgttyb and tchars structs to termio. ! 1264: */ ! 1265: static void ! 1266: make_termio(sgp, tcp, trp) ! 1267: struct sgttyb * sgp; ! 1268: struct tchars * tcp; ! 1269: struct termio * trp; ! 1270: { ! 1271: char vmin = 1, vtime = 0; ! 1272: char veof = 4, veol = 10; /* default to ^D, ^J */ ! 1273: ! 1274: /* ! 1275: * If VMIN/VTIME are active, save now for possible restore. ! 1276: */ ! 1277: if ((trp->c_lflag & ICANON) == 0) { ! 1278: vmin = trp->c_cc[VMIN]; ! 1279: vtime = trp->c_cc[VTIME]; ! 1280: } else { ! 1281: veol = trp->c_cc[VEOL]; ! 1282: } ! 1283: ! 1284: trp->c_cc[VINTR] = tcp->t_intrc; ! 1285: trp->c_cc[VQUIT] = tcp->t_quitc; ! 1286: veof = tcp->t_eofc; ! 1287: trp->c_cc[VERASE] = sgp->sg_erase; ! 1288: trp->c_cc[VKILL ] = sgp->sg_kill; ! 1289: ! 1290: trp->c_iflag = BRKINT | IXON | IGNPAR | INPCK; ! 1291: trp->c_oflag = OPOST; ! 1292: trp->c_cflag &= (CSIZE|HUPCL|CLOCAL|CREAD); ! 1293: trp->c_lflag = ICANON | ISIG | ECHONL | ECHOK; ! 1294: ! 1295: if (sgp->sg_flags & TANDEM) ! 1296: trp->c_iflag |= IXOFF; ! 1297: ! 1298: if (sgp->sg_flags & CRMOD) { ! 1299: trp->c_iflag |= ICRNL; ! 1300: trp->c_oflag |= ONLCR; ! 1301: } ! 1302: ! 1303: if (sgp->sg_flags & LCASE) { ! 1304: trp->c_lflag |= XCASE; ! 1305: trp->c_iflag |= IUCLC; ! 1306: trp->c_oflag |= OLCUC; ! 1307: } ! 1308: ! 1309: if (sgp->sg_flags & (RAW|RAWIN)) { ! 1310: trp->c_iflag = 0; ! 1311: trp->c_cflag &= ~(PARODD|PARENB); ! 1312: trp->c_cflag |= (CS8|CREAD); ! 1313: trp->c_lflag &= ~(ECHONL|ISIG|ICANON); ! 1314: } ! 1315: ! 1316: if (sgp->sg_flags & (RAW|RAWOUT)) { ! 1317: trp->c_oflag &= ~OPOST; ! 1318: trp->c_lflag &= ~(XCASE); ! 1319: } ! 1320: ! 1321: if (sgp->sg_flags & XTABS) ! 1322: trp->c_oflag |= TAB3; ! 1323: ! 1324: if (sgp->sg_flags & (EVENP|ODDP)) { ! 1325: trp->c_cflag |= PARENB; ! 1326: if (sgp->sg_flags & ODDP) ! 1327: trp->c_cflag |= PARODD; ! 1328: } ! 1329: trp->c_cflag |= sgp->sg_ispeed; ! 1330: ! 1331: if (sgp->sg_flags & CRT) ! 1332: trp->c_lflag |= ECHOE; ! 1333: ! 1334: if (sgp->sg_flags & CBREAK) ! 1335: trp->c_lflag &= ~ICANON; ! 1336: ! 1337: if (sgp->sg_flags & ECHO) ! 1338: trp->c_lflag |= ECHO; ! 1339: ! 1340: /* ! 1341: * If not doing canonical processing, set VMIN/VTIME. ! 1342: */ ! 1343: if ((trp->c_lflag & ICANON) == 0) { ! 1344: trp->c_cc[VMIN] = vmin; ! 1345: trp->c_cc[VTIME] = vtime; ! 1346: } else { ! 1347: trp->c_cc[VEOF] = veof; ! 1348: trp->c_cc[VEOL] = veol; ! 1349: } ! 1350: } ! 1351: ! 1352: /* ! 1353: * Convert from termio struct to sgttyb and tchars. ! 1354: */ ! 1355: static void ! 1356: make_sg(trp, sgp, tcp) ! 1357: struct termio * trp; ! 1358: struct sgttyb * sgp; ! 1359: struct tchars * tcp; ! 1360: { ! 1361: T_HAL(1, { printf("T:%x:%x:%x:%x ", trp->c_iflag, trp->c_oflag, \ ! 1362: trp->c_cflag, trp->c_lflag);}); ! 1363: tcp->t_intrc = trp->c_cc[VINTR]; ! 1364: tcp->t_quitc = trp->c_cc[VQUIT]; ! 1365: tcp->t_startc= '\021'; /* Ctrl-Q */ ! 1366: tcp->t_stopc = '\023'; /* Ctrl-S */ ! 1367: tcp->t_eofc = trp->c_cc[VEOF]; ! 1368: tcp->t_brkc = -1; ! 1369: ! 1370: sgp->sg_erase = trp->c_cc[VERASE]; ! 1371: sgp->sg_kill = trp->c_cc[VKILL ]; ! 1372: sgp->sg_ispeed = trp->c_cflag & CBAUD; ! 1373: sgp->sg_ospeed = sgp->sg_ispeed; ! 1374: sgp->sg_flags = RAWIN | RAWOUT | CBREAK; ! 1375: ! 1376: if (trp->c_lflag & ECHO) ! 1377: sgp->sg_flags |= ECHO; ! 1378: ! 1379: if (trp->c_lflag & ECHOE) ! 1380: sgp->sg_flags |= CRT; ! 1381: ! 1382: if ( (trp->c_lflag & XCASE) ! 1383: || (trp->c_oflag & OLCUC) ! 1384: || (trp->c_iflag & IUCLC)) ! 1385: sgp->sg_flags |= LCASE; ! 1386: ! 1387: if (trp->c_iflag & IXOFF) ! 1388: sgp->sg_flags |= TANDEM; ! 1389: ! 1390: if (trp->c_iflag & ICRNL) ! 1391: sgp->sg_flags |= CRMOD; ! 1392: ! 1393: if (trp->c_oflag & ONLCR) ! 1394: sgp->sg_flags |= CRMOD; ! 1395: ! 1396: if (trp->c_oflag & OPOST) ! 1397: sgp->sg_flags &= ~RAWOUT; ! 1398: ! 1399: if ((trp->c_oflag & TABDLY) == TAB3) ! 1400: sgp->sg_flags |= XTABS; ! 1401: ! 1402: if (trp->c_cflag & PARENB) { ! 1403: if (trp->c_cflag & PARODD) ! 1404: sgp->sg_flags |= ODDP; ! 1405: else ! 1406: sgp->sg_flags |= EVENP; ! 1407: } ! 1408: ! 1409: if (trp->c_lflag & ISIG) ! 1410: sgp->sg_flags &= ~RAWIN; ! 1411: ! 1412: if (trp->c_lflag & ICANON) ! 1413: sgp->sg_flags &= ~CBREAK; ! 1414: } ! 1415: #endif ! 1416: ! 1417: /* ! 1418: * ttrtp() ! 1419: * ! 1420: * Recover contents of typeahead when changing modes. ! 1421: * Called for ioctls of TIOCSETP and TCSETA, ! 1422: * when going from not byte-by-byte input to BBYB. ! 1423: */ ! 1424: static void ! 1425: ttrtp(tp) ! 1426: TTY * tp; ! 1427: { ! 1428: register char *p1, *p2; ! 1429: ! 1430: if (tp->t_ibx) { ! 1431: p1 = &tp->t_ib[0]; ! 1432: p2 = &tp->t_ib[tp->t_ibx]; ! 1433: while (p1 < p2) { ! 1434: #if NOT_8_BIT ! 1435: cltputq(&tp->t_iq, (*p1++) & 0177); ! 1436: #else ! 1437: cltputq(&tp->t_iq, (*p1++)); ! 1438: #endif ! 1439: } ! 1440: tp->t_ibx = 0; ! 1441: } ! 1442: } ! 1443: ! 1444: /* ! 1445: * ttinp() ! 1446: * ! 1447: * Return nonzero if ttin() may be called to send data for pickup by ttread(), ! 1448: * or 0 if not. ! 1449: */ ! 1450: int ! 1451: ttinp(tp) ! 1452: TTY * tp; ! 1453: { ! 1454: return ((tp->t_flags&T_ISTOP) == 0); ! 1455: } ! 1456: ! 1457: /* ! 1458: * ttoutp() ! 1459: * ! 1460: * Return nonzero if ttout() may be called to fetch data stored by ttwrite(), ! 1461: * or 0 if not. ! 1462: */ ! 1463: int ! 1464: ttoutp(tp) ! 1465: TTY * tp; ! 1466: { ! 1467: return (tp->t_nfill || (tp->t_flags&T_INL) || tp->t_oq.cq_cc); ! 1468: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.