1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2008 Ed Schouten <ed@FreeBSD.org> 5 * All rights reserved. 6 * 7 * Portions of this software were developed under sponsorship from Snow 8 * B.V., the Netherlands. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __FBSDID("$FreeBSD$"); 34 35 #include <sys/param.h> 36 #include <sys/fcntl.h> 37 #include <sys/filio.h> 38 #include <sys/kernel.h> 39 #include <sys/signal.h> 40 #include <sys/sysctl.h> 41 #include <sys/systm.h> 42 #include <sys/tty.h> 43 #include <sys/ttycom.h> 44 #include <sys/ttydefaults.h> 45 #include <sys/uio.h> 46 #include <sys/vnode.h> 47 48 /* 49 * Standard TTYDISC `termios' line discipline. 50 */ 51 52 /* Statistics. */ 53 static unsigned long tty_nin = 0; 54 SYSCTL_ULONG(_kern, OID_AUTO, tty_nin, CTLFLAG_RD, 55 &tty_nin, 0, "Total amount of bytes received"); 56 static unsigned long tty_nout = 0; 57 SYSCTL_ULONG(_kern, OID_AUTO, tty_nout, CTLFLAG_RD, 58 &tty_nout, 0, "Total amount of bytes transmitted"); 59 60 /* termios comparison macro's. */ 61 #define CMP_CC(v,c) (tp->t_termios.c_cc[v] != _POSIX_VDISABLE && \ 62 tp->t_termios.c_cc[v] == (c)) 63 #define CMP_FLAG(field,opt) (tp->t_termios.c_ ## field ## flag & (opt)) 64 65 /* Characters that cannot be modified through c_cc. */ 66 #define CTAB '\t' 67 #define CNL '\n' 68 #define CCR '\r' 69 70 /* Character is a control character. */ 71 #define CTL_VALID(c) ((c) == 0x7f || (unsigned char)(c) < 0x20) 72 /* Control character should be processed on echo. */ 73 #define CTL_ECHO(c,q) (!(q) && ((c) == CERASE2 || (c) == CTAB || \ 74 (c) == CNL || (c) == CCR)) 75 /* Control character should be printed using ^X notation. */ 76 #define CTL_PRINT(c,q) ((c) == 0x7f || ((unsigned char)(c) < 0x20 && \ 77 ((q) || ((c) != CTAB && (c) != CNL)))) 78 /* Character is whitespace. */ 79 #define CTL_WHITE(c) ((c) == ' ' || (c) == CTAB) 80 /* Character is alphanumeric. */ 81 #define CTL_ALNUM(c) (((c) >= '0' && (c) <= '9') || \ 82 ((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z')) 83 84 #define TTY_STACKBUF 256 85 86 void 87 ttydisc_open(struct tty *tp) 88 { 89 ttydisc_optimize(tp); 90 } 91 92 void 93 ttydisc_close(struct tty *tp) 94 { 95 96 /* Clean up our flags when leaving the discipline. */ 97 tp->t_flags &= ~(TF_STOPPED|TF_HIWAT|TF_ZOMBIE); 98 99 /* 100 * POSIX states that we must drain output and flush input on 101 * last close. Draining has already been done if possible. 102 */ 103 tty_flush(tp, FREAD | FWRITE); 104 105 if (ttyhook_hashook(tp, close)) 106 ttyhook_close(tp); 107 } 108 109 static int 110 ttydisc_read_canonical(struct tty *tp, struct uio *uio, int ioflag) 111 { 112 char breakc[4] = { CNL }; /* enough to hold \n, VEOF and VEOL. */ 113 int error; 114 size_t clen, flen = 0, n = 1; 115 unsigned char lastc = _POSIX_VDISABLE; 116 117 #define BREAK_ADD(c) do { \ 118 if (tp->t_termios.c_cc[c] != _POSIX_VDISABLE) \ 119 breakc[n++] = tp->t_termios.c_cc[c]; \ 120 } while (0) 121 /* Determine which characters we should trigger on. */ 122 BREAK_ADD(VEOF); 123 BREAK_ADD(VEOL); 124 #undef BREAK_ADD 125 breakc[n] = '\0'; 126 127 do { 128 error = tty_wait_background(tp, curthread, SIGTTIN); 129 if (error) 130 return (error); 131 132 /* 133 * Quite a tricky case: unlike the old TTY 134 * implementation, this implementation copies data back 135 * to userspace in large chunks. Unfortunately, we can't 136 * calculate the line length on beforehand if it crosses 137 * ttyinq_block boundaries, because multiple reads could 138 * then make this code read beyond the newline. 139 * 140 * This is why we limit the read to: 141 * - The size the user has requested 142 * - The blocksize (done in tty_inq.c) 143 * - The amount of bytes until the newline 144 * 145 * This causes the line length to be recalculated after 146 * each block has been copied to userspace. This will 147 * cause the TTY layer to return data in chunks using 148 * the blocksize (except the first and last blocks). 149 */ 150 clen = ttyinq_findchar(&tp->t_inq, breakc, uio->uio_resid, 151 &lastc); 152 153 /* No more data. */ 154 if (clen == 0) { 155 if (tp->t_flags & TF_ZOMBIE) 156 return (0); 157 else if (ioflag & IO_NDELAY) 158 return (EWOULDBLOCK); 159 160 error = tty_wait(tp, &tp->t_inwait); 161 if (error) 162 return (error); 163 continue; 164 } 165 166 /* Don't send the EOF char back to userspace. */ 167 if (CMP_CC(VEOF, lastc)) 168 flen = 1; 169 170 MPASS(flen <= clen); 171 172 /* Read and throw away the EOF character. */ 173 error = ttyinq_read_uio(&tp->t_inq, tp, uio, clen, flen); 174 if (error) 175 return (error); 176 177 } while (uio->uio_resid > 0 && lastc == _POSIX_VDISABLE); 178 179 return (0); 180 } 181 182 static int 183 ttydisc_read_raw_no_timer(struct tty *tp, struct uio *uio, int ioflag) 184 { 185 size_t vmin = tp->t_termios.c_cc[VMIN]; 186 ssize_t oresid = uio->uio_resid; 187 int error; 188 189 MPASS(tp->t_termios.c_cc[VTIME] == 0); 190 191 /* 192 * This routine implements the easy cases of read()s while in 193 * non-canonical mode, namely case B and D, where we don't have 194 * any timers at all. 195 */ 196 197 for (;;) { 198 error = tty_wait_background(tp, curthread, SIGTTIN); 199 if (error) 200 return (error); 201 202 error = ttyinq_read_uio(&tp->t_inq, tp, uio, 203 uio->uio_resid, 0); 204 if (error) 205 return (error); 206 if (uio->uio_resid == 0 || (oresid - uio->uio_resid) >= vmin) 207 return (0); 208 209 /* We have to wait for more. */ 210 if (tp->t_flags & TF_ZOMBIE) 211 return (0); 212 else if (ioflag & IO_NDELAY) 213 return (EWOULDBLOCK); 214 215 error = tty_wait(tp, &tp->t_inwait); 216 if (error) 217 return (error); 218 } 219 } 220 221 static int 222 ttydisc_read_raw_read_timer(struct tty *tp, struct uio *uio, int ioflag, 223 int oresid) 224 { 225 size_t vmin = MAX(tp->t_termios.c_cc[VMIN], 1); 226 unsigned int vtime = tp->t_termios.c_cc[VTIME]; 227 struct timeval end, now, left; 228 int error, hz; 229 230 MPASS(tp->t_termios.c_cc[VTIME] != 0); 231 232 /* Determine when the read should be expired. */ 233 end.tv_sec = vtime / 10; 234 end.tv_usec = (vtime % 10) * 100000; 235 getmicrotime(&now); 236 timevaladd(&end, &now); 237 238 for (;;) { 239 error = tty_wait_background(tp, curthread, SIGTTIN); 240 if (error) 241 return (error); 242 243 error = ttyinq_read_uio(&tp->t_inq, tp, uio, 244 uio->uio_resid, 0); 245 if (error) 246 return (error); 247 if (uio->uio_resid == 0 || (oresid - uio->uio_resid) >= vmin) 248 return (0); 249 250 /* Calculate how long we should wait. */ 251 getmicrotime(&now); 252 if (timevalcmp(&now, &end, >)) 253 return (0); 254 left = end; 255 timevalsub(&left, &now); 256 hz = tvtohz(&left); 257 258 /* 259 * We have to wait for more. If the timer expires, we 260 * should return a 0-byte read. 261 */ 262 if (tp->t_flags & TF_ZOMBIE) 263 return (0); 264 else if (ioflag & IO_NDELAY) 265 return (EWOULDBLOCK); 266 267 error = tty_timedwait(tp, &tp->t_inwait, hz); 268 if (error) 269 return (error == EWOULDBLOCK ? 0 : error); 270 } 271 272 return (0); 273 } 274 275 static int 276 ttydisc_read_raw_interbyte_timer(struct tty *tp, struct uio *uio, int ioflag) 277 { 278 size_t vmin = tp->t_termios.c_cc[VMIN]; 279 ssize_t oresid = uio->uio_resid; 280 int error; 281 282 MPASS(tp->t_termios.c_cc[VMIN] != 0); 283 MPASS(tp->t_termios.c_cc[VTIME] != 0); 284 285 /* 286 * When using the interbyte timer, the timer should be started 287 * after the first byte has been received. We just call into the 288 * generic read timer code after we've received the first byte. 289 */ 290 291 for (;;) { 292 error = tty_wait_background(tp, curthread, SIGTTIN); 293 if (error) 294 return (error); 295 296 error = ttyinq_read_uio(&tp->t_inq, tp, uio, 297 uio->uio_resid, 0); 298 if (error) 299 return (error); 300 if (uio->uio_resid == 0 || (oresid - uio->uio_resid) >= vmin) 301 return (0); 302 303 /* 304 * Not enough data, but we did receive some, which means 305 * we'll now start using the interbyte timer. 306 */ 307 if (oresid != uio->uio_resid) 308 break; 309 310 /* We have to wait for more. */ 311 if (tp->t_flags & TF_ZOMBIE) 312 return (0); 313 else if (ioflag & IO_NDELAY) 314 return (EWOULDBLOCK); 315 316 error = tty_wait(tp, &tp->t_inwait); 317 if (error) 318 return (error); 319 } 320 321 return ttydisc_read_raw_read_timer(tp, uio, ioflag, oresid); 322 } 323 324 int 325 ttydisc_read(struct tty *tp, struct uio *uio, int ioflag) 326 { 327 int error; 328 329 tty_lock_assert(tp, MA_OWNED); 330 331 if (uio->uio_resid == 0) 332 return (0); 333 334 if (CMP_FLAG(l, ICANON)) 335 error = ttydisc_read_canonical(tp, uio, ioflag); 336 else if (tp->t_termios.c_cc[VTIME] == 0) 337 error = ttydisc_read_raw_no_timer(tp, uio, ioflag); 338 else if (tp->t_termios.c_cc[VMIN] == 0) 339 error = ttydisc_read_raw_read_timer(tp, uio, ioflag, 340 uio->uio_resid); 341 else 342 error = ttydisc_read_raw_interbyte_timer(tp, uio, ioflag); 343 344 if (ttyinq_bytesleft(&tp->t_inq) >= tp->t_inlow || 345 ttyinq_bytescanonicalized(&tp->t_inq) == 0) { 346 /* Unset the input watermark when we've got enough space. */ 347 tty_hiwat_in_unblock(tp); 348 } 349 350 return (error); 351 } 352 353 static __inline unsigned int 354 ttydisc_findchar(const char *obstart, unsigned int oblen) 355 { 356 const char *c = obstart; 357 358 while (oblen--) { 359 if (CTL_VALID(*c)) 360 break; 361 c++; 362 } 363 364 return (c - obstart); 365 } 366 367 static int 368 ttydisc_write_oproc(struct tty *tp, char c) 369 { 370 unsigned int scnt, error; 371 372 MPASS(CMP_FLAG(o, OPOST)); 373 MPASS(CTL_VALID(c)); 374 375 #define PRINT_NORMAL() ttyoutq_write_nofrag(&tp->t_outq, &c, 1) 376 switch (c) { 377 case CEOF: 378 /* End-of-text dropping. */ 379 if (CMP_FLAG(o, ONOEOT)) 380 return (0); 381 return PRINT_NORMAL(); 382 383 case CERASE2: 384 /* Handle backspace to fix tab expansion. */ 385 if (PRINT_NORMAL() != 0) 386 return (-1); 387 if (tp->t_column > 0) 388 tp->t_column--; 389 return (0); 390 391 case CTAB: 392 /* Tab expansion. */ 393 scnt = 8 - (tp->t_column & 7); 394 if (CMP_FLAG(o, TAB3)) { 395 error = ttyoutq_write_nofrag(&tp->t_outq, 396 " ", scnt); 397 } else { 398 error = PRINT_NORMAL(); 399 } 400 if (error) 401 return (-1); 402 403 tp->t_column += scnt; 404 MPASS((tp->t_column % 8) == 0); 405 return (0); 406 407 case CNL: 408 /* Newline conversion. */ 409 if (CMP_FLAG(o, ONLCR)) { 410 /* Convert \n to \r\n. */ 411 error = ttyoutq_write_nofrag(&tp->t_outq, "\r\n", 2); 412 } else { 413 error = PRINT_NORMAL(); 414 } 415 if (error) 416 return (-1); 417 418 if (CMP_FLAG(o, ONLCR|ONLRET)) { 419 tp->t_column = tp->t_writepos = 0; 420 ttyinq_reprintpos_set(&tp->t_inq); 421 } 422 return (0); 423 424 case CCR: 425 /* Carriage return to newline conversion. */ 426 if (CMP_FLAG(o, OCRNL)) 427 c = CNL; 428 /* Omit carriage returns on column 0. */ 429 if (CMP_FLAG(o, ONOCR) && tp->t_column == 0) 430 return (0); 431 if (PRINT_NORMAL() != 0) 432 return (-1); 433 434 tp->t_column = tp->t_writepos = 0; 435 ttyinq_reprintpos_set(&tp->t_inq); 436 return (0); 437 } 438 439 /* 440 * Invisible control character. Print it, but don't 441 * increase the column count. 442 */ 443 return PRINT_NORMAL(); 444 #undef PRINT_NORMAL 445 } 446 447 /* 448 * Just like the old TTY implementation, we need to copy data in chunks 449 * into a temporary buffer. One of the reasons why we need to do this, 450 * is because output processing (only TAB3 though) may allow the buffer 451 * to grow eight times. 452 */ 453 int 454 ttydisc_write(struct tty *tp, struct uio *uio, int ioflag) 455 { 456 char ob[TTY_STACKBUF]; 457 char *obstart; 458 int error = 0; 459 unsigned int oblen = 0; 460 461 tty_lock_assert(tp, MA_OWNED); 462 463 if (tp->t_flags & TF_ZOMBIE) 464 return (EIO); 465 466 /* 467 * We don't need to check whether the process is the foreground 468 * process group or if we have a carrier. This is already done 469 * in ttydev_write(). 470 */ 471 472 while (uio->uio_resid > 0) { 473 unsigned int nlen; 474 475 MPASS(oblen == 0); 476 477 /* Step 1: read data. */ 478 obstart = ob; 479 nlen = MIN(uio->uio_resid, sizeof ob); 480 tty_unlock(tp); 481 error = uiomove(ob, nlen, uio); 482 tty_lock(tp); 483 if (error != 0) 484 break; 485 oblen = nlen; 486 487 if (tty_gone(tp)) { 488 error = ENXIO; 489 break; 490 } 491 492 MPASS(oblen > 0); 493 494 /* Step 2: process data. */ 495 do { 496 unsigned int plen, wlen; 497 498 /* Search for special characters for post processing. */ 499 if (CMP_FLAG(o, OPOST)) { 500 plen = ttydisc_findchar(obstart, oblen); 501 } else { 502 plen = oblen; 503 } 504 505 if (plen == 0) { 506 /* 507 * We're going to process a character 508 * that needs processing 509 */ 510 if (ttydisc_write_oproc(tp, *obstart) == 0) { 511 obstart++; 512 oblen--; 513 514 tp->t_writepos = tp->t_column; 515 ttyinq_reprintpos_set(&tp->t_inq); 516 continue; 517 } 518 } else { 519 /* We're going to write regular data. */ 520 wlen = ttyoutq_write(&tp->t_outq, obstart, plen); 521 obstart += wlen; 522 oblen -= wlen; 523 tp->t_column += wlen; 524 525 tp->t_writepos = tp->t_column; 526 ttyinq_reprintpos_set(&tp->t_inq); 527 528 if (wlen == plen) 529 continue; 530 } 531 532 /* Watermark reached. Try to sleep. */ 533 tp->t_flags |= TF_HIWAT_OUT; 534 535 if (ioflag & IO_NDELAY) { 536 error = EWOULDBLOCK; 537 goto done; 538 } 539 540 /* 541 * The driver may write back the data 542 * synchronously. Be sure to check the high 543 * water mark before going to sleep. 544 */ 545 ttydevsw_outwakeup(tp); 546 if ((tp->t_flags & TF_HIWAT_OUT) == 0) 547 continue; 548 549 error = tty_wait(tp, &tp->t_outwait); 550 if (error) 551 goto done; 552 553 if (tp->t_flags & TF_ZOMBIE) { 554 error = EIO; 555 goto done; 556 } 557 } while (oblen > 0); 558 } 559 560 done: 561 if (!tty_gone(tp)) 562 ttydevsw_outwakeup(tp); 563 564 /* 565 * Add the amount of bytes that we didn't process back to the 566 * uio counters. We need to do this to make sure write() doesn't 567 * count the bytes we didn't store in the queue. 568 */ 569 uio->uio_resid += oblen; 570 return (error); 571 } 572 573 void 574 ttydisc_optimize(struct tty *tp) 575 { 576 tty_lock_assert(tp, MA_OWNED); 577 578 if (ttyhook_hashook(tp, rint_bypass)) { 579 tp->t_flags |= TF_BYPASS; 580 } else if (ttyhook_hashook(tp, rint)) { 581 tp->t_flags &= ~TF_BYPASS; 582 } else if (!CMP_FLAG(i, ICRNL|IGNCR|IMAXBEL|INLCR|ISTRIP|IXON) && 583 (!CMP_FLAG(i, BRKINT) || CMP_FLAG(i, IGNBRK)) && 584 (!CMP_FLAG(i, PARMRK) || 585 CMP_FLAG(i, IGNPAR|IGNBRK) == (IGNPAR|IGNBRK)) && 586 !CMP_FLAG(l, ECHO|ICANON|IEXTEN|ISIG|PENDIN)) { 587 tp->t_flags |= TF_BYPASS; 588 } else { 589 tp->t_flags &= ~TF_BYPASS; 590 } 591 } 592 593 void 594 ttydisc_modem(struct tty *tp, int open) 595 { 596 597 tty_lock_assert(tp, MA_OWNED); 598 599 if (open) 600 cv_broadcast(&tp->t_dcdwait); 601 602 /* 603 * Ignore modem status lines when CLOCAL is turned on, but don't 604 * enter the zombie state when the TTY isn't opened, because 605 * that would cause the TTY to be in zombie state after being 606 * opened. 607 */ 608 if (!tty_opened(tp) || CMP_FLAG(c, CLOCAL)) 609 return; 610 611 if (open == 0) { 612 /* 613 * Lost carrier. 614 */ 615 tp->t_flags |= TF_ZOMBIE; 616 617 tty_signal_sessleader(tp, SIGHUP); 618 tty_flush(tp, FREAD|FWRITE); 619 } else { 620 /* 621 * Carrier is back again. 622 */ 623 624 /* XXX: what should we do here? */ 625 } 626 } 627 628 static int 629 ttydisc_echo_force(struct tty *tp, char c, int quote) 630 { 631 632 if (CMP_FLAG(o, OPOST) && CTL_ECHO(c, quote)) { 633 /* 634 * Only perform postprocessing when OPOST is turned on 635 * and the character is an unquoted BS/TB/NL/CR. 636 */ 637 return ttydisc_write_oproc(tp, c); 638 } else if (CMP_FLAG(l, ECHOCTL) && CTL_PRINT(c, quote)) { 639 /* 640 * Only use ^X notation when ECHOCTL is turned on and 641 * we've got an quoted control character. 642 * 643 * Print backspaces when echoing an end-of-file. 644 */ 645 char ob[4] = "^?\b\b"; 646 647 /* Print ^X notation. */ 648 if (c != 0x7f) 649 ob[1] = c + 'A' - 1; 650 651 if (!quote && CMP_CC(VEOF, c)) { 652 return ttyoutq_write_nofrag(&tp->t_outq, ob, 4); 653 } else { 654 tp->t_column += 2; 655 return ttyoutq_write_nofrag(&tp->t_outq, ob, 2); 656 } 657 } else { 658 /* Can just be printed. */ 659 tp->t_column++; 660 return ttyoutq_write_nofrag(&tp->t_outq, &c, 1); 661 } 662 } 663 664 static int 665 ttydisc_echo(struct tty *tp, char c, int quote) 666 { 667 668 /* 669 * Only echo characters when ECHO is turned on, or ECHONL when 670 * the character is an unquoted newline. 671 */ 672 if (!CMP_FLAG(l, ECHO) && 673 (!CMP_FLAG(l, ECHONL) || c != CNL || quote)) 674 return (0); 675 676 return ttydisc_echo_force(tp, c, quote); 677 } 678 679 static void 680 ttydisc_reprint_char(void *d, char c, int quote) 681 { 682 struct tty *tp = d; 683 684 ttydisc_echo(tp, c, quote); 685 } 686 687 static void 688 ttydisc_reprint(struct tty *tp) 689 { 690 cc_t c; 691 692 /* Print ^R\n, followed by the line. */ 693 c = tp->t_termios.c_cc[VREPRINT]; 694 if (c != _POSIX_VDISABLE) 695 ttydisc_echo(tp, c, 0); 696 ttydisc_echo(tp, CNL, 0); 697 ttyinq_reprintpos_reset(&tp->t_inq); 698 699 ttyinq_line_iterate_from_linestart(&tp->t_inq, ttydisc_reprint_char, tp); 700 } 701 702 struct ttydisc_recalc_length { 703 struct tty *tp; 704 unsigned int curlen; 705 }; 706 707 static void 708 ttydisc_recalc_charlength(void *d, char c, int quote) 709 { 710 struct ttydisc_recalc_length *data = d; 711 struct tty *tp = data->tp; 712 713 if (CTL_PRINT(c, quote)) { 714 if (CMP_FLAG(l, ECHOCTL)) 715 data->curlen += 2; 716 } else if (c == CTAB) { 717 data->curlen += 8 - (data->curlen & 7); 718 } else { 719 data->curlen++; 720 } 721 } 722 723 static unsigned int 724 ttydisc_recalc_linelength(struct tty *tp) 725 { 726 struct ttydisc_recalc_length data = { tp, tp->t_writepos }; 727 728 ttyinq_line_iterate_from_reprintpos(&tp->t_inq, 729 ttydisc_recalc_charlength, &data); 730 return (data.curlen); 731 } 732 733 static int 734 ttydisc_rubchar(struct tty *tp) 735 { 736 char c; 737 int quote; 738 unsigned int prevpos, tablen; 739 740 if (ttyinq_peekchar(&tp->t_inq, &c, "e) != 0) 741 return (-1); 742 ttyinq_unputchar(&tp->t_inq); 743 744 if (CMP_FLAG(l, ECHO)) { 745 /* 746 * Remove the character from the screen. This is even 747 * safe for characters that span multiple characters 748 * (tabs, quoted, etc). 749 */ 750 if (tp->t_writepos >= tp->t_column) { 751 /* Retype the sentence. */ 752 ttydisc_reprint(tp); 753 } else if (CMP_FLAG(l, ECHOE)) { 754 if (CTL_PRINT(c, quote)) { 755 /* Remove ^X formatted chars. */ 756 if (CMP_FLAG(l, ECHOCTL)) { 757 tp->t_column -= 2; 758 ttyoutq_write_nofrag(&tp->t_outq, 759 "\b\b \b\b", 6); 760 } 761 } else if (c == ' ') { 762 /* Space character needs no rubbing. */ 763 tp->t_column -= 1; 764 ttyoutq_write_nofrag(&tp->t_outq, "\b", 1); 765 } else if (c == CTAB) { 766 /* 767 * Making backspace work with tabs is 768 * quite hard. Recalculate the length of 769 * this character and remove it. 770 * 771 * Because terminal settings could be 772 * changed while the line is being 773 * inserted, the calculations don't have 774 * to be correct. Make sure we keep the 775 * tab length within proper bounds. 776 */ 777 prevpos = ttydisc_recalc_linelength(tp); 778 if (prevpos >= tp->t_column) 779 tablen = 1; 780 else 781 tablen = tp->t_column - prevpos; 782 if (tablen > 8) 783 tablen = 8; 784 785 tp->t_column = prevpos; 786 ttyoutq_write_nofrag(&tp->t_outq, 787 "\b\b\b\b\b\b\b\b", tablen); 788 return (0); 789 } else { 790 /* 791 * Remove a regular character by 792 * punching a space over it. 793 */ 794 tp->t_column -= 1; 795 ttyoutq_write_nofrag(&tp->t_outq, "\b \b", 3); 796 } 797 } else { 798 /* Don't print spaces. */ 799 ttydisc_echo(tp, tp->t_termios.c_cc[VERASE], 0); 800 } 801 } 802 803 return (0); 804 } 805 806 static void 807 ttydisc_rubword(struct tty *tp) 808 { 809 char c; 810 int quote, alnum; 811 812 /* Strip whitespace first. */ 813 for (;;) { 814 if (ttyinq_peekchar(&tp->t_inq, &c, "e) != 0) 815 return; 816 if (!CTL_WHITE(c)) 817 break; 818 ttydisc_rubchar(tp); 819 } 820 821 /* 822 * Record whether the last character from the previous iteration 823 * was alphanumeric or not. We need this to implement ALTWERASE. 824 */ 825 alnum = CTL_ALNUM(c); 826 for (;;) { 827 ttydisc_rubchar(tp); 828 829 if (ttyinq_peekchar(&tp->t_inq, &c, "e) != 0) 830 return; 831 if (CTL_WHITE(c)) 832 return; 833 if (CMP_FLAG(l, ALTWERASE) && CTL_ALNUM(c) != alnum) 834 return; 835 } 836 } 837 838 int 839 ttydisc_rint(struct tty *tp, char c, int flags) 840 { 841 int signal, quote = 0; 842 char ob[3] = { 0xff, 0x00 }; 843 size_t ol; 844 845 tty_lock_assert(tp, MA_OWNED); 846 847 atomic_add_long(&tty_nin, 1); 848 849 if (ttyhook_hashook(tp, rint)) 850 return ttyhook_rint(tp, c, flags); 851 852 if (tp->t_flags & TF_BYPASS) 853 goto processed; 854 855 if (flags) { 856 if (flags & TRE_BREAK) { 857 if (CMP_FLAG(i, IGNBRK)) { 858 /* Ignore break characters. */ 859 return (0); 860 } else if (CMP_FLAG(i, BRKINT)) { 861 /* Generate SIGINT on break. */ 862 tty_flush(tp, FREAD|FWRITE); 863 tty_signal_pgrp(tp, SIGINT); 864 return (0); 865 } else { 866 /* Just print it. */ 867 goto parmrk; 868 } 869 } else if (flags & TRE_FRAMING || 870 (flags & TRE_PARITY && CMP_FLAG(i, INPCK))) { 871 if (CMP_FLAG(i, IGNPAR)) { 872 /* Ignore bad characters. */ 873 return (0); 874 } else { 875 /* Just print it. */ 876 goto parmrk; 877 } 878 } 879 } 880 881 /* Allow any character to perform a wakeup. */ 882 if (CMP_FLAG(i, IXANY)) 883 tp->t_flags &= ~TF_STOPPED; 884 885 /* Remove the top bit. */ 886 if (CMP_FLAG(i, ISTRIP)) 887 c &= ~0x80; 888 889 /* Skip input processing when we want to print it literally. */ 890 if (tp->t_flags & TF_LITERAL) { 891 tp->t_flags &= ~TF_LITERAL; 892 quote = 1; 893 goto processed; 894 } 895 896 /* Special control characters that are implementation dependent. */ 897 if (CMP_FLAG(l, IEXTEN)) { 898 /* Accept the next character as literal. */ 899 if (CMP_CC(VLNEXT, c)) { 900 if (CMP_FLAG(l, ECHO)) { 901 if (CMP_FLAG(l, ECHOE)) 902 ttyoutq_write_nofrag(&tp->t_outq, "^\b", 2); 903 else 904 ttydisc_echo(tp, c, 0); 905 } 906 tp->t_flags |= TF_LITERAL; 907 return (0); 908 } 909 } 910 911 /* 912 * Handle signal processing. 913 */ 914 if (CMP_FLAG(l, ISIG)) { 915 if (CMP_FLAG(l, ICANON|IEXTEN) == (ICANON|IEXTEN)) { 916 if (CMP_CC(VSTATUS, c)) { 917 tty_signal_pgrp(tp, SIGINFO); 918 return (0); 919 } 920 } 921 922 /* 923 * When compared to the old implementation, this 924 * implementation also flushes the output queue. POSIX 925 * is really brief about this, but does makes us assume 926 * we have to do so. 927 */ 928 signal = 0; 929 if (CMP_CC(VINTR, c)) { 930 signal = SIGINT; 931 } else if (CMP_CC(VQUIT, c)) { 932 signal = SIGQUIT; 933 } else if (CMP_CC(VSUSP, c)) { 934 signal = SIGTSTP; 935 } 936 937 if (signal != 0) { 938 /* 939 * Echo the character before signalling the 940 * processes. 941 */ 942 if (!CMP_FLAG(l, NOFLSH)) 943 tty_flush(tp, FREAD|FWRITE); 944 ttydisc_echo(tp, c, 0); 945 tty_signal_pgrp(tp, signal); 946 return (0); 947 } 948 } 949 950 /* 951 * Handle start/stop characters. 952 */ 953 if (CMP_FLAG(i, IXON)) { 954 if (CMP_CC(VSTOP, c)) { 955 /* Stop it if we aren't stopped yet. */ 956 if ((tp->t_flags & TF_STOPPED) == 0) { 957 tp->t_flags |= TF_STOPPED; 958 return (0); 959 } 960 /* 961 * Fallthrough: 962 * When VSTART == VSTOP, we should make this key 963 * toggle it. 964 */ 965 if (!CMP_CC(VSTART, c)) 966 return (0); 967 } 968 if (CMP_CC(VSTART, c)) { 969 tp->t_flags &= ~TF_STOPPED; 970 return (0); 971 } 972 } 973 974 /* Conversion of CR and NL. */ 975 switch (c) { 976 case CCR: 977 if (CMP_FLAG(i, IGNCR)) 978 return (0); 979 if (CMP_FLAG(i, ICRNL)) 980 c = CNL; 981 break; 982 case CNL: 983 if (CMP_FLAG(i, INLCR)) 984 c = CCR; 985 break; 986 } 987 988 /* Canonical line editing. */ 989 if (CMP_FLAG(l, ICANON)) { 990 if (CMP_CC(VERASE, c) || CMP_CC(VERASE2, c)) { 991 ttydisc_rubchar(tp); 992 return (0); 993 } else if (CMP_CC(VKILL, c)) { 994 while (ttydisc_rubchar(tp) == 0); 995 return (0); 996 } else if (CMP_FLAG(l, IEXTEN)) { 997 if (CMP_CC(VWERASE, c)) { 998 ttydisc_rubword(tp); 999 return (0); 1000 } else if (CMP_CC(VREPRINT, c)) { 1001 ttydisc_reprint(tp); 1002 return (0); 1003 } 1004 } 1005 } 1006 1007 processed: 1008 if (CMP_FLAG(i, PARMRK) && (unsigned char)c == 0xff) { 1009 /* Print 0xff 0xff. */ 1010 ob[1] = 0xff; 1011 ol = 2; 1012 quote = 1; 1013 } else { 1014 ob[0] = c; 1015 ol = 1; 1016 } 1017 1018 goto print; 1019 1020 parmrk: 1021 if (CMP_FLAG(i, PARMRK)) { 1022 /* Prepend 0xff 0x00 0x.. */ 1023 ob[2] = c; 1024 ol = 3; 1025 quote = 1; 1026 } else { 1027 ob[0] = c; 1028 ol = 1; 1029 } 1030 1031 print: 1032 /* See if we can store this on the input queue. */ 1033 if (ttyinq_write_nofrag(&tp->t_inq, ob, ol, quote) != 0) { 1034 if (CMP_FLAG(i, IMAXBEL)) 1035 ttyoutq_write_nofrag(&tp->t_outq, "\a", 1); 1036 1037 /* 1038 * Prevent a deadlock here. It may be possible that a 1039 * user has entered so much data, there is no data 1040 * available to read(), but the buffers are full anyway. 1041 * 1042 * Only enter the high watermark if the device driver 1043 * can actually transmit something. 1044 */ 1045 if (ttyinq_bytescanonicalized(&tp->t_inq) == 0) 1046 return (0); 1047 1048 tty_hiwat_in_block(tp); 1049 return (-1); 1050 } 1051 1052 /* 1053 * In raw mode, we canonicalize after receiving a single 1054 * character. Otherwise, we canonicalize when we receive a 1055 * newline, VEOL or VEOF, but only when it isn't quoted. 1056 */ 1057 if (!CMP_FLAG(l, ICANON) || 1058 (!quote && (c == CNL || CMP_CC(VEOL, c) || CMP_CC(VEOF, c)))) { 1059 ttyinq_canonicalize(&tp->t_inq); 1060 } 1061 1062 ttydisc_echo(tp, c, quote); 1063 1064 return (0); 1065 } 1066 1067 size_t 1068 ttydisc_rint_simple(struct tty *tp, const void *buf, size_t len) 1069 { 1070 const char *cbuf; 1071 1072 if (ttydisc_can_bypass(tp)) 1073 return (ttydisc_rint_bypass(tp, buf, len)); 1074 1075 for (cbuf = buf; len-- > 0; cbuf++) { 1076 if (ttydisc_rint(tp, *cbuf, 0) != 0) 1077 break; 1078 } 1079 1080 return (cbuf - (const char *)buf); 1081 } 1082 1083 size_t 1084 ttydisc_rint_bypass(struct tty *tp, const void *buf, size_t len) 1085 { 1086 size_t ret; 1087 1088 tty_lock_assert(tp, MA_OWNED); 1089 1090 MPASS(tp->t_flags & TF_BYPASS); 1091 1092 atomic_add_long(&tty_nin, len); 1093 1094 if (ttyhook_hashook(tp, rint_bypass)) 1095 return ttyhook_rint_bypass(tp, buf, len); 1096 1097 ret = ttyinq_write(&tp->t_inq, buf, len, 0); 1098 ttyinq_canonicalize(&tp->t_inq); 1099 if (ret < len) 1100 tty_hiwat_in_block(tp); 1101 1102 return (ret); 1103 } 1104 1105 void 1106 ttydisc_rint_done(struct tty *tp) 1107 { 1108 1109 tty_lock_assert(tp, MA_OWNED); 1110 1111 if (ttyhook_hashook(tp, rint_done)) 1112 ttyhook_rint_done(tp); 1113 1114 /* Wake up readers. */ 1115 tty_wakeup(tp, FREAD); 1116 /* Wake up driver for echo. */ 1117 ttydevsw_outwakeup(tp); 1118 } 1119 1120 size_t 1121 ttydisc_rint_poll(struct tty *tp) 1122 { 1123 size_t l; 1124 1125 tty_lock_assert(tp, MA_OWNED); 1126 1127 if (ttyhook_hashook(tp, rint_poll)) 1128 return ttyhook_rint_poll(tp); 1129 1130 /* 1131 * XXX: Still allow character input when there's no space in the 1132 * buffers, but we haven't entered the high watermark. This is 1133 * to allow backspace characters to be inserted when in 1134 * canonical mode. 1135 */ 1136 l = ttyinq_bytesleft(&tp->t_inq); 1137 if (l == 0 && (tp->t_flags & TF_HIWAT_IN) == 0) 1138 return (1); 1139 1140 return (l); 1141 } 1142 1143 static void 1144 ttydisc_wakeup_watermark(struct tty *tp) 1145 { 1146 size_t c; 1147 1148 c = ttyoutq_bytesleft(&tp->t_outq); 1149 if (tp->t_flags & TF_HIWAT_OUT) { 1150 /* Only allow us to run when we're below the watermark. */ 1151 if (c < tp->t_outlow) 1152 return; 1153 1154 /* Reset the watermark. */ 1155 tp->t_flags &= ~TF_HIWAT_OUT; 1156 } else { 1157 /* Only run when we have data at all. */ 1158 if (c == 0) 1159 return; 1160 } 1161 tty_wakeup(tp, FWRITE); 1162 } 1163 1164 size_t 1165 ttydisc_getc(struct tty *tp, void *buf, size_t len) 1166 { 1167 1168 tty_lock_assert(tp, MA_OWNED); 1169 1170 if (tp->t_flags & TF_STOPPED) 1171 return (0); 1172 1173 if (ttyhook_hashook(tp, getc_inject)) 1174 return ttyhook_getc_inject(tp, buf, len); 1175 1176 len = ttyoutq_read(&tp->t_outq, buf, len); 1177 1178 if (ttyhook_hashook(tp, getc_capture)) 1179 ttyhook_getc_capture(tp, buf, len); 1180 1181 ttydisc_wakeup_watermark(tp); 1182 atomic_add_long(&tty_nout, len); 1183 1184 return (len); 1185 } 1186 1187 int 1188 ttydisc_getc_uio(struct tty *tp, struct uio *uio) 1189 { 1190 int error = 0; 1191 ssize_t obytes = uio->uio_resid; 1192 size_t len; 1193 char buf[TTY_STACKBUF]; 1194 1195 tty_lock_assert(tp, MA_OWNED); 1196 1197 if (tp->t_flags & TF_STOPPED) 1198 return (0); 1199 1200 /* 1201 * When a TTY hook is attached, we cannot perform unbuffered 1202 * copying to userspace. Just call ttydisc_getc() and 1203 * temporarily store data in a shadow buffer. 1204 */ 1205 if (ttyhook_hashook(tp, getc_capture) || 1206 ttyhook_hashook(tp, getc_inject)) { 1207 while (uio->uio_resid > 0) { 1208 /* Read to shadow buffer. */ 1209 len = ttydisc_getc(tp, buf, 1210 MIN(uio->uio_resid, sizeof buf)); 1211 if (len == 0) 1212 break; 1213 1214 /* Copy to userspace. */ 1215 tty_unlock(tp); 1216 error = uiomove(buf, len, uio); 1217 tty_lock(tp); 1218 1219 if (error != 0) 1220 break; 1221 } 1222 } else { 1223 error = ttyoutq_read_uio(&tp->t_outq, tp, uio); 1224 1225 ttydisc_wakeup_watermark(tp); 1226 atomic_add_long(&tty_nout, obytes - uio->uio_resid); 1227 } 1228 1229 return (error); 1230 } 1231 1232 size_t 1233 ttydisc_getc_poll(struct tty *tp) 1234 { 1235 1236 tty_lock_assert(tp, MA_OWNED); 1237 1238 if (tp->t_flags & TF_STOPPED) 1239 return (0); 1240 1241 if (ttyhook_hashook(tp, getc_poll)) 1242 return ttyhook_getc_poll(tp); 1243 1244 return ttyoutq_bytesused(&tp->t_outq); 1245 } 1246 1247 /* 1248 * XXX: not really related to the TTYDISC, but we'd better put 1249 * tty_putchar() here, because we need to perform proper output 1250 * processing. 1251 */ 1252 1253 int 1254 tty_putstrn(struct tty *tp, const char *p, size_t n) 1255 { 1256 size_t i; 1257 1258 tty_lock_assert(tp, MA_OWNED); 1259 1260 if (tty_gone(tp)) 1261 return (-1); 1262 1263 for (i = 0; i < n; i++) 1264 ttydisc_echo_force(tp, p[i], 0); 1265 1266 tp->t_writepos = tp->t_column; 1267 ttyinq_reprintpos_set(&tp->t_inq); 1268 1269 ttydevsw_outwakeup(tp); 1270 return (0); 1271 } 1272 1273 int 1274 tty_putchar(struct tty *tp, char c) 1275 { 1276 return (tty_putstrn(tp, &c, 1)); 1277 } 1278