xref: /freebsd/sys/kern/tty_ttydisc.c (revision 39beb93c3f8bdbf72a61fda42300b5ebed7390c8)
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$");
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) >= '0' && (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 	/* 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 
110 static int
111 ttydisc_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 
179 static int
180 ttydisc_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 
214 static int
215 ttydisc_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 
264 static int
265 ttydisc_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 
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 
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 
309 int
310 ttydisc_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 
335 	return (error);
336 }
337 
338 static __inline unsigned int
339 ttydisc_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 
352 static int
353 ttydisc_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  */
438 int
439 ttydisc_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 
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 
545 done:
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 
558 void
559 ttydisc_optimize(struct tty *tp)
560 {
561 	tty_lock_assert(tp, MA_OWNED);
562 
563 	if ((!CMP_FLAG(i, ICRNL|IGNCR|IMAXBEL|INLCR|ISTRIP|IXON) &&
564 	    (!CMP_FLAG(i, BRKINT) || CMP_FLAG(i, IGNBRK)) &&
565 	    (!CMP_FLAG(i, PARMRK) ||
566 	        CMP_FLAG(i, IGNPAR|IGNBRK) == (IGNPAR|IGNBRK)) &&
567 	    !CMP_FLAG(l, ECHO|ICANON|IEXTEN|ISIG|PENDIN)) ||
568 	    ttyhook_hashook(tp, rint_bypass)) {
569 		tp->t_flags |= TF_BYPASS;
570 	} else {
571 		tp->t_flags &= ~TF_BYPASS;
572 	}
573 }
574 
575 void
576 ttydisc_modem(struct tty *tp, int open)
577 {
578 
579 	tty_lock_assert(tp, MA_OWNED);
580 
581 	if (open)
582 		cv_broadcast(&tp->t_dcdwait);
583 
584 	/*
585 	 * Ignore modem status lines when CLOCAL is turned on, but don't
586 	 * enter the zombie state when the TTY isn't opened, because
587 	 * that would cause the TTY to be in zombie state after being
588 	 * opened.
589 	 */
590 	if (!tty_opened(tp) || CMP_FLAG(c, CLOCAL))
591 		return;
592 
593 	if (open == 0) {
594 		/*
595 		 * Lost carrier.
596 		 */
597 		tp->t_flags |= TF_ZOMBIE;
598 
599 		tty_signal_sessleader(tp, SIGHUP);
600 		tty_flush(tp, FREAD|FWRITE);
601 	} else {
602 		/*
603 		 * Carrier is back again.
604 		 */
605 
606 		/* XXX: what should we do here? */
607 	}
608 }
609 
610 static int
611 ttydisc_echo_force(struct tty *tp, char c, int quote)
612 {
613 
614 	if (CMP_FLAG(o, OPOST) && CTL_ECHO(c, quote)) {
615 		/*
616 		 * Only perform postprocessing when OPOST is turned on
617 		 * and the character is an unquoted BS/TB/NL/CR.
618 		 */
619 		return ttydisc_write_oproc(tp, c);
620 	} else if (CMP_FLAG(l, ECHOCTL) && CTL_PRINT(c, quote)) {
621 		/*
622 		 * Only use ^X notation when ECHOCTL is turned on and
623 		 * we've got an quoted control character.
624 		 */
625 		char ob[2] = { '^', '?' };
626 
627 		/* Print ^X notation. */
628 		if (c != 0x7f)
629 			ob[1] = c + 'A' - 1;
630 
631 		tp->t_column += 2;
632 		return ttyoutq_write_nofrag(&tp->t_outq, ob, 2);
633 	} else {
634 		/* Can just be printed. */
635 		tp->t_column++;
636 		return ttyoutq_write_nofrag(&tp->t_outq, &c, 1);
637 	}
638 }
639 
640 static int
641 ttydisc_echo(struct tty *tp, char c, int quote)
642 {
643 
644 	/*
645 	 * Only echo characters when ECHO is turned on, or ECHONL when
646 	 * the character is an unquoted newline.
647 	 */
648 	if (!CMP_FLAG(l, ECHO) &&
649 	    (!CMP_FLAG(l, ECHONL) || c != CNL || quote))
650 		return (0);
651 
652 	return ttydisc_echo_force(tp, c, quote);
653 }
654 
655 
656 static void
657 ttydisc_reprint_char(void *d, char c, int quote)
658 {
659 	struct tty *tp = d;
660 
661 	ttydisc_echo(tp, c, quote);
662 }
663 
664 static void
665 ttydisc_reprint(struct tty *tp)
666 {
667 	cc_t c;
668 
669 	/* Print  ^R\n, followed by the line. */
670 	c = tp->t_termios.c_cc[VREPRINT];
671 	if (c != _POSIX_VDISABLE)
672 		ttydisc_echo(tp, c, 0);
673 	ttydisc_echo(tp, CNL, 0);
674 	ttyinq_reprintpos_reset(&tp->t_inq);
675 
676 	ttyinq_line_iterate_from_linestart(&tp->t_inq, ttydisc_reprint_char, tp);
677 }
678 
679 struct ttydisc_recalc_length {
680 	struct tty *tp;
681 	unsigned int curlen;
682 };
683 
684 static void
685 ttydisc_recalc_charlength(void *d, char c, int quote)
686 {
687 	struct ttydisc_recalc_length *data = d;
688 	struct tty *tp = data->tp;
689 
690 	if (CTL_PRINT(c, quote)) {
691 		if (CMP_FLAG(l, ECHOCTL))
692 			data->curlen += 2;
693 	} else if (c == CTAB) {
694 		data->curlen += 8 - (data->curlen & 7);
695 	} else {
696 		data->curlen++;
697 	}
698 }
699 
700 static unsigned int
701 ttydisc_recalc_linelength(struct tty *tp)
702 {
703 	struct ttydisc_recalc_length data = { tp, tp->t_writepos };
704 
705 	ttyinq_line_iterate_from_reprintpos(&tp->t_inq,
706 	    ttydisc_recalc_charlength, &data);
707 	return (data.curlen);
708 }
709 
710 static int
711 ttydisc_rubchar(struct tty *tp)
712 {
713 	char c;
714 	int quote;
715 	unsigned int prevpos, tablen;
716 
717 	if (ttyinq_peekchar(&tp->t_inq, &c, &quote) != 0)
718 		return (-1);
719 	ttyinq_unputchar(&tp->t_inq);
720 
721 	if (CMP_FLAG(l, ECHO)) {
722 		/*
723 		 * Remove the character from the screen. This is even
724 		 * safe for characters that span multiple characters
725 		 * (tabs, quoted, etc).
726 		 */
727 		if (tp->t_writepos >= tp->t_column) {
728 			/* Retype the sentence. */
729 			ttydisc_reprint(tp);
730 		} else if (CMP_FLAG(l, ECHOE)) {
731 			if (CTL_PRINT(c, quote)) {
732 				/* Remove ^X formatted chars. */
733 				if (CMP_FLAG(l, ECHOCTL)) {
734 					tp->t_column -= 2;
735 					ttyoutq_write_nofrag(&tp->t_outq,
736 					    "\b\b  \b\b", 6);
737 				}
738 			} else if (c == ' ') {
739 				/* Space character needs no rubbing. */
740 				tp->t_column -= 1;
741 				ttyoutq_write_nofrag(&tp->t_outq, "\b", 1);
742 			} else if (c == CTAB) {
743 				/*
744 				 * Making backspace work with tabs is
745 				 * quite hard. Recalculate the length of
746 				 * this character and remove it.
747 				 *
748 				 * Because terminal settings could be
749 				 * changed while the line is being
750 				 * inserted, the calculations don't have
751 				 * to be correct. Make sure we keep the
752 				 * tab length within proper bounds.
753 				 */
754 				prevpos = ttydisc_recalc_linelength(tp);
755 				if (prevpos >= tp->t_column)
756 					tablen = 1;
757 				else
758 					tablen = tp->t_column - prevpos;
759 				if (tablen > 8)
760 					tablen = 8;
761 
762 				tp->t_column = prevpos;
763 				ttyoutq_write_nofrag(&tp->t_outq,
764 				    "\b\b\b\b\b\b\b\b", tablen);
765 				return (0);
766 			} else {
767 				/*
768 				 * Remove a regular character by
769 				 * punching a space over it.
770 				 */
771 				tp->t_column -= 1;
772 				ttyoutq_write_nofrag(&tp->t_outq, "\b \b", 3);
773 			}
774 		} else {
775 			/* Don't print spaces. */
776 			ttydisc_echo(tp, tp->t_termios.c_cc[VERASE], 0);
777 		}
778 	}
779 
780 	return (0);
781 }
782 
783 static void
784 ttydisc_rubword(struct tty *tp)
785 {
786 	char c;
787 	int quote, alnum;
788 
789 	/* Strip whitespace first. */
790 	for (;;) {
791 		if (ttyinq_peekchar(&tp->t_inq, &c, &quote) != 0)
792 			return;
793 		if (!CTL_WHITE(c))
794 			break;
795 		ttydisc_rubchar(tp);
796 	}
797 
798 	/*
799 	 * Record whether the last character from the previous iteration
800 	 * was alphanumeric or not. We need this to implement ALTWERASE.
801 	 */
802 	alnum = CTL_ALNUM(c);
803 	for (;;) {
804 		ttydisc_rubchar(tp);
805 
806 		if (ttyinq_peekchar(&tp->t_inq, &c, &quote) != 0)
807 			return;
808 		if (CTL_WHITE(c))
809 			return;
810 		if (CMP_FLAG(l, ALTWERASE) && CTL_ALNUM(c) != alnum)
811 			return;
812 	}
813 }
814 
815 int
816 ttydisc_rint(struct tty *tp, char c, int flags)
817 {
818 	int signal, quote = 0;
819 	char ob[3] = { 0xff, 0x00 };
820 	size_t ol;
821 
822 	tty_lock_assert(tp, MA_OWNED);
823 
824 	atomic_add_long(&tty_nin, 1);
825 
826 	if (ttyhook_hashook(tp, rint))
827 		return ttyhook_rint(tp, c, flags);
828 
829 	if (tp->t_flags & TF_BYPASS)
830 		goto processed;
831 
832 	if (flags) {
833 		if (flags & TRE_BREAK) {
834 			if (CMP_FLAG(i, IGNBRK)) {
835 				/* Ignore break characters. */
836 				return (0);
837 			} else if (CMP_FLAG(i, BRKINT)) {
838 				/* Generate SIGINT on break. */
839 				tty_flush(tp, FREAD|FWRITE);
840 				tty_signal_pgrp(tp, SIGINT);
841 				return (0);
842 			} else {
843 				/* Just print it. */
844 				goto parmrk;
845 			}
846 		} else if (flags & TRE_FRAMING ||
847 		    (flags & TRE_PARITY && CMP_FLAG(i, INPCK))) {
848 			if (CMP_FLAG(i, IGNPAR)) {
849 				/* Ignore bad characters. */
850 				return (0);
851 			} else {
852 				/* Just print it. */
853 				goto parmrk;
854 			}
855 		}
856 	}
857 
858 	/* Allow any character to perform a wakeup. */
859 	if (CMP_FLAG(i, IXANY))
860 		tp->t_flags &= ~TF_STOPPED;
861 
862 	/* Remove the top bit. */
863 	if (CMP_FLAG(i, ISTRIP))
864 		c &= ~0x80;
865 
866 	/* Skip input processing when we want to print it literally. */
867 	if (tp->t_flags & TF_LITERAL) {
868 		tp->t_flags &= ~TF_LITERAL;
869 		quote = 1;
870 		goto processed;
871 	}
872 
873 	/* Special control characters that are implementation dependent. */
874 	if (CMP_FLAG(l, IEXTEN)) {
875 		/* Accept the next character as literal. */
876 		if (CMP_CC(VLNEXT, c)) {
877 			if (CMP_FLAG(l, ECHO)) {
878 				if (CMP_FLAG(l, ECHOE))
879 					ttyoutq_write_nofrag(&tp->t_outq, "^\b", 2);
880 				else
881 					ttydisc_echo(tp, c, 0);
882 			}
883 			tp->t_flags |= TF_LITERAL;
884 			return (0);
885 		}
886 	}
887 
888 	/*
889 	 * Handle signal processing.
890 	 */
891 	if (CMP_FLAG(l, ISIG)) {
892 		if (CMP_FLAG(l, ICANON|IEXTEN) == (ICANON|IEXTEN)) {
893 			if (CMP_CC(VSTATUS, c)) {
894 				tty_signal_pgrp(tp, SIGINFO);
895 				return (0);
896 			}
897 		}
898 
899 		/*
900 		 * When compared to the old implementation, this
901 		 * implementation also flushes the output queue. POSIX
902 		 * is really brief about this, but does makes us assume
903 		 * we have to do so.
904 		 */
905 		signal = 0;
906 		if (CMP_CC(VINTR, c)) {
907 			signal = SIGINT;
908 		} else if (CMP_CC(VQUIT, c)) {
909 			signal = SIGQUIT;
910 		} else if (CMP_CC(VSUSP, c)) {
911 			signal = SIGTSTP;
912 		}
913 
914 		if (signal != 0) {
915 			/*
916 			 * Echo the character before signalling the
917 			 * processes.
918 			 */
919 			if (!CMP_FLAG(l, NOFLSH))
920 				tty_flush(tp, FREAD|FWRITE);
921 			ttydisc_echo(tp, c, 0);
922 			tty_signal_pgrp(tp, signal);
923 			return (0);
924 		}
925 	}
926 
927 	/*
928 	 * Handle start/stop characters.
929 	 */
930 	if (CMP_FLAG(i, IXON)) {
931 		if (CMP_CC(VSTOP, c)) {
932 			/* Stop it if we aren't stopped yet. */
933 			if ((tp->t_flags & TF_STOPPED) == 0) {
934 				tp->t_flags |= TF_STOPPED;
935 				return (0);
936 			}
937 			/*
938 			 * Fallthrough:
939 			 * When VSTART == VSTOP, we should make this key
940 			 * toggle it.
941 			 */
942 			if (!CMP_CC(VSTART, c))
943 				return (0);
944 		}
945 		if (CMP_CC(VSTART, c)) {
946 			tp->t_flags &= ~TF_STOPPED;
947 			return (0);
948 		}
949 	}
950 
951 	/* Conversion of CR and NL. */
952 	switch (c) {
953 	case CCR:
954 		if (CMP_FLAG(i, IGNCR))
955 			return (0);
956 		if (CMP_FLAG(i, ICRNL))
957 			c = CNL;
958 		break;
959 	case CNL:
960 		if (CMP_FLAG(i, INLCR))
961 			c = CCR;
962 		break;
963 	}
964 
965 	/* Canonical line editing. */
966 	if (CMP_FLAG(l, ICANON)) {
967 		if (CMP_CC(VERASE, c) || CMP_CC(VERASE2, c)) {
968 			ttydisc_rubchar(tp);
969 			return (0);
970 		} else if (CMP_CC(VKILL, c)) {
971 			while (ttydisc_rubchar(tp) == 0);
972 			return (0);
973 		} else if (CMP_FLAG(l, IEXTEN)) {
974 			if (CMP_CC(VWERASE, c)) {
975 				ttydisc_rubword(tp);
976 				return (0);
977 			} else if (CMP_CC(VREPRINT, c)) {
978 				ttydisc_reprint(tp);
979 				return (0);
980 			}
981 		}
982 	}
983 
984 processed:
985 	if (CMP_FLAG(i, PARMRK) && (unsigned char)c == 0xff) {
986 		/* Print 0xff 0xff. */
987 		ob[1] = 0xff;
988 		ol = 2;
989 		quote = 1;
990 	} else {
991 		ob[0] = c;
992 		ol = 1;
993 	}
994 
995 	goto print;
996 
997 parmrk:
998 	if (CMP_FLAG(i, PARMRK)) {
999 		/* Prepend 0xff 0x00 0x.. */
1000 		ob[2] = c;
1001 		ol = 3;
1002 		quote = 1;
1003 	} else {
1004 		ob[0] = c;
1005 		ol = 1;
1006 	}
1007 
1008 print:
1009 	/* See if we can store this on the input queue. */
1010 	if (ttyinq_write_nofrag(&tp->t_inq, ob, ol, quote) != 0) {
1011 		if (CMP_FLAG(i, IMAXBEL))
1012 			ttyoutq_write_nofrag(&tp->t_outq, "\a", 1);
1013 
1014 		/*
1015 		 * Prevent a deadlock here. It may be possible that a
1016 		 * user has entered so much data, there is no data
1017 		 * available to read(), but the buffers are full anyway.
1018 		 *
1019 		 * Only enter the high watermark if the device driver
1020 		 * can actually transmit something.
1021 		 */
1022 		if (ttyinq_bytescanonicalized(&tp->t_inq) == 0)
1023 			return (0);
1024 
1025 		tty_hiwat_in_block(tp);
1026 		return (-1);
1027 	}
1028 
1029 	/*
1030 	 * In raw mode, we canonicalize after receiving a single
1031 	 * character. Otherwise, we canonicalize when we receive a
1032 	 * newline, VEOL or VEOF, but only when it isn't quoted.
1033 	 */
1034 	if (!CMP_FLAG(l, ICANON) ||
1035 	    (!quote && (c == CNL || CMP_CC(VEOL, c) || CMP_CC(VEOF, c)))) {
1036 		ttyinq_canonicalize(&tp->t_inq);
1037 	}
1038 
1039 	ttydisc_echo(tp, c, quote);
1040 
1041 	return (0);
1042 }
1043 
1044 size_t
1045 ttydisc_rint_bypass(struct tty *tp, const void *buf, size_t len)
1046 {
1047 	size_t ret;
1048 
1049 	tty_lock_assert(tp, MA_OWNED);
1050 
1051 	MPASS(tp->t_flags & TF_BYPASS);
1052 
1053 	atomic_add_long(&tty_nin, len);
1054 
1055 	if (ttyhook_hashook(tp, rint_bypass))
1056 		return ttyhook_rint_bypass(tp, buf, len);
1057 
1058 	ret = ttyinq_write(&tp->t_inq, buf, len, 0);
1059 	ttyinq_canonicalize(&tp->t_inq);
1060 
1061 	return (ret);
1062 }
1063 
1064 void
1065 ttydisc_rint_done(struct tty *tp)
1066 {
1067 
1068 	tty_lock_assert(tp, MA_OWNED);
1069 
1070 	if (ttyhook_hashook(tp, rint_done))
1071 		ttyhook_rint_done(tp);
1072 
1073 	/* Wake up readers. */
1074 	tty_wakeup(tp, FREAD);
1075 	/* Wake up driver for echo. */
1076 	ttydevsw_outwakeup(tp);
1077 }
1078 
1079 size_t
1080 ttydisc_rint_poll(struct tty *tp)
1081 {
1082 	size_t l;
1083 
1084 	tty_lock_assert(tp, MA_OWNED);
1085 
1086 	if (ttyhook_hashook(tp, rint_poll))
1087 		return ttyhook_rint_poll(tp);
1088 
1089 	/*
1090 	 * XXX: Still allow character input when there's no space in the
1091 	 * buffers, but we haven't entered the high watermark. This is
1092 	 * to allow backspace characters to be inserted when in
1093 	 * canonical mode.
1094 	 */
1095 	l = ttyinq_bytesleft(&tp->t_inq);
1096 	if (l == 0 && (tp->t_flags & TF_HIWAT_IN) == 0)
1097 		return (1);
1098 
1099 	return (l);
1100 }
1101 
1102 static void
1103 ttydisc_wakeup_watermark(struct tty *tp)
1104 {
1105 	size_t c;
1106 
1107 	c = ttyoutq_bytesleft(&tp->t_outq);
1108 	if (tp->t_flags & TF_HIWAT_OUT) {
1109 		/* Only allow us to run when we're below the watermark. */
1110 		if (c < tp->t_outlow)
1111 			return;
1112 
1113 		/* Reset the watermark. */
1114 		tp->t_flags &= ~TF_HIWAT_OUT;
1115 	} else {
1116 		/* Only run when we have data at all. */
1117 		if (c == 0)
1118 			return;
1119 	}
1120 	tty_wakeup(tp, FWRITE);
1121 }
1122 
1123 size_t
1124 ttydisc_getc(struct tty *tp, void *buf, size_t len)
1125 {
1126 
1127 	tty_lock_assert(tp, MA_OWNED);
1128 
1129 	if (tp->t_flags & TF_STOPPED)
1130 		return (0);
1131 
1132 	if (ttyhook_hashook(tp, getc_inject))
1133 		return ttyhook_getc_inject(tp, buf, len);
1134 
1135 	len = ttyoutq_read(&tp->t_outq, buf, len);
1136 
1137 	if (ttyhook_hashook(tp, getc_capture))
1138 		ttyhook_getc_capture(tp, buf, len);
1139 
1140 	ttydisc_wakeup_watermark(tp);
1141 	atomic_add_long(&tty_nout, len);
1142 
1143 	return (len);
1144 }
1145 
1146 int
1147 ttydisc_getc_uio(struct tty *tp, struct uio *uio)
1148 {
1149 	int error = 0;
1150 	int obytes = uio->uio_resid;
1151 	size_t len;
1152 	char buf[TTY_STACKBUF];
1153 
1154 	tty_lock_assert(tp, MA_OWNED);
1155 
1156 	if (tp->t_flags & TF_STOPPED)
1157 		return (0);
1158 
1159 	/*
1160 	 * When a TTY hook is attached, we cannot perform unbuffered
1161 	 * copying to userspace. Just call ttydisc_getc() and
1162 	 * temporarily store data in a shadow buffer.
1163 	 */
1164 	if (ttyhook_hashook(tp, getc_capture) ||
1165 	    ttyhook_hashook(tp, getc_inject)) {
1166 		while (uio->uio_resid > 0) {
1167 			/* Read to shadow buffer. */
1168 			len = ttydisc_getc(tp, buf,
1169 			    MIN(uio->uio_resid, sizeof buf));
1170 			if (len == 0)
1171 				break;
1172 
1173 			/* Copy to userspace. */
1174 			tty_unlock(tp);
1175 			error = uiomove(buf, len, uio);
1176 			tty_lock(tp);
1177 
1178 			if (error != 0)
1179 				break;
1180 		}
1181 	} else {
1182 		error = ttyoutq_read_uio(&tp->t_outq, tp, uio);
1183 
1184 		ttydisc_wakeup_watermark(tp);
1185 		atomic_add_long(&tty_nout, obytes - uio->uio_resid);
1186 	}
1187 
1188 	return (error);
1189 }
1190 
1191 size_t
1192 ttydisc_getc_poll(struct tty *tp)
1193 {
1194 
1195 	tty_lock_assert(tp, MA_OWNED);
1196 
1197 	if (tp->t_flags & TF_STOPPED)
1198 		return (0);
1199 
1200 	if (ttyhook_hashook(tp, getc_poll))
1201 		return ttyhook_getc_poll(tp);
1202 
1203 	return ttyoutq_bytesused(&tp->t_outq);
1204 }
1205 
1206 /*
1207  * XXX: not really related to the TTYDISC, but we'd better put
1208  * tty_putchar() here, because we need to perform proper output
1209  * processing.
1210  */
1211 
1212 int
1213 tty_putchar(struct tty *tp, char c)
1214 {
1215 	tty_lock_assert(tp, MA_OWNED);
1216 
1217 	if (tty_gone(tp))
1218 		return (-1);
1219 
1220 	ttydisc_echo_force(tp, c, 0);
1221 	tp->t_writepos = tp->t_column;
1222 	ttyinq_reprintpos_set(&tp->t_inq);
1223 
1224 	ttydevsw_outwakeup(tp);
1225 	return (0);
1226 }
1227