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