{
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
termios_printf ("sending EOF to slave");
get_ttyp ()->read_retval = 0;
}
- else
+ else if (!to_be_read_from_pcon ())
{
char *p = rabuf ();
DWORD rc;
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;
}
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<ralen (); i++)
+ if (memchr (eols, rabuf ()[i], sizeof (eols)))
+ return true;
+ return false;
+ }
+ else
+ return ralen () > raixget ();
+}
+
void
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;
/* 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)
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) ||
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
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;
}
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:
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);
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; i<sizeof (sigs); i++)
+ if (memchr (buf, sigs[i], nlen))
+ {
+ eat_readahead (-1);
+ SetEvent (input_available_event);
+ }
+
mb_str_free (buf);
return len;
}
get_ttyp ()->num_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);
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 ())
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)
{
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);
}
}
git://sourceware.org / newlib-cygwin.git / commitdiff