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