libs/newlib-cygwin
libs
/
newlib-cygwin
mirror of git://sourceware.org/git/newlib-cygwin.git
4
0
Fork 0
Code Issues Projects Releases Wiki Activity
newlib-cygwin/winsup/cygwin/fhandler/termios.cc

908 lines
25 KiB
C++
Raw Permalink Blame History

/* fhandler_termios.cc
This file is part of Cygwin.
This software is a copyrighted work licensed under the terms of the
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
details. */
#include "winsup.h"
#include <stdlib.h>
#include <ctype.h>
#include "cygerrno.h"
#include "path.h"
#include "fhandler.h"
#include "sigproc.h"
#include "pinfo.h"
#include "tty.h"
#include "cygtls.h"
#include "dtable.h"
#include "cygheap.h"
#include "child_info.h"
#include "ntdll.h"
#include "tls_pbuf.h"
/* Wait time for some treminal mutexes. This is set to 0 when the
process calls CreateProcess() with DEBUG_PROCESS flag, because
the debuggie may be suspended while it grabs the mutex. Without
this, GDB may cause deadlock in console or pty I/O. */
DWORD NO_COPY mutex_timeout = INFINITE;
/* Common functions shared by tty/console */
void
fhandler_termios::tcinit (bool is_pty_master)
{
/* Initial termios values */
if (is_pty_master || !tc ()->initialized ())
{
tc ()->ti.c_iflag = BRKINT | ICRNL | IXON | IUTF8;
tc ()->ti.c_oflag = OPOST | ONLCR;
tc ()->ti.c_cflag = B38400 | CS8 | CREAD;
tc ()->ti.c_lflag = ISIG | ICANON | ECHO | IEXTEN
| ECHOE | ECHOK | ECHOCTL | ECHOKE;
tc ()->ti.c_cc[VDISCARD] = CFLUSH;
tc ()->ti.c_cc[VEOL] = CEOL;
tc ()->ti.c_cc[VEOL2] = CEOL2;
tc ()->ti.c_cc[VEOF] = CEOF;
tc ()->ti.c_cc[VERASE] = CERASE;
tc ()->ti.c_cc[VINTR] = CINTR;
tc ()->ti.c_cc[VKILL] = CKILL;
tc ()->ti.c_cc[VLNEXT] = CLNEXT;
tc ()->ti.c_cc[VMIN] = CMIN;
tc ()->ti.c_cc[VQUIT] = CQUIT;
tc ()->ti.c_cc[VREPRINT] = CRPRNT;
tc ()->ti.c_cc[VSTART] = CSTART;
tc ()->ti.c_cc[VSTOP] = CSTOP;
tc ()->ti.c_cc[VSUSP] = CSUSP;
tc ()->ti.c_cc[VSWTC] = CSWTCH;
tc ()->ti.c_cc[VTIME] = CTIME;
tc ()->ti.c_cc[VWERASE] = CWERASE;
tc ()->ti.c_ispeed = tc ()->ti.c_ospeed = B38400;
tc ()->pgid = is_pty_master ? 0 : myself->pgid;
tc ()->initialized (true);
}
}
int
fhandler_termios::tcsetpgrp (const pid_t pgid)
{
termios_printf ("%s, pgid %d, sid %d, tsid %d", tc ()->ttyname (), pgid,
myself->sid, tc ()->getsid ());
if (myself->sid != tc ()->getsid ())
{
set_errno (EPERM);
return -1;
}
else if (pgid < 0)
{
set_errno (EINVAL);
return -1;
}
int res;
while (1)
{
res = bg_check (-SIGTTOU);
switch (res)
{
case bg_ok:
tc ()->setpgid (pgid);
if (tc ()->is_console && (strace.active () || !being_debugged ()))
tc ()->kill_pgrp (__SIGSETPGRP);
res = 0;
break;
case bg_signalled:
if (_my_tls.call_signal_handler ())
continue;
set_errno (EINTR);
fallthrough;
default:
res = -1;
break;
}
break;
}
return res;
}
int
fhandler_termios::tcgetpgrp ()
{
if (CTTY_IS_VALID (myself->ctty) && myself->ctty == tc ()->ntty)
return tc ()->pgid;
set_errno (ENOTTY);
return -1;
}
int
fhandler_pty_master::tcgetpgrp ()
{
return tc ()->pgid;
}
static inline bool
is_flush_sig (int sig)
{
return sig == SIGINT || sig == SIGQUIT || sig == SIGTSTP;
}
void
tty_min::kill_pgrp (int sig, pid_t target_pgid)
{
target_pgid = target_pgid ?: pgid;
bool killself = false;
if (is_flush_sig (sig) && cygheap->ctty)
cygheap->ctty->sigflush ();
winpids pids ((DWORD) PID_MAP_RW);
siginfo_t si = {0};
si.si_signo = sig;
si.si_code = SI_KERNEL;
if (sig > 0 && sig < _NSIG)
last_sig = sig;
for (unsigned i = 0; i < pids.npids; i++)
{
_pinfo *p = pids[i];
if (!p || !p->exists () || p->ctty != ntty || p->pgid != target_pgid)
continue;
if (p->process_state & PID_NOTCYGWIN)
continue; /* Do not send signal to non-cygwin process to prevent
cmd.exe from crash. */
if (p == myself)
killself = sig != __SIGSETPGRP && !exit_state;
else
sig_send (p, si);
}
if (killself)
sig_send (myself, si);
}
int
tty_min::is_orphaned_process_group (int pgid)
{
/* An orphaned process group is a process group in which the parent
of every member is either itself a member of the group or is not
a member of the group's session. */
termios_printf ("checking pgid %d, my sid %d, my parent %d", pgid, myself->sid, myself->ppid);
winpids pids ((DWORD) 0);
for (unsigned i = 0; i < pids.npids; i++)
{
_pinfo *p = pids[i];
termios_printf ("checking pid %d - has pgid %d\n", p->pid, p->pgid);
if (!p || !p->exists () || p->pgid != pgid)
continue;
pinfo ppid (p->ppid);
if (!ppid)
continue;
termios_printf ("ppid->pgid %d, ppid->sid %d", ppid->pgid, ppid->sid);
if (ppid->pgid != pgid && ppid->sid == myself->sid)
return 0;
}
return 1;
}
/*
bg_check: check that this process is either in the foreground process group,
or if the terminal operation is allowed for processes which are in a
background process group.
If the operation is not permitted by the terminal configuration for processes
which are a member of a background process group, return an error or raise a
signal as appropriate.
This handles the following terminal operations:
write: sig = SIGTTOU
read: sig = SIGTTIN
change terminal settings: sig = -SIGTTOU
(tcsetattr, tcsetpgrp, etc.)
peek (poll, select): sig = SIGTTIN, dontsignal = TRUE
*/
bg_check_types
fhandler_termios::bg_check (int sig, bool dontsignal)
{
/* Ignore errors:
- this process isn't in a process group
- tty is invalid
Everything is ok if:
- this process is in the foreground process group, or
- this tty is not the controlling tty for this process (???), or
- writing, when TOSTOP TTY mode is not set on this tty
*/
if (!myself->pgid || !tc () || tc ()->getpgid () == myself->pgid ||
myself->ctty != tc ()->ntty ||
((sig == SIGTTOU) && !(tc ()->ti.c_lflag & TOSTOP)))
return bg_ok;
/* sig -SIGTTOU is used to indicate a change to terminal settings, where
TOSTOP TTY mode isn't considered when determining if we need to send a
signal. */
if (sig < 0)
sig = -sig;
termios_printf ("%s, bg I/O pgid %d, tpgid %d, myctty %s", tc ()->ttyname (),
myself->pgid, tc ()->getpgid (), myctty ());
if (tc ()->getsid () == 0)
{
/* The pty has been closed by the master. Return an EOF
indication. FIXME: There is nothing to stop somebody
from reallocating this pty. I think this is the case
which is handled by unlockpt on a Unix system. */
termios_printf ("closed by master");
return bg_eof;
}
threadlist_t *tl_entry;
tl_entry = cygheap->find_tls (_main_tls);
int sigs_ignored =
((void *) global_sigs[sig].sa_handler == (void *) SIG_IGN) ||
(_main_tls->sigmask & SIGTOMASK (sig));
cygheap->unlock_tls (tl_entry);
/* If the process is blocking or ignoring SIGTT*, then signals are not sent
and background IO is allowed */
if (sigs_ignored)
return bg_ok; /* Just allow the IO */
/* If the process group of the process is orphaned, return EIO */
else if (tc ()->is_orphaned_process_group (myself->pgid))
{
termios_printf ("process group is orphaned");
set_errno (EIO); /* This is an IO error */
return bg_error;
}
/* Otherwise, if signalling is desired, the signal is sent to all processes in
the process group */
else if (!dontsignal)
{
/* Don't raise a SIGTT* signal if we have already been
interrupted by another signal. */
if (cygwait ((DWORD) 0) != WAIT_SIGNALED)
{
siginfo_t si = {0};
si.si_signo = sig;
si.si_code = SI_KERNEL;
kill_pgrp (myself->pgid, si);
}
return bg_signalled;
}
return bg_ok;
}
#define set_input_done(x) input_done = input_done || (x)
int
fhandler_termios::eat_readahead (int n)
{
int oralen = ralen ();
if (n < 0)
n = ralen () - raixget ();
if (n > 0 && ralen () > raixget ())
{
if ((int) (ralen () -= n) < (int) raixget ())
ralen () = raixget ();
/* 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 (tc ()->ti.c_iflag & IUTF8)
while (ralen () > raixget () &&
((unsigned char) rabuf ()[ralen ()] & 0xc0) == 0x80)
--ralen ();
}
oralen = oralen - ralen ();
if (raixget () >= ralen ())
raixget () = raixput () = ralen () = 0;
else if (raixput () > ralen ())
raixput () = ralen ();
return oralen;
}
inline void
fhandler_termios::echo_erase (int force)
{
if (force || tc ()->ti.c_lflag & ECHO)
doecho ("\b \b", 3);
}
/* The basic policy is as follows:
- The signal generated by key press will be sent only to cygwin process.
- For non-cygwin process, CTRL_C_EVENT will be sent on Ctrl-C. */
/* The inferior of GDB is an exception. GDB does not support to hook signal
even if the inferior is a cygwin app. As a result, inferior cannot be
continued after interruption by Ctrl-C if SIGINT was sent. Therefore,
CTRL_C_EVENT rather than SIGINT is sent to the inferior of GDB. */
fhandler_termios::process_sig_state
fhandler_termios::process_sigs (char c, tty* ttyp, fhandler_termios *fh)
{
termios &ti = ttyp->ti;
pid_t pgid = ttyp->pgid;
/* The name *_nat stands for 'native' which means non-cygwin apps. */
bool ctrl_c_event_sent = false;
bool need_discard_input = false;
bool pg_with_nat = false; /* The process group has non-cygwin processes. */
bool need_send_sig = false; /* There is process which need the signal. */
bool nat_shell = false; /* The shell seems to be a non-cygwin process. */
bool cyg_reader = false; /* Cygwin process is reading the tty. */
bool with_debugger = false; /* GDB is debugging cygwin app. */
bool with_debugger_nat = false; /* GDB is debugging non-cygwin app. */
winpids pids ((DWORD) 0);
for (unsigned i = 0; i < pids.npids; i++)
{
_pinfo *p = pids[i];
/* PID_NOTCYGWIN: check this for non-cygwin process.
exec_dwProcessId == dwProcessId:
check this for GDB with non-cygwin inferior in pty
without pcon enabled. In this case, the inferior is not
cygwin process list. This condition is set true as
a marker for GDB with non-cygwin inferior in pty code.
!PID_CYGPARENT: check this for GDB with cygwin inferior or
cygwin apps started from non-cygwin shell. */
if (c == '\003' && p && p->ctty == ttyp->ntty && p->pgid == pgid
&& ((p->process_state & PID_NOTCYGWIN)
|| ((p->exec_dwProcessId == p->dwProcessId)
&& ttyp->pty_input_state_eq (tty::to_nat))
|| !(p->process_state & PID_CYGPARENT)))
{
/* Ctrl-C event will be sent only to the processes attaching
to the same console. Therefore, attach to the console to
which the target process is attaching before sending the
CTRL_C_EVENT. After sending the event, reattach to the
console to which the process was previously attached. */
DWORD resume_pid = 0;
if (fh && !fh->is_console ())
resume_pid =
fhandler_pty_common::attach_console_temporarily (p->dwProcessId);
if (fh && p == myself && being_debugged ())
{ /* Avoid deadlock in gdb on console. */
fh->tcflush(TCIFLUSH);
fh->release_input_mutex_if_necessary ();
}
/* CTRL_C_EVENT does not work for the process started with
CREATE_NEW_PROCESS_GROUP flag, so send CTRL_BREAK_EVENT
instead. */
if (p->process_state & PID_NEW_PG)
GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, p->dwProcessId);
else if ((!fh || fh->need_send_ctrl_c_event ()
|| p->exec_dwProcessId == p->dwProcessId)
&& !ctrl_c_event_sent)
{
GenerateConsoleCtrlEvent (CTRL_C_EVENT, 0);
ctrl_c_event_sent = true;
}
if (fh && !fh->is_console ())
{
/* If a process on pseudo console is killed by Ctrl-C,
this process may take over the ownership of the
pseudo console because this process attached to it
before sending CTRL_C_EVENT. In this case, closing
pseudo console is necessary. */
fhandler_pty_slave::release_ownership_of_nat_pipe (ttyp, fh);
fhandler_pty_common::resume_from_temporarily_attach (resume_pid);
}
need_discard_input = true;
}
if (p && p->ctty == ttyp->ntty && p->pgid == pgid)
{
if (p->process_state & PID_NOTCYGWIN)
pg_with_nat = true; /* The process group has non-cygwin process */
if (!(p->process_state & PID_NOTCYGWIN))
need_send_sig = true; /* Process which needs signal exists */
if (!p->cygstarted)
nat_shell = true; /* The shell seems to a non-cygwin shell */
if (p->process_state & PID_TTYIN)
cyg_reader = true; /* Theh process is reading the tty */
if (!p->cygstarted && !(p->process_state & PID_NOTCYGWIN)
&& (p->process_state & PID_DEBUGGED))
with_debugger = true; /* inferior is cygwin app */
if (!(p->process_state & PID_NOTCYGWIN)
&& (p->exec_dwProcessId == p->dwProcessId) /* Check marker */
&& ttyp->pty_input_state_eq (tty::to_nat)
&& p->pid == pgid)
with_debugger_nat = true; /* inferior is non-cygwin app */
}
}
if ((with_debugger || with_debugger_nat) && need_discard_input)
{
if (!(ti.c_lflag & NOFLSH) && fh)
{
fh->eat_readahead (-1);
fh->discard_input ();
}
ti.c_lflag &= ~FLUSHO;
return done_with_debugger;
}
if (with_debugger_nat)
return not_signalled; /* Do not process slgnal keys further.
The non-cygwin inferior of GDB cannot receive
the signals. */
/* Send SIGQUIT to non-cygwin process. Non-cygwin app will not be alerted
by kill_pgrp(), however, QUIT key should quit the non-cygwin app
if it is started along with cygwin process from cygwin shell. */
if ((ti.c_lflag & ISIG) && CCEQ (ti.c_cc[VQUIT], c)
&& pg_with_nat && need_send_sig && !nat_shell)
{
for (unsigned i = 0; i < pids.npids; i++)
{
_pinfo *p = pids[i];
if (p && p->ctty == ttyp->ntty && p->pgid == pgid
&& (p->process_state & PID_NOTCYGWIN))
sig_send (p, SIGQUIT);
}
}
if ((ti.c_lflag & ISIG) && need_send_sig)
{
int sig;
if (CCEQ (ti.c_cc[VINTR], c))
sig = SIGINT;
else if (CCEQ (ti.c_cc[VQUIT], c))
sig = SIGQUIT;
else if (pg_with_nat) /* If the process group has a non-cygwin process,
it cannot be suspended correctly. Therefore,
do not send SIGTSTP. */
goto not_a_sig;
else if (CCEQ (ti.c_cc[VSUSP], c))
sig = SIGTSTP;
else
goto not_a_sig;
termios_printf ("got interrupt %d, sending signal %d", c, sig);
if (!(ti.c_lflag & NOFLSH) && fh)
{
fh->eat_readahead (-1);
fh->discard_input ();
}
if (fh)
fh->release_input_mutex_if_necessary ();
ttyp->kill_pgrp (sig, pgid);
if (fh)
fh->acquire_input_mutex_if_necessary (mutex_timeout);
ti.c_lflag &= ~FLUSHO;
return signalled;
}
not_a_sig:
if ((ti.c_lflag & ISIG) && need_discard_input)
{
if (!(ti.c_lflag & NOFLSH) && fh)
{
fh->eat_readahead (-1);
fh->discard_input ();
}
ti.c_lflag &= ~FLUSHO;
return not_signalled_but_done;
}
bool to_nat = !cyg_reader && pg_with_nat;
return to_nat ? not_signalled_with_nat_reader : not_signalled;
}
bool
fhandler_termios::process_stop_start (char c, tty *ttyp)
{
termios &ti = ttyp->ti;
if (ti.c_iflag & IXON)
{
if (CCEQ (ti.c_cc[VSTOP], c))
{
ttyp->output_stopped = true;
return true;
}
else if (CCEQ (ti.c_cc[VSTART], c))
{
restart_output:
ttyp->output_stopped = false;
return true;
}
else if ((ti.c_iflag & IXANY) && ttyp->output_stopped)
goto restart_output;
}
if ((ti.c_lflag & ICANON) && (ti.c_lflag & IEXTEN)
&& CCEQ (ti.c_cc[VDISCARD], c))
{
ti.c_lflag ^= FLUSHO;
return true;
}
return false;
}
line_edit_status
fhandler_termios::line_edit (const char *rptr, size_t nread, termios& ti,
ssize_t *bytes_read)
{
line_edit_status ret = line_edit_ok;
char c;
int input_done = 0;
bool sawsig = false;
int iscanon = ti.c_lflag & ICANON;
size_t read_cnt = 0;
while (read_cnt < nread)
{
c = *rptr++;
read_cnt++;
paranoid_printf ("char %0o", c);
if (ti.c_iflag & ISTRIP)
c &= 0x7f;
bool disable_eof_key = false;
switch (process_sigs (c, get_ttyp (), this))
{
case signalled:
sawsig = true;
fallthrough;
case not_signalled_but_done:
case done_with_debugger:
get_ttyp ()->output_stopped = false;
continue;
case not_signalled_with_nat_reader:
disable_eof_key = true;
break;
default: /* Not signalled */
break;
}
if (process_stop_start (c, get_ttyp ()))
continue;
/* Check for special chars */
if (c == '\r')
{
if (ti.c_iflag & IGNCR)
continue;
if (ti.c_iflag & ICRNL)
{
c = '\n';
set_input_done (iscanon);
}
}
else if (c == '\n')
{
if (ti.c_iflag & INLCR)
c = '\r';
else
set_input_done (iscanon);
}
if (!iscanon)
/* nothing */;
else if (CCEQ (ti.c_cc[VERASE], c))
{
if (eat_readahead (1))
echo_erase ();
continue;
}
else if (CCEQ (ti.c_cc[VWERASE], c))
{
int ch;
do
if (!eat_readahead (1))
break;
else
echo_erase ();
while ((ch = peek_readahead (1)) >= 0 && !isspace (ch));
continue;
}
else if (CCEQ (ti.c_cc[VKILL], c))
{
int nchars = eat_readahead (-1);
if (ti.c_lflag & ECHO)
while (nchars--)
echo_erase (1);
continue;
}
else if (CCEQ (ti.c_cc[VREPRINT], c))
{
if (ti.c_lflag & ECHO)
{
doecho ("\n\r", 2);
doecho (rabuf (), ralen ());
}
continue;
}
else if (CCEQ (ti.c_cc[VEOF], c) && !disable_eof_key)
{
termios_printf ("EOF");
accept_input ();
ret = line_edit_input_done;
continue;
}
else if (CCEQ (ti.c_cc[VEOL], c) ||
CCEQ (ti.c_cc[VEOL2], c) ||
c == '\n')
{
set_input_done (1);
termios_printf ("EOL");
}
if (ti.c_iflag & IUCLC && isupper (c))
c = cyg_tolower (c);
put_readahead (c);
if (ti.c_lflag & ECHO)
doecho (&c, 1);
/* Write in chunks of 32 bytes to reduce the number of WriteFile calls
in non-canonical mode. */
if ((!iscanon && ralen () >= 32) || input_done)
{
int status = accept_input ();
if (status != 1)
{
ret = status ? line_edit_error : line_edit_pipe_full;
break;
}
ret = line_edit_input_done;
input_done = 0;
}
}
/* If we didn't write all bytes in non-canonical mode, write them now. */
if ((input_done || !iscanon) && ralen () > 0 && ret != line_edit_error)
{
int status;
int retry_count = 3;
while ((status = accept_input ()) != 1 &&
ralen () > 0 && --retry_count > 0)
cygwait ((DWORD) 10);
if (status != 1)
ret = status ? line_edit_error : line_edit_pipe_full;
else
ret = line_edit_input_done;
}
if (bytes_read)
*bytes_read = read_cnt;
if (sawsig)
ret = line_edit_signalled;
return ret;
}
off_t
fhandler_termios::lseek (off_t, int)
{
set_errno (ESPIPE);
return -1;
}
void
fhandler_termios::sigflush ()
{
/* FIXME: Checking get_ttyp() for NULL is not right since it should not
be NULL while this is alive. However, we can conceivably close a
ctty while exiting and that will zero this. */
if ((!have_execed || have_execed_cygwin) && tc ()
&& (tc ()->getpgid () == myself->pgid)
&& !(tc ()->ti.c_lflag & NOFLSH))
tcflush (TCIFLUSH);
}
pid_t
fhandler_termios::tcgetsid ()
{
if (CTTY_IS_VALID (myself->ctty) && myself->ctty == tc ()->ntty)
return tc ()->getsid ();
set_errno (ENOTTY);
return -1;
}
int
fhandler_termios::fstat (struct stat *buf)
{
fhandler_base::fstat (buf);
if (dev_referred_via > 0)
buf->st_rdev = dev_referred_via;
return 0;
}
static bool
is_console_app (const WCHAR *filename)
{
HANDLE h;
h = CreateFileW (filename, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, 0, NULL);
char buf[1024];
DWORD n;
ReadFile (h, buf, sizeof (buf), &n, 0);
CloseHandle (h);
/* The offset of Subsystem is the same for both IMAGE_NT_HEADERS32 and
IMAGE_NT_HEADERS64, so only IMAGE_NT_HEADERS32 is used here. */
IMAGE_NT_HEADERS32 *p = (IMAGE_NT_HEADERS32 *) memmem (buf, n, "PE\0\0", 4);
if (p && (char *) &p->OptionalHeader.DllCharacteristics <= buf + n)
return p->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI;
wchar_t *e = wcsrchr (filename, L'.');
if (e && (wcscasecmp (e, L".bat") == 0 || wcscasecmp (e, L".cmd") == 0))
return true;
return false;
}
int
fhandler_termios::ioctl (int cmd, void *varg)
{
if (cmd != TIOCSCTTY)
return 1; /* Not handled by this function */
int arg = (int) (intptr_t) varg;
if (arg != 0 && arg != 1)
{
set_errno (EINVAL);
return -1;
}
termios_printf ("myself->ctty %d, myself->sid %d, myself->pid %d, arg %d, tc()->getsid () %d\n",
myself->ctty, myself->sid, myself->pid, arg, tc ()->getsid ());
if (CTTY_IS_VALID (myself->ctty) || myself->sid != myself->pid
|| (!arg && tc ()->getsid () > 0))
{
set_errno (EPERM);
return -1;
}
if (!myself->set_ctty (this, 0))
{
set_errno (EPERM);
return -1;
}
return 0;
}
void
fhandler_termios::spawn_worker::setup (bool iscygwin, HANDLE h_stdin,
const WCHAR *runpath, bool nopcon,
bool reset_sendsig,
const WCHAR *envblock)
{
fhandler_pty_slave *ptys_primary = NULL;
fhandler_console *cons_native = NULL;
for (int i = 0; i < 3; i ++)
{
const int chk_order[] = {1, 0, 2};
int fd = chk_order[i];
fhandler_base *fh = ::cygheap->fdtab[fd];
if (fh && fh->get_major () == DEV_PTYS_MAJOR && ptys_primary == NULL)
ptys_primary = (fhandler_pty_slave *) fh;
else if (fh && fh->get_major () == DEV_CONS_MAJOR
&& !iscygwin && cons_native == NULL)
cons_native = (fhandler_console *) fh;
}
if (cons_native)
{
cons_native->setup_for_non_cygwin_app ();
/* Console handles will be already closed by close_all_files()
when cleaning up, therefore, duplicate them here. */
cons_native->get_duplicated_handle_set (&cons_handle_set);
cons_need_cleanup = true;
}
if (!iscygwin)
{
int fd;
cygheap_fdenum cfd (false);
while ((fd = cfd.next ()) >= 0)
if (cfd->get_major () == DEV_PTYS_MAJOR)
{
fhandler_pty_slave *ptys
= (fhandler_pty_slave *)(fhandler_base *) cfd;
ptys->create_invisible_console ();
ptys->setup_locale ();
}
}
if (!iscygwin && ptys_primary && is_console_app (runpath))
{
if (h_stdin == ptys_primary->get_handle_nat ())
stdin_is_ptys = true;
if (reset_sendsig)
myself->sendsig = myself->exec_sendsig;
ptys_primary->setup_for_non_cygwin_app (nopcon, envblock, stdin_is_ptys);
if (reset_sendsig)
myself->sendsig = NULL;
ptys_primary->get_duplicated_handle_set (&ptys_handle_set);
ptys_ttyp = (tty *) ptys_primary->tc ();
ptys_need_cleanup = true;
}
}
void
fhandler_termios::spawn_worker::cleanup ()
{
if (ptys_need_cleanup)
fhandler_pty_slave::cleanup_for_non_cygwin_app (&ptys_handle_set,
ptys_ttyp, stdin_is_ptys);
if (cons_need_cleanup)
fhandler_console::cleanup_for_non_cygwin_app (&cons_handle_set);
close_handle_set ();
}
void
fhandler_termios::spawn_worker::close_handle_set ()
{
if (ptys_need_cleanup)
fhandler_pty_slave::close_handle_set (&ptys_handle_set);
if (cons_need_cleanup)
fhandler_console::close_handle_set (&cons_handle_set);
}
void
fhandler_termios::atexit_func ()
{
fhandler_console::pcon_hand_over_proc ();
}
bool
fhandler_termios::process_alive (DWORD pid)
{
/* This function is very similar to _pinfo::alive(), however, this
can be used for non-cygwin process which is started from non-cygwin
shell. In addition, this checks exit code as well. */
if (pid == 0)
return false;
HANDLE h = OpenProcess (PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid);
if (h == NULL)
return false;
DWORD exit_code;
BOOL r = GetExitCodeProcess (h, &exit_code);
CloseHandle (h);
if (r && exit_code == STILL_ACTIVE)
return true;
return false;
}
/* This functions looks for a process which attached to the same console
with current process and is matched to given conditions:
match: If true, return given pid if the process pid attaches to the
same console, otherwise, return 0. If false, return pid except
for given pid.
cygwin: return only process's pid which has cygwin pid.
stub_only: return only stub process's pid of non-cygwin process. */
DWORD
fhandler_termios::get_console_process_id (DWORD pid, bool match,
bool cygwin, bool stub_only,
bool nat)
{
tmp_pathbuf tp;
DWORD *list = (DWORD *) tp.c_get ();
const DWORD buf_size = NT_MAX_PATH / sizeof (DWORD);
DWORD num = GetConsoleProcessList (list, buf_size);
if (num == 0 || num > buf_size)
return 0;
DWORD res_pri = 0, res = 0;
/* Last one is the oldest. */
/* https://github.com/microsoft/terminal/issues/95 */
for (int i = (int) num - 1; i >= 0; i--)
if ((match && list[i] == pid) || (!match && list[i] != pid))
{
if (!process_alive (list[i]))
continue;
if (!cygwin)
{
res_pri = list[i];
break;
}
else
{
pinfo p (cygwin_pid (list[i]));
if (nat && !!p && !ISSTATE(p, PID_NOTCYGWIN))
continue;
if (!!p && p->exec_dwProcessId)
{
res_pri = stub_only ? p->exec_dwProcessId : list[i];
break;
}
if (!p && !res && stub_only)
res = list[i];
if (!!p && !res && !stub_only)
res = list[i];
}
}
return res_pri ?: res;
}
Reference in New Issue View Git Blame Copy Permalink