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