diff --git a/sys/kern/tty_ttydisc.c b/sys/kern/tty_ttydisc.c index 665275ee93e7..eae7162e31c0 100644 --- a/sys/kern/tty_ttydisc.c +++ b/sys/kern/tty_ttydisc.c @@ -1,1305 +1,1379 @@ /*- * SPDX-License-Identifier: BSD-2-Clause * * Copyright (c) 2008 Ed Schouten * All rights reserved. * * Portions of this software were developed under sponsorship from Snow * B.V., the Netherlands. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include +#include +#include + /* * Standard TTYDISC `termios' line discipline. */ /* Statistics. */ static unsigned long tty_nin = 0; SYSCTL_ULONG(_kern, OID_AUTO, tty_nin, CTLFLAG_RD, &tty_nin, 0, "Total amount of bytes received"); static unsigned long tty_nout = 0; SYSCTL_ULONG(_kern, OID_AUTO, tty_nout, CTLFLAG_RD, &tty_nout, 0, "Total amount of bytes transmitted"); /* termios comparison macro's. */ #define CMP_CC(v,c) (tp->t_termios.c_cc[v] != _POSIX_VDISABLE && \ tp->t_termios.c_cc[v] == (c)) #define CMP_FLAG(field,opt) (tp->t_termios.c_ ## field ## flag & (opt)) /* Characters that cannot be modified through c_cc. */ #define CTAB '\t' #define CNL '\n' #define CCR '\r' /* Character is a control character. */ #define CTL_VALID(c) ((c) == 0x7f || (unsigned char)(c) < 0x20) /* Control character should be processed on echo. */ #define CTL_ECHO(c,q) (!(q) && ((c) == CERASE2 || (c) == CTAB || \ (c) == CNL || (c) == CCR)) /* Control character should be printed using ^X notation. */ #define CTL_PRINT(c,q) ((c) == 0x7f || ((unsigned char)(c) < 0x20 && \ ((q) || ((c) != CTAB && (c) != CNL)))) /* Character is whitespace. */ #define CTL_WHITE(c) ((c) == ' ' || (c) == CTAB) /* Character is alphanumeric. */ #define CTL_ALNUM(c) (((c) >= '0' && (c) <= '9') || \ ((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z')) +/* Character is UTF8-encoded. */ +#define CTL_UTF8(c) (!!((c) & 0x80)) +/* Character is a UTF8 continuation byte. */ +#define CTL_UTF8_CONT(c) (((c) & 0xc0) == 0x80) #define TTY_STACKBUF 256 +#define UTF8_STACKBUF 4 void ttydisc_open(struct tty *tp) { ttydisc_optimize(tp); } void ttydisc_close(struct tty *tp) { /* Clean up our flags when leaving the discipline. */ tp->t_flags &= ~(TF_STOPPED|TF_HIWAT|TF_ZOMBIE); tp->t_termios.c_lflag &= ~FLUSHO; /* * POSIX states that we must drain output and flush input on * last close. Draining has already been done if possible. */ tty_flush(tp, FREAD | FWRITE); if (ttyhook_hashook(tp, close)) ttyhook_close(tp); } static int ttydisc_read_canonical(struct tty *tp, struct uio *uio, int ioflag) { char breakc[4] = { CNL }; /* enough to hold \n, VEOF and VEOL. */ int error; size_t clen, flen = 0, n = 1; unsigned char lastc = _POSIX_VDISABLE; #define BREAK_ADD(c) do { \ if (tp->t_termios.c_cc[c] != _POSIX_VDISABLE) \ breakc[n++] = tp->t_termios.c_cc[c]; \ } while (0) /* Determine which characters we should trigger on. */ BREAK_ADD(VEOF); BREAK_ADD(VEOL); #undef BREAK_ADD breakc[n] = '\0'; do { error = tty_wait_background(tp, curthread, SIGTTIN); if (error) return (error); /* * Quite a tricky case: unlike the old TTY * implementation, this implementation copies data back * to userspace in large chunks. Unfortunately, we can't * calculate the line length on beforehand if it crosses * ttyinq_block boundaries, because multiple reads could * then make this code read beyond the newline. * * This is why we limit the read to: * - The size the user has requested * - The blocksize (done in tty_inq.c) * - The amount of bytes until the newline * * This causes the line length to be recalculated after * each block has been copied to userspace. This will * cause the TTY layer to return data in chunks using * the blocksize (except the first and last blocks). */ clen = ttyinq_findchar(&tp->t_inq, breakc, uio->uio_resid, &lastc); /* No more data. */ if (clen == 0) { if (tp->t_flags & TF_ZOMBIE) return (0); else if (ioflag & IO_NDELAY) return (EWOULDBLOCK); error = tty_wait(tp, &tp->t_inwait); if (error) return (error); continue; } /* Don't send the EOF char back to userspace. */ if (CMP_CC(VEOF, lastc)) flen = 1; MPASS(flen <= clen); /* Read and throw away the EOF character. */ error = ttyinq_read_uio(&tp->t_inq, tp, uio, clen, flen); if (error) return (error); } while (uio->uio_resid > 0 && lastc == _POSIX_VDISABLE); return (0); } static int ttydisc_read_raw_no_timer(struct tty *tp, struct uio *uio, int ioflag) { size_t vmin = tp->t_termios.c_cc[VMIN]; ssize_t oresid = uio->uio_resid; int error; MPASS(tp->t_termios.c_cc[VTIME] == 0); /* * This routine implements the easy cases of read()s while in * non-canonical mode, namely case B and D, where we don't have * any timers at all. */ for (;;) { error = tty_wait_background(tp, curthread, SIGTTIN); if (error) return (error); error = ttyinq_read_uio(&tp->t_inq, tp, uio, uio->uio_resid, 0); if (error) return (error); if (uio->uio_resid == 0 || (oresid - uio->uio_resid) >= vmin) return (0); /* We have to wait for more. */ if (tp->t_flags & TF_ZOMBIE) return (0); else if (ioflag & IO_NDELAY) return (EWOULDBLOCK); error = tty_wait(tp, &tp->t_inwait); if (error) return (error); } } static int ttydisc_read_raw_read_timer(struct tty *tp, struct uio *uio, int ioflag, int oresid) { size_t vmin = MAX(tp->t_termios.c_cc[VMIN], 1); unsigned int vtime = tp->t_termios.c_cc[VTIME]; struct timeval end, now, left; int error, hz; MPASS(tp->t_termios.c_cc[VTIME] != 0); /* Determine when the read should be expired. */ end.tv_sec = vtime / 10; end.tv_usec = (vtime % 10) * 100000; getmicrotime(&now); timevaladd(&end, &now); for (;;) { error = tty_wait_background(tp, curthread, SIGTTIN); if (error) return (error); error = ttyinq_read_uio(&tp->t_inq, tp, uio, uio->uio_resid, 0); if (error) return (error); if (uio->uio_resid == 0 || (oresid - uio->uio_resid) >= vmin) return (0); /* Calculate how long we should wait. */ getmicrotime(&now); if (timevalcmp(&now, &end, >)) return (0); left = end; timevalsub(&left, &now); hz = tvtohz(&left); /* * We have to wait for more. If the timer expires, we * should return a 0-byte read. */ if (tp->t_flags & TF_ZOMBIE) return (0); else if (ioflag & IO_NDELAY) return (EWOULDBLOCK); error = tty_timedwait(tp, &tp->t_inwait, hz); if (error) return (error == EWOULDBLOCK ? 0 : error); } return (0); } static int ttydisc_read_raw_interbyte_timer(struct tty *tp, struct uio *uio, int ioflag) { size_t vmin = tp->t_termios.c_cc[VMIN]; ssize_t oresid = uio->uio_resid; int error; MPASS(tp->t_termios.c_cc[VMIN] != 0); MPASS(tp->t_termios.c_cc[VTIME] != 0); /* * When using the interbyte timer, the timer should be started * after the first byte has been received. We just call into the * generic read timer code after we've received the first byte. */ for (;;) { error = tty_wait_background(tp, curthread, SIGTTIN); if (error) return (error); error = ttyinq_read_uio(&tp->t_inq, tp, uio, uio->uio_resid, 0); if (error) return (error); if (uio->uio_resid == 0 || (oresid - uio->uio_resid) >= vmin) return (0); /* * Not enough data, but we did receive some, which means * we'll now start using the interbyte timer. */ if (oresid != uio->uio_resid) break; /* We have to wait for more. */ if (tp->t_flags & TF_ZOMBIE) return (0); else if (ioflag & IO_NDELAY) return (EWOULDBLOCK); error = tty_wait(tp, &tp->t_inwait); if (error) return (error); } return ttydisc_read_raw_read_timer(tp, uio, ioflag, oresid); } int ttydisc_read(struct tty *tp, struct uio *uio, int ioflag) { int error; tty_assert_locked(tp); if (uio->uio_resid == 0) return (0); if (CMP_FLAG(l, ICANON)) error = ttydisc_read_canonical(tp, uio, ioflag); else if (tp->t_termios.c_cc[VTIME] == 0) error = ttydisc_read_raw_no_timer(tp, uio, ioflag); else if (tp->t_termios.c_cc[VMIN] == 0) error = ttydisc_read_raw_read_timer(tp, uio, ioflag, uio->uio_resid); else error = ttydisc_read_raw_interbyte_timer(tp, uio, ioflag); if (ttyinq_bytesleft(&tp->t_inq) >= tp->t_inlow || ttyinq_bytescanonicalized(&tp->t_inq) == 0) { /* Unset the input watermark when we've got enough space. */ tty_hiwat_in_unblock(tp); } return (error); } static __inline unsigned int ttydisc_findchar(const char *obstart, unsigned int oblen) { const char *c = obstart; while (oblen--) { if (CTL_VALID(*c)) break; c++; } return (c - obstart); } static int ttydisc_write_oproc(struct tty *tp, char c) { unsigned int scnt, error; MPASS(CMP_FLAG(o, OPOST)); MPASS(CTL_VALID(c)); #define PRINT_NORMAL() ttyoutq_write_nofrag(&tp->t_outq, &c, 1) switch (c) { case CEOF: /* End-of-text dropping. */ if (CMP_FLAG(o, ONOEOT)) return (0); return PRINT_NORMAL(); case CERASE2: /* Handle backspace to fix tab expansion. */ if (PRINT_NORMAL() != 0) return (-1); if (tp->t_column > 0) tp->t_column--; return (0); case CTAB: /* Tab expansion. */ scnt = 8 - (tp->t_column & 7); if (CMP_FLAG(o, TAB3)) { error = ttyoutq_write_nofrag(&tp->t_outq, " ", scnt); } else { error = PRINT_NORMAL(); } if (error) return (-1); tp->t_column += scnt; MPASS((tp->t_column % 8) == 0); return (0); case CNL: /* Newline conversion. */ if (CMP_FLAG(o, ONLCR)) { /* Convert \n to \r\n. */ error = ttyoutq_write_nofrag(&tp->t_outq, "\r\n", 2); } else { error = PRINT_NORMAL(); } if (error) return (-1); if (CMP_FLAG(o, ONLCR|ONLRET)) { tp->t_column = tp->t_writepos = 0; ttyinq_reprintpos_set(&tp->t_inq); } return (0); case CCR: /* Carriage return to newline conversion. */ if (CMP_FLAG(o, OCRNL)) c = CNL; /* Omit carriage returns on column 0. */ if (CMP_FLAG(o, ONOCR) && tp->t_column == 0) return (0); if (PRINT_NORMAL() != 0) return (-1); tp->t_column = tp->t_writepos = 0; ttyinq_reprintpos_set(&tp->t_inq); return (0); } /* * Invisible control character. Print it, but don't * increase the column count. */ return PRINT_NORMAL(); #undef PRINT_NORMAL } /* * Just like the old TTY implementation, we need to copy data in chunks * into a temporary buffer. One of the reasons why we need to do this, * is because output processing (only TAB3 though) may allow the buffer * to grow eight times. */ int ttydisc_write(struct tty *tp, struct uio *uio, int ioflag) { char ob[TTY_STACKBUF]; char *obstart; int error = 0; unsigned int oblen = 0; tty_assert_locked(tp); if (tp->t_flags & TF_ZOMBIE) return (EIO); /* * We don't need to check whether the process is the foreground * process group or if we have a carrier. This is already done * in ttydev_write(). */ while (uio->uio_resid > 0) { unsigned int nlen; MPASS(oblen == 0); if (CMP_FLAG(l, FLUSHO)) { uio->uio_offset += uio->uio_resid; uio->uio_resid = 0; return (0); } /* Step 1: read data. */ obstart = ob; nlen = MIN(uio->uio_resid, sizeof ob); tty_unlock(tp); error = uiomove(ob, nlen, uio); tty_lock(tp); if (error != 0) break; oblen = nlen; if (tty_gone(tp)) { error = ENXIO; break; } MPASS(oblen > 0); /* Step 2: process data. */ do { unsigned int plen, wlen; if (CMP_FLAG(l, FLUSHO)) { uio->uio_offset += uio->uio_resid; uio->uio_resid = 0; return (0); } /* Search for special characters for post processing. */ if (CMP_FLAG(o, OPOST)) { plen = ttydisc_findchar(obstart, oblen); } else { plen = oblen; } if (plen == 0) { /* * We're going to process a character * that needs processing */ if (ttydisc_write_oproc(tp, *obstart) == 0) { obstart++; oblen--; tp->t_writepos = tp->t_column; ttyinq_reprintpos_set(&tp->t_inq); continue; } } else { /* We're going to write regular data. */ wlen = ttyoutq_write(&tp->t_outq, obstart, plen); obstart += wlen; oblen -= wlen; tp->t_column += wlen; tp->t_writepos = tp->t_column; ttyinq_reprintpos_set(&tp->t_inq); if (wlen == plen) continue; } /* Watermark reached. Try to sleep. */ tp->t_flags |= TF_HIWAT_OUT; if (ioflag & IO_NDELAY) { error = EWOULDBLOCK; goto done; } /* * The driver may write back the data * synchronously. Be sure to check the high * water mark before going to sleep. */ ttydevsw_outwakeup(tp); if ((tp->t_flags & TF_HIWAT_OUT) == 0) continue; error = tty_wait(tp, &tp->t_outwait); if (error) goto done; if (tp->t_flags & TF_ZOMBIE) { error = EIO; goto done; } } while (oblen > 0); } done: if (!tty_gone(tp)) ttydevsw_outwakeup(tp); /* * Add the amount of bytes that we didn't process back to the * uio counters. We need to do this to make sure write() doesn't * count the bytes we didn't store in the queue. */ uio->uio_resid += oblen; return (error); } void ttydisc_optimize(struct tty *tp) { tty_assert_locked(tp); if (ttyhook_hashook(tp, rint_bypass)) { tp->t_flags |= TF_BYPASS; } else if (ttyhook_hashook(tp, rint)) { tp->t_flags &= ~TF_BYPASS; } else if (!CMP_FLAG(i, ICRNL|IGNCR|IMAXBEL|INLCR|ISTRIP|IXON) && (!CMP_FLAG(i, BRKINT) || CMP_FLAG(i, IGNBRK)) && (!CMP_FLAG(i, PARMRK) || CMP_FLAG(i, IGNPAR|IGNBRK) == (IGNPAR|IGNBRK)) && !CMP_FLAG(l, ECHO|ICANON|IEXTEN|ISIG|PENDIN)) { tp->t_flags |= TF_BYPASS; } else { tp->t_flags &= ~TF_BYPASS; } } void ttydisc_modem(struct tty *tp, int open) { tty_assert_locked(tp); if (open) cv_broadcast(&tp->t_dcdwait); /* * Ignore modem status lines when CLOCAL is turned on, but don't * enter the zombie state when the TTY isn't opened, because * that would cause the TTY to be in zombie state after being * opened. */ if (!tty_opened(tp) || CMP_FLAG(c, CLOCAL)) return; if (open == 0) { /* * Lost carrier. */ tp->t_flags |= TF_ZOMBIE; tty_signal_sessleader(tp, SIGHUP); tty_flush(tp, FREAD|FWRITE); } else { /* * Carrier is back again. */ /* XXX: what should we do here? */ } } static int ttydisc_echo_force(struct tty *tp, char c, int quote) { if (CMP_FLAG(l, FLUSHO)) return 0; if (CMP_FLAG(o, OPOST) && CTL_ECHO(c, quote)) { /* * Only perform postprocessing when OPOST is turned on * and the character is an unquoted BS/TB/NL/CR. */ return ttydisc_write_oproc(tp, c); } else if (CMP_FLAG(l, ECHOCTL) && CTL_PRINT(c, quote)) { /* * Only use ^X notation when ECHOCTL is turned on and * we've got an quoted control character. * * Print backspaces when echoing an end-of-file. */ char ob[4] = "^?\b\b"; /* Print ^X notation. */ if (c != 0x7f) ob[1] = c + 'A' - 1; if (!quote && CMP_CC(VEOF, c)) { return ttyoutq_write_nofrag(&tp->t_outq, ob, 4); } else { tp->t_column += 2; return ttyoutq_write_nofrag(&tp->t_outq, ob, 2); } } else { /* Can just be printed. */ tp->t_column++; return ttyoutq_write_nofrag(&tp->t_outq, &c, 1); } } static int ttydisc_echo(struct tty *tp, char c, int quote) { /* * Only echo characters when ECHO is turned on, or ECHONL when * the character is an unquoted newline. */ if (!CMP_FLAG(l, ECHO) && (!CMP_FLAG(l, ECHONL) || c != CNL || quote)) return (0); return ttydisc_echo_force(tp, c, quote); } static void ttydisc_reprint_char(void *d, char c, int quote) { struct tty *tp = d; ttydisc_echo(tp, c, quote); } static void ttydisc_reprint(struct tty *tp) { cc_t c; /* Print ^R\n, followed by the line. */ c = tp->t_termios.c_cc[VREPRINT]; if (c != _POSIX_VDISABLE) ttydisc_echo(tp, c, 0); ttydisc_echo(tp, CNL, 0); ttyinq_reprintpos_reset(&tp->t_inq); ttyinq_line_iterate_from_linestart(&tp->t_inq, ttydisc_reprint_char, tp); } struct ttydisc_recalc_length { struct tty *tp; unsigned int curlen; }; static void ttydisc_recalc_charlength(void *d, char c, int quote) { struct ttydisc_recalc_length *data = d; struct tty *tp = data->tp; if (CTL_PRINT(c, quote)) { if (CMP_FLAG(l, ECHOCTL)) data->curlen += 2; } else if (c == CTAB) { data->curlen += 8 - (data->curlen & 7); } else { data->curlen++; } } static unsigned int ttydisc_recalc_linelength(struct tty *tp) { struct ttydisc_recalc_length data = { tp, tp->t_writepos }; ttyinq_line_iterate_from_reprintpos(&tp->t_inq, ttydisc_recalc_charlength, &data); return (data.curlen); } static int ttydisc_rubchar(struct tty *tp) { char c; int quote; unsigned int prevpos, tablen; if (ttyinq_peekchar(&tp->t_inq, &c, "e) != 0) return (-1); ttyinq_unputchar(&tp->t_inq); if (CMP_FLAG(l, ECHO)) { /* * Remove the character from the screen. This is even * safe for characters that span multiple characters * (tabs, quoted, etc). */ if (tp->t_writepos >= tp->t_column) { /* Retype the sentence. */ ttydisc_reprint(tp); } else if (CMP_FLAG(l, ECHOE)) { if (CTL_PRINT(c, quote)) { /* Remove ^X formatted chars. */ if (CMP_FLAG(l, ECHOCTL)) { tp->t_column -= 2; ttyoutq_write_nofrag(&tp->t_outq, "\b\b \b\b", 6); } } else if (c == ' ') { /* Space character needs no rubbing. */ tp->t_column -= 1; ttyoutq_write_nofrag(&tp->t_outq, "\b", 1); } else if (c == CTAB) { /* * Making backspace work with tabs is * quite hard. Recalculate the length of * this character and remove it. * * Because terminal settings could be * changed while the line is being * inserted, the calculations don't have * to be correct. Make sure we keep the * tab length within proper bounds. */ prevpos = ttydisc_recalc_linelength(tp); if (prevpos >= tp->t_column) tablen = 1; else tablen = tp->t_column - prevpos; if (tablen > 8) tablen = 8; tp->t_column = prevpos; ttyoutq_write_nofrag(&tp->t_outq, "\b\b\b\b\b\b\b\b", tablen); return (0); + } else if ((tp->t_termios.c_iflag & IUTF8) != 0 && + CTL_UTF8(c)) { + uint8_t bytes[UTF8_STACKBUF] = { 0 }; + int curidx = UTF8_STACKBUF - 1, cwidth = 1, + nb = 0; + teken_char_t codepoint; + + /* Save current byte. */ + bytes[curidx] = c; + curidx--; + nb++; + /* Loop back through inq until we hit the + * leading byte. */ + while (CTL_UTF8_CONT(c) && nb < UTF8_STACKBUF) { + ttyinq_peekchar(&tp->t_inq, &c, "e); + ttyinq_unputchar(&tp->t_inq); + bytes[curidx] = c; + curidx--; + nb++; + } + /* + * Shift array so that the leading + * byte ends up at idx 0. + */ + if (nb < UTF8_STACKBUF) + memmove(&bytes[0], &bytes[curidx + 1], + nb * sizeof(uint8_t)); + /* Check for malformed UTF8 characters. */ + if (nb == UTF8_STACKBUF && + CTL_UTF8_CONT(bytes[0])) { + /* + * Place all bytes back into the inq and + * delete the last byte only. + */ + ttyinq_write(&tp->t_inq, bytes, + UTF8_STACKBUF, 0); + } else { + /* Find codepoint and width. */ + codepoint = + teken_utf8_bytes_to_codepoint(bytes, + nb); + if (codepoint != + TEKEN_UTF8_INVALID_CODEPOINT) { + cwidth = teken_wcwidth( + codepoint); + } else { + /* + * Place all bytes back into the + * inq and fall back to + * default behaviour. + */ + ttyinq_write(&tp->t_inq, bytes, + nb, 0); + } + } + tp->t_column -= cwidth; + /* + * Delete character by punching + * 'cwidth' spaces over it. + */ + if (cwidth == 1) + ttyoutq_write_nofrag(&tp->t_outq, + "\b \b", 3); + else if (cwidth == 2) + ttyoutq_write_nofrag(&tp->t_outq, + "\b\b \b\b", 6); } else { /* * Remove a regular character by * punching a space over it. */ tp->t_column -= 1; ttyoutq_write_nofrag(&tp->t_outq, "\b \b", 3); } } else { /* Don't print spaces. */ ttydisc_echo(tp, tp->t_termios.c_cc[VERASE], 0); } } return (0); } static void ttydisc_rubword(struct tty *tp) { char c; int quote, alnum; /* Strip whitespace first. */ for (;;) { if (ttyinq_peekchar(&tp->t_inq, &c, "e) != 0) return; if (!CTL_WHITE(c)) break; ttydisc_rubchar(tp); } /* * Record whether the last character from the previous iteration * was alphanumeric or not. We need this to implement ALTWERASE. */ alnum = CTL_ALNUM(c); for (;;) { ttydisc_rubchar(tp); if (ttyinq_peekchar(&tp->t_inq, &c, "e) != 0) return; if (CTL_WHITE(c)) return; if (CMP_FLAG(l, ALTWERASE) && CTL_ALNUM(c) != alnum) return; } } int ttydisc_rint(struct tty *tp, char c, int flags) { int signal, quote = 0; char ob[3] = { 0xff, 0x00 }; size_t ol; tty_assert_locked(tp); atomic_add_long(&tty_nin, 1); if (ttyhook_hashook(tp, rint)) return ttyhook_rint(tp, c, flags); if (tp->t_flags & TF_BYPASS) goto processed; if (flags) { if (flags & TRE_BREAK) { if (CMP_FLAG(i, IGNBRK)) { /* Ignore break characters. */ return (0); } else if (CMP_FLAG(i, BRKINT)) { /* Generate SIGINT on break. */ tty_flush(tp, FREAD|FWRITE); tty_signal_pgrp(tp, SIGINT); return (0); } else { /* Just print it. */ goto parmrk; } } else if (flags & TRE_FRAMING || (flags & TRE_PARITY && CMP_FLAG(i, INPCK))) { if (CMP_FLAG(i, IGNPAR)) { /* Ignore bad characters. */ return (0); } else { /* Just print it. */ goto parmrk; } } } /* Allow any character to perform a wakeup. */ if (CMP_FLAG(i, IXANY)) { tp->t_flags &= ~TF_STOPPED; tp->t_termios.c_lflag &= ~FLUSHO; } /* Remove the top bit. */ if (CMP_FLAG(i, ISTRIP)) c &= ~0x80; /* Skip input processing when we want to print it literally. */ if (tp->t_flags & TF_LITERAL) { tp->t_flags &= ~TF_LITERAL; quote = 1; goto processed; } /* Special control characters that are implementation dependent. */ if (CMP_FLAG(l, IEXTEN)) { /* Accept the next character as literal. */ if (CMP_CC(VLNEXT, c)) { if (CMP_FLAG(l, ECHO)) { if (CMP_FLAG(l, ECHOE)) ttyoutq_write_nofrag(&tp->t_outq, "^\b", 2); else ttydisc_echo(tp, c, 0); } tp->t_flags |= TF_LITERAL; return (0); } /* Discard processing */ if (CMP_CC(VDISCARD, c)) { if (CMP_FLAG(l, FLUSHO)) { tp->t_termios.c_lflag &= ~FLUSHO; } else { tty_flush(tp, FWRITE); ttydisc_echo(tp, c, 0); if (tp->t_inq.ti_end > 0) ttydisc_reprint(tp); tp->t_termios.c_lflag |= FLUSHO; } } } /* * Handle signal processing. */ if (CMP_FLAG(l, ISIG)) { if (CMP_FLAG(l, ICANON|IEXTEN) == (ICANON|IEXTEN)) { if (CMP_CC(VSTATUS, c)) { tty_signal_pgrp(tp, SIGINFO); return (0); } } /* * When compared to the old implementation, this * implementation also flushes the output queue. POSIX * is really brief about this, but does makes us assume * we have to do so. */ signal = 0; if (CMP_CC(VINTR, c)) { signal = SIGINT; } else if (CMP_CC(VQUIT, c)) { signal = SIGQUIT; } else if (CMP_CC(VSUSP, c)) { signal = SIGTSTP; } if (signal != 0) { /* * Echo the character before signalling the * processes. */ if (!CMP_FLAG(l, NOFLSH)) tty_flush(tp, FREAD|FWRITE); ttydisc_echo(tp, c, 0); tty_signal_pgrp(tp, signal); return (0); } } /* * Handle start/stop characters. */ if (CMP_FLAG(i, IXON)) { if (CMP_CC(VSTOP, c)) { /* Stop it if we aren't stopped yet. */ if ((tp->t_flags & TF_STOPPED) == 0) { tp->t_flags |= TF_STOPPED; return (0); } /* * Fallthrough: * When VSTART == VSTOP, we should make this key * toggle it. */ if (!CMP_CC(VSTART, c)) return (0); } if (CMP_CC(VSTART, c)) { tp->t_flags &= ~TF_STOPPED; return (0); } } /* Conversion of CR and NL. */ switch (c) { case CCR: if (CMP_FLAG(i, IGNCR)) return (0); if (CMP_FLAG(i, ICRNL)) c = CNL; break; case CNL: if (CMP_FLAG(i, INLCR)) c = CCR; break; } /* Canonical line editing. */ if (CMP_FLAG(l, ICANON)) { if (CMP_CC(VERASE, c) || CMP_CC(VERASE2, c)) { ttydisc_rubchar(tp); return (0); } else if (CMP_CC(VKILL, c)) { while (ttydisc_rubchar(tp) == 0); return (0); } else if (CMP_FLAG(l, IEXTEN)) { if (CMP_CC(VWERASE, c)) { ttydisc_rubword(tp); return (0); } else if (CMP_CC(VREPRINT, c)) { ttydisc_reprint(tp); return (0); } } } processed: if (CMP_FLAG(i, PARMRK) && (unsigned char)c == 0xff) { /* Print 0xff 0xff. */ ob[1] = 0xff; ol = 2; quote = 1; } else { ob[0] = c; ol = 1; } goto print; parmrk: if (CMP_FLAG(i, PARMRK)) { /* Prepend 0xff 0x00 0x.. */ ob[2] = c; ol = 3; quote = 1; } else { ob[0] = c; ol = 1; } print: /* See if we can store this on the input queue. */ if (ttyinq_write_nofrag(&tp->t_inq, ob, ol, quote) != 0) { if (CMP_FLAG(i, IMAXBEL)) ttyoutq_write_nofrag(&tp->t_outq, "\a", 1); /* * Prevent a deadlock here. It may be possible that a * user has entered so much data, there is no data * available to read(), but the buffers are full anyway. * * Only enter the high watermark if the device driver * can actually transmit something. */ if (ttyinq_bytescanonicalized(&tp->t_inq) == 0) return (0); tty_hiwat_in_block(tp); return (-1); } /* * In raw mode, we canonicalize after receiving a single * character. Otherwise, we canonicalize when we receive a * newline, VEOL or VEOF, but only when it isn't quoted. */ if (!CMP_FLAG(l, ICANON) || (!quote && (c == CNL || CMP_CC(VEOL, c) || CMP_CC(VEOF, c)))) { ttyinq_canonicalize(&tp->t_inq); } ttydisc_echo(tp, c, quote); return (0); } size_t ttydisc_rint_simple(struct tty *tp, const void *buf, size_t len) { const char *cbuf; if (ttydisc_can_bypass(tp)) return (ttydisc_rint_bypass(tp, buf, len)); for (cbuf = buf; len-- > 0; cbuf++) { if (ttydisc_rint(tp, *cbuf, 0) != 0) break; } return (cbuf - (const char *)buf); } size_t ttydisc_rint_bypass(struct tty *tp, const void *buf, size_t len) { size_t ret; tty_assert_locked(tp); MPASS(tp->t_flags & TF_BYPASS); atomic_add_long(&tty_nin, len); if (ttyhook_hashook(tp, rint_bypass)) return ttyhook_rint_bypass(tp, buf, len); ret = ttyinq_write(&tp->t_inq, buf, len, 0); ttyinq_canonicalize(&tp->t_inq); if (ret < len) tty_hiwat_in_block(tp); return (ret); } void ttydisc_rint_done(struct tty *tp) { tty_assert_locked(tp); if (ttyhook_hashook(tp, rint_done)) ttyhook_rint_done(tp); /* Wake up readers. */ tty_wakeup(tp, FREAD); /* Wake up driver for echo. */ ttydevsw_outwakeup(tp); } size_t ttydisc_rint_poll(struct tty *tp) { size_t l; tty_assert_locked(tp); if (ttyhook_hashook(tp, rint_poll)) return ttyhook_rint_poll(tp); /* * XXX: Still allow character input when there's no space in the * buffers, but we haven't entered the high watermark. This is * to allow backspace characters to be inserted when in * canonical mode. */ l = ttyinq_bytesleft(&tp->t_inq); if (l == 0 && (tp->t_flags & TF_HIWAT_IN) == 0) return (1); return (l); } static void ttydisc_wakeup_watermark(struct tty *tp) { size_t c; c = ttyoutq_bytesleft(&tp->t_outq); if (tp->t_flags & TF_HIWAT_OUT) { /* Only allow us to run when we're below the watermark. */ if (c < tp->t_outlow) return; /* Reset the watermark. */ tp->t_flags &= ~TF_HIWAT_OUT; } else { /* Only run when we have data at all. */ if (c == 0) return; } tty_wakeup(tp, FWRITE); } size_t ttydisc_getc(struct tty *tp, void *buf, size_t len) { tty_assert_locked(tp); if (tp->t_flags & TF_STOPPED) return (0); if (ttyhook_hashook(tp, getc_inject)) return ttyhook_getc_inject(tp, buf, len); len = ttyoutq_read(&tp->t_outq, buf, len); if (ttyhook_hashook(tp, getc_capture)) ttyhook_getc_capture(tp, buf, len); ttydisc_wakeup_watermark(tp); atomic_add_long(&tty_nout, len); return (len); } int ttydisc_getc_uio(struct tty *tp, struct uio *uio) { int error = 0; ssize_t obytes = uio->uio_resid; size_t len; char buf[TTY_STACKBUF]; tty_assert_locked(tp); if (tp->t_flags & TF_STOPPED) return (0); /* * When a TTY hook is attached, we cannot perform unbuffered * copying to userspace. Just call ttydisc_getc() and * temporarily store data in a shadow buffer. */ if (ttyhook_hashook(tp, getc_capture) || ttyhook_hashook(tp, getc_inject)) { while (uio->uio_resid > 0) { /* Read to shadow buffer. */ len = ttydisc_getc(tp, buf, MIN(uio->uio_resid, sizeof buf)); if (len == 0) break; /* Copy to userspace. */ tty_unlock(tp); error = uiomove(buf, len, uio); tty_lock(tp); if (error != 0) break; } } else { error = ttyoutq_read_uio(&tp->t_outq, tp, uio); ttydisc_wakeup_watermark(tp); atomic_add_long(&tty_nout, obytes - uio->uio_resid); } return (error); } size_t ttydisc_getc_poll(struct tty *tp) { tty_assert_locked(tp); if (tp->t_flags & TF_STOPPED) return (0); if (ttyhook_hashook(tp, getc_poll)) return ttyhook_getc_poll(tp); return ttyoutq_bytesused(&tp->t_outq); } /* * XXX: not really related to the TTYDISC, but we'd better put * tty_putchar() here, because we need to perform proper output * processing. */ int tty_putstrn(struct tty *tp, const char *p, size_t n) { size_t i; tty_assert_locked(tp); if (tty_gone(tp)) return (-1); for (i = 0; i < n; i++) ttydisc_echo_force(tp, p[i], 0); tp->t_writepos = tp->t_column; ttyinq_reprintpos_set(&tp->t_inq); ttydevsw_outwakeup(tp); return (0); } int tty_putchar(struct tty *tp, char c) { return (tty_putstrn(tp, &c, 1)); } diff --git a/sys/teken/teken_wcwidth.h b/sys/teken/teken_wcwidth.h index f57a185c2433..f5a23dbc9679 100644 --- a/sys/teken/teken_wcwidth.h +++ b/sys/teken/teken_wcwidth.h @@ -1,118 +1,148 @@ /* * Markus Kuhn -- 2007-05-26 (Unicode 5.0) * * Permission to use, copy, modify, and distribute this software * for any purpose and without fee is hereby granted. The author * disclaims all warranties with regard to this software. * * Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c */ +#define TEKEN_UTF8_INVALID_CODEPOINT -1 + struct interval { teken_char_t first; teken_char_t last; }; /* auxiliary function for binary search in interval table */ static int bisearch(teken_char_t ucs, const struct interval *table, int max) { int min = 0; int mid; if (ucs < table[0].first || ucs > table[max].last) return 0; while (max >= min) { mid = (min + max) / 2; if (ucs > table[mid].last) min = mid + 1; else if (ucs < table[mid].first) max = mid - 1; else return 1; } return 0; } static int teken_wcwidth(teken_char_t ucs) { /* sorted list of non-overlapping intervals of non-spacing characters */ /* generated by "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c" */ static const struct interval combining[] = { { 0x0300, 0x036F }, { 0x0483, 0x0486 }, { 0x0488, 0x0489 }, { 0x0591, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 }, { 0x05C4, 0x05C5 }, { 0x05C7, 0x05C7 }, { 0x0600, 0x0603 }, { 0x0610, 0x0615 }, { 0x064B, 0x065E }, { 0x0670, 0x0670 }, { 0x06D6, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED }, { 0x070F, 0x070F }, { 0x0711, 0x0711 }, { 0x0730, 0x074A }, { 0x07A6, 0x07B0 }, { 0x07EB, 0x07F3 }, { 0x0901, 0x0902 }, { 0x093C, 0x093C }, { 0x0941, 0x0948 }, { 0x094D, 0x094D }, { 0x0951, 0x0954 }, { 0x0962, 0x0963 }, { 0x0981, 0x0981 }, { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 }, { 0x09CD, 0x09CD }, { 0x09E2, 0x09E3 }, { 0x0A01, 0x0A02 }, { 0x0A3C, 0x0A3C }, { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 }, { 0x0A4B, 0x0A4D }, { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 }, { 0x0ABC, 0x0ABC }, { 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 }, { 0x0ACD, 0x0ACD }, { 0x0AE2, 0x0AE3 }, { 0x0B01, 0x0B01 }, { 0x0B3C, 0x0B3C }, { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 }, { 0x0B4D, 0x0B4D }, { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 }, { 0x0BC0, 0x0BC0 }, { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 }, { 0x0C46, 0x0C48 }, { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, { 0x0CBC, 0x0CBC }, { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 }, { 0x0CCC, 0x0CCD }, { 0x0CE2, 0x0CE3 }, { 0x0D41, 0x0D43 }, { 0x0D4D, 0x0D4D }, { 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 }, { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E }, { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC }, { 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 }, { 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E }, { 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 }, { 0x0F90, 0x0F97 }, { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 }, { 0x1032, 0x1032 }, { 0x1036, 0x1037 }, { 0x1039, 0x1039 }, { 0x1058, 0x1059 }, { 0x1160, 0x11FF }, { 0x135F, 0x135F }, { 0x1712, 0x1714 }, { 0x1732, 0x1734 }, { 0x1752, 0x1753 }, { 0x1772, 0x1773 }, { 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD }, { 0x17C6, 0x17C6 }, { 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD }, { 0x180B, 0x180D }, { 0x18A9, 0x18A9 }, { 0x1920, 0x1922 }, { 0x1927, 0x1928 }, { 0x1932, 0x1932 }, { 0x1939, 0x193B }, { 0x1A17, 0x1A18 }, { 0x1B00, 0x1B03 }, { 0x1B34, 0x1B34 }, { 0x1B36, 0x1B3A }, { 0x1B3C, 0x1B3C }, { 0x1B42, 0x1B42 }, { 0x1B6B, 0x1B73 }, { 0x1DC0, 0x1DCA }, { 0x1DFE, 0x1DFF }, { 0x200B, 0x200F }, { 0x202A, 0x202E }, { 0x2060, 0x2063 }, { 0x206A, 0x206F }, { 0x20D0, 0x20EF }, { 0x302A, 0x302F }, { 0x3099, 0x309A }, { 0xA806, 0xA806 }, { 0xA80B, 0xA80B }, { 0xA825, 0xA826 }, { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F }, { 0xFE20, 0xFE23 }, { 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB }, { 0x10A01, 0x10A03 }, { 0x10A05, 0x10A06 }, { 0x10A0C, 0x10A0F }, { 0x10A38, 0x10A3A }, { 0x10A3F, 0x10A3F }, { 0x1D167, 0x1D169 }, { 0x1D173, 0x1D182 }, { 0x1D185, 0x1D18B }, { 0x1D1AA, 0x1D1AD }, { 0x1D242, 0x1D244 }, { 0xE0001, 0xE0001 }, { 0xE0020, 0xE007F }, { 0xE0100, 0xE01EF } }; /* test for 8-bit control characters */ if (ucs == 0) return 0; if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0)) return -1; /* binary search in table of non-spacing characters */ if (bisearch(ucs, combining, sizeof(combining) / sizeof(struct interval) - 1)) return 0; /* if we arrive here, ucs is not a combining or C0/C1 control character */ return 1 + (ucs >= 0x1100 && (ucs <= 0x115f || /* Hangul Jamo init. consonants */ ucs == 0x2329 || ucs == 0x232a || (ucs >= 0x2e80 && ucs <= 0xa4cf && ucs != 0x303f) || /* CJK ... Yi */ (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */ (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */ (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */ (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */ (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */ (ucs >= 0xffe0 && ucs <= 0xffe6) || (ucs >= 0x20000 && ucs <= 0x2fffd) || (ucs >= 0x30000 && ucs <= 0x3fffd))); } + +/* + * Converts an UTF-8 byte sequence to a codepoint as specified in + * https://datatracker.ietf.org/doc/html/rfc3629#section-3 . The function + * expects the 'bytes' array to start with the leading character. + */ +static teken_char_t +teken_utf8_bytes_to_codepoint(uint8_t bytes[4], int nbytes) +{ + + /* Check for malformed characters. */ + if (bitcount(bytes[0] & 0xf0) != nbytes) + return (TEKEN_UTF8_INVALID_CODEPOINT); + + switch (nbytes) { + case 1: + return (bytes[0] & 0x7f); + case 2: + return (bytes[0] & 0xf) << 6 | (bytes[1] & 0x3f); + case 3: + return (bytes[0] & 0xf) << 12 | (bytes[1] & 0x3f) << 6 | (bytes[2] & 0x3f); + case 4: + return (bytes[0] & 0x7) << 18 | (bytes[1] & 0x3f) << 12 | + (bytes[2] & 0x3f) << 6 | (bytes[3] & 0x3f); + default: + return (TEKEN_UTF8_INVALID_CODEPOINT); + } +}