From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 119690 invoked by alias); 10 Feb 2020 10:04:51 -0000 Mailing-List: contact cygwin-cvs-help@cygwin.com; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Post: List-Help: , Sender: cygwin-cvs-owner@cygwin.com Received: (qmail 119597 invoked by uid 9078); 10 Feb 2020 10:04:50 -0000 Date: Mon, 10 Feb 2020 10:04:00 -0000 Message-ID: <20200210100450.119595.qmail@sourceware.org> Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Corinna Vinschen To: cygwin-cvs@sourceware.org Subject: [newlib-cygwin] Cygwin: pty: Inherit typeahead data between two input pipes. X-Act-Checkin: newlib-cygwin X-Git-Author: Takashi Yano X-Git-Refname: refs/heads/master X-Git-Oldrev: a4ca6c4861a4d7fa75b7e0a98dca0ad6bfda3390 X-Git-Newrev: 29431fcb5b14d4c5ac3b3161a076eb1a208349d9 X-SW-Source: 2020-q1/txt/msg00059.txt https://sourceware.org/git/gitweb.cgi?p=newlib-cygwin.git;h=29431fcb5b14d4c5ac3b3161a076eb1a208349d9 commit 29431fcb5b14d4c5ac3b3161a076eb1a208349d9 Author: Takashi Yano Date: Sun Feb 9 23:46:59 2020 +0900 Cygwin: pty: Inherit typeahead data between two input pipes. - PTY has a problem that the key input, which is typed during windows native app is running, disappear when it returns to shell. (Problem 3 in https://cygwin.com/ml/cygwin/2020-02/msg00007.html) This is beacuse pty has two input pipes, one is for cygwin apps and the other one is for native windows apps. The key input during windows native program is running is sent to the second input pipe while cygwin shell reads input from the first input pipe. This patch realize transfering input data between these two pipes. Diff: --- winsup/cygwin/fhandler.h | 12 +- winsup/cygwin/fhandler_tty.cc | 400 ++++++++++++++++++++++++++++++++---------- winsup/cygwin/select.cc | 2 + winsup/cygwin/tty.cc | 3 + winsup/cygwin/tty.h | 3 + 5 files changed, 329 insertions(+), 91 deletions(-) diff --git a/winsup/cygwin/fhandler.h b/winsup/cygwin/fhandler.h index a22f3a1..993d735 100644 --- a/winsup/cygwin/fhandler.h +++ b/winsup/cygwin/fhandler.h @@ -326,7 +326,7 @@ class fhandler_base virtual size_t &raixput () { return ra.raixput; }; virtual size_t &rabuflen () { return ra.rabuflen; }; - bool get_readahead_valid () { return raixget () < ralen (); } + virtual bool get_readahead_valid () { return raixget () < ralen (); } int puts_readahead (const char *s, size_t len = (size_t) -1); int put_readahead (char value); @@ -335,7 +335,7 @@ class fhandler_base void set_readahead_valid (int val, int ch = -1); - int get_readahead_into_buffer (char *buf, size_t buflen); + virtual int get_readahead_into_buffer (char *buf, size_t buflen); bool has_acls () const { return pc.has_acls (); } @@ -1768,7 +1768,7 @@ class fhandler_termios: public fhandler_base int ioctl (int, void *); tty_min *_tc; tty *get_ttyp () {return (tty *) tc ();} - int eat_readahead (int n); + virtual int eat_readahead (int n); public: tty_min*& tc () {return _tc;} @@ -2168,6 +2168,9 @@ class fhandler_pty_slave: public fhandler_pty_common ssize_t __stdcall write (const void *ptr, size_t len); void __reg3 read (void *ptr, size_t& len); int init (HANDLE, DWORD, mode_t); + int eat_readahead (int n); + int get_readahead_into_buffer (char *buf, size_t buflen); + bool get_readahead_valid (void); int tcsetattr (int a, const struct termios *t); int tcgetattr (struct termios *t); @@ -2217,6 +2220,8 @@ class fhandler_pty_slave: public fhandler_pty_common void set_freeconsole_on_close (bool val); void trigger_redraw_screen (void); void wait_pcon_fwd (void); + void pull_pcon_input (void); + void update_pcon_input_state (bool need_lock); }; #define __ptsname(buf, unit) __small_sprintf ((buf), "/dev/pty%d", (unit)) @@ -2281,6 +2286,7 @@ public: } bool setup_pseudoconsole (void); + void transfer_input_to_pcon (void); }; class fhandler_dev_null: public fhandler_base diff --git a/winsup/cygwin/fhandler_tty.cc b/winsup/cygwin/fhandler_tty.cc index 1c23c93..f2fd680 100644 --- a/winsup/cygwin/fhandler_tty.cc +++ b/winsup/cygwin/fhandler_tty.cc @@ -440,6 +440,10 @@ fhandler_pty_master::flush_to_slave () { if (get_readahead_valid () && !(get_ttyp ()->ti.c_lflag & ICANON)) accept_input (); + WaitForSingleObject (input_mutex, INFINITE); + if (!get_ttyp ()->pcon_in_empty && !(get_ttyp ()->ti.c_lflag & ICANON)) + SetEvent (input_available_event); + ReleaseMutex (input_mutex); } DWORD @@ -519,7 +523,7 @@ fhandler_pty_master::accept_input () termios_printf ("sending EOF to slave"); get_ttyp ()->read_retval = 0; } - else + else if (!to_be_read_from_pcon ()) { char *p = rabuf (); DWORD rc; @@ -986,7 +990,6 @@ fhandler_pty_slave::close () termios_printf ("CloseHandle (output_mutex<%p>), %E", output_mutex); if (pcon_attached_to == get_minor ()) get_ttyp ()->num_pcon_attached_slaves --; - get_ttyp ()->mask_switch_to_pcon_in = false; return 0; } @@ -1076,6 +1079,157 @@ fhandler_pty_slave::restore_reattach_pcon (void) pid_restore = 0; } +/* This function requests transfering the input data from the input + pipe for cygwin apps to the other input pipe for native apps. */ +void +fhandler_pty_slave::pull_pcon_input (void) +{ + get_ttyp ()->req_transfer_input_to_pcon = true; + while (get_ttyp ()->req_transfer_input_to_pcon) + Sleep (1); +} + +void +fhandler_pty_slave::update_pcon_input_state (bool need_lock) +{ + if (need_lock) + WaitForSingleObject (input_mutex, INFINITE); + /* Flush input buffer if it is requested by master. + This happens if ^C is pressed in pseudo console side. */ + if (get_ttyp ()->req_flush_pcon_input) + { + FlushConsoleInputBuffer (get_handle ()); + get_ttyp ()->req_flush_pcon_input = false; + } + /* Peek console input buffer and update state. */ + INPUT_RECORD inp[INREC_SIZE]; + DWORD n; + BOOL (WINAPI *PeekFunc) + (HANDLE, PINPUT_RECORD, DWORD, LPDWORD); + PeekFunc = + PeekConsoleInputA_Orig ? : PeekConsoleInput; + PeekFunc (get_handle (), inp, INREC_SIZE, &n); + bool saw_accept = false; + bool pipe_empty = true; + while (n-- > 0) + if (inp[n].EventType == KEY_EVENT && inp[n].Event.KeyEvent.bKeyDown && + inp[n].Event.KeyEvent.uChar.AsciiChar) + { + pipe_empty = false; + char c = inp[n].Event.KeyEvent.uChar.AsciiChar; + const char sigs[] = { + (char) get_ttyp ()->ti.c_cc[VINTR], + (char) get_ttyp ()->ti.c_cc[VQUIT], + (char) get_ttyp ()->ti.c_cc[VSUSP], + }; + const char eols[] = { + (char) get_ttyp ()->ti.c_cc[VEOF], + (char) get_ttyp ()->ti.c_cc[VEOL], + (char) get_ttyp ()->ti.c_cc[VEOL2], + '\n', + '\r' + }; + if (is_line_input () && memchr (eols, c, sizeof (eols))) + saw_accept = true; + if ((get_ttyp ()->ti.c_lflag & ISIG) && + memchr (sigs, c, sizeof (sigs))) + saw_accept = true; + } + get_ttyp ()->pcon_in_empty = pipe_empty && !(ralen () > raixget ()); + if (!get_readahead_valid () && + (pipe_empty || (is_line_input () && !saw_accept)) && + get_ttyp ()->read_retval == 1 && bytes_available (n) && n == 0) + ResetEvent (input_available_event); + if (need_lock) + ReleaseMutex (input_mutex); +} + +int +fhandler_pty_slave::eat_readahead (int n) +{ + int oralen = ralen () - raixget (); + if (n < 0) + n = ralen () - raixget (); + if (n > 0 && ralen () > raixget ()) + { + const char eols[] = { + (char) get_ttyp ()->ti.c_cc[VEOF], + (char) get_ttyp ()->ti.c_cc[VEOL], + (char) get_ttyp ()->ti.c_cc[VEOL2], + '\n' + }; + while (n > 0 && ralen () > raixget ()) + { + if (memchr (eols, rabuf ()[ralen ()-1], sizeof (eols))) + break; + -- n; + -- ralen (); + } + + /* If IUTF8 is set, the terminal is in UTF-8 mode. If so, we erase + a complete UTF-8 multibyte sequence on VERASE/VWERASE. Otherwise, + if we only erase a single byte, invalid unicode chars are left in + the input. */ + if (get_ttyp ()->ti.c_iflag & IUTF8) + while (ralen () > 0 && + ((unsigned char) rabuf ()[ralen ()] & 0xc0) == 0x80) + --ralen (); + + if (raixget () >= ralen ()) + raixget () = raixput () = ralen () = 0; + else if (raixput () > ralen ()) + raixput () = ralen (); + } + + return oralen; +} + +int +fhandler_pty_slave::get_readahead_into_buffer (char *buf, size_t buflen) +{ + int ch; + int copied_chars = 0; + + while (buflen) + if ((ch = get_readahead ()) < 0) + break; + else + { + const char eols[] = { + (char) get_ttyp ()->ti.c_cc[VEOF], + (char) get_ttyp ()->ti.c_cc[VEOL], + (char) get_ttyp ()->ti.c_cc[VEOL2], + '\n' + }; + buf[copied_chars++] = (unsigned char)(ch & 0xff); + buflen--; + if (is_line_input () && memchr (eols, ch & 0xff, sizeof (eols))) + break; + } + + return copied_chars; +} + +bool +fhandler_pty_slave::get_readahead_valid (void) +{ + if (is_line_input ()) + { + const char eols[] = { + (char) get_ttyp ()->ti.c_cc[VEOF], + (char) get_ttyp ()->ti.c_cc[VEOL], + (char) get_ttyp ()->ti.c_cc[VEOL2], + '\n' + }; + for (size_t i=raixget (); i raixget (); +} + void fhandler_pty_slave::set_switch_to_pcon (int fd_set) { @@ -1083,13 +1237,7 @@ fhandler_pty_slave::set_switch_to_pcon (int fd_set) fd = fd_set; if (fd == 0 && !get_ttyp ()->switch_to_pcon_in) { - pid_restore = 0; - if (pcon_attached_to != get_minor ()) - if (!try_reattach_pcon ()) - goto skip_console_setting; - FlushConsoleInputBuffer (get_handle ()); -skip_console_setting: - restore_reattach_pcon (); + pull_pcon_input (); if (get_ttyp ()->pcon_pid == 0 || !pinfo (get_ttyp ()->pcon_pid)) get_ttyp ()->pcon_pid = myself->pid; @@ -1121,16 +1269,7 @@ fhandler_pty_slave::reset_switch_to_pcon (void) /* There is a process which is grabbing pseudo console. */ return; if (isHybrid) - { - DWORD bytes_in_pipe; - WaitForSingleObject (input_mutex, INFINITE); - if (bytes_available (bytes_in_pipe) && !bytes_in_pipe) - ResetEvent (input_available_event); - FlushConsoleInputBuffer (get_handle ()); - ReleaseMutex (input_mutex); - init_console_handler (true); - return; - } + return; if (do_not_reset_switch_to_pcon) return; if (get_ttyp ()->switch_to_pcon_out) @@ -1333,6 +1472,14 @@ fhandler_pty_slave::write (const void *ptr, size_t len) if (!try_reattach_pcon ()) fallback = true; + if (get_ttyp ()->switch_to_pcon_out && !fallback && + (memmem (buf, nlen, "\033[6n", 4) || memmem (buf, nlen, "\033[0c", 4))) + { + get_ttyp ()->pcon_in_empty = false; + if (!is_line_input ()) + SetEvent (input_available_event); + } + DWORD dwMode, flags; flags = ENABLE_VIRTUAL_TERMINAL_PROCESSING; if (!(get_ttyp ()->ti.c_oflag & OPOST) || @@ -1382,18 +1529,14 @@ fhandler_pty_slave::write (const void *ptr, size_t len) void fhandler_pty_slave::mask_switch_to_pcon_in (bool mask) { - if (!mask && get_ttyp ()->pcon_pid && - get_ttyp ()->pcon_pid != myself->pid && - !!pinfo (get_ttyp ()->pcon_pid)) - return; get_ttyp ()->mask_switch_to_pcon_in = mask; } bool fhandler_pty_common::to_be_read_from_pcon (void) { - return get_ttyp ()->switch_to_pcon_in && - !get_ttyp ()->mask_switch_to_pcon_in; + return !get_ttyp ()->pcon_in_empty || + (get_ttyp ()->switch_to_pcon_in && !get_ttyp ()->mask_switch_to_pcon_in); } void __reg3 @@ -1424,6 +1567,8 @@ fhandler_pty_slave::read (void *ptr, size_t& len) mask_switch_to_pcon_in (true); reset_switch_to_pcon (); } + if (to_be_read_from_pcon ()) + update_pcon_input_state (true); if (is_nonblocking () || !ptr) /* Indicating tcflush(). */ time_to_wait = 0; @@ -1523,60 +1668,81 @@ fhandler_pty_slave::read (void *ptr, size_t& len) } goto out; } - if (to_be_read_from_pcon ()) + if (ptr && to_be_read_from_pcon ()) { - if (!try_reattach_pcon ()) + if (get_readahead_valid ()) { - restore_reattach_pcon (); - goto do_read_cyg; + ReleaseMutex (input_mutex); + totalread = get_readahead_into_buffer ((char *) ptr, len); } - - DWORD dwMode; - GetConsoleMode (get_handle (), &dwMode); - DWORD flags = ENABLE_VIRTUAL_TERMINAL_INPUT; - if (get_ttyp ()->ti.c_lflag & ECHO) - flags |= ENABLE_ECHO_INPUT; - if (get_ttyp ()->ti.c_lflag & ICANON) - flags |= ENABLE_LINE_INPUT; - if (flags & ENABLE_ECHO_INPUT && !(flags & ENABLE_LINE_INPUT)) - flags &= ~ENABLE_ECHO_INPUT; - if ((get_ttyp ()->ti.c_lflag & ISIG) && - !(get_ttyp ()->ti.c_iflag & IGNBRK)) - flags |= ENABLE_PROCESSED_INPUT; - if (dwMode != flags) - SetConsoleMode (get_handle (), flags); - /* Read get_handle() instad of get_handle_cyg() */ - BOOL (WINAPI *ReadFunc) - (HANDLE, LPVOID, DWORD, LPDWORD, LPOVERLAPPED); - ReadFunc = ReadFile_Orig ? ReadFile_Orig : ReadFile; - DWORD rlen; - if (!ReadFunc (get_handle (), ptr, len, &rlen, NULL)) + else { - termios_printf ("read failed, %E"); + if (!try_reattach_pcon ()) + { + restore_reattach_pcon (); + goto do_read_cyg; + } + + DWORD dwMode; + GetConsoleMode (get_handle (), &dwMode); + DWORD flags = ENABLE_VIRTUAL_TERMINAL_INPUT; + if (dwMode != flags) + SetConsoleMode (get_handle (), flags); + /* Read get_handle() instad of get_handle_cyg() */ + BOOL (WINAPI *ReadFunc) + (HANDLE, LPVOID, DWORD, LPDWORD, LPVOID); + ReadFunc = ReadConsoleA_Orig ? ReadConsoleA_Orig : ReadConsoleA; + DWORD rlen; + readlen = MIN (len, sizeof (buf)); + if (!ReadFunc (get_handle (), buf, readlen, &rlen, NULL)) + { + termios_printf ("read failed, %E"); + SetConsoleMode (get_handle (), dwMode); + restore_reattach_pcon (); + ReleaseMutex (input_mutex); + set_errno (EIO); + totalread = -1; + goto out; + } + SetConsoleMode (get_handle (), dwMode); + restore_reattach_pcon (); ReleaseMutex (input_mutex); - set_errno (EIO); - totalread = -1; - goto out; + + ssize_t nlen; + char *nbuf = convert_mb_str (get_ttyp ()->term_code_page, + (size_t *) &nlen, GetConsoleCP (), buf, rlen); + + ssize_t ret; + line_edit_status res = + line_edit (nbuf, nlen, get_ttyp ()->ti, &ret); + + mb_str_free (nbuf); + + if (res == line_edit_input_done || res == line_edit_ok) + totalread = get_readahead_into_buffer ((char *) ptr, len); + else if (res > line_edit_signalled) + { + set_sig_errno (EINTR); + totalread = -1; + } + else + { + update_pcon_input_state (true); + continue; + } } - INPUT_RECORD inp[128]; - DWORD n; - BOOL (WINAPI *PeekFunc) - (HANDLE, PINPUT_RECORD, DWORD, LPDWORD); - PeekFunc = - PeekConsoleInputA_Orig ? PeekConsoleInputA_Orig : PeekConsoleInput; - PeekFunc (get_handle (), inp, 128, &n); - bool pipe_empty = true; - while (n-- > 0) - if (inp[n].EventType == KEY_EVENT && inp[n].Event.KeyEvent.bKeyDown) - pipe_empty = false; - if (pipe_empty) - ResetEvent (input_available_event); - ReleaseMutex (input_mutex); - len = rlen; - restore_reattach_pcon (); + update_pcon_input_state (true); mask_switch_to_pcon_in (false); - return; + goto out; + } + if (!ptr && len == UINT_MAX && !get_ttyp ()->pcon_in_empty) + { + FlushConsoleInputBuffer (get_handle ()); + get_ttyp ()->pcon_in_empty = true; + DWORD n; + if (bytes_available (n) && n == 0) + ResetEvent (input_available_event); } do_read_cyg: @@ -1697,7 +1863,8 @@ out: termios_printf ("%d = read(%p, %lu)", totalread, ptr, len); len = (size_t) totalread; /* Push slave read as echo to pseudo console screen buffer. */ - if (get_pseudo_console () && ptr0 && (get_ttyp ()->ti.c_lflag & ECHO)) + if (get_pseudo_console () && ptr0 && totalread > 0 && + (get_ttyp ()->ti.c_lflag & ECHO)) { acquire_output_mutex (INFINITE); push_to_pcon_screenbuffer (ptr0, len, true); @@ -2307,19 +2474,41 @@ fhandler_pty_master::write (const void *ptr, size_t len) WaitForSingleObject (input_mutex, INFINITE); + if (memchr (buf, '\003', nlen)) /* ^C intr key in pcon */ + get_ttyp ()->req_flush_pcon_input = true; + DWORD wLen; WriteFile (to_slave, buf, nlen, &wLen, NULL); - - if (ti.c_lflag & ICANON) - { - if (memchr (buf, '\r', nlen)) - SetEvent (input_available_event); - } - else - SetEvent (input_available_event); + get_ttyp ()->pcon_in_empty = false; ReleaseMutex (input_mutex); + /* Use line_edit () in order to set input_available_event. */ + bool is_echo = tc ()->ti.c_lflag & ECHO; + if (!get_ttyp ()->mask_switch_to_pcon_in) + { + tc ()->ti.c_lflag &= ~ECHO; + ti.c_lflag &= ~ECHO; + } + ti.c_lflag &= ~ISIG; + line_edit (buf, nlen, ti, &ret); + if (is_echo) + tc ()->ti.c_lflag |= ECHO; + get_ttyp ()->read_retval = 1; + + const char sigs[] = { + (char) ti.c_cc[VINTR], + (char) ti.c_cc[VQUIT], + (char) ti.c_cc[VSUSP], + }; + if (tc ()->ti.c_lflag & ISIG) + for (size_t i=0; inum_pcon_attached_slaves ++; } +#if 0 /* This is for debug only. */ + isHybrid = true; + get_ttyp ()->switch_to_pcon_in = true; + get_ttyp ()->switch_to_pcon_out = true; +#endif + if (pcon_attached_to == get_minor () && native_maybe) { if (fd == 0) { - FlushConsoleInputBuffer (get_handle ()); + pull_pcon_input (); DWORD mode = ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT; SetConsoleMode (get_handle (), mode); @@ -2764,13 +2959,6 @@ fhandler_pty_slave::fixup_after_fork (HANDLE parent) void fhandler_pty_slave::fixup_after_exec () { - /* Native windows program does not reset event on read. - Therefore, reset here if no input is available. */ - DWORD bytes_in_pipe; - if (!to_be_read_from_pcon () && - bytes_available (bytes_in_pipe) && !bytes_in_pipe) - ResetEvent (input_available_event); - reset_switch_to_pcon (); if (!close_on_exec ()) @@ -2988,6 +3176,33 @@ reply: return 0; } +void +fhandler_pty_master::transfer_input_to_pcon (void) +{ + WaitForSingleObject (input_mutex, INFINITE); + DWORD n; + size_t transfered = 0; + while (::bytes_available (n, from_master_cyg) && n) + { + char buf[1024]; + ReadFile (from_master_cyg, buf, sizeof (buf), &n, 0); + char *p = buf; + while ((p = (char *) memchr (p, '\n', n - (p - buf)))) + *p = '\r'; + if (WriteFile (to_slave, buf, n, &n, 0)) + transfered += n; + } + DWORD bytes_left = eat_readahead (-1); + if (bytes_left) + { + if (WriteFile (to_slave, rabuf (), bytes_left, &n, NULL)) + transfered += n; + } + if (transfered) + get_ttyp ()->pcon_in_empty = false; + ReleaseMutex (input_mutex); +} + static DWORD WINAPI pty_master_thread (VOID *arg) { @@ -3018,6 +3233,15 @@ fhandler_pty_master::pty_master_fwd_thread () if (GetTickCount () - get_ttyp ()->pcon_last_time > time_to_wait) SetEvent (get_ttyp ()->fwd_done); release_output_mutex (); + /* Forcibly transfer input if it is requested by slave. + This happens when input data should be transfered + from the input pipe for cygwin apps to the input pipe + for native apps. */ + if (get_ttyp ()->req_transfer_input_to_pcon) + { + transfer_input_to_pcon (); + get_ttyp ()->req_transfer_input_to_pcon = false; + } Sleep (1); } } diff --git a/winsup/cygwin/select.cc b/winsup/cygwin/select.cc index 5048e54..b06441c 100644 --- a/winsup/cygwin/select.cc +++ b/winsup/cygwin/select.cc @@ -1195,6 +1195,8 @@ peek_pty_slave (select_record *s, bool from_select) fhandler_pty_slave *ptys = (fhandler_pty_slave *) fh; ptys->reset_switch_to_pcon (); + if (ptys->to_be_read_from_pcon ()) + ptys->update_pcon_input_state (true); if (s->read_selected) { diff --git a/winsup/cygwin/tty.cc b/winsup/cygwin/tty.cc index a3d4a0f..0663dc5 100644 --- a/winsup/cygwin/tty.cc +++ b/winsup/cygwin/tty.cc @@ -247,6 +247,9 @@ tty::init () need_redraw_screen = false; fwd_done = NULL; pcon_last_time = 0; + pcon_in_empty = true; + req_transfer_input_to_pcon = false; + req_flush_pcon_input = false; } HANDLE diff --git a/winsup/cygwin/tty.h b/winsup/cygwin/tty.h index 755897d..a24afad 100644 --- a/winsup/cygwin/tty.h +++ b/winsup/cygwin/tty.h @@ -108,6 +108,9 @@ private: bool need_redraw_screen; HANDLE fwd_done; DWORD pcon_last_time; + bool pcon_in_empty; + bool req_transfer_input_to_pcon; + bool req_flush_pcon_input; public: HANDLE from_master () const { return _from_master; }