mirror of
git://sourceware.org/git/newlib-cygwin.git
synced 2025-02-08 10:09:32 +08:00
Cygwin: fhandler: Rename handles from XXX_cyg/XXX to XXX/XXX_nat.
- Currently, functions/variables regarding the handles for cygwin apps are with "_cyg", and those of handles for non-cygwin apps are without "_cyg", such as get_handle_cyg() and get_handle(). This patch renames these to the names without "_nat" and with "_nat" respectively, such as get_handle() and get_handle_nat().
This commit is contained in:
Takashi Yano
Ken Brown
parent
5a1b11bd7d
commit
6af72215d6
@ -457,9 +457,9 @@ public:
|
||||
/* Virtual accessor functions to hide the fact
|
||||
that some fd's have two handles. */
|
||||
virtual HANDLE& get_handle () { return io_handle; }
|
||||
virtual HANDLE& get_handle_cyg () { return io_handle; }
|
||||
virtual HANDLE& get_handle_nat () { return io_handle; }
|
||||
virtual HANDLE& get_output_handle () { return io_handle; }
|
||||
virtual HANDLE& get_output_handle_cyg () { return io_handle; }
|
||||
virtual HANDLE& get_output_handle_nat () { return io_handle; }
|
||||
virtual HANDLE get_stat_handle () { return pc.handle () ?: io_handle; }
|
||||
virtual HANDLE get_echo_handle () const { return NULL; }
|
||||
virtual bool hit_eof () {return false;}
|
||||
@ -2117,7 +2117,7 @@ class fhandler_termios: public fhandler_base
|
||||
need_fork_fixup (true);
|
||||
}
|
||||
HANDLE& get_output_handle () { return output_handle; }
|
||||
HANDLE& get_output_handle_cyg () { return output_handle; }
|
||||
HANDLE& get_output_handle_nat () { return output_handle; }
|
||||
line_edit_status line_edit (const char *rptr, size_t nread, termios&,
|
||||
ssize_t *bytes_read = NULL);
|
||||
void set_output_handle (HANDLE h) { output_handle = h; }
|
||||
@ -2506,7 +2506,7 @@ class fhandler_pty_common: public fhandler_termios
|
||||
class fhandler_pty_slave: public fhandler_pty_common
|
||||
{
|
||||
HANDLE inuse; // used to indicate that a tty is in use
|
||||
HANDLE output_handle_cyg, io_handle_cyg;
|
||||
HANDLE output_handle_nat, io_handle_nat;
|
||||
HANDLE slave_reading;
|
||||
LONG num_reader;
|
||||
|
||||
@ -2519,10 +2519,10 @@ class fhandler_pty_slave: public fhandler_pty_common
|
||||
/* Constructor */
|
||||
fhandler_pty_slave (int);
|
||||
|
||||
void set_output_handle_cyg (HANDLE h) { output_handle_cyg = h; }
|
||||
HANDLE& get_output_handle_cyg () { return output_handle_cyg; }
|
||||
void set_handle_cyg (HANDLE h) { io_handle_cyg = h; }
|
||||
HANDLE& get_handle_cyg () { return io_handle_cyg; }
|
||||
void set_output_handle_nat (HANDLE h) { output_handle_nat = h; }
|
||||
HANDLE& get_output_handle_nat () { return output_handle_nat; }
|
||||
void set_handle_nat (HANDLE h) { io_handle_nat = h; }
|
||||
HANDLE& get_handle_nat () { return io_handle_nat; }
|
||||
|
||||
int open (int flags, mode_t mode = 0);
|
||||
void open_setup (int flags);
|
||||
@ -2588,19 +2588,19 @@ class fhandler_pty_master: public fhandler_pty_common
|
||||
public:
|
||||
/* Parameter set for the static function pty_master_thread() */
|
||||
struct master_thread_param_t {
|
||||
HANDLE from_master_nat;
|
||||
HANDLE from_master;
|
||||
HANDLE from_master_cyg;
|
||||
HANDLE to_master_nat;
|
||||
HANDLE to_master;
|
||||
HANDLE to_master_cyg;
|
||||
HANDLE to_slave_nat;
|
||||
HANDLE to_slave;
|
||||
HANDLE to_slave_cyg;
|
||||
HANDLE master_ctl;
|
||||
HANDLE input_available_event;
|
||||
};
|
||||
/* Parameter set for the static function pty_master_fwd_thread() */
|
||||
struct master_fwd_thread_param_t {
|
||||
HANDLE to_master_cyg;
|
||||
HANDLE from_slave;
|
||||
HANDLE to_master;
|
||||
HANDLE from_slave_nat;
|
||||
HANDLE output_mutex;
|
||||
tty *ttyp;
|
||||
};
|
||||
@ -2608,10 +2608,10 @@ private:
|
||||
int pktmode; // non-zero if pty in a packet mode.
|
||||
HANDLE master_ctl; // Control socket for handle duplication
|
||||
cygthread *master_thread; // Master control thread
|
||||
HANDLE from_master, to_master, from_slave, to_slave;
|
||||
HANDLE from_master_nat, to_master_nat, from_slave_nat, to_slave_nat;
|
||||
HANDLE echo_r, echo_w;
|
||||
DWORD dwProcessId; // Owner of master handles
|
||||
HANDLE to_master_cyg, from_master_cyg;
|
||||
HANDLE to_master, from_master;
|
||||
cygthread *master_fwd_thread; // Master forwarding thread
|
||||
HANDLE thread_param_copied_event;
|
||||
|
||||
|
||||
@ -2096,7 +2096,7 @@ struct fh_ser
|
||||
/* FIXME: Deal with file name for FIFOs aside from O_PATH case. Maybe
|
||||
create a path_conv handle before serializing.
|
||||
|
||||
Modify pty and related cases due to renaming. */
|
||||
Recheck pty and related cases due to renaming. */
|
||||
|
||||
/* Return a pointer to an allocated buffer containing an fh_ser. The
|
||||
caller has to free it. */
|
||||
|
||||
@ -53,12 +53,12 @@ struct pipe_request {
|
||||
};
|
||||
|
||||
struct pipe_reply {
|
||||
HANDLE from_master_nat;
|
||||
HANDLE from_master;
|
||||
HANDLE from_master_cyg;
|
||||
HANDLE to_master_nat;
|
||||
HANDLE to_master;
|
||||
HANDLE to_master_cyg;
|
||||
HANDLE to_slave_nat;
|
||||
HANDLE to_slave;
|
||||
HANDLE to_slave_cyg;
|
||||
DWORD error;
|
||||
};
|
||||
|
||||
@ -140,16 +140,11 @@ set_switch_to_pcon (HANDLE *in, HANDLE *out, HANDLE *err, bool iscygwin)
|
||||
if (!iscygwin && ptys_pcon)
|
||||
ptys_pcon->set_switch_to_pcon ();
|
||||
if (replace_in)
|
||||
{
|
||||
if (iscygwin && ptys_pcon->pcon_activated ())
|
||||
*in = replace_in->get_handle_cyg ();
|
||||
else
|
||||
*in = replace_in->get_handle ();
|
||||
}
|
||||
*in = replace_in->get_handle_nat ();
|
||||
if (replace_out)
|
||||
*out = replace_out->get_output_handle ();
|
||||
*out = replace_out->get_output_handle_nat ();
|
||||
if (replace_err)
|
||||
*err = replace_err->get_output_handle ();
|
||||
*err = replace_err->get_output_handle_nat ();
|
||||
}
|
||||
|
||||
#define DEF_HOOK(name) static __typeof__ (name) *name##_Orig
|
||||
@ -283,7 +278,7 @@ exit_Hooked (int e)
|
||||
fhandler_base *fh = cfd;
|
||||
fhandler_pty_slave *ptys = (fhandler_pty_slave *) fh;
|
||||
tty *ttyp = ptys->get_ttyp ();
|
||||
HANDLE from = ptys->get_handle ();
|
||||
HANDLE from = ptys->get_handle_nat ();
|
||||
HANDLE input_available_event = ptys->get_input_available_event ();
|
||||
if (ttyp->getpgid () == myself->pgid
|
||||
&& GetStdHandle (STD_INPUT_HANDLE) == ptys->get_handle ()
|
||||
@ -372,7 +367,7 @@ bytes_available (DWORD& n, HANDLE h)
|
||||
bool
|
||||
fhandler_pty_common::bytes_available (DWORD &n)
|
||||
{
|
||||
return ::bytes_available (n, get_handle_cyg ());
|
||||
return ::bytes_available (n, get_handle ());
|
||||
}
|
||||
|
||||
#ifdef DEBUGGING
|
||||
@ -402,8 +397,8 @@ fhandler_pty_master::discard_input ()
|
||||
DWORD n;
|
||||
|
||||
WaitForSingleObject (input_mutex, INFINITE);
|
||||
while (::bytes_available (bytes_in_pipe, from_master_cyg) && bytes_in_pipe)
|
||||
ReadFile (from_master_cyg, buf, sizeof(buf), &n, NULL);
|
||||
while (::bytes_available (bytes_in_pipe, from_master) && bytes_in_pipe)
|
||||
ReadFile (from_master, buf, sizeof(buf), &n, NULL);
|
||||
ResetEvent (input_available_event);
|
||||
get_ttyp ()->discard_input = true;
|
||||
ReleaseMutex (input_mutex);
|
||||
@ -488,7 +483,7 @@ fhandler_pty_master::accept_input ()
|
||||
if (to_be_read_from_pcon ()
|
||||
&& get_ttyp ()->pcon_input_state == tty::to_nat)
|
||||
{
|
||||
write_to = to_slave;
|
||||
write_to = to_slave_nat;
|
||||
|
||||
UINT cp_to;
|
||||
pinfo pinfo_target = pinfo (get_ttyp ()->invisible_console_pid);
|
||||
@ -719,8 +714,8 @@ out:
|
||||
/* pty slave stuff */
|
||||
|
||||
fhandler_pty_slave::fhandler_pty_slave (int unit)
|
||||
: fhandler_pty_common (), inuse (NULL), output_handle_cyg (NULL),
|
||||
io_handle_cyg (NULL), slave_reading (NULL), num_reader (0)
|
||||
: fhandler_pty_common (), inuse (NULL), output_handle_nat (NULL),
|
||||
io_handle_nat (NULL), slave_reading (NULL), num_reader (0)
|
||||
{
|
||||
if (unit >= 0)
|
||||
dev ().parse (DEV_PTYS_MAJOR, unit);
|
||||
@ -730,13 +725,13 @@ int
|
||||
fhandler_pty_slave::open (int flags, mode_t)
|
||||
{
|
||||
HANDLE pty_owner;
|
||||
HANDLE from_master_local, from_master_cyg_local;
|
||||
HANDLE to_master_local, to_master_cyg_local;
|
||||
HANDLE from_master_nat_local, from_master_local;
|
||||
HANDLE to_master_nat_local, to_master_local;
|
||||
HANDLE *handles[] =
|
||||
{
|
||||
&from_master_local, &input_available_event, &input_mutex, &inuse,
|
||||
&output_mutex, &to_master_local, &pty_owner, &to_master_cyg_local,
|
||||
&from_master_cyg_local, &pcon_mutex,
|
||||
&from_master_nat_local, &input_available_event, &input_mutex, &inuse,
|
||||
&output_mutex, &to_master_nat_local, &pty_owner, &to_master_local,
|
||||
&from_master_local, &pcon_mutex,
|
||||
NULL
|
||||
};
|
||||
|
||||
@ -793,8 +788,8 @@ fhandler_pty_slave::open (int flags, mode_t)
|
||||
release_output_mutex ();
|
||||
}
|
||||
|
||||
if (!get_ttyp ()->from_master () || !get_ttyp ()->from_master_cyg ()
|
||||
|| !get_ttyp ()->to_master () || !get_ttyp ()->to_master_cyg ())
|
||||
if (!get_ttyp ()->from_master_nat () || !get_ttyp ()->from_master ()
|
||||
|| !get_ttyp ()->to_master_nat () || !get_ttyp ()->to_master ())
|
||||
{
|
||||
errmsg = "pty handles have been closed";
|
||||
set_errno (EACCES);
|
||||
@ -829,33 +824,39 @@ fhandler_pty_slave::open (int flags, mode_t)
|
||||
}
|
||||
if (pty_owner)
|
||||
{
|
||||
if (!DuplicateHandle (pty_owner, get_ttyp ()->from_master_nat (),
|
||||
GetCurrentProcess (),
|
||||
&from_master_nat_local, 0, TRUE,
|
||||
DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("can't duplicate input from %u/%p, %E",
|
||||
get_ttyp ()->master_pid,
|
||||
get_ttyp ()->from_master_nat ());
|
||||
__seterrno ();
|
||||
goto err_no_msg;
|
||||
}
|
||||
if (!DuplicateHandle (pty_owner, get_ttyp ()->from_master (),
|
||||
GetCurrentProcess (), &from_master_local, 0, TRUE,
|
||||
GetCurrentProcess (),
|
||||
&from_master_local, 0, TRUE,
|
||||
DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("can't duplicate input from %u/%p, %E",
|
||||
get_ttyp ()->master_pid, get_ttyp ()->from_master ());
|
||||
get_ttyp ()->master_pid,
|
||||
get_ttyp ()->from_master ());
|
||||
__seterrno ();
|
||||
goto err_no_msg;
|
||||
}
|
||||
if (!DuplicateHandle (pty_owner, get_ttyp ()->from_master_cyg (),
|
||||
GetCurrentProcess (), &from_master_cyg_local, 0, TRUE,
|
||||
DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("can't duplicate input from %u/%p, %E",
|
||||
get_ttyp ()->master_pid, get_ttyp ()->from_master_cyg ());
|
||||
__seterrno ();
|
||||
goto err_no_msg;
|
||||
}
|
||||
if (!DuplicateHandle (pty_owner, get_ttyp ()->to_master (),
|
||||
GetCurrentProcess (), &to_master_local, 0, TRUE,
|
||||
if (!DuplicateHandle (pty_owner, get_ttyp ()->to_master_nat (),
|
||||
GetCurrentProcess (),
|
||||
&to_master_nat_local, 0, TRUE,
|
||||
DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
errmsg = "can't duplicate output, %E";
|
||||
goto err;
|
||||
}
|
||||
if (!DuplicateHandle (pty_owner, get_ttyp ()->to_master_cyg (),
|
||||
GetCurrentProcess (), &to_master_cyg_local, 0, TRUE,
|
||||
if (!DuplicateHandle (pty_owner, get_ttyp ()->to_master (),
|
||||
GetCurrentProcess (),
|
||||
&to_master_local, 0, TRUE,
|
||||
DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
errmsg = "can't duplicate output for cygwin, %E";
|
||||
@ -879,36 +880,36 @@ fhandler_pty_slave::open (int flags, mode_t)
|
||||
errmsg = "can't call master, %E";
|
||||
goto err;
|
||||
}
|
||||
from_master_nat_local = repl.from_master_nat;
|
||||
from_master_local = repl.from_master;
|
||||
from_master_cyg_local = repl.from_master_cyg;
|
||||
to_master_nat_local = repl.to_master_nat;
|
||||
to_master_local = repl.to_master;
|
||||
to_master_cyg_local = repl.to_master_cyg;
|
||||
if (!from_master_local || !from_master_cyg_local
|
||||
|| !to_master_local || !to_master_cyg_local)
|
||||
if (!from_master_nat_local || !from_master_local
|
||||
|| !to_master_nat_local || !to_master_local)
|
||||
{
|
||||
SetLastError (repl.error);
|
||||
errmsg = "error duplicating pipes, %E";
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
VerifyHandle (from_master_nat_local);
|
||||
VerifyHandle (from_master_local);
|
||||
VerifyHandle (from_master_cyg_local);
|
||||
VerifyHandle (to_master_nat_local);
|
||||
VerifyHandle (to_master_local);
|
||||
VerifyHandle (to_master_cyg_local);
|
||||
|
||||
termios_printf ("duplicated from_master_nat %p->%p from pty_owner",
|
||||
get_ttyp ()->from_master_nat (), from_master_nat_local);
|
||||
termios_printf ("duplicated from_master %p->%p from pty_owner",
|
||||
get_ttyp ()->from_master (), from_master_local);
|
||||
termios_printf ("duplicated from_master_cyg %p->%p from pty_owner",
|
||||
get_ttyp ()->from_master_cyg (), from_master_cyg_local);
|
||||
termios_printf ("duplicated to_master_nat %p->%p from pty_owner",
|
||||
get_ttyp ()->to_master_nat (), to_master_nat_local);
|
||||
termios_printf ("duplicated to_master %p->%p from pty_owner",
|
||||
get_ttyp ()->to_master (), to_master_local);
|
||||
termios_printf ("duplicated to_master_cyg %p->%p from pty_owner",
|
||||
get_ttyp ()->to_master_cyg (), to_master_cyg_local);
|
||||
|
||||
set_handle_nat (from_master_nat_local);
|
||||
set_handle (from_master_local);
|
||||
set_handle_cyg (from_master_cyg_local);
|
||||
set_output_handle_nat (to_master_nat_local);
|
||||
set_output_handle (to_master_local);
|
||||
set_output_handle_cyg (to_master_cyg_local);
|
||||
|
||||
if (_major (myself->ctty) == DEV_CONS_MAJOR
|
||||
&& !(!pinfo (myself->ppid) && getenv ("ConEmuPID")))
|
||||
@ -971,12 +972,12 @@ fhandler_pty_slave::close ()
|
||||
termios_printf ("CloseHandle (inuse), %E");
|
||||
if (!ForceCloseHandle (input_available_event))
|
||||
termios_printf ("CloseHandle (input_available_event<%p>), %E", input_available_event);
|
||||
if (!ForceCloseHandle (get_output_handle_cyg ()))
|
||||
termios_printf ("CloseHandle (get_output_handle_cyg ()<%p>), %E",
|
||||
get_output_handle_cyg ());
|
||||
if (!ForceCloseHandle (get_handle_cyg ()))
|
||||
termios_printf ("CloseHandle (get_handle_cyg ()<%p>), %E",
|
||||
get_handle_cyg ());
|
||||
if (!ForceCloseHandle (get_output_handle_nat ()))
|
||||
termios_printf ("CloseHandle (get_output_handle_nat ()<%p>), %E",
|
||||
get_output_handle_nat ());
|
||||
if (!ForceCloseHandle (get_handle_nat ()))
|
||||
termios_printf ("CloseHandle (get_handle_nat ()<%p>), %E",
|
||||
get_handle_nat ());
|
||||
if ((unsigned) myself->ctty == FHDEV (DEV_PTYS_MAJOR, get_minor ()))
|
||||
fhandler_console::free_console (); /* assumes that we are the last pty closer */
|
||||
fhandler_pty_common::close ();
|
||||
@ -1042,7 +1043,7 @@ fhandler_pty_slave::set_switch_to_pcon (void)
|
||||
&& get_ttyp ()->pcon_input_state_eq (tty::to_cyg))
|
||||
{
|
||||
WaitForSingleObject (input_mutex, INFINITE);
|
||||
transfer_input (tty::to_nat, get_handle_cyg (), get_ttyp (),
|
||||
transfer_input (tty::to_nat, get_handle (), get_ttyp (),
|
||||
input_available_event);
|
||||
ReleaseMutex (input_mutex);
|
||||
}
|
||||
@ -1070,7 +1071,7 @@ fhandler_pty_slave::reset_switch_to_pcon (void)
|
||||
&& get_ttyp ()->pcon_input_state_eq (tty::to_nat))
|
||||
{
|
||||
WaitForSingleObject (input_mutex, INFINITE);
|
||||
transfer_input (tty::to_cyg, get_handle (), get_ttyp (),
|
||||
transfer_input (tty::to_cyg, get_handle_nat (), get_ttyp (),
|
||||
input_available_event);
|
||||
ReleaseMutex (input_mutex);
|
||||
}
|
||||
@ -1089,23 +1090,18 @@ fhandler_pty_slave::reset_switch_to_pcon (void)
|
||||
pinfo p (get_ttyp ()->master_pid);
|
||||
HANDLE pty_owner =
|
||||
OpenProcess (PROCESS_DUP_HANDLE, FALSE, p->dwProcessId);
|
||||
bool fix_in, fix_out, fix_err;
|
||||
fix_in =
|
||||
GetStdHandle (STD_INPUT_HANDLE) == get_handle ();
|
||||
fix_out =
|
||||
GetStdHandle (STD_OUTPUT_HANDLE) == get_output_handle ();
|
||||
fix_err =
|
||||
GetStdHandle (STD_ERROR_HANDLE) == get_output_handle ();
|
||||
if (pty_owner)
|
||||
{
|
||||
CloseHandle (get_handle ());
|
||||
DuplicateHandle (pty_owner, get_ttyp ()->from_master (),
|
||||
GetCurrentProcess (), &get_handle (),
|
||||
CloseHandle (get_handle_nat ());
|
||||
DuplicateHandle (pty_owner,
|
||||
get_ttyp ()->from_master_nat (),
|
||||
GetCurrentProcess (), &get_handle_nat (),
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS);
|
||||
CloseHandle (get_output_handle ());
|
||||
DuplicateHandle (pty_owner, get_ttyp ()->to_master (),
|
||||
CloseHandle (get_output_handle_nat ());
|
||||
DuplicateHandle (pty_owner,
|
||||
get_ttyp ()->to_master_nat (),
|
||||
GetCurrentProcess (),
|
||||
&get_output_handle (),
|
||||
&get_output_handle_nat (),
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS);
|
||||
CloseHandle (pty_owner);
|
||||
}
|
||||
@ -1121,17 +1117,11 @@ fhandler_pty_slave::reset_switch_to_pcon (void)
|
||||
if (!CallNamedPipe (pipe, &req, sizeof req,
|
||||
&repl, sizeof repl, &len, 500))
|
||||
return; /* What can we do? */
|
||||
CloseHandle (get_handle ());
|
||||
set_handle (repl.from_master);
|
||||
CloseHandle (get_output_handle ());
|
||||
set_output_handle (repl.to_master);
|
||||
CloseHandle (get_handle_nat ());
|
||||
set_handle_nat (repl.from_master_nat);
|
||||
CloseHandle (get_output_handle_nat ());
|
||||
set_output_handle_nat (repl.to_master_nat);
|
||||
}
|
||||
if (fix_in)
|
||||
SetStdHandle (STD_INPUT_HANDLE, get_handle ());
|
||||
if (fix_out)
|
||||
SetStdHandle (STD_OUTPUT_HANDLE, get_output_handle ());
|
||||
if (fix_err)
|
||||
SetStdHandle (STD_ERROR_HANDLE, get_output_handle ());
|
||||
}
|
||||
myself->exec_dwProcessId = 0;
|
||||
isHybrid = false;
|
||||
@ -1170,7 +1160,7 @@ fhandler_pty_slave::write (const void *ptr, size_t len)
|
||||
reset_switch_to_pcon ();
|
||||
|
||||
acquire_output_mutex (INFINITE);
|
||||
if (!process_opost_output (get_output_handle_cyg (), ptr, towrite, false,
|
||||
if (!process_opost_output (get_output_handle (), ptr, towrite, false,
|
||||
get_ttyp (), is_nonblocking ()))
|
||||
{
|
||||
DWORD err = GetLastError ();
|
||||
@ -1215,14 +1205,14 @@ fhandler_pty_slave::mask_switch_to_pcon_in (bool mask, bool xfer)
|
||||
if (mask && get_ttyp ()->pcon_input_state_eq (tty::to_nat))
|
||||
{
|
||||
WaitForSingleObject (input_mutex, INFINITE);
|
||||
transfer_input (tty::to_cyg, get_handle (), get_ttyp (),
|
||||
transfer_input (tty::to_cyg, get_handle_nat (), get_ttyp (),
|
||||
input_available_event);
|
||||
ReleaseMutex (input_mutex);
|
||||
}
|
||||
else if (!mask && get_ttyp ()->pcon_input_state_eq (tty::to_cyg))
|
||||
{
|
||||
WaitForSingleObject (input_mutex, INFINITE);
|
||||
transfer_input (tty::to_nat, get_handle_cyg (), get_ttyp (),
|
||||
transfer_input (tty::to_nat, get_handle (), get_ttyp (),
|
||||
input_available_event);
|
||||
ReleaseMutex (input_mutex);
|
||||
}
|
||||
@ -1269,7 +1259,7 @@ fhandler_pty_slave::read (void *ptr, size_t& len)
|
||||
return;
|
||||
}
|
||||
|
||||
termios_printf ("read(%p, %lu) handle %p", ptr, len, get_handle_cyg ());
|
||||
termios_printf ("read(%p, %lu) handle %p", ptr, len, get_handle ());
|
||||
|
||||
push_process_state process_state (PID_TTYIN);
|
||||
|
||||
@ -1416,7 +1406,7 @@ wait_retry:
|
||||
if (readlen)
|
||||
{
|
||||
termios_printf ("reading %lu bytes (vtime %d)", readlen, vtime);
|
||||
if (!ReadFile (get_handle_cyg (), buf, readlen, &n, NULL))
|
||||
if (!ReadFile (get_handle (), buf, readlen, &n, NULL))
|
||||
{
|
||||
termios_printf ("read failed, %E");
|
||||
ReleaseMutex (input_mutex);
|
||||
@ -1538,8 +1528,8 @@ dup_handles:
|
||||
HANDLE *handles[] =
|
||||
{
|
||||
&src_proc,
|
||||
&fhp->get_handle (), &fhp->get_handle_cyg (),
|
||||
&fhp->get_output_handle (), &fhp->get_output_handle_cyg (),
|
||||
&fhp->get_handle_nat (), &fhp->get_handle (),
|
||||
&fhp->get_output_handle_nat (), &fhp->get_output_handle (),
|
||||
&fhp->output_mutex, &fhp->input_mutex, &fhp->inuse,
|
||||
&fhp->input_available_event,
|
||||
NULL
|
||||
@ -1584,6 +1574,14 @@ dup_handles:
|
||||
src_pid, inuse);
|
||||
goto err;
|
||||
}
|
||||
if (!DuplicateHandle (src_proc, get_handle_nat (),
|
||||
GetCurrentProcess (), &fhp->get_handle_nat (),
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("can't duplicate input from %u/%p, %E",
|
||||
src_pid, get_handle_nat ());
|
||||
goto err;
|
||||
}
|
||||
if (!DuplicateHandle (src_proc, get_handle (),
|
||||
GetCurrentProcess (), &fhp->get_handle (),
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS))
|
||||
@ -1592,12 +1590,12 @@ dup_handles:
|
||||
src_pid, get_handle ());
|
||||
goto err;
|
||||
}
|
||||
if (!DuplicateHandle (src_proc, get_handle_cyg (),
|
||||
GetCurrentProcess (), &fhp->get_handle_cyg (),
|
||||
if (!DuplicateHandle (src_proc, get_output_handle_nat (),
|
||||
GetCurrentProcess (), &fhp->get_output_handle_nat (),
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("can't duplicate input from %u/%p, %E",
|
||||
src_pid, get_handle_cyg ());
|
||||
termios_printf ("can't duplicate output from %u/%p, %E",
|
||||
src_pid, get_output_handle_nat ());
|
||||
goto err;
|
||||
}
|
||||
if (!DuplicateHandle (src_proc, get_output_handle (),
|
||||
@ -1608,14 +1606,6 @@ dup_handles:
|
||||
src_pid, get_output_handle ());
|
||||
goto err;
|
||||
}
|
||||
if (!DuplicateHandle (src_proc, get_output_handle_cyg (),
|
||||
GetCurrentProcess (), &fhp->get_output_handle_cyg (),
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("can't duplicate output from %u/%p, %E",
|
||||
src_pid, get_output_handle_cyg ());
|
||||
goto err;
|
||||
}
|
||||
CloseHandle (src_proc);
|
||||
return 0;
|
||||
err:
|
||||
@ -1647,10 +1637,10 @@ dup_handles:
|
||||
HANDLE *handles[] =
|
||||
{
|
||||
&src_proc,
|
||||
&fhp->from_master_cyg, &fhp->get_output_handle (),
|
||||
&fhp->from_slave, &fhp->to_master,
|
||||
&fhp->get_handle (), &fhp->to_master_cyg,
|
||||
&fhp->from_master, &fhp->to_slave,
|
||||
&fhp->from_master, &fhp->get_output_handle (),
|
||||
&fhp->from_slave_nat, &fhp->to_master_nat,
|
||||
&fhp->get_handle (), &fhp->to_master,
|
||||
&fhp->from_master_nat, &fhp->to_slave_nat,
|
||||
&fhp->echo_r, &fhp->echo_w,
|
||||
&fhp->input_available_event,
|
||||
&fhp->output_mutex, &fhp->input_mutex,
|
||||
@ -1667,12 +1657,12 @@ dup_handles:
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (!DuplicateHandle (src_proc, from_master_cyg,
|
||||
GetCurrentProcess (), &fhp->from_master_cyg,
|
||||
if (!DuplicateHandle (src_proc, from_master,
|
||||
GetCurrentProcess (), &fhp->from_master,
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("can't duplicate from_master_cyg from %u/%p, %E",
|
||||
src_pid, from_master_cyg);
|
||||
termios_printf ("can't duplicate from_master from %u/%p, %E",
|
||||
src_pid, from_master);
|
||||
goto err;
|
||||
}
|
||||
if (!DuplicateHandle (src_proc, get_output_handle (),
|
||||
@ -1683,20 +1673,20 @@ dup_handles:
|
||||
src_pid, get_output_handle ());
|
||||
goto err;
|
||||
}
|
||||
if (!DuplicateHandle (src_proc, from_slave,
|
||||
GetCurrentProcess (), &fhp->from_slave,
|
||||
if (!DuplicateHandle (src_proc, from_slave_nat,
|
||||
GetCurrentProcess (), &fhp->from_slave_nat,
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("can't duplicate from_slave from %u/%p, %E",
|
||||
src_pid, from_slave);
|
||||
termios_printf ("can't duplicate from_slave_nat from %u/%p, %E",
|
||||
src_pid, from_slave_nat);
|
||||
goto err;
|
||||
}
|
||||
if (!DuplicateHandle (src_proc, to_master,
|
||||
GetCurrentProcess (), &fhp->to_master,
|
||||
if (!DuplicateHandle (src_proc, to_master_nat,
|
||||
GetCurrentProcess (), &fhp->to_master_nat,
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("can't duplicate to_master from %u/%p, %E",
|
||||
src_pid, to_master);
|
||||
termios_printf ("can't duplicate to_master_nat from %u/%p, %E",
|
||||
src_pid, to_master_nat);
|
||||
goto err;
|
||||
}
|
||||
if (!DuplicateHandle (src_proc, get_handle (),
|
||||
@ -1707,28 +1697,28 @@ dup_handles:
|
||||
src_pid, get_handle ());
|
||||
goto err;
|
||||
}
|
||||
if (!DuplicateHandle (src_proc, to_master_cyg,
|
||||
GetCurrentProcess (), &fhp->to_master_cyg,
|
||||
if (!DuplicateHandle (src_proc, to_master,
|
||||
GetCurrentProcess (), &fhp->to_master,
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("can't duplicate output from %u/%p, %E",
|
||||
src_pid, to_master_cyg);
|
||||
src_pid, to_master);
|
||||
goto err;
|
||||
}
|
||||
if (!DuplicateHandle (src_proc, from_master,
|
||||
GetCurrentProcess (), &fhp->from_master,
|
||||
if (!DuplicateHandle (src_proc, from_master_nat,
|
||||
GetCurrentProcess (), &fhp->from_master_nat,
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("can't duplicate from_master from %u/%p, %E",
|
||||
src_pid, from_master);
|
||||
termios_printf ("can't duplicate from_master_nat from %u/%p, %E",
|
||||
src_pid, from_master_nat);
|
||||
goto err;
|
||||
}
|
||||
if (!DuplicateHandle (src_proc, to_slave,
|
||||
GetCurrentProcess (), &fhp->to_slave,
|
||||
if (!DuplicateHandle (src_proc, to_slave_nat,
|
||||
GetCurrentProcess (), &fhp->to_slave_nat,
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("can't duplicate to_slave from %u/%p, %E",
|
||||
src_pid, to_slave);
|
||||
termios_printf ("can't duplicate to_slave_nat from %u/%p, %E",
|
||||
src_pid, to_slave_nat);
|
||||
goto err;
|
||||
}
|
||||
if (!DuplicateHandle (src_proc, echo_r,
|
||||
@ -1816,7 +1806,7 @@ fhandler_pty_slave::tcflush (int queue)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
termios_printf ("tcflush(%d) handle %p", queue, get_handle_cyg ());
|
||||
termios_printf ("tcflush(%d) handle %p", queue, get_handle ());
|
||||
|
||||
reset_switch_to_pcon ();
|
||||
|
||||
@ -2141,9 +2131,9 @@ errout:
|
||||
*/
|
||||
fhandler_pty_master::fhandler_pty_master (int unit)
|
||||
: fhandler_pty_common (), pktmode (0), master_ctl (NULL),
|
||||
master_thread (NULL), from_master (NULL), to_master (NULL),
|
||||
from_slave (NULL), to_slave (NULL), echo_r (NULL), echo_w (NULL),
|
||||
dwProcessId (0), to_master_cyg (NULL), from_master_cyg (NULL),
|
||||
master_thread (NULL), from_master_nat (NULL), to_master_nat (NULL),
|
||||
from_slave_nat (NULL), to_slave_nat (NULL), echo_r (NULL), echo_w (NULL),
|
||||
dwProcessId (0), to_master (NULL), from_master (NULL),
|
||||
master_fwd_thread (NULL)
|
||||
{
|
||||
if (unit >= 0)
|
||||
@ -2222,8 +2212,8 @@ fhandler_pty_master::cleanup ()
|
||||
{
|
||||
report_tty_counts (this, "closing master", "");
|
||||
if (archetype)
|
||||
from_master = from_master_cyg =
|
||||
to_master = to_master_cyg = from_slave = to_slave = NULL;
|
||||
from_master_nat = from_master =
|
||||
to_master_nat = to_master = from_slave_nat = to_slave_nat = NULL;
|
||||
fhandler_base::cleanup ();
|
||||
}
|
||||
|
||||
@ -2233,9 +2223,9 @@ fhandler_pty_master::close ()
|
||||
OBJECT_BASIC_INFORMATION obi;
|
||||
NTSTATUS status;
|
||||
|
||||
termios_printf ("closing from_master(%p)/from_master_cyg(%p)/to_master(%p)/to_master_cyg(%p) since we own them(%u)",
|
||||
from_master, from_master_cyg,
|
||||
to_master, to_master_cyg, dwProcessId);
|
||||
termios_printf ("closing from_master_nat(%p)/from_master(%p)/to_master_nat(%p)/to_master(%p) since we own them(%u)",
|
||||
from_master_nat, from_master,
|
||||
to_master_nat, to_master, dwProcessId);
|
||||
if (cygwin_finished_initializing)
|
||||
{
|
||||
if (master_ctl && get_ttyp ()->master_pid == myself->pid)
|
||||
@ -2282,25 +2272,25 @@ fhandler_pty_master::close ()
|
||||
SetEvent (input_available_event);
|
||||
}
|
||||
|
||||
if (!ForceCloseHandle (from_master_nat))
|
||||
termios_printf ("error closing from_master_nat %p, %E", from_master_nat);
|
||||
if (!ForceCloseHandle (from_master))
|
||||
termios_printf ("error closing from_master %p, %E", from_master);
|
||||
if (!ForceCloseHandle (from_master_cyg))
|
||||
termios_printf ("error closing from_master_cyg %p, %E", from_master_cyg);
|
||||
if (!ForceCloseHandle (to_master_nat))
|
||||
termios_printf ("error closing to_master_nat %p, %E", to_master_nat);
|
||||
from_master_nat = to_master_nat = NULL;
|
||||
if (!ForceCloseHandle (from_slave_nat))
|
||||
termios_printf ("error closing from_slave_nat %p, %E", from_slave_nat);
|
||||
from_slave_nat = NULL;
|
||||
if (!ForceCloseHandle (to_master))
|
||||
termios_printf ("error closing to_master %p, %E", to_master);
|
||||
from_master = to_master = NULL;
|
||||
if (!ForceCloseHandle (from_slave))
|
||||
termios_printf ("error closing from_slave %p, %E", from_slave);
|
||||
from_slave = NULL;
|
||||
if (!ForceCloseHandle (to_master_cyg))
|
||||
termios_printf ("error closing to_master_cyg %p, %E", to_master_cyg);
|
||||
to_master_cyg = from_master_cyg = NULL;
|
||||
to_master = from_master = NULL;
|
||||
ForceCloseHandle (echo_r);
|
||||
ForceCloseHandle (echo_w);
|
||||
echo_r = echo_w = NULL;
|
||||
if (to_slave)
|
||||
ForceCloseHandle (to_slave);
|
||||
to_slave = NULL;
|
||||
if (to_slave_nat)
|
||||
ForceCloseHandle (to_slave_nat);
|
||||
to_slave_nat = NULL;
|
||||
|
||||
if (have_execed || get_ttyp ()->master_pid != myself->pid)
|
||||
termios_printf ("not clearing: %d, master_pid %d",
|
||||
@ -2354,7 +2344,7 @@ fhandler_pty_master::write (const void *ptr, size_t len)
|
||||
else
|
||||
{
|
||||
if (!get_ttyp ()->req_xfer_input)
|
||||
WriteFile (to_slave, wpbuf, ixput, &n, NULL);
|
||||
WriteFile (to_slave_nat, wpbuf, ixput, &n, NULL);
|
||||
ixput = 0;
|
||||
wpbuf[ixput++] = p[i];
|
||||
}
|
||||
@ -2367,7 +2357,7 @@ fhandler_pty_master::write (const void *ptr, size_t len)
|
||||
if (state == 2)
|
||||
{
|
||||
if (!get_ttyp ()->req_xfer_input)
|
||||
WriteFile (to_slave, wpbuf, ixput, &n, NULL);
|
||||
WriteFile (to_slave_nat, wpbuf, ixput, &n, NULL);
|
||||
ixput = 0;
|
||||
state = 0;
|
||||
get_ttyp ()->req_xfer_input = false;
|
||||
@ -2390,7 +2380,7 @@ fhandler_pty_master::write (const void *ptr, size_t len)
|
||||
if (get_readahead_valid ())
|
||||
accept_input ();
|
||||
WaitForSingleObject (input_mutex, INFINITE);
|
||||
fhandler_pty_slave::transfer_input (tty::to_nat, from_master_cyg,
|
||||
fhandler_pty_slave::transfer_input (tty::to_nat, from_master,
|
||||
get_ttyp (),
|
||||
input_available_event);
|
||||
ReleaseMutex (input_mutex);
|
||||
@ -2401,7 +2391,7 @@ fhandler_pty_master::write (const void *ptr, size_t len)
|
||||
return len;
|
||||
}
|
||||
|
||||
/* Write terminal input to to_slave pipe instead of output_handle
|
||||
/* Write terminal input to to_slave_nat pipe instead of output_handle
|
||||
if current application is native console application. */
|
||||
if (to_be_read_from_pcon () && get_ttyp ()->pcon_activated
|
||||
&& get_ttyp ()->pcon_input_state == tty::to_nat)
|
||||
@ -2424,7 +2414,7 @@ fhandler_pty_master::write (const void *ptr, size_t len)
|
||||
&& memchr (buf, '\003', nlen))
|
||||
get_ttyp ()->discard_input = true;
|
||||
DWORD n;
|
||||
WriteFile (to_slave, buf, nlen, &n, NULL);
|
||||
WriteFile (to_slave_nat, buf, nlen, &n, NULL);
|
||||
ReleaseMutex (input_mutex);
|
||||
|
||||
return len;
|
||||
@ -2705,6 +2695,13 @@ fhandler_pty_master::pty_master_thread (const master_thread_param_t *p)
|
||||
termios_printf ("OpenProcess, %E");
|
||||
goto reply;
|
||||
}
|
||||
if (!DuplicateHandle (GetCurrentProcess (), p->from_master_nat,
|
||||
client, &repl.from_master_nat,
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("DuplicateHandle (from_master_nat), %E");
|
||||
goto reply;
|
||||
}
|
||||
if (!DuplicateHandle (GetCurrentProcess (), p->from_master,
|
||||
client, &repl.from_master,
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS))
|
||||
@ -2712,11 +2709,11 @@ fhandler_pty_master::pty_master_thread (const master_thread_param_t *p)
|
||||
termios_printf ("DuplicateHandle (from_master), %E");
|
||||
goto reply;
|
||||
}
|
||||
if (!DuplicateHandle (GetCurrentProcess (), p->from_master_cyg,
|
||||
client, &repl.from_master_cyg,
|
||||
if (!DuplicateHandle (GetCurrentProcess (), p->to_master_nat,
|
||||
client, &repl.to_master_nat,
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("DuplicateHandle (from_master_cyg), %E");
|
||||
termios_printf ("DuplicateHandle (to_master_nat), %E");
|
||||
goto reply;
|
||||
}
|
||||
if (!DuplicateHandle (GetCurrentProcess (), p->to_master,
|
||||
@ -2726,11 +2723,11 @@ fhandler_pty_master::pty_master_thread (const master_thread_param_t *p)
|
||||
termios_printf ("DuplicateHandle (to_master), %E");
|
||||
goto reply;
|
||||
}
|
||||
if (!DuplicateHandle (GetCurrentProcess (), p->to_master_cyg,
|
||||
client, &repl.to_master_cyg,
|
||||
if (!DuplicateHandle (GetCurrentProcess (), p->to_slave_nat,
|
||||
client, &repl.to_slave_nat,
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("DuplicateHandle (to_master_cyg), %E");
|
||||
termios_printf ("DuplicateHandle (to_slave_nat), %E");
|
||||
goto reply;
|
||||
}
|
||||
if (!DuplicateHandle (GetCurrentProcess (), p->to_slave,
|
||||
@ -2740,13 +2737,6 @@ fhandler_pty_master::pty_master_thread (const master_thread_param_t *p)
|
||||
termios_printf ("DuplicateHandle (to_slave), %E");
|
||||
goto reply;
|
||||
}
|
||||
if (!DuplicateHandle (GetCurrentProcess (), p->to_slave_cyg,
|
||||
client, &repl.to_slave_cyg,
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS))
|
||||
{
|
||||
termios_printf ("DuplicateHandle (to_slave_cyg), %E");
|
||||
goto reply;
|
||||
}
|
||||
}
|
||||
reply:
|
||||
repl.error = GetLastError ();
|
||||
@ -2756,7 +2746,7 @@ reply:
|
||||
cygheap->user.reimpersonate ();
|
||||
sd.free ();
|
||||
termios_printf ("Reply: from %p, to %p, error %u",
|
||||
repl.from_master, repl.to_master, repl.error );
|
||||
repl.from_master_nat, repl.to_master_nat, repl.error );
|
||||
if (!WriteFile (p->master_ctl, &repl, sizeof repl, &len, NULL))
|
||||
termios_printf ("WriteFile, %E");
|
||||
if (!DisconnectNamedPipe (p->master_ctl))
|
||||
@ -2794,7 +2784,7 @@ fhandler_pty_master::pty_master_fwd_thread (const master_fwd_thread_param_t *p)
|
||||
for (;;)
|
||||
{
|
||||
p->ttyp->pcon_last_time = GetTickCount ();
|
||||
if (!ReadFile (p->from_slave, outbuf, NT_MAX_PATH, &rlen, NULL))
|
||||
if (!ReadFile (p->from_slave_nat, outbuf, NT_MAX_PATH, &rlen, NULL))
|
||||
{
|
||||
termios_printf ("ReadFile for forwarding failed, %E");
|
||||
break;
|
||||
@ -2908,11 +2898,11 @@ fhandler_pty_master::pty_master_fwd_thread (const master_fwd_thread_param_t *p)
|
||||
}
|
||||
|
||||
/* OPOST processing was already done in pseudo console,
|
||||
so just write it to to_master_cyg. */
|
||||
so just write it to to_master. */
|
||||
DWORD written;
|
||||
while (rlen>0)
|
||||
{
|
||||
if (!WriteFile (p->to_master_cyg, ptr, wlen, &written, NULL))
|
||||
if (!WriteFile (p->to_master, ptr, wlen, &written, NULL))
|
||||
{
|
||||
termios_printf ("WriteFile for forwarding failed, %E");
|
||||
break;
|
||||
@ -2962,7 +2952,7 @@ fhandler_pty_master::pty_master_fwd_thread (const master_fwd_thread_param_t *p)
|
||||
WaitForSingleObject (p->output_mutex, INFINITE);
|
||||
while (rlen>0)
|
||||
{
|
||||
if (!process_opost_output (p->to_master_cyg, ptr, wlen, false,
|
||||
if (!process_opost_output (p->to_master, ptr, wlen, false,
|
||||
p->ttyp, false))
|
||||
{
|
||||
termios_printf ("WriteFile for forwarding failed, %E");
|
||||
@ -2999,7 +2989,7 @@ fhandler_pty_master::setup ()
|
||||
SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE };
|
||||
|
||||
/* Find an unallocated pty to use. */
|
||||
int unit = cygwin_shared->tty.allocate (from_master_cyg, get_output_handle ());
|
||||
int unit = cygwin_shared->tty.allocate (from_master, get_output_handle ());
|
||||
if (unit < 0)
|
||||
return false;
|
||||
|
||||
@ -3019,7 +3009,7 @@ fhandler_pty_master::setup ()
|
||||
|
||||
char pipename[sizeof ("ptyNNNN-from-master-nat")];
|
||||
__small_sprintf (pipename, "pty%d-to-master-nat", unit);
|
||||
res = fhandler_pipe::create (&sec_none, &from_slave, &to_master,
|
||||
res = fhandler_pipe::create (&sec_none, &from_slave_nat, &to_master_nat,
|
||||
fhandler_pty_common::pipesize, pipename, 0);
|
||||
if (res)
|
||||
{
|
||||
@ -3028,7 +3018,7 @@ fhandler_pty_master::setup ()
|
||||
}
|
||||
|
||||
__small_sprintf (pipename, "pty%d-to-master", unit);
|
||||
res = fhandler_pipe::create (&sec_none, &get_handle (), &to_master_cyg,
|
||||
res = fhandler_pipe::create (&sec_none, &get_handle (), &to_master,
|
||||
fhandler_pty_common::pipesize, pipename, 0);
|
||||
if (res)
|
||||
{
|
||||
@ -3043,7 +3033,7 @@ fhandler_pty_master::setup ()
|
||||
opened with FILE_FLAG_OVERLAPPED, it is mandatory to pass the
|
||||
OVERLAPP structure, but in fact, it seems that the access will
|
||||
fallback to the blocking access if it is not specified. */
|
||||
res = fhandler_pipe::create (&sec_none, &from_master, &to_slave,
|
||||
res = fhandler_pipe::create (&sec_none, &from_master_nat, &to_slave_nat,
|
||||
fhandler_pty_common::pipesize, pipename,
|
||||
FILE_FLAG_OVERLAPPED);
|
||||
if (res)
|
||||
@ -3052,7 +3042,7 @@ fhandler_pty_master::setup ()
|
||||
goto err;
|
||||
}
|
||||
|
||||
ProtectHandle1 (from_slave, from_pty);
|
||||
ProtectHandle1 (get_handle (), from_pty);
|
||||
|
||||
__small_sprintf (pipename, "pty%d-echoloop", unit);
|
||||
res = fhandler_pipe::create (&sec_none, &echo_r, &echo_w,
|
||||
@ -3128,12 +3118,12 @@ fhandler_pty_master::setup ()
|
||||
WaitForSingleObject (thread_param_copied_event, INFINITE);
|
||||
CloseHandle (thread_param_copied_event);
|
||||
|
||||
t.set_from_master_nat (from_master_nat);
|
||||
t.set_from_master (from_master);
|
||||
t.set_from_master_cyg (from_master_cyg);
|
||||
t.set_to_master_nat (to_master_nat);
|
||||
t.set_to_master (to_master);
|
||||
t.set_to_master_cyg (to_master_cyg);
|
||||
t.set_to_slave (to_slave);
|
||||
t.set_to_slave_cyg (get_output_handle ());
|
||||
t.set_to_slave_nat (to_slave_nat);
|
||||
t.set_to_slave (get_output_handle ());
|
||||
t.winsize.ws_col = 80;
|
||||
t.winsize.ws_row = 25;
|
||||
t.master_pid = myself->pid;
|
||||
@ -3143,24 +3133,24 @@ fhandler_pty_master::setup ()
|
||||
t.master_is_running_as_service = is_running_as_service ();
|
||||
|
||||
termios_printf ("this %p, pty%d opened - from_pty <%p,%p>, to_pty %p",
|
||||
this, unit, from_slave, get_handle (),
|
||||
this, unit, from_slave_nat, get_handle (),
|
||||
get_output_handle ());
|
||||
return true;
|
||||
|
||||
err:
|
||||
__seterrno ();
|
||||
close_maybe (from_slave);
|
||||
close_maybe (to_slave);
|
||||
close_maybe (from_slave_nat);
|
||||
close_maybe (to_slave_nat);
|
||||
close_maybe (get_handle ());
|
||||
close_maybe (get_output_handle ());
|
||||
close_maybe (input_available_event);
|
||||
close_maybe (output_mutex);
|
||||
close_maybe (input_mutex);
|
||||
close_maybe (attach_mutex);
|
||||
close_maybe (from_master_nat);
|
||||
close_maybe (from_master);
|
||||
close_maybe (from_master_cyg);
|
||||
close_maybe (to_master_nat);
|
||||
close_maybe (to_master);
|
||||
close_maybe (to_master_cyg);
|
||||
close_maybe (echo_r);
|
||||
close_maybe (echo_w);
|
||||
close_maybe (master_ctl);
|
||||
@ -3178,20 +3168,20 @@ fhandler_pty_master::fixup_after_fork (HANDLE parent)
|
||||
tty& t = *get_ttyp ();
|
||||
if (myself->pid == t.master_pid)
|
||||
{
|
||||
t.set_from_master_nat (arch->from_master_nat);
|
||||
t.set_from_master (arch->from_master);
|
||||
t.set_from_master_cyg (arch->from_master_cyg);
|
||||
t.set_to_master_nat (arch->to_master_nat);
|
||||
t.set_to_master (arch->to_master);
|
||||
t.set_to_master_cyg (arch->to_master_cyg);
|
||||
}
|
||||
arch->dwProcessId = wpid;
|
||||
}
|
||||
from_master_nat = arch->from_master_nat;
|
||||
from_master = arch->from_master;
|
||||
from_master_cyg = arch->from_master_cyg;
|
||||
to_master_nat = arch->to_master_nat;
|
||||
to_master = arch->to_master;
|
||||
to_master_cyg = arch->to_master_cyg;
|
||||
#if 0 /* Not sure if this is necessary. */
|
||||
from_slave = arch->from_slave;
|
||||
to_slave = arch->to_slave;
|
||||
from_slave_nat = arch->from_slave_nat;
|
||||
to_slave_nat = arch->to_slave_nat;
|
||||
#endif
|
||||
report_tty_counts (this, "inherited master", "");
|
||||
}
|
||||
@ -3202,8 +3192,8 @@ fhandler_pty_master::fixup_after_exec ()
|
||||
if (!close_on_exec ())
|
||||
fixup_after_fork (spawn_info->parent);
|
||||
else
|
||||
from_master = from_master_cyg = to_master = to_master_cyg =
|
||||
from_slave = to_slave = NULL;
|
||||
from_master_nat = from_master = to_master_nat = to_master =
|
||||
from_slave_nat = to_slave_nat = NULL;
|
||||
}
|
||||
|
||||
BOOL
|
||||
@ -3346,7 +3336,7 @@ fhandler_pty_slave::setup_pseudoconsole (bool nopcon)
|
||||
get_ttyp ()->req_xfer_input = true;
|
||||
get_ttyp ()->pcon_start = true;
|
||||
get_ttyp ()->pcon_start_pid = myself->pid;
|
||||
WriteFile (get_output_handle_cyg (), "\033[6n", 4, &n, NULL);
|
||||
WriteFile (get_output_handle (), "\033[6n", 4, &n, NULL);
|
||||
ReleaseMutex (input_mutex);
|
||||
}
|
||||
/* Attach to the pseudo console which already exits. */
|
||||
@ -3380,8 +3370,8 @@ fhandler_pty_slave::setup_pseudoconsole (bool nopcon)
|
||||
const DWORD inherit_cursor = 1;
|
||||
hpcon = NULL;
|
||||
SetLastError (ERROR_SUCCESS);
|
||||
HRESULT res = CreatePseudoConsole (size, get_handle (),
|
||||
get_output_handle (),
|
||||
HRESULT res = CreatePseudoConsole (size, get_handle_nat (),
|
||||
get_output_handle_nat (),
|
||||
inherit_cursor, &hpcon);
|
||||
if (res != S_OK || GetLastError () == ERROR_PROC_NOT_FOUND)
|
||||
{
|
||||
@ -3497,30 +3487,22 @@ fhandler_pty_slave::setup_pseudoconsole (bool nopcon)
|
||||
skip_create:
|
||||
do
|
||||
{
|
||||
/* Set handle */
|
||||
if (GetStdHandle (STD_INPUT_HANDLE) == get_handle ())
|
||||
SetStdHandle (STD_INPUT_HANDLE, hpConIn);
|
||||
if (GetStdHandle (STD_OUTPUT_HANDLE) == get_output_handle ())
|
||||
SetStdHandle (STD_OUTPUT_HANDLE, hpConOut);
|
||||
if (GetStdHandle (STD_ERROR_HANDLE) == get_output_handle ())
|
||||
SetStdHandle (STD_ERROR_HANDLE, hpConOut);
|
||||
|
||||
/* Fixup handles */
|
||||
HANDLE orig_input_handle = get_handle ();
|
||||
HANDLE orig_output_handle = get_output_handle ();
|
||||
HANDLE orig_input_handle_nat = get_handle_nat ();
|
||||
HANDLE orig_output_handle_nat = get_output_handle_nat ();
|
||||
cygheap_fdenum cfd (false);
|
||||
while (cfd.next () >= 0)
|
||||
if (cfd->get_device () == get_device ())
|
||||
{
|
||||
fhandler_base *fh = cfd;
|
||||
fhandler_pty_slave *ptys = (fhandler_pty_slave *) fh;
|
||||
if (ptys->get_handle () == orig_input_handle)
|
||||
ptys->set_handle (hpConIn);
|
||||
if (ptys->get_output_handle () == orig_output_handle)
|
||||
ptys->set_output_handle (hpConOut);
|
||||
if (ptys->get_handle_nat () == orig_input_handle_nat)
|
||||
ptys->set_handle_nat (hpConIn);
|
||||
if (ptys->get_output_handle_nat () == orig_output_handle_nat)
|
||||
ptys->set_output_handle_nat (hpConOut);
|
||||
}
|
||||
CloseHandle (orig_input_handle);
|
||||
CloseHandle (orig_output_handle);
|
||||
CloseHandle (orig_input_handle_nat);
|
||||
CloseHandle (orig_output_handle_nat);
|
||||
}
|
||||
while (false);
|
||||
|
||||
@ -3821,19 +3803,19 @@ fhandler_pty_slave::term_has_pcon_cap (const WCHAR *env)
|
||||
WaitForSingleObject (pcon_mutex, INFINITE);
|
||||
WaitForSingleObject (input_mutex, INFINITE);
|
||||
/* Set pcon_activated and pcon_start so that the response
|
||||
will sent to io_handle rather than io_handle_cyg. */
|
||||
will sent to io_handle_nat rather than io_handle. */
|
||||
get_ttyp ()->pcon_activated = true;
|
||||
/* pcon_start will be cleared in master write() when CSI6n is responded. */
|
||||
get_ttyp ()->pcon_start = true;
|
||||
WriteFile (get_output_handle_cyg (), "\033[6n", 4, &n, NULL);
|
||||
WriteFile (get_output_handle (), "\033[6n", 4, &n, NULL);
|
||||
ReleaseMutex (input_mutex);
|
||||
p = buf;
|
||||
len = sizeof (buf) - 1;
|
||||
do
|
||||
{
|
||||
if (::bytes_available (n, get_handle ()) && n)
|
||||
if (::bytes_available (n, get_handle_nat ()) && n)
|
||||
{
|
||||
ReadFile (get_handle (), p, len, &n, NULL);
|
||||
ReadFile (get_handle_nat (), p, len, &n, NULL);
|
||||
p += n;
|
||||
len -= n;
|
||||
*p = '\0';
|
||||
@ -3897,12 +3879,12 @@ fhandler_pty_slave::create_invisible_console ()
|
||||
void
|
||||
fhandler_pty_master::get_master_thread_param (master_thread_param_t *p)
|
||||
{
|
||||
p->from_master_nat = from_master_nat;
|
||||
p->from_master = from_master;
|
||||
p->from_master_cyg = from_master_cyg;
|
||||
p->to_master_nat = to_master_nat;
|
||||
p->to_master = to_master;
|
||||
p->to_master_cyg = to_master_cyg;
|
||||
p->to_slave = to_slave;
|
||||
p->to_slave_cyg = get_output_handle ();
|
||||
p->to_slave_nat = to_slave_nat;
|
||||
p->to_slave = get_output_handle ();
|
||||
p->master_ctl = master_ctl;
|
||||
p->input_available_event = input_available_event;
|
||||
SetEvent (thread_param_copied_event);
|
||||
@ -3911,8 +3893,8 @@ fhandler_pty_master::get_master_thread_param (master_thread_param_t *p)
|
||||
void
|
||||
fhandler_pty_master::get_master_fwd_thread_param (master_fwd_thread_param_t *p)
|
||||
{
|
||||
p->to_master_cyg = to_master_cyg;
|
||||
p->from_slave = from_slave;
|
||||
p->to_master = to_master;
|
||||
p->from_slave_nat = from_slave_nat;
|
||||
p->output_mutex = output_mutex;
|
||||
p->ttyp = get_ttyp ();
|
||||
SetEvent (thread_param_copied_event);
|
||||
@ -3926,9 +3908,9 @@ fhandler_pty_slave::transfer_input (tty::xfer_dir dir, HANDLE from, tty *ttyp,
|
||||
{
|
||||
HANDLE to;
|
||||
if (dir == tty::to_nat)
|
||||
to = ttyp->to_slave ();
|
||||
to = ttyp->to_slave_nat ();
|
||||
else
|
||||
to = ttyp->to_slave_cyg ();
|
||||
to = ttyp->to_slave ();
|
||||
|
||||
pinfo p (ttyp->master_pid);
|
||||
HANDLE pty_owner = OpenProcess (PROCESS_DUP_HANDLE, FALSE, p->dwProcessId);
|
||||
@ -3951,9 +3933,9 @@ fhandler_pty_slave::transfer_input (tty::xfer_dir dir, HANDLE from, tty *ttyp,
|
||||
&repl, sizeof repl, &len, 500))
|
||||
return; /* What can we do? */
|
||||
if (dir == tty::to_nat)
|
||||
to = repl.to_slave;
|
||||
to = repl.to_slave_nat;
|
||||
else
|
||||
to = repl.to_slave_cyg;
|
||||
to = repl.to_slave;
|
||||
}
|
||||
|
||||
UINT cp_from = 0, cp_to = 0;
|
||||
|
||||
@ -74,7 +74,7 @@ details. */
|
||||
})
|
||||
|
||||
#define set_handle_or_return_if_not_open(h, s) \
|
||||
h = (s)->fh->get_handle_cyg (); \
|
||||
h = (s)->fh->get_handle (); \
|
||||
if (cygheap->fdtab.not_open ((s)->fd)) \
|
||||
{ \
|
||||
(s)->thread_errno = EBADF; \
|
||||
@ -715,7 +715,7 @@ out:
|
||||
fhandler_pty_master *fhm = (fhandler_pty_master *) fh;
|
||||
fhm->set_mask_flusho (s->read_ready);
|
||||
}
|
||||
h = fh->get_output_handle_cyg ();
|
||||
h = fh->get_output_handle ();
|
||||
if (s->write_selected && dev != FH_PIPER)
|
||||
{
|
||||
gotone += s->write_ready = pipe_data_available (s->fd, fh, h, true);
|
||||
@ -1344,7 +1344,7 @@ peek_pty_slave (select_record *s, bool from_select)
|
||||
}
|
||||
|
||||
out:
|
||||
HANDLE h = ptys->get_output_handle_cyg ();
|
||||
HANDLE h = ptys->get_output_handle ();
|
||||
if (s->write_selected)
|
||||
{
|
||||
gotone += s->write_ready = pipe_data_available (s->fd, fh, h, true);
|
||||
@ -1572,7 +1572,7 @@ serial_read_cleanup (select_record *s, select_stuff *stuff)
|
||||
{
|
||||
if (s->h)
|
||||
{
|
||||
HANDLE h = ((fhandler_serial *) s->fh)->get_handle_cyg ();
|
||||
HANDLE h = ((fhandler_serial *) s->fh)->get_handle ();
|
||||
DWORD undefined;
|
||||
|
||||
if (h)
|
||||
@ -1611,11 +1611,11 @@ fhandler_serial::select_read (select_stuff *ss)
|
||||
|
||||
/* This is apparently necessary for the com0com driver.
|
||||
See: http://cygwin.com/ml/cygwin/2009-01/msg00667.html */
|
||||
SetCommMask (get_handle_cyg (), 0);
|
||||
SetCommMask (get_handle_cyg (), EV_RXCHAR);
|
||||
if (ClearCommError (get_handle_cyg (), &io_err, &st) && st.cbInQue)
|
||||
SetCommMask (get_handle (), 0);
|
||||
SetCommMask (get_handle (), EV_RXCHAR);
|
||||
if (ClearCommError (get_handle (), &io_err, &st) && st.cbInQue)
|
||||
s->read_ready = true;
|
||||
else if (WaitCommEvent (get_handle_cyg (), &s->fh_data_serial->event,
|
||||
else if (WaitCommEvent (get_handle (), &s->fh_data_serial->event,
|
||||
&s->fh_data_serial->ov))
|
||||
s->read_ready = true;
|
||||
else if (GetLastError () == ERROR_IO_PENDING)
|
||||
@ -1667,7 +1667,7 @@ fhandler_base::select_read (select_stuff *ss)
|
||||
s->startup = no_startup;
|
||||
s->verify = verify_ok;
|
||||
}
|
||||
s->h = get_handle_cyg ();
|
||||
s->h = get_handle ();
|
||||
s->read_selected = true;
|
||||
s->read_ready = true;
|
||||
return s;
|
||||
@ -1682,7 +1682,7 @@ fhandler_base::select_write (select_stuff *ss)
|
||||
s->startup = no_startup;
|
||||
s->verify = verify_ok;
|
||||
}
|
||||
s->h = get_output_handle_cyg ();
|
||||
s->h = get_output_handle ();
|
||||
s->write_selected = true;
|
||||
s->write_ready = true;
|
||||
return s;
|
||||
|
||||
@ -187,9 +187,9 @@ handle (int fd, bool writing)
|
||||
else if (cfd->close_on_exec ())
|
||||
h = INVALID_HANDLE_VALUE;
|
||||
else if (!writing)
|
||||
h = cfd->get_handle ();
|
||||
h = cfd->get_handle_nat ();
|
||||
else
|
||||
h = cfd->get_output_handle ();
|
||||
h = cfd->get_output_handle_nat ();
|
||||
|
||||
return h;
|
||||
}
|
||||
@ -660,7 +660,7 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
|
||||
}
|
||||
|
||||
bool enable_pcon = false;
|
||||
HANDLE ptys_from_master = NULL;
|
||||
HANDLE ptys_from_master_nat = NULL;
|
||||
HANDLE ptys_input_available_event = NULL;
|
||||
HANDLE ptys_pcon_mutex = NULL;
|
||||
HANDLE ptys_input_mutex = NULL;
|
||||
@ -677,11 +677,11 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
|
||||
enable_pcon = true;
|
||||
ReleaseMutex (ptys_primary->pcon_mutex);
|
||||
HANDLE h_stdin = handle ((in__stdin < 0 ? 0 : in__stdin), false);
|
||||
if (h_stdin == ptys_primary->get_handle ())
|
||||
if (h_stdin == ptys_primary->get_handle_nat ())
|
||||
stdin_is_ptys = true;
|
||||
ptys_from_master = ptys_primary->get_handle ();
|
||||
DuplicateHandle (GetCurrentProcess (), ptys_from_master,
|
||||
GetCurrentProcess (), &ptys_from_master,
|
||||
ptys_from_master_nat = ptys_primary->get_handle_nat ();
|
||||
DuplicateHandle (GetCurrentProcess (), ptys_from_master_nat,
|
||||
GetCurrentProcess (), &ptys_from_master_nat,
|
||||
0, 0, DUPLICATE_SAME_ACCESS);
|
||||
ptys_input_available_event =
|
||||
ptys_primary->get_input_available_event ();
|
||||
@ -700,7 +700,7 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
|
||||
{
|
||||
WaitForSingleObject (ptys_input_mutex, INFINITE);
|
||||
fhandler_pty_slave::transfer_input (tty::to_nat,
|
||||
ptys_primary->get_handle_cyg (),
|
||||
ptys_primary->get_handle (),
|
||||
ptys_ttyp, ptys_input_available_event);
|
||||
ReleaseMutex (ptys_input_mutex);
|
||||
}
|
||||
@ -993,11 +993,11 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
|
||||
{
|
||||
WaitForSingleObject (ptys_input_mutex, INFINITE);
|
||||
fhandler_pty_slave::transfer_input (tty::to_cyg,
|
||||
ptys_from_master, ptys_ttyp,
|
||||
ptys_from_master_nat, ptys_ttyp,
|
||||
ptys_input_available_event);
|
||||
ReleaseMutex (ptys_input_mutex);
|
||||
}
|
||||
CloseHandle (ptys_from_master);
|
||||
CloseHandle (ptys_from_master_nat);
|
||||
CloseHandle (ptys_input_mutex);
|
||||
CloseHandle (ptys_input_available_event);
|
||||
WaitForSingleObject (ptys_pcon_mutex, INFINITE);
|
||||
@ -1030,11 +1030,11 @@ child_info_spawn::worker (const char *prog_arg, const char *const *argv,
|
||||
{
|
||||
WaitForSingleObject (ptys_input_mutex, INFINITE);
|
||||
fhandler_pty_slave::transfer_input (tty::to_cyg,
|
||||
ptys_from_master, ptys_ttyp,
|
||||
ptys_from_master_nat, ptys_ttyp,
|
||||
ptys_input_available_event);
|
||||
ReleaseMutex (ptys_input_mutex);
|
||||
}
|
||||
CloseHandle (ptys_from_master);
|
||||
CloseHandle (ptys_from_master_nat);
|
||||
CloseHandle (ptys_input_mutex);
|
||||
CloseHandle (ptys_input_available_event);
|
||||
WaitForSingleObject (ptys_pcon_mutex, INFINITE);
|
||||
|
||||
@ -319,7 +319,7 @@ tty_min::setpgid (int pid)
|
||||
{
|
||||
WaitForSingleObject (ptys->input_mutex, INFINITE);
|
||||
fhandler_pty_slave::transfer_input (tty::to_nat,
|
||||
ptys->get_handle_cyg (), ttyp,
|
||||
ptys->get_handle (), ttyp,
|
||||
ptys->get_input_available_event ());
|
||||
ReleaseMutex (ptys->input_mutex);
|
||||
}
|
||||
@ -334,7 +334,7 @@ tty_min::setpgid (int pid)
|
||||
if (p)
|
||||
pcon_winpid = p->exec_dwProcessId ?: p->dwProcessId;
|
||||
}
|
||||
HANDLE from = ptys->get_handle ();
|
||||
HANDLE from = ptys->get_handle_nat ();
|
||||
if (ttyp->pcon_activated && pcon_winpid
|
||||
&& !ptys->get_console_process_id (pcon_winpid, true))
|
||||
{
|
||||
|
||||
@ -103,12 +103,12 @@ public:
|
||||
};
|
||||
|
||||
private:
|
||||
HANDLE _from_master_nat;
|
||||
HANDLE _from_master;
|
||||
HANDLE _from_master_cyg;
|
||||
HANDLE _to_master_nat;
|
||||
HANDLE _to_master;
|
||||
HANDLE _to_master_cyg;
|
||||
HANDLE _to_slave_nat;
|
||||
HANDLE _to_slave;
|
||||
HANDLE _to_slave_cyg;
|
||||
bool pcon_activated;
|
||||
bool pcon_start;
|
||||
pid_t pcon_start_pid;
|
||||
@ -134,18 +134,18 @@ private:
|
||||
bool discard_input;
|
||||
|
||||
public:
|
||||
HANDLE from_master_nat () const { return _from_master_nat; }
|
||||
HANDLE from_master () const { return _from_master; }
|
||||
HANDLE from_master_cyg () const { return _from_master_cyg; }
|
||||
HANDLE to_master_nat () const { return _to_master_nat; }
|
||||
HANDLE to_master () const { return _to_master; }
|
||||
HANDLE to_master_cyg () const { return _to_master_cyg; }
|
||||
HANDLE to_slave_nat () const { return _to_slave_nat; }
|
||||
HANDLE to_slave () const { return _to_slave; }
|
||||
HANDLE to_slave_cyg () const { return _to_slave_cyg; }
|
||||
void set_from_master_nat (HANDLE h) { _from_master_nat = h; }
|
||||
void set_from_master (HANDLE h) { _from_master = h; }
|
||||
void set_from_master_cyg (HANDLE h) { _from_master_cyg = h; }
|
||||
void set_to_master_nat (HANDLE h) { _to_master_nat = h; }
|
||||
void set_to_master (HANDLE h) { _to_master = h; }
|
||||
void set_to_master_cyg (HANDLE h) { _to_master_cyg = h; }
|
||||
void set_to_slave_nat (HANDLE h) { _to_slave_nat = h; }
|
||||
void set_to_slave (HANDLE h) { _to_slave = h; }
|
||||
void set_to_slave_cyg (HANDLE h) { _to_slave_cyg = h; }
|
||||
|
||||
int read_retval;
|
||||
bool was_opened; /* True if opened at least once. */
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user