3674 lines
98 KiB
C++
3674 lines
98 KiB
C++
/* fhandler_tty.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 <sys/param.h>
|
|
#include <cygwin/acl.h>
|
|
#include <cygwin/kd.h>
|
|
#include "cygerrno.h"
|
|
#include "security.h"
|
|
#include "path.h"
|
|
#include "fhandler.h"
|
|
#include "dtable.h"
|
|
#include "sigproc.h"
|
|
#include "pinfo.h"
|
|
#include "ntdll.h"
|
|
#include "cygheap.h"
|
|
#include "shared_info.h"
|
|
#include "cygthread.h"
|
|
#include "child_info.h"
|
|
#include <asm/socket.h>
|
|
#include "cygwait.h"
|
|
#include "tls_pbuf.h"
|
|
|
|
#define ALWAYS_USE_PCON false
|
|
#define USE_API_HOOK true
|
|
#define USE_OWN_NLS_FUNC true
|
|
|
|
#if !USE_OWN_NLS_FUNC
|
|
#include "langinfo.h"
|
|
#endif
|
|
|
|
/* Not yet defined in Mingw-w64 */
|
|
#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
|
|
#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
|
|
#endif /* ENABLE_VIRTUAL_TERMINAL_PROCESSING */
|
|
#ifndef DISABLE_NEWLINE_AUTO_RETURN
|
|
#define DISABLE_NEWLINE_AUTO_RETURN 0x0008
|
|
#endif /* DISABLE_NEWLINE_AUTO_RETURN */
|
|
#ifndef PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE
|
|
#define PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE 0x00020016
|
|
#endif /* PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE */
|
|
#ifndef ENABLE_VIRTUAL_TERMINAL_INPUT
|
|
#define ENABLE_VIRTUAL_TERMINAL_INPUT 0x0200
|
|
#endif /* ENABLE_VIRTUAL_TERMINAL_INPUT */
|
|
|
|
extern "C" int sscanf (const char *, const char *, ...);
|
|
extern "C" int ttyname_r(int, char*, size_t);
|
|
|
|
#define close_maybe(h) \
|
|
do { \
|
|
if (h && h != INVALID_HANDLE_VALUE) \
|
|
CloseHandle (h); \
|
|
} while (0)
|
|
|
|
/* pty master control pipe messages */
|
|
struct pipe_request {
|
|
DWORD pid;
|
|
};
|
|
|
|
struct pipe_reply {
|
|
HANDLE from_master;
|
|
HANDLE from_master_cyg;
|
|
HANDLE to_master;
|
|
HANDLE to_master_cyg;
|
|
DWORD error;
|
|
};
|
|
|
|
static int pcon_attached_to = -1;
|
|
static bool isHybrid;
|
|
|
|
#if USE_API_HOOK
|
|
static void
|
|
set_switch_to_pcon (void)
|
|
{
|
|
cygheap_fdenum cfd (false);
|
|
while (cfd.next () >= 0)
|
|
if (cfd->get_major () == DEV_PTYS_MAJOR)
|
|
{
|
|
fhandler_base *fh = cfd;
|
|
fhandler_pty_slave *ptys = (fhandler_pty_slave *) fh;
|
|
ptys->set_switch_to_pcon ();
|
|
}
|
|
}
|
|
|
|
static void
|
|
force_attach_to_pcon (HANDLE h)
|
|
{
|
|
bool attach_done = false;
|
|
for (int n = 0; n < 2; n ++)
|
|
{
|
|
/* First time, attach to the pty whose handle value is match.
|
|
Second time, try to attach to any pty. */
|
|
cygheap_fdenum cfd (false);
|
|
while (cfd.next () >= 0)
|
|
if (cfd->get_major () == DEV_PTYS_MAJOR)
|
|
{
|
|
fhandler_base *fh = cfd;
|
|
fhandler_pty_slave *ptys = (fhandler_pty_slave *) fh;
|
|
if (n != 0
|
|
|| h == ptys->get_handle ()
|
|
|| h == ptys->get_output_handle ())
|
|
{
|
|
if (fhandler_console::get_console_process_id
|
|
(ptys->getHelperProcessId (), true))
|
|
attach_done = true;
|
|
else
|
|
{
|
|
FreeConsole ();
|
|
if (AttachConsole (ptys->getHelperProcessId ()))
|
|
{
|
|
pcon_attached_to = ptys->get_minor ();
|
|
attach_done = true;
|
|
}
|
|
else
|
|
pcon_attached_to = -1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (attach_done)
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
set_ishybrid_and_switch_to_pcon (HANDLE h)
|
|
{
|
|
if (GetFileType (h) == FILE_TYPE_CHAR)
|
|
{
|
|
force_attach_to_pcon (h);
|
|
DWORD dummy;
|
|
if (!isHybrid && (GetConsoleMode (h, &dummy)
|
|
|| GetLastError () != ERROR_INVALID_HANDLE))
|
|
{
|
|
isHybrid = true;
|
|
set_switch_to_pcon ();
|
|
}
|
|
}
|
|
}
|
|
|
|
#define DEF_HOOK(name) static __typeof__ (name) *name##_Orig
|
|
DEF_HOOK (WriteFile);
|
|
DEF_HOOK (WriteConsoleA);
|
|
DEF_HOOK (WriteConsoleW);
|
|
DEF_HOOK (ReadFile);
|
|
DEF_HOOK (ReadConsoleA);
|
|
DEF_HOOK (ReadConsoleW);
|
|
DEF_HOOK (WriteConsoleOutputA);
|
|
DEF_HOOK (WriteConsoleOutputW);
|
|
DEF_HOOK (WriteConsoleOutputCharacterA);
|
|
DEF_HOOK (WriteConsoleOutputCharacterW);
|
|
DEF_HOOK (WriteConsoleOutputAttribute);
|
|
DEF_HOOK (SetConsoleCursorPosition);
|
|
DEF_HOOK (SetConsoleTextAttribute);
|
|
DEF_HOOK (WriteConsoleInputA);
|
|
DEF_HOOK (WriteConsoleInputW);
|
|
DEF_HOOK (ReadConsoleInputA);
|
|
DEF_HOOK (ReadConsoleInputW);
|
|
DEF_HOOK (PeekConsoleInputA);
|
|
DEF_HOOK (PeekConsoleInputW);
|
|
|
|
static BOOL WINAPI
|
|
WriteFile_Hooked
|
|
(HANDLE h, LPCVOID p, DWORD l, LPDWORD n, LPOVERLAPPED o)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return WriteFile_Orig (h, p, l, n, o);
|
|
}
|
|
static BOOL WINAPI
|
|
WriteConsoleA_Hooked
|
|
(HANDLE h, LPCVOID p, DWORD l, LPDWORD n, LPVOID o)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return WriteConsoleA_Orig (h, p, l, n, o);
|
|
}
|
|
static BOOL WINAPI
|
|
WriteConsoleW_Hooked
|
|
(HANDLE h, LPCVOID p, DWORD l, LPDWORD n, LPVOID o)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return WriteConsoleW_Orig (h, p, l, n, o);
|
|
}
|
|
static BOOL WINAPI
|
|
ReadFile_Hooked
|
|
(HANDLE h, LPVOID p, DWORD l, LPDWORD n, LPOVERLAPPED o)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return ReadFile_Orig (h, p, l, n, o);
|
|
}
|
|
static BOOL WINAPI
|
|
ReadConsoleA_Hooked
|
|
(HANDLE h, LPVOID p, DWORD l, LPDWORD n, LPVOID o)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return ReadConsoleA_Orig (h, p, l, n, o);
|
|
}
|
|
static BOOL WINAPI
|
|
ReadConsoleW_Hooked
|
|
(HANDLE h, LPVOID p, DWORD l, LPDWORD n, LPVOID o)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return ReadConsoleW_Orig (h, p, l, n, o);
|
|
}
|
|
static BOOL WINAPI
|
|
WriteConsoleOutputA_Hooked
|
|
(HANDLE h, CONST CHAR_INFO *p, COORD s, COORD c, PSMALL_RECT r)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return WriteConsoleOutputA_Orig (h, p, s, c, r);
|
|
}
|
|
static BOOL WINAPI
|
|
WriteConsoleOutputW_Hooked
|
|
(HANDLE h, CONST CHAR_INFO *p, COORD s, COORD c, PSMALL_RECT r)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return WriteConsoleOutputW_Orig (h, p, s, c, r);
|
|
}
|
|
static BOOL WINAPI
|
|
WriteConsoleOutputCharacterA_Hooked
|
|
(HANDLE h, LPCSTR p, DWORD l, COORD c, LPDWORD n)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return WriteConsoleOutputCharacterA_Orig (h, p, l, c, n);
|
|
}
|
|
static BOOL WINAPI
|
|
WriteConsoleOutputCharacterW_Hooked
|
|
(HANDLE h, LPCWSTR p, DWORD l, COORD c, LPDWORD n)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return WriteConsoleOutputCharacterW_Orig (h, p, l, c, n);
|
|
}
|
|
static BOOL WINAPI
|
|
WriteConsoleOutputAttribute_Hooked
|
|
(HANDLE h, CONST WORD *a, DWORD l, COORD c, LPDWORD n)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return WriteConsoleOutputAttribute_Orig (h, a, l, c, n);
|
|
}
|
|
static BOOL WINAPI
|
|
SetConsoleCursorPosition_Hooked
|
|
(HANDLE h, COORD c)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return SetConsoleCursorPosition_Orig (h, c);
|
|
}
|
|
static BOOL WINAPI
|
|
SetConsoleTextAttribute_Hooked
|
|
(HANDLE h, WORD a)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return SetConsoleTextAttribute_Orig (h, a);
|
|
}
|
|
static BOOL WINAPI
|
|
WriteConsoleInputA_Hooked
|
|
(HANDLE h, CONST INPUT_RECORD *r, DWORD l, LPDWORD n)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return WriteConsoleInputA_Orig (h, r, l, n);
|
|
}
|
|
static BOOL WINAPI
|
|
WriteConsoleInputW_Hooked
|
|
(HANDLE h, CONST INPUT_RECORD *r, DWORD l, LPDWORD n)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return WriteConsoleInputW_Orig (h, r, l, n);
|
|
}
|
|
static BOOL WINAPI
|
|
ReadConsoleInputA_Hooked
|
|
(HANDLE h, PINPUT_RECORD r, DWORD l, LPDWORD n)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return ReadConsoleInputA_Orig (h, r, l, n);
|
|
}
|
|
static BOOL WINAPI
|
|
ReadConsoleInputW_Hooked
|
|
(HANDLE h, PINPUT_RECORD r, DWORD l, LPDWORD n)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return ReadConsoleInputW_Orig (h, r, l, n);
|
|
}
|
|
static BOOL WINAPI
|
|
PeekConsoleInputA_Hooked
|
|
(HANDLE h, PINPUT_RECORD r, DWORD l, LPDWORD n)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return PeekConsoleInputA_Orig (h, r, l, n);
|
|
}
|
|
static BOOL WINAPI
|
|
PeekConsoleInputW_Hooked
|
|
(HANDLE h, PINPUT_RECORD r, DWORD l, LPDWORD n)
|
|
{
|
|
set_ishybrid_and_switch_to_pcon (h);
|
|
return PeekConsoleInputW_Orig (h, r, l, n);
|
|
}
|
|
#else /* USE_API_HOOK */
|
|
#define WriteFile_Orig 0
|
|
#define ReadFile_Orig 0
|
|
#define PeekConsoleInputA_Orig 0
|
|
void set_ishybrid_and_switch_to_pcon (void) {}
|
|
#endif /* USE_API_HOOK */
|
|
|
|
bool
|
|
bytes_available (DWORD& n, HANDLE h)
|
|
{
|
|
DWORD navail, nleft;
|
|
navail = nleft = 0;
|
|
bool succeeded = PeekNamedPipe (h, NULL, 0, NULL, &navail, &nleft);
|
|
if (succeeded)
|
|
/* nleft should always be the right choice unless something has written 0
|
|
bytes to the pipe. In that pathological case we return the actual number
|
|
of bytes available in the pipe. See cgf-000008 for more details. */
|
|
n = nleft ?: navail;
|
|
else
|
|
{
|
|
termios_printf ("PeekNamedPipe(%p) failed, %E", h);
|
|
n = 0;
|
|
}
|
|
debug_only_printf ("n %u, nleft %u, navail %u", n, nleft, navail);
|
|
return succeeded;
|
|
}
|
|
|
|
bool
|
|
fhandler_pty_common::bytes_available (DWORD &n)
|
|
{
|
|
return ::bytes_available (n, get_handle_cyg ());
|
|
}
|
|
|
|
#ifdef DEBUGGING
|
|
static class mutex_stack
|
|
{
|
|
public:
|
|
const char *fn;
|
|
int ln;
|
|
const char *tname;
|
|
} ostack[100];
|
|
|
|
static int osi;
|
|
#endif /*DEBUGGING*/
|
|
|
|
void
|
|
fhandler_pty_master::flush_to_slave ()
|
|
{
|
|
if (get_readahead_valid () && !(get_ttyp ()->ti.c_lflag & ICANON))
|
|
accept_input ();
|
|
}
|
|
|
|
DWORD
|
|
fhandler_pty_common::__acquire_output_mutex (const char *fn, int ln,
|
|
DWORD ms)
|
|
{
|
|
if (strace.active ())
|
|
strace.prntf (_STRACE_TERMIOS, fn, "(%d): pty output_mutex (%p): waiting %d ms", ln, output_mutex, ms);
|
|
if (ms == INFINITE)
|
|
ms = 100;
|
|
DWORD res = WaitForSingleObject (output_mutex, ms);
|
|
if (res == WAIT_OBJECT_0)
|
|
{
|
|
#ifndef DEBUGGING
|
|
if (strace.active ())
|
|
strace.prntf (_STRACE_TERMIOS, fn, "(%d): pty output_mutex: acquired", ln, res);
|
|
#else
|
|
ostack[osi].fn = fn;
|
|
ostack[osi].ln = ln;
|
|
ostack[osi].tname = mythreadname ();
|
|
termios_printf ("acquired for %s:%d, osi %d", fn, ln, osi);
|
|
osi++;
|
|
#endif
|
|
}
|
|
return res;
|
|
}
|
|
|
|
void
|
|
fhandler_pty_common::__release_output_mutex (const char *fn, int ln)
|
|
{
|
|
if (ReleaseMutex (output_mutex))
|
|
{
|
|
#ifndef DEBUGGING
|
|
if (strace.active ())
|
|
strace.prntf (_STRACE_TERMIOS, fn, "(%d): pty output_mutex(%p) released", ln, output_mutex);
|
|
#else
|
|
if (osi > 0)
|
|
osi--;
|
|
termios_printf ("released(%p) at %s:%d, osi %d", output_mutex, fn, ln, osi);
|
|
termios_printf (" for %s:%d (%s)", ostack[osi].fn, ostack[osi].ln, ostack[osi].tname);
|
|
ostack[osi].ln = -ln;
|
|
#endif
|
|
}
|
|
#ifdef DEBUGGING
|
|
else if (osi > 0)
|
|
{
|
|
system_printf ("couldn't release output mutex but we seem to own it, %E");
|
|
try_to_debug ();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/* Process pty input. */
|
|
|
|
void
|
|
fhandler_pty_master::doecho (const void *str, DWORD len)
|
|
{
|
|
ssize_t towrite = len;
|
|
acquire_output_mutex (INFINITE);
|
|
if (!process_opost_output (echo_w, str, towrite, true))
|
|
termios_printf ("Write to echo pipe failed, %E");
|
|
release_output_mutex ();
|
|
}
|
|
|
|
int
|
|
fhandler_pty_master::accept_input ()
|
|
{
|
|
DWORD bytes_left;
|
|
int ret = 1;
|
|
|
|
WaitForSingleObject (input_mutex, INFINITE);
|
|
|
|
bytes_left = eat_readahead (-1);
|
|
|
|
if (!bytes_left)
|
|
{
|
|
termios_printf ("sending EOF to slave");
|
|
get_ttyp ()->read_retval = 0;
|
|
}
|
|
else
|
|
{
|
|
char *p = rabuf;
|
|
DWORD rc;
|
|
DWORD written = 0;
|
|
|
|
paranoid_printf ("about to write %u chars to slave", bytes_left);
|
|
rc = WriteFile (get_output_handle (), p, bytes_left, &written, NULL);
|
|
if (!rc)
|
|
{
|
|
debug_printf ("error writing to pipe %p %E", get_output_handle ());
|
|
get_ttyp ()->read_retval = -1;
|
|
ret = -1;
|
|
}
|
|
else
|
|
{
|
|
get_ttyp ()->read_retval = 1;
|
|
p += written;
|
|
bytes_left -= written;
|
|
if (bytes_left > 0)
|
|
{
|
|
debug_printf ("to_slave pipe is full");
|
|
puts_readahead (p, bytes_left);
|
|
ret = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
SetEvent (input_available_event);
|
|
ReleaseMutex (input_mutex);
|
|
return ret;
|
|
}
|
|
|
|
bool
|
|
fhandler_pty_master::hit_eof ()
|
|
{
|
|
if (get_ttyp ()->was_opened && !get_ttyp ()->slave_alive ())
|
|
{
|
|
/* We have the only remaining open handle to this pty, and
|
|
the slave pty has been opened at least once. We treat
|
|
this as EOF. */
|
|
termios_printf ("all other handles closed");
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Process pty output requests */
|
|
|
|
int
|
|
fhandler_pty_master::process_slave_output (char *buf, size_t len, int pktmode_on)
|
|
{
|
|
size_t rlen;
|
|
char outbuf[OUT_BUFFER_SIZE];
|
|
DWORD n;
|
|
DWORD echo_cnt;
|
|
int rc = 0;
|
|
|
|
flush_to_slave ();
|
|
|
|
if (len == 0)
|
|
goto out;
|
|
|
|
for (;;)
|
|
{
|
|
n = echo_cnt = 0;
|
|
for (;;)
|
|
{
|
|
/* Check echo pipe first. */
|
|
if (::bytes_available (echo_cnt, echo_r) && echo_cnt > 0)
|
|
break;
|
|
if (!bytes_available (n))
|
|
goto err;
|
|
if (n)
|
|
break;
|
|
if (hit_eof ())
|
|
{
|
|
set_errno (EIO);
|
|
rc = -1;
|
|
goto out;
|
|
}
|
|
/* DISCARD (FLUSHO) and tcflush can finish here. */
|
|
if ((get_ttyp ()->ti.c_lflag & FLUSHO || !buf))
|
|
goto out;
|
|
|
|
if (is_nonblocking ())
|
|
{
|
|
set_errno (EAGAIN);
|
|
rc = -1;
|
|
goto out;
|
|
}
|
|
pthread_testcancel ();
|
|
if (cygwait (NULL, 10, cw_sig_eintr) == WAIT_SIGNALED
|
|
&& !_my_tls.call_signal_handler ())
|
|
{
|
|
set_errno (EINTR);
|
|
rc = -1;
|
|
goto out;
|
|
}
|
|
flush_to_slave ();
|
|
}
|
|
|
|
/* Set RLEN to the number of bytes to read from the pipe. */
|
|
rlen = len;
|
|
|
|
char *optr;
|
|
optr = buf;
|
|
if (pktmode_on && buf)
|
|
{
|
|
*optr++ = TIOCPKT_DATA;
|
|
rlen -= 1;
|
|
}
|
|
|
|
if (rlen == 0)
|
|
{
|
|
rc = optr - buf;
|
|
goto out;
|
|
}
|
|
|
|
if (rlen > sizeof outbuf)
|
|
rlen = sizeof outbuf;
|
|
|
|
/* If echo pipe has data (something has been typed or pasted), prefer
|
|
it over slave output. */
|
|
if (echo_cnt > 0)
|
|
{
|
|
if (!ReadFile (echo_r, outbuf, rlen, &n, NULL))
|
|
{
|
|
termios_printf ("ReadFile on echo pipe failed, %E");
|
|
goto err;
|
|
}
|
|
}
|
|
else if (!ReadFile (get_handle (), outbuf, rlen, &n, NULL))
|
|
{
|
|
termios_printf ("ReadFile failed, %E");
|
|
goto err;
|
|
}
|
|
|
|
termios_printf ("bytes read %u", n);
|
|
|
|
if (get_ttyp ()->ti.c_lflag & FLUSHO || !buf)
|
|
continue;
|
|
|
|
memcpy (optr, outbuf, n);
|
|
optr += n;
|
|
rc = optr - buf;
|
|
break;
|
|
|
|
err:
|
|
if (GetLastError () == ERROR_BROKEN_PIPE)
|
|
rc = 0;
|
|
else
|
|
{
|
|
__seterrno ();
|
|
rc = -1;
|
|
}
|
|
break;
|
|
}
|
|
|
|
out:
|
|
termios_printf ("returning %d", rc);
|
|
return rc;
|
|
}
|
|
|
|
/* pty slave stuff */
|
|
|
|
fhandler_pty_slave::fhandler_pty_slave (int unit)
|
|
: fhandler_pty_common (), inuse (NULL), output_handle_cyg (NULL),
|
|
io_handle_cyg (NULL), pid_restore (0)
|
|
{
|
|
if (unit >= 0)
|
|
dev ().parse (DEV_PTYS_MAJOR, unit);
|
|
}
|
|
|
|
fhandler_pty_slave::~fhandler_pty_slave ()
|
|
{
|
|
if (!get_ttyp ())
|
|
/* Why comes here? Who clears _tc? */
|
|
return;
|
|
if (getPseudoConsole ())
|
|
{
|
|
int used = 0;
|
|
int attached = 0;
|
|
cygheap_fdenum cfd (false);
|
|
while (cfd.next () >= 0)
|
|
{
|
|
if (cfd->get_major () == DEV_PTYS_MAJOR ||
|
|
cfd->get_major () == DEV_CONS_MAJOR)
|
|
used ++;
|
|
if (cfd->get_major () == DEV_PTYS_MAJOR &&
|
|
cfd->get_minor () == pcon_attached_to)
|
|
attached ++;
|
|
}
|
|
|
|
/* Call FreeConsole() if no tty is opened and the process
|
|
is attached to console corresponding to tty. This is
|
|
needed to make GNU screen and tmux work in Windows 10
|
|
1903. */
|
|
if (attached == 0)
|
|
pcon_attached_to = -1;
|
|
if (used == 0)
|
|
{
|
|
init_console_handler (false);
|
|
FreeConsole ();
|
|
}
|
|
}
|
|
}
|
|
|
|
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 *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,
|
|
NULL
|
|
};
|
|
|
|
for (HANDLE **h = handles; *h; h++)
|
|
**h = NULL;
|
|
|
|
_tc = cygwin_shared->tty[get_minor ()];
|
|
|
|
tcinit (false);
|
|
|
|
cygwin_shared->tty.attach (get_minor ());
|
|
|
|
/* Create synchronisation events */
|
|
char buf[MAX_PATH];
|
|
|
|
const char *errmsg = NULL;
|
|
|
|
if (!(output_mutex = get_ttyp ()->open_output_mutex (MAXIMUM_ALLOWED)))
|
|
{
|
|
errmsg = "open output mutex failed, %E";
|
|
goto err;
|
|
}
|
|
if (!(input_mutex = get_ttyp ()->open_input_mutex (MAXIMUM_ALLOWED)))
|
|
{
|
|
errmsg = "open input mutex failed, %E";
|
|
goto err;
|
|
}
|
|
shared_name (buf, INPUT_AVAILABLE_EVENT, get_minor ());
|
|
if (!(input_available_event = OpenEvent (MAXIMUM_ALLOWED, TRUE, buf)))
|
|
{
|
|
errmsg = "open input event failed, %E";
|
|
goto err;
|
|
}
|
|
|
|
/* FIXME: Needs a method to eliminate tty races */
|
|
{
|
|
/* Create security attribute. Default permissions are 0620. */
|
|
security_descriptor sd;
|
|
sd.malloc (sizeof (SECURITY_DESCRIPTOR));
|
|
RtlCreateSecurityDescriptor (sd, SECURITY_DESCRIPTOR_REVISION);
|
|
SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE };
|
|
if (!create_object_sd_from_attribute (myself->uid, myself->gid,
|
|
S_IFCHR | S_IRUSR | S_IWUSR | S_IWGRP,
|
|
sd))
|
|
sa.lpSecurityDescriptor = (PSECURITY_DESCRIPTOR) sd;
|
|
acquire_output_mutex (INFINITE);
|
|
inuse = get_ttyp ()->create_inuse (&sa);
|
|
get_ttyp ()->was_opened = true;
|
|
release_output_mutex ();
|
|
}
|
|
|
|
if (!get_ttyp ()->from_master () || !get_ttyp ()->from_master_cyg () ||
|
|
!get_ttyp ()->to_master () || !get_ttyp ()->to_master_cyg ())
|
|
{
|
|
errmsg = "pty handles have been closed";
|
|
set_errno (EACCES);
|
|
goto err_no_errno;
|
|
}
|
|
|
|
/* Three case for duplicating the pipe handles:
|
|
- Either we're the master. In this case, just duplicate the handles.
|
|
- Or, we have the right to open the master process for handle duplication.
|
|
In this case, just duplicate the handles.
|
|
- Or, we have to ask the master process itself. In this case, send our
|
|
pid to the master process and check the reply. The reply contains
|
|
either the handles, or an error code which tells us why we didn't
|
|
get the handles. */
|
|
if (myself->pid == get_ttyp ()->master_pid)
|
|
{
|
|
/* This is the most common case, just calling openpty. */
|
|
termios_printf ("dup handles within myself.");
|
|
pty_owner = GetCurrentProcess ();
|
|
}
|
|
else
|
|
{
|
|
pinfo p (get_ttyp ()->master_pid);
|
|
if (!p)
|
|
termios_printf ("*** couldn't find pty master");
|
|
else
|
|
{
|
|
pty_owner = OpenProcess (PROCESS_DUP_HANDLE, FALSE, p->dwProcessId);
|
|
if (pty_owner)
|
|
termios_printf ("dup handles directly since I'm the owner");
|
|
}
|
|
}
|
|
if (pty_owner)
|
|
{
|
|
if (!DuplicateHandle (pty_owner, get_ttyp ()->from_master (),
|
|
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 ());
|
|
__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,
|
|
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,
|
|
DUPLICATE_SAME_ACCESS))
|
|
{
|
|
errmsg = "can't duplicate output for cygwin, %E";
|
|
goto err;
|
|
}
|
|
if (pty_owner != GetCurrentProcess ())
|
|
CloseHandle (pty_owner);
|
|
}
|
|
else
|
|
{
|
|
pipe_request req = { GetCurrentProcessId () };
|
|
pipe_reply repl;
|
|
DWORD len;
|
|
|
|
__small_sprintf (buf, "\\\\.\\pipe\\cygwin-%S-pty%d-master-ctl",
|
|
&cygheap->installation_key, get_minor ());
|
|
termios_printf ("dup handles via master control pipe %s", buf);
|
|
if (!CallNamedPipe (buf, &req, sizeof req, &repl, sizeof repl,
|
|
&len, 500))
|
|
{
|
|
errmsg = "can't call master, %E";
|
|
goto err;
|
|
}
|
|
from_master_local = repl.from_master;
|
|
from_master_cyg_local = repl.from_master_cyg;
|
|
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)
|
|
{
|
|
SetLastError (repl.error);
|
|
errmsg = "error duplicating pipes, %E";
|
|
goto err;
|
|
}
|
|
}
|
|
VerifyHandle (from_master_local);
|
|
VerifyHandle (from_master_cyg_local);
|
|
VerifyHandle (to_master_local);
|
|
VerifyHandle (to_master_cyg_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 %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 (from_master_local);
|
|
set_handle_cyg (from_master_cyg_local);
|
|
set_output_handle (to_master_local);
|
|
set_output_handle_cyg (to_master_cyg_local);
|
|
|
|
if (!getPseudoConsole ())
|
|
{
|
|
fhandler_console::need_invisible ();
|
|
pcon_attached_to = -1;
|
|
}
|
|
else if (!fhandler_console::get_console_process_id
|
|
(GetCurrentProcessId (), true))
|
|
{
|
|
fhandler_console::need_invisible ();
|
|
pcon_attached_to = -1;
|
|
}
|
|
else if (fhandler_console::get_console_process_id
|
|
(getHelperProcessId (), true))
|
|
/* Attached to pcon of this pty */
|
|
{
|
|
pcon_attached_to = get_minor ();
|
|
init_console_handler (true);
|
|
}
|
|
else if (pcon_attached_to < 0)
|
|
fhandler_console::need_invisible ();
|
|
|
|
set_open_status ();
|
|
return 1;
|
|
|
|
err:
|
|
if (GetLastError () == ERROR_FILE_NOT_FOUND)
|
|
set_errno (ENXIO);
|
|
else
|
|
__seterrno ();
|
|
err_no_errno:
|
|
termios_printf (errmsg);
|
|
err_no_msg:
|
|
for (HANDLE **h = handles; *h; h++)
|
|
if (**h && **h != INVALID_HANDLE_VALUE)
|
|
CloseHandle (**h);
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
fhandler_pty_slave::open_setup (int flags)
|
|
{
|
|
set_flags ((flags & ~O_TEXT) | O_BINARY);
|
|
myself->set_ctty (this, flags);
|
|
report_tty_counts (this, "opened", "");
|
|
fhandler_base::open_setup (flags);
|
|
}
|
|
|
|
void
|
|
fhandler_pty_slave::cleanup ()
|
|
{
|
|
/* This used to always call fhandler_pty_common::close when we were execing
|
|
but that caused multiple closes of the handles associated with this pty.
|
|
Since close_all_files is not called until after the cygwin process has
|
|
synced or before a non-cygwin process has exited, it should be safe to
|
|
just close this normally. cgf 2006-05-20 */
|
|
report_tty_counts (this, "closed", "");
|
|
fhandler_base::cleanup ();
|
|
}
|
|
|
|
int
|
|
fhandler_pty_slave::close ()
|
|
{
|
|
termios_printf ("closing last open %s handle", ttyname ());
|
|
if (inuse && !CloseHandle (inuse))
|
|
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 (!getPseudoConsole () &&
|
|
(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 ();
|
|
if (!ForceCloseHandle (output_mutex))
|
|
termios_printf ("CloseHandle (output_mutex<%p>), %E", output_mutex);
|
|
if (pcon_attached_to == get_minor ())
|
|
get_ttyp ()->num_pcon_attached_slaves --;
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fhandler_pty_slave::init (HANDLE h, DWORD a, mode_t)
|
|
{
|
|
int flags = 0;
|
|
|
|
a &= GENERIC_READ | GENERIC_WRITE;
|
|
if (a == GENERIC_READ)
|
|
flags = O_RDONLY;
|
|
if (a == GENERIC_WRITE)
|
|
flags = O_WRONLY;
|
|
if (a == (GENERIC_READ | GENERIC_WRITE))
|
|
flags = O_RDWR;
|
|
|
|
int ret = open_with_arch (flags);
|
|
|
|
if (ret && !cygwin_finished_initializing && !being_debugged ())
|
|
{
|
|
/* This only occurs when called from dtable::init_std_file_from_handle
|
|
We have been started from a non-Cygwin process. So we should become
|
|
pty process group leader.
|
|
TODO: Investigate how SIGTTIN should be handled with pure-windows
|
|
programs. */
|
|
pinfo p (tc ()->getpgid ());
|
|
/* We should only grab this when the process group owner for this
|
|
pty is a non-cygwin process or we've been started directly
|
|
from a non-Cygwin process with no Cygwin ancestry. */
|
|
if (!p || ISSTATE (p, PID_NOTCYGWIN))
|
|
{
|
|
termios_printf ("Setting process group leader to %d since %W(%d) is not a cygwin process",
|
|
myself->pgid, p->progname, p->pid);
|
|
tc ()->setpgid (myself->pgid);
|
|
}
|
|
}
|
|
|
|
if (h != INVALID_HANDLE_VALUE)
|
|
CloseHandle (h); /* Reopened by open */
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool
|
|
fhandler_pty_slave::try_reattach_pcon (void)
|
|
{
|
|
pid_restore = 0;
|
|
|
|
/* Do not detach from the console because re-attaching will
|
|
fail if helper process is running as service account. */
|
|
if (pcon_attached_to >= 0 &&
|
|
cygwin_shared->tty[pcon_attached_to]->attach_pcon_in_fork)
|
|
return false;
|
|
|
|
pid_restore =
|
|
fhandler_console::get_console_process_id (GetCurrentProcessId (),
|
|
false);
|
|
/* If pid_restore is not set, give up. */
|
|
if (!pid_restore)
|
|
return false;
|
|
|
|
FreeConsole ();
|
|
if (!AttachConsole (getHelperProcessId ()))
|
|
{
|
|
system_printf ("pty%d: AttachConsole(helper=%d) failed. 0x%08lx",
|
|
get_minor (), getHelperProcessId (), GetLastError ());
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void
|
|
fhandler_pty_slave::restore_reattach_pcon (void)
|
|
{
|
|
if (pid_restore)
|
|
{
|
|
FreeConsole ();
|
|
if (!AttachConsole (pid_restore))
|
|
{
|
|
system_printf ("pty%d: AttachConsole(restore=%d) failed. 0x%08lx",
|
|
get_minor (), pid_restore, GetLastError ());
|
|
pcon_attached_to = -1;
|
|
}
|
|
}
|
|
pid_restore = 0;
|
|
}
|
|
|
|
void
|
|
fhandler_pty_slave::set_switch_to_pcon (void)
|
|
{
|
|
if (!isHybrid)
|
|
{
|
|
reset_switch_to_pcon ();
|
|
return;
|
|
}
|
|
if (!get_ttyp ()->switch_to_pcon)
|
|
{
|
|
pid_restore = 0;
|
|
if (pcon_attached_to != get_minor ())
|
|
if (!try_reattach_pcon ())
|
|
goto skip_console_setting;
|
|
FlushConsoleInputBuffer (get_handle ());
|
|
DWORD mode;
|
|
GetConsoleMode (get_handle (), &mode);
|
|
SetConsoleMode (get_handle (), mode | ENABLE_ECHO_INPUT);
|
|
skip_console_setting:
|
|
restore_reattach_pcon ();
|
|
Sleep (20);
|
|
if (get_ttyp ()->pcon_pid == 0 ||
|
|
kill (get_ttyp ()->pcon_pid, 0) != 0)
|
|
get_ttyp ()->pcon_pid = myself->pid;
|
|
get_ttyp ()->switch_to_pcon = true;
|
|
}
|
|
}
|
|
|
|
void
|
|
fhandler_pty_slave::reset_switch_to_pcon (void)
|
|
{
|
|
if (get_ttyp ()->need_clear_screen)
|
|
{
|
|
const char *term = getenv ("TERM");
|
|
if (term && strcmp (term, "dumb") && !strstr (term, "emacs"))
|
|
{
|
|
/* FIXME: Clearing sequence may not be "^[[H^[[J"
|
|
depending on the terminal type. */
|
|
DWORD n;
|
|
WriteFile (get_output_handle_cyg (), "\033[H\033[J", 6, &n, NULL);
|
|
}
|
|
get_ttyp ()->need_clear_screen = false;
|
|
}
|
|
|
|
if (ALWAYS_USE_PCON)
|
|
return;
|
|
if (isHybrid)
|
|
{
|
|
this->set_switch_to_pcon ();
|
|
return;
|
|
}
|
|
if (get_ttyp ()->pcon_pid &&
|
|
get_ttyp ()->pcon_pid != myself->pid &&
|
|
kill (get_ttyp ()->pcon_pid, 0) == 0)
|
|
/* There is a process which is grabbing pseudo console. */
|
|
return;
|
|
if (get_ttyp ()->switch_to_pcon &&
|
|
get_ttyp ()->pcon_pid != myself->pid)
|
|
{
|
|
DWORD mode;
|
|
GetConsoleMode (get_handle (), &mode);
|
|
SetConsoleMode (get_handle (), mode & ~ENABLE_ECHO_INPUT);
|
|
Sleep (20); /* Wait for pty_master_fwd_thread() */
|
|
}
|
|
get_ttyp ()->pcon_pid = 0;
|
|
get_ttyp ()->switch_to_pcon = false;
|
|
}
|
|
|
|
void
|
|
fhandler_pty_slave::push_to_pcon_screenbuffer (const char *ptr, size_t len)
|
|
{
|
|
bool attached =
|
|
!!fhandler_console::get_console_process_id (getHelperProcessId (), true);
|
|
if (!attached && pcon_attached_to == get_minor ())
|
|
{
|
|
for (DWORD t0 = GetTickCount (); GetTickCount () - t0 < 100; )
|
|
{
|
|
Sleep (1);
|
|
attached = fhandler_console::get_console_process_id
|
|
(getHelperProcessId (), true);
|
|
if (attached)
|
|
break;
|
|
}
|
|
if (!attached)
|
|
{
|
|
system_printf ("pty%d: pcon_attach_to mismatch??????", get_minor ());
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* If not attached to this pseudo console, try to attach temporarily. */
|
|
pid_restore = 0;
|
|
if (pcon_attached_to != get_minor ())
|
|
if (!try_reattach_pcon ())
|
|
goto detach;
|
|
|
|
char *buf;
|
|
size_t nlen;
|
|
DWORD origCP;
|
|
origCP = GetConsoleOutputCP ();
|
|
SetConsoleOutputCP (get_ttyp ()->TermCodePage);
|
|
/* Just copy */
|
|
buf = (char *) HeapAlloc (GetProcessHeap (), 0, len);
|
|
memcpy (buf, (char *)ptr, len);
|
|
nlen = len;
|
|
char *p0, *p1;
|
|
p0 = p1 = buf;
|
|
/* Remove alternate screen buffer drawing */
|
|
while (p0 && p1)
|
|
{
|
|
if (!get_ttyp ()->screen_alternated)
|
|
{
|
|
/* Check switching to alternate screen buffer */
|
|
p0 = (char *) memmem (p1, nlen - (p1-buf), "\033[?1049h", 8);
|
|
if (p0)
|
|
{
|
|
//p0 += 8;
|
|
get_ttyp ()->screen_alternated = true;
|
|
}
|
|
}
|
|
if (get_ttyp ()->screen_alternated)
|
|
{
|
|
/* Check switching to main screen buffer */
|
|
p1 = (char *) memmem (p0, nlen - (p0-buf), "\033[?1049l", 8);
|
|
if (p1)
|
|
{
|
|
p1 += 8;
|
|
get_ttyp ()->screen_alternated = false;
|
|
memmove (p0, p1, buf+nlen - p1);
|
|
nlen -= p1 - p0;
|
|
}
|
|
else
|
|
nlen = p0 - buf;
|
|
}
|
|
}
|
|
if (!nlen) /* Nothing to be synchronized */
|
|
goto cleanup;
|
|
if (get_ttyp ()->switch_to_pcon)
|
|
goto cleanup;
|
|
/* Remove ESC sequence which returns results to console
|
|
input buffer. Without this, cursor position report
|
|
is put into the input buffer as a garbage. */
|
|
/* Remove ESC sequence to report cursor position. */
|
|
while ((p0 = (char *) memmem (buf, nlen, "\033[6n", 4)))
|
|
{
|
|
memmove (p0, p0+4, nlen - (p0+4 - buf));
|
|
nlen -= 4;
|
|
}
|
|
/* Remove ESC sequence to report terminal identity. */
|
|
while ((p0 = (char *) memmem (buf, nlen, "\033[0c", 4)))
|
|
{
|
|
memmove (p0, p0+4, nlen - (p0+4 - buf));
|
|
nlen -= 4;
|
|
}
|
|
DWORD dwMode, flags;
|
|
flags = ENABLE_VIRTUAL_TERMINAL_PROCESSING;
|
|
GetConsoleMode (get_output_handle (), &dwMode);
|
|
if (!(get_ttyp ()->ti.c_oflag & OPOST) ||
|
|
!(get_ttyp ()->ti.c_oflag & ONLCR))
|
|
flags |= DISABLE_NEWLINE_AUTO_RETURN;
|
|
SetConsoleMode (get_output_handle (), dwMode | flags);
|
|
char *p;
|
|
p = buf;
|
|
DWORD wLen, written;
|
|
written = 0;
|
|
int retry_count;
|
|
retry_count = 0;
|
|
BOOL (WINAPI *WriteFunc)
|
|
(HANDLE, LPCVOID, DWORD, LPDWORD, LPOVERLAPPED);
|
|
WriteFunc = WriteFile_Orig ? WriteFile_Orig : WriteFile;
|
|
while (written < nlen)
|
|
{
|
|
if (!WriteFunc (get_output_handle (), p, nlen - written, &wLen, NULL))
|
|
{
|
|
termios_printf ("WriteFile failed, %E");
|
|
this->open (0, 0); /* Re-open handles */
|
|
/* Fix pseudo console window size */
|
|
struct winsize win;
|
|
this->ioctl (TIOCGWINSZ, &win);
|
|
this->ioctl (TIOCSWINSZ, &win);
|
|
if (++retry_count > 3)
|
|
break;
|
|
}
|
|
written += wLen;
|
|
p += wLen;
|
|
}
|
|
/* Detach from pseudo console and resume. */
|
|
SetConsoleMode (get_output_handle (), dwMode);
|
|
cleanup:
|
|
SetConsoleOutputCP (origCP);
|
|
HeapFree (GetProcessHeap (), 0, buf);
|
|
detach:
|
|
restore_reattach_pcon ();
|
|
}
|
|
|
|
ssize_t __stdcall
|
|
fhandler_pty_slave::write (const void *ptr, size_t len)
|
|
{
|
|
ssize_t towrite = len;
|
|
|
|
bg_check_types bg = bg_check (SIGTTOU);
|
|
if (bg <= bg_eof)
|
|
return (ssize_t) bg;
|
|
|
|
termios_printf ("pty%d, write(%p, %lu)", get_minor (), ptr, len);
|
|
|
|
push_process_state process_state (PID_TTYOU);
|
|
|
|
reset_switch_to_pcon ();
|
|
|
|
char *buf;
|
|
ssize_t nlen;
|
|
UINT targetCodePage = get_ttyp ()->switch_to_pcon ?
|
|
GetConsoleOutputCP () : get_ttyp ()->TermCodePage;
|
|
if (targetCodePage != get_ttyp ()->TermCodePage)
|
|
{
|
|
size_t wlen =
|
|
MultiByteToWideChar (get_ttyp ()->TermCodePage, 0,
|
|
(char *)ptr, len, NULL, 0);
|
|
wchar_t *wbuf = (wchar_t *)
|
|
HeapAlloc (GetProcessHeap (), 0, wlen * sizeof (wchar_t));
|
|
wlen =
|
|
MultiByteToWideChar (get_ttyp ()->TermCodePage, 0,
|
|
(char *)ptr, len, wbuf, wlen);
|
|
nlen = WideCharToMultiByte (targetCodePage, 0,
|
|
wbuf, wlen, NULL, 0, NULL, NULL);
|
|
buf = (char *) HeapAlloc (GetProcessHeap (), 0, nlen);
|
|
nlen = WideCharToMultiByte (targetCodePage, 0,
|
|
wbuf, wlen, buf, nlen, NULL, NULL);
|
|
HeapFree (GetProcessHeap (), 0, wbuf);
|
|
}
|
|
else
|
|
{
|
|
/* Just copy */
|
|
buf = (char *) HeapAlloc (GetProcessHeap (), 0, len);
|
|
memcpy (buf, (char *)ptr, len);
|
|
nlen = len;
|
|
}
|
|
|
|
/* If not attached to this pseudo console, try to attach temporarily. */
|
|
pid_restore = 0;
|
|
bool fallback = false;
|
|
if (get_ttyp ()->switch_to_pcon && pcon_attached_to != get_minor ())
|
|
if (!try_reattach_pcon ())
|
|
fallback = true;
|
|
|
|
DWORD dwMode, flags;
|
|
flags = ENABLE_VIRTUAL_TERMINAL_PROCESSING;
|
|
if (!(get_ttyp ()->ti.c_oflag & OPOST) ||
|
|
!(get_ttyp ()->ti.c_oflag & ONLCR))
|
|
flags |= DISABLE_NEWLINE_AUTO_RETURN;
|
|
if (get_ttyp ()->switch_to_pcon && !fallback)
|
|
{
|
|
GetConsoleMode (get_output_handle (), &dwMode);
|
|
SetConsoleMode (get_output_handle (), dwMode | flags);
|
|
}
|
|
HANDLE to = (get_ttyp ()->switch_to_pcon && !fallback) ?
|
|
get_output_handle () : get_output_handle_cyg ();
|
|
acquire_output_mutex (INFINITE);
|
|
if (!process_opost_output (to, buf, nlen, false))
|
|
{
|
|
DWORD err = GetLastError ();
|
|
termios_printf ("WriteFile failed, %E");
|
|
switch (err)
|
|
{
|
|
case ERROR_NO_DATA:
|
|
err = ERROR_IO_DEVICE;
|
|
/*FALLTHRU*/
|
|
default:
|
|
__seterrno_from_win_error (err);
|
|
}
|
|
towrite = -1;
|
|
}
|
|
release_output_mutex ();
|
|
HeapFree (GetProcessHeap (), 0, buf);
|
|
flags = ENABLE_VIRTUAL_TERMINAL_PROCESSING;
|
|
if (get_ttyp ()->switch_to_pcon && !fallback)
|
|
SetConsoleMode (get_output_handle (), dwMode);
|
|
|
|
restore_reattach_pcon ();
|
|
|
|
/* Push slave output to pseudo console screen buffer */
|
|
if (getPseudoConsole ())
|
|
{
|
|
acquire_output_mutex (INFINITE);
|
|
push_to_pcon_screenbuffer ((char *)ptr, len);
|
|
release_output_mutex ();
|
|
}
|
|
|
|
return towrite;
|
|
}
|
|
|
|
bool
|
|
fhandler_pty_common::to_be_read_from_pcon (void)
|
|
{
|
|
return get_ttyp ()->switch_to_pcon &&
|
|
(!get_ttyp ()->mask_switch_to_pcon || ALWAYS_USE_PCON);
|
|
}
|
|
|
|
void __reg3
|
|
fhandler_pty_slave::read (void *ptr, size_t& len)
|
|
{
|
|
char *ptr0 = (char *)ptr;
|
|
ssize_t totalread = 0;
|
|
int vmin = 0;
|
|
int vtime = 0; /* Initialized to prevent -Wuninitialized warning */
|
|
size_t readlen;
|
|
DWORD bytes_in_pipe;
|
|
char buf[INP_BUFFER_SIZE];
|
|
DWORD time_to_wait;
|
|
|
|
bg_check_types bg = bg_check (SIGTTIN);
|
|
if (bg <= bg_eof)
|
|
{
|
|
len = (size_t) bg;
|
|
return;
|
|
}
|
|
|
|
termios_printf ("read(%p, %lu) handle %p", ptr, len, get_handle_cyg ());
|
|
|
|
push_process_state process_state (PID_TTYIN);
|
|
|
|
if (ptr) /* Indicating not tcflush(). */
|
|
{
|
|
reset_switch_to_pcon ();
|
|
if (get_ttyp ()->pcon_pid != myself->pid)
|
|
mask_switch_to_pcon (true);
|
|
}
|
|
|
|
if (is_nonblocking () || !ptr) /* Indicating tcflush(). */
|
|
time_to_wait = 0;
|
|
else if ((get_ttyp ()->ti.c_lflag & ICANON))
|
|
time_to_wait = INFINITE;
|
|
else
|
|
{
|
|
vmin = get_ttyp ()->ti.c_cc[VMIN];
|
|
if (vmin > INP_BUFFER_SIZE)
|
|
vmin = INP_BUFFER_SIZE;
|
|
vtime = get_ttyp ()->ti.c_cc[VTIME];
|
|
if (vmin < 0)
|
|
vmin = 0;
|
|
if (vtime < 0)
|
|
vtime = 0;
|
|
if (!vmin && !vtime)
|
|
time_to_wait = 0;
|
|
else
|
|
time_to_wait = !vtime ? INFINITE : 100 * vtime;
|
|
}
|
|
|
|
while (len)
|
|
{
|
|
switch (cygwait (input_available_event, time_to_wait))
|
|
{
|
|
case WAIT_OBJECT_0:
|
|
break;
|
|
case WAIT_SIGNALED:
|
|
if (totalread > 0)
|
|
goto out;
|
|
termios_printf ("wait catched signal");
|
|
set_sig_errno (EINTR);
|
|
totalread = -1;
|
|
goto out;
|
|
case WAIT_CANCELED:
|
|
process_state.pop ();
|
|
pthread::static_cancel_self ();
|
|
/*NOTREACHED*/
|
|
case WAIT_TIMEOUT:
|
|
termios_printf ("wait timed out, time_to_wait %u", time_to_wait);
|
|
/* No error condition when called from tcflush. */
|
|
if (!totalread && ptr)
|
|
{
|
|
set_sig_errno (EAGAIN);
|
|
totalread = -1;
|
|
}
|
|
goto out;
|
|
default:
|
|
termios_printf ("wait for input event failed, %E");
|
|
if (!totalread)
|
|
{
|
|
__seterrno ();
|
|
totalread = -1;
|
|
}
|
|
goto out;
|
|
}
|
|
/* Now that we know that input is available we have to grab the
|
|
input mutex. */
|
|
switch (cygwait (input_mutex, 1000))
|
|
{
|
|
case WAIT_OBJECT_0:
|
|
case WAIT_ABANDONED_0:
|
|
break;
|
|
case WAIT_SIGNALED:
|
|
if (totalread > 0)
|
|
goto out;
|
|
termios_printf ("wait for mutex caught signal");
|
|
set_sig_errno (EINTR);
|
|
totalread = -1;
|
|
goto out;
|
|
case WAIT_CANCELED:
|
|
process_state.pop ();
|
|
pthread::static_cancel_self ();
|
|
/*NOTREACHED*/
|
|
case WAIT_TIMEOUT:
|
|
termios_printf ("failed to acquire input mutex after input event "
|
|
"arrived");
|
|
/* If we have a timeout, we can simply handle this failure to
|
|
grab the mutex as an EAGAIN situation. Otherwise, if this
|
|
is an infinitely blocking read, restart the loop. */
|
|
if (time_to_wait != INFINITE)
|
|
{
|
|
if (!totalread)
|
|
{
|
|
set_sig_errno (EAGAIN);
|
|
totalread = -1;
|
|
}
|
|
goto out;
|
|
}
|
|
continue;
|
|
default:
|
|
termios_printf ("wait for input mutex failed, %E");
|
|
if (!totalread)
|
|
{
|
|
__seterrno ();
|
|
totalread = -1;
|
|
}
|
|
goto out;
|
|
}
|
|
if (to_be_read_from_pcon ())
|
|
{
|
|
if (!try_reattach_pcon ())
|
|
{
|
|
restore_reattach_pcon ();
|
|
goto do_read_cyg;
|
|
}
|
|
|
|
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))
|
|
{
|
|
termios_printf ("read failed, %E");
|
|
ReleaseMutex (input_mutex);
|
|
set_errno (EIO);
|
|
totalread = -1;
|
|
goto out;
|
|
}
|
|
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 ();
|
|
mask_switch_to_pcon (false);
|
|
return;
|
|
}
|
|
|
|
do_read_cyg:
|
|
if (!bytes_available (bytes_in_pipe))
|
|
{
|
|
ReleaseMutex (input_mutex);
|
|
set_errno (EIO);
|
|
totalread = -1;
|
|
goto out;
|
|
}
|
|
|
|
if (ptr && !bytes_in_pipe && !vmin && !time_to_wait)
|
|
{
|
|
ReleaseMutex (input_mutex);
|
|
mask_switch_to_pcon (false);
|
|
len = (size_t) bytes_in_pipe;
|
|
return;
|
|
}
|
|
|
|
readlen = bytes_in_pipe ? MIN (len, sizeof (buf)) : 0;
|
|
if (get_ttyp ()->ti.c_lflag & ICANON && ptr)
|
|
readlen = MIN (bytes_in_pipe, readlen);
|
|
|
|
#if 0
|
|
/* Why on earth is the read length reduced to vmin, even if more bytes
|
|
are available *and* len is bigger *and* the local buf is big enough?
|
|
Disable this code for now, it looks like a remnant of old. */
|
|
if (ptr && vmin && readlen > (unsigned) vmin)
|
|
readlen = vmin;
|
|
#endif
|
|
|
|
DWORD n = 0;
|
|
if (readlen)
|
|
{
|
|
termios_printf ("reading %lu bytes (vtime %d)", readlen, vtime);
|
|
if (!ReadFile (get_handle_cyg (), buf, readlen, &n, NULL))
|
|
{
|
|
termios_printf ("read failed, %E");
|
|
ReleaseMutex (input_mutex);
|
|
set_errno (EIO);
|
|
totalread = -1;
|
|
goto out;
|
|
}
|
|
else
|
|
{
|
|
/* MSDN states that 5th prameter can be used to determine total
|
|
number of bytes in pipe, but for some reason this number doesn't
|
|
change after successful read. So we have to peek into the pipe
|
|
again to see if input is still available */
|
|
if (!bytes_available (bytes_in_pipe))
|
|
{
|
|
ReleaseMutex (input_mutex);
|
|
set_errno (EIO);
|
|
totalread = -1;
|
|
goto out;
|
|
}
|
|
if (n)
|
|
{
|
|
if (!(!ptr && len == UINT_MAX)) /* not tcflush() */
|
|
len -= n;
|
|
totalread += n;
|
|
if (ptr)
|
|
{
|
|
memcpy (ptr, buf, n);
|
|
ptr = (char *) ptr + n;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bytes_in_pipe)
|
|
ResetEvent (input_available_event);
|
|
|
|
ReleaseMutex (input_mutex);
|
|
|
|
if (!ptr)
|
|
{
|
|
if (!bytes_in_pipe)
|
|
break;
|
|
continue;
|
|
}
|
|
|
|
if (get_ttyp ()->read_retval < 0) // read error
|
|
{
|
|
set_errno (-get_ttyp ()->read_retval);
|
|
totalread = -1;
|
|
break;
|
|
}
|
|
if (get_ttyp ()->read_retval == 0) //EOF
|
|
{
|
|
termios_printf ("saw EOF");
|
|
break;
|
|
}
|
|
if (get_ttyp ()->ti.c_lflag & ICANON || is_nonblocking ())
|
|
break;
|
|
if (vmin && totalread >= vmin)
|
|
break;
|
|
|
|
/* vmin == 0 && vtime == 0:
|
|
* we've already read all input, if any, so return immediately
|
|
* vmin == 0 && vtime > 0:
|
|
* we've waited for input 10*vtime ms in WFSO(input_available_event),
|
|
* no matter whether any input arrived, we shouldn't wait any longer,
|
|
* so return immediately
|
|
* vmin > 0 && vtime == 0:
|
|
* here, totalread < vmin, so continue waiting until more data
|
|
* arrive
|
|
* vmin > 0 && vtime > 0:
|
|
* similar to the previous here, totalread < vmin, and timer
|
|
* hadn't expired -- WFSO(input_available_event) != WAIT_TIMEOUT,
|
|
* so "restart timer" and wait until more data arrive
|
|
*/
|
|
|
|
if (vmin == 0)
|
|
break;
|
|
}
|
|
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 (getPseudoConsole () && ptr0 && (get_ttyp ()->ti.c_lflag & ECHO))
|
|
{
|
|
acquire_output_mutex (INFINITE);
|
|
push_to_pcon_screenbuffer (ptr0, len);
|
|
release_output_mutex ();
|
|
}
|
|
mask_switch_to_pcon (false);
|
|
}
|
|
|
|
int
|
|
fhandler_pty_slave::dup (fhandler_base *child, int flags)
|
|
{
|
|
/* This code was added in Oct 2001 for some undisclosed reason.
|
|
However, setting the controlling tty on a dup causes rxvt to
|
|
hang when the parent does a dup since the controlling pgid changes.
|
|
Specifically testing for -2 (ctty has been setsid'ed) works around
|
|
this problem. However, it's difficult to see scenarios in which you
|
|
have a dup'able fd, no controlling tty, and not having run setsid.
|
|
So, we might want to consider getting rid of the set_ctty in tty-like dup
|
|
methods entirely at some point */
|
|
if (myself->ctty != -2)
|
|
myself->set_ctty (this, flags);
|
|
report_tty_counts (child, "duped slave", "");
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fhandler_pty_master::dup (fhandler_base *child, int)
|
|
{
|
|
report_tty_counts (child, "duped master", "");
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fhandler_pty_slave::tcgetattr (struct termios *t)
|
|
{
|
|
reset_switch_to_pcon ();
|
|
*t = get_ttyp ()->ti;
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fhandler_pty_slave::tcsetattr (int, const struct termios *t)
|
|
{
|
|
reset_switch_to_pcon ();
|
|
acquire_output_mutex (INFINITE);
|
|
get_ttyp ()->ti = *t;
|
|
release_output_mutex ();
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fhandler_pty_slave::tcflush (int queue)
|
|
{
|
|
int ret = 0;
|
|
|
|
termios_printf ("tcflush(%d) handle %p", queue, get_handle_cyg ());
|
|
|
|
reset_switch_to_pcon ();
|
|
|
|
if (queue == TCIFLUSH || queue == TCIOFLUSH)
|
|
{
|
|
size_t len = UINT_MAX;
|
|
read (NULL, len);
|
|
ret = ((int) len) >= 0 ? 0 : -1;
|
|
}
|
|
if (queue == TCOFLUSH || queue == TCIOFLUSH)
|
|
{
|
|
/* do nothing for now. */
|
|
}
|
|
|
|
termios_printf ("%d=tcflush(%d)", ret, queue);
|
|
return ret;
|
|
}
|
|
|
|
int
|
|
fhandler_pty_slave::ioctl (unsigned int cmd, void *arg)
|
|
{
|
|
termios_printf ("ioctl (%x)", cmd);
|
|
reset_switch_to_pcon ();
|
|
int res = fhandler_termios::ioctl (cmd, arg);
|
|
if (res <= 0)
|
|
return res;
|
|
|
|
if (myself->pgid && get_ttyp ()->getpgid () != myself->pgid
|
|
&& (unsigned) myself->ctty == FHDEV (DEV_PTYS_MAJOR, get_minor ())
|
|
&& (get_ttyp ()->ti.c_lflag & TOSTOP))
|
|
{
|
|
/* background process */
|
|
termios_printf ("bg ioctl pgid %d, tpgid %d, %s", myself->pgid,
|
|
get_ttyp ()->getpgid (), myctty ());
|
|
raise (SIGTTOU);
|
|
}
|
|
|
|
int retval;
|
|
switch (cmd)
|
|
{
|
|
case TIOCGWINSZ:
|
|
case TIOCSWINSZ:
|
|
break;
|
|
case TIOCGPGRP:
|
|
{
|
|
pid_t pid = this->tcgetpgrp ();
|
|
if (pid < 0)
|
|
retval = -1;
|
|
else
|
|
{
|
|
*((pid_t *) arg) = pid;
|
|
retval = 0;
|
|
}
|
|
}
|
|
goto out;
|
|
case TIOCSPGRP:
|
|
retval = this->tcsetpgrp ((pid_t) (intptr_t) arg);
|
|
goto out;
|
|
case FIONREAD:
|
|
{
|
|
DWORD n;
|
|
if (!bytes_available (n))
|
|
{
|
|
set_errno (EINVAL);
|
|
retval = -1;
|
|
}
|
|
else
|
|
{
|
|
*(int *) arg = (int) n;
|
|
retval = 0;
|
|
}
|
|
}
|
|
goto out;
|
|
default:
|
|
return fhandler_base::ioctl (cmd, arg);
|
|
}
|
|
|
|
acquire_output_mutex (INFINITE);
|
|
|
|
get_ttyp ()->cmd = cmd;
|
|
get_ttyp ()->ioctl_retval = 0;
|
|
switch (cmd)
|
|
{
|
|
case TIOCGWINSZ:
|
|
get_ttyp ()->arg.winsize = get_ttyp ()->winsize;
|
|
*(struct winsize *) arg = get_ttyp ()->arg.winsize;
|
|
get_ttyp ()->winsize = get_ttyp ()->arg.winsize;
|
|
break;
|
|
case TIOCSWINSZ:
|
|
if (getPseudoConsole ())
|
|
{
|
|
/* If not attached to this pseudo console,
|
|
try to attach temporarily. */
|
|
pid_restore = 0;
|
|
if (pcon_attached_to != get_minor ())
|
|
if (!try_reattach_pcon ())
|
|
goto cleanup;
|
|
|
|
COORD size;
|
|
size.X = ((struct winsize *) arg)->ws_col;
|
|
size.Y = ((struct winsize *) arg)->ws_row;
|
|
CONSOLE_SCREEN_BUFFER_INFO csbi;
|
|
if (GetConsoleScreenBufferInfo (get_output_handle (), &csbi))
|
|
if (size.X == csbi.srWindow.Right - csbi.srWindow.Left + 1 &&
|
|
size.Y == csbi.srWindow.Bottom - csbi.srWindow.Top + 1)
|
|
goto cleanup;
|
|
if (!SetConsoleScreenBufferSize (get_output_handle (), size))
|
|
goto cleanup;
|
|
SMALL_RECT rect;
|
|
rect.Left = 0;
|
|
rect.Top = 0;
|
|
rect.Right = size.X-1;
|
|
rect.Bottom = size.Y-1;
|
|
SetConsoleWindowInfo (get_output_handle (), TRUE, &rect);
|
|
cleanup:
|
|
restore_reattach_pcon ();
|
|
}
|
|
|
|
if (get_ttyp ()->winsize.ws_row != ((struct winsize *) arg)->ws_row
|
|
|| get_ttyp ()->winsize.ws_col != ((struct winsize *) arg)->ws_col)
|
|
{
|
|
get_ttyp ()->arg.winsize = *(struct winsize *) arg;
|
|
get_ttyp ()->winsize = *(struct winsize *) arg;
|
|
get_ttyp ()->kill_pgrp (SIGWINCH);
|
|
}
|
|
break;
|
|
}
|
|
|
|
release_output_mutex ();
|
|
retval = get_ttyp ()->ioctl_retval;
|
|
if (retval < 0)
|
|
{
|
|
set_errno (-retval);
|
|
retval = -1;
|
|
}
|
|
|
|
out:
|
|
termios_printf ("%d = ioctl(%x)", retval, cmd);
|
|
return retval;
|
|
}
|
|
|
|
int __reg2
|
|
fhandler_pty_slave::fstat (struct stat *st)
|
|
{
|
|
fhandler_base::fstat (st);
|
|
|
|
bool to_close = false;
|
|
if (!input_available_event)
|
|
{
|
|
char buf[MAX_PATH];
|
|
shared_name (buf, INPUT_AVAILABLE_EVENT, get_minor ());
|
|
input_available_event = OpenEvent (READ_CONTROL, TRUE, buf);
|
|
if (input_available_event)
|
|
to_close = true;
|
|
}
|
|
st->st_mode = S_IFCHR;
|
|
if (!input_available_event
|
|
|| get_object_attribute (input_available_event, &st->st_uid, &st->st_gid,
|
|
&st->st_mode))
|
|
{
|
|
/* If we can't access the ACL, or if the tty doesn't actually exist,
|
|
then fake uid and gid to strict, system-like values. */
|
|
st->st_mode = S_IFCHR | S_IRUSR | S_IWUSR;
|
|
st->st_uid = 18;
|
|
st->st_gid = 544;
|
|
}
|
|
if (to_close)
|
|
CloseHandle (input_available_event);
|
|
return 0;
|
|
}
|
|
|
|
int __reg3
|
|
fhandler_pty_slave::facl (int cmd, int nentries, aclent_t *aclbufp)
|
|
{
|
|
int res = -1;
|
|
bool to_close = false;
|
|
security_descriptor sd;
|
|
mode_t attr = S_IFCHR;
|
|
|
|
switch (cmd)
|
|
{
|
|
case SETACL:
|
|
if (!aclsort32 (nentries, 0, aclbufp))
|
|
set_errno (ENOTSUP);
|
|
break;
|
|
case GETACL:
|
|
if (!aclbufp)
|
|
{
|
|
set_errno (EFAULT);
|
|
break;
|
|
}
|
|
/*FALLTHRU*/
|
|
case GETACLCNT:
|
|
if (!input_available_event)
|
|
{
|
|
char buf[MAX_PATH];
|
|
shared_name (buf, INPUT_AVAILABLE_EVENT, get_minor ());
|
|
input_available_event = OpenEvent (READ_CONTROL, TRUE, buf);
|
|
if (input_available_event)
|
|
to_close = true;
|
|
}
|
|
if (!input_available_event
|
|
|| get_object_sd (input_available_event, sd))
|
|
{
|
|
res = get_posix_access (NULL, &attr, NULL, NULL, aclbufp, nentries);
|
|
if (aclbufp && res == MIN_ACL_ENTRIES)
|
|
{
|
|
aclbufp[0].a_perm = S_IROTH | S_IWOTH;
|
|
aclbufp[0].a_id = 18;
|
|
aclbufp[1].a_id = 544;
|
|
}
|
|
break;
|
|
}
|
|
if (cmd == GETACL)
|
|
res = get_posix_access (sd, &attr, NULL, NULL, aclbufp, nentries);
|
|
else
|
|
res = get_posix_access (sd, &attr, NULL, NULL, NULL, 0);
|
|
break;
|
|
default:
|
|
set_errno (EINVAL);
|
|
break;
|
|
}
|
|
if (to_close)
|
|
CloseHandle (input_available_event);
|
|
return res;
|
|
}
|
|
|
|
/* Helper function for fchmod and fchown, which just opens all handles
|
|
and signals success via bool return. */
|
|
bool
|
|
fhandler_pty_slave::fch_open_handles (bool chown)
|
|
{
|
|
char buf[MAX_PATH];
|
|
DWORD write_access = WRITE_DAC | (chown ? WRITE_OWNER : 0);
|
|
|
|
_tc = cygwin_shared->tty[get_minor ()];
|
|
shared_name (buf, INPUT_AVAILABLE_EVENT, get_minor ());
|
|
input_available_event = OpenEvent (READ_CONTROL | write_access,
|
|
TRUE, buf);
|
|
output_mutex = get_ttyp ()->open_output_mutex (write_access);
|
|
input_mutex = get_ttyp ()->open_input_mutex (write_access);
|
|
inuse = get_ttyp ()->open_inuse (write_access);
|
|
if (!input_available_event || !output_mutex || !input_mutex || !inuse)
|
|
{
|
|
__seterrno ();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* Helper function for fchmod and fchown, which sets the new security
|
|
descriptor on all objects representing the pty. */
|
|
int
|
|
fhandler_pty_slave::fch_set_sd (security_descriptor &sd, bool chown)
|
|
{
|
|
security_descriptor sd_old;
|
|
|
|
get_object_sd (input_available_event, sd_old);
|
|
if (!set_object_sd (input_available_event, sd, chown)
|
|
&& !set_object_sd (output_mutex, sd, chown)
|
|
&& !set_object_sd (input_mutex, sd, chown)
|
|
&& !set_object_sd (inuse, sd, chown))
|
|
return 0;
|
|
set_object_sd (input_available_event, sd_old, chown);
|
|
set_object_sd (output_mutex, sd_old, chown);
|
|
set_object_sd (input_mutex, sd_old, chown);
|
|
set_object_sd (inuse, sd_old, chown);
|
|
return -1;
|
|
}
|
|
|
|
/* Helper function for fchmod and fchown, which closes all object handles in
|
|
the pty. */
|
|
void
|
|
fhandler_pty_slave::fch_close_handles ()
|
|
{
|
|
close_maybe (input_available_event);
|
|
close_maybe (output_mutex);
|
|
close_maybe (input_mutex);
|
|
close_maybe (inuse);
|
|
}
|
|
|
|
int __reg1
|
|
fhandler_pty_slave::fchmod (mode_t mode)
|
|
{
|
|
int ret = -1;
|
|
bool to_close = false;
|
|
security_descriptor sd;
|
|
uid_t uid;
|
|
gid_t gid;
|
|
mode_t orig_mode = S_IFCHR;
|
|
|
|
if (!input_available_event)
|
|
{
|
|
to_close = true;
|
|
if (!fch_open_handles (false))
|
|
goto errout;
|
|
}
|
|
sd.malloc (sizeof (SECURITY_DESCRIPTOR));
|
|
RtlCreateSecurityDescriptor (sd, SECURITY_DESCRIPTOR_REVISION);
|
|
if (!get_object_attribute (input_available_event, &uid, &gid, &orig_mode)
|
|
&& !create_object_sd_from_attribute (uid, gid, S_IFCHR | mode, sd))
|
|
ret = fch_set_sd (sd, false);
|
|
errout:
|
|
if (to_close)
|
|
fch_close_handles ();
|
|
return ret;
|
|
}
|
|
|
|
int __reg2
|
|
fhandler_pty_slave::fchown (uid_t uid, gid_t gid)
|
|
{
|
|
int ret = -1;
|
|
bool to_close = false;
|
|
security_descriptor sd;
|
|
uid_t o_uid;
|
|
gid_t o_gid;
|
|
mode_t mode = S_IFCHR;
|
|
|
|
if (uid == ILLEGAL_UID && gid == ILLEGAL_GID)
|
|
return 0;
|
|
if (!input_available_event)
|
|
{
|
|
to_close = true;
|
|
if (!fch_open_handles (true))
|
|
goto errout;
|
|
}
|
|
sd.malloc (sizeof (SECURITY_DESCRIPTOR));
|
|
RtlCreateSecurityDescriptor (sd, SECURITY_DESCRIPTOR_REVISION);
|
|
if (!get_object_attribute (input_available_event, &o_uid, &o_gid, &mode))
|
|
{
|
|
if (uid == ILLEGAL_UID)
|
|
uid = o_uid;
|
|
if (gid == ILLEGAL_GID)
|
|
gid = o_gid;
|
|
if (uid == o_uid && gid == o_gid)
|
|
ret = 0;
|
|
else if (!create_object_sd_from_attribute (uid, gid, mode, sd))
|
|
ret = fch_set_sd (sd, true);
|
|
}
|
|
errout:
|
|
if (to_close)
|
|
fch_close_handles ();
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************
|
|
fhandler_pty_master
|
|
*/
|
|
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_fwd_thread (NULL)
|
|
{
|
|
if (unit >= 0)
|
|
dev ().parse (DEV_PTYM_MAJOR, unit);
|
|
else if (!setup ())
|
|
{
|
|
dev ().parse (FH_ERROR);
|
|
return;
|
|
}
|
|
set_name ("/dev/ptmx");
|
|
}
|
|
|
|
fhandler_pty_master::~fhandler_pty_master ()
|
|
{
|
|
/* Without this wait, helper process for pseudo console
|
|
sometimes remains running after the pty session is
|
|
closed. The reason is not clear. */
|
|
if (to_master && from_master)
|
|
Sleep (20);
|
|
}
|
|
|
|
int
|
|
fhandler_pty_master::open (int flags, mode_t)
|
|
{
|
|
set_open_status ();
|
|
dwProcessId = GetCurrentProcessId ();
|
|
return 1;
|
|
}
|
|
|
|
void
|
|
fhandler_pty_master::open_setup (int flags)
|
|
{
|
|
set_flags ((flags & ~O_TEXT) | O_BINARY);
|
|
char buf[sizeof ("opened pty master for ptyNNNNNNNNNNN")];
|
|
__small_sprintf (buf, "opened pty master for pty%d", get_minor ());
|
|
report_tty_counts (this, buf, "");
|
|
fhandler_base::open_setup (flags);
|
|
}
|
|
|
|
off_t
|
|
fhandler_pty_common::lseek (off_t, int)
|
|
{
|
|
set_errno (ESPIPE);
|
|
return -1;
|
|
}
|
|
|
|
int
|
|
fhandler_pty_common::close ()
|
|
{
|
|
termios_printf ("pty%d <%p,%p> closing",
|
|
get_minor (), get_handle (), get_output_handle ());
|
|
if (!ForceCloseHandle (input_mutex))
|
|
termios_printf ("CloseHandle (input_mutex<%p>), %E", input_mutex);
|
|
if (!ForceCloseHandle1 (get_handle (), from_pty))
|
|
termios_printf ("CloseHandle (get_handle ()<%p>), %E", get_handle ());
|
|
if (!ForceCloseHandle1 (get_output_handle (), to_pty))
|
|
termios_printf ("CloseHandle (get_output_handle ()<%p>), %E",
|
|
get_output_handle ());
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
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;
|
|
fhandler_base::cleanup ();
|
|
}
|
|
|
|
int
|
|
fhandler_pty_master::close ()
|
|
{
|
|
OBJECT_BASIC_INFORMATION obi;
|
|
NTSTATUS status;
|
|
pid_t master_pid_tmp = get_ttyp ()->master_pid;
|
|
|
|
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);
|
|
if (cygwin_finished_initializing)
|
|
{
|
|
if (master_ctl && get_ttyp ()->master_pid == myself->pid)
|
|
{
|
|
char buf[MAX_PATH];
|
|
pipe_request req = { (DWORD) -1 };
|
|
pipe_reply repl;
|
|
DWORD len;
|
|
|
|
__small_sprintf (buf, "\\\\.\\pipe\\cygwin-%S-pty%d-master-ctl",
|
|
&cygheap->installation_key, get_minor ());
|
|
acquire_output_mutex (INFINITE);
|
|
if (master_ctl)
|
|
{
|
|
CallNamedPipe (buf, &req, sizeof req, &repl, sizeof repl, &len,
|
|
500);
|
|
CloseHandle (master_ctl);
|
|
master_thread->detach ();
|
|
get_ttyp ()->set_master_ctl_closed ();
|
|
master_ctl = NULL;
|
|
}
|
|
release_output_mutex ();
|
|
master_fwd_thread->terminate_thread ();
|
|
}
|
|
}
|
|
|
|
/* Check if the last master handle has been closed. If so, set
|
|
input_available_event to wake up potentially waiting slaves. */
|
|
acquire_output_mutex (INFINITE);
|
|
status = NtQueryObject (get_output_handle (), ObjectBasicInformation,
|
|
&obi, sizeof obi, NULL);
|
|
fhandler_pty_common::close ();
|
|
release_output_mutex ();
|
|
if (!ForceCloseHandle (output_mutex))
|
|
termios_printf ("CloseHandle (output_mutex<%p>), %E", output_mutex);
|
|
if (!NT_SUCCESS (status))
|
|
debug_printf ("NtQueryObject: %y", status);
|
|
else if (obi.HandleCount == (getPseudoConsole () ? 2 : 1))
|
|
/* Helper process has inherited one. */
|
|
{
|
|
termios_printf("Closing last master of pty%d", get_minor ());
|
|
/* Close Pseudo Console */
|
|
if (getPseudoConsole ())
|
|
{
|
|
/* Terminate helper process */
|
|
SetEvent (get_ttyp ()->hHelperGoodbye);
|
|
WaitForSingleObject (get_ttyp ()->hHelperProcess, INFINITE);
|
|
/* FIXME: Pseudo console can be accessed via its handle
|
|
only in the process which created it. What else can we do? */
|
|
if (master_pid_tmp == myself->pid)
|
|
{
|
|
/* Release pseudo console */
|
|
HMODULE hModule = GetModuleHandle ("kernel32.dll");
|
|
FARPROC func = GetProcAddress (hModule, "ClosePseudoConsole");
|
|
VOID (WINAPI *ClosePseudoConsole) (HPCON) = NULL;
|
|
ClosePseudoConsole = (VOID (WINAPI *) (HPCON)) func;
|
|
ClosePseudoConsole (getPseudoConsole ());
|
|
}
|
|
get_ttyp ()->switch_to_pcon = false;
|
|
}
|
|
if (get_ttyp ()->getsid () > 0)
|
|
kill (get_ttyp ()->getsid (), SIGHUP);
|
|
SetEvent (input_available_event);
|
|
}
|
|
|
|
if (!ForceCloseHandle (from_master))
|
|
termios_printf ("error closing from_master %p, %E", from_master);
|
|
if (from_master_cyg != from_master) /* Avoid double close. */
|
|
if (!ForceCloseHandle (from_master_cyg))
|
|
termios_printf ("error closing from_master_cyg %p, %E", from_master_cyg);
|
|
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;
|
|
ForceCloseHandle (echo_r);
|
|
ForceCloseHandle (echo_w);
|
|
echo_r = echo_w = NULL;
|
|
if (to_slave)
|
|
ForceCloseHandle (to_slave);
|
|
to_slave = NULL;
|
|
|
|
if (have_execed || get_ttyp ()->master_pid != myself->pid)
|
|
termios_printf ("not clearing: %d, master_pid %d",
|
|
have_execed, get_ttyp ()->master_pid);
|
|
if (!ForceCloseHandle (input_available_event))
|
|
termios_printf ("CloseHandle (input_available_event<%p>), %E",
|
|
input_available_event);
|
|
|
|
return 0;
|
|
}
|
|
|
|
ssize_t __stdcall
|
|
fhandler_pty_master::write (const void *ptr, size_t len)
|
|
{
|
|
ssize_t ret;
|
|
char *p = (char *) ptr;
|
|
termios ti = tc ()->ti;
|
|
|
|
bg_check_types bg = bg_check (SIGTTOU);
|
|
if (bg <= bg_eof)
|
|
return (ssize_t) bg;
|
|
|
|
push_process_state process_state (PID_TTYOU);
|
|
|
|
/* Write terminal input to to_slave pipe instead of output_handle
|
|
if current application is native console application. */
|
|
if (to_be_read_from_pcon ())
|
|
{
|
|
char *buf;
|
|
size_t nlen;
|
|
|
|
if (get_ttyp ()->TermCodePage != CP_UTF8)
|
|
{
|
|
size_t wlen =
|
|
MultiByteToWideChar (get_ttyp ()->TermCodePage, 0,
|
|
(char *)ptr, len, NULL, 0);
|
|
wchar_t *wbuf = (wchar_t *)
|
|
HeapAlloc (GetProcessHeap (), 0, wlen * sizeof (wchar_t));
|
|
wlen =
|
|
MultiByteToWideChar (get_ttyp ()->TermCodePage, 0,
|
|
(char *)ptr, len, wbuf, wlen);
|
|
nlen = WideCharToMultiByte (CP_UTF8, 0,
|
|
wbuf, wlen, NULL, 0, NULL, NULL);
|
|
buf = (char *) HeapAlloc (GetProcessHeap (), 0, nlen);
|
|
nlen = WideCharToMultiByte (CP_UTF8, 0,
|
|
wbuf, wlen, buf, nlen, NULL, NULL);
|
|
HeapFree (GetProcessHeap (), 0, wbuf);
|
|
}
|
|
else
|
|
{
|
|
/* Just copy */
|
|
buf = (char *) HeapAlloc (GetProcessHeap (), 0, len);
|
|
memcpy (buf, (char *)ptr, len);
|
|
nlen = len;
|
|
}
|
|
DWORD wLen;
|
|
WriteFile (to_slave, buf, nlen, &wLen, NULL);
|
|
SetEvent (input_available_event);
|
|
HeapFree (GetProcessHeap (), 0, buf);
|
|
return len;
|
|
}
|
|
|
|
line_edit_status status = line_edit (p++, len, ti, &ret);
|
|
if (status > line_edit_signalled && status != line_edit_pipe_full)
|
|
ret = -1;
|
|
return ret;
|
|
}
|
|
|
|
void __reg3
|
|
fhandler_pty_master::read (void *ptr, size_t& len)
|
|
{
|
|
bg_check_types bg = bg_check (SIGTTIN);
|
|
if (bg <= bg_eof)
|
|
{
|
|
len = (size_t) bg;
|
|
return;
|
|
}
|
|
push_process_state process_state (PID_TTYIN);
|
|
len = (size_t) process_slave_output ((char *) ptr, len, pktmode);
|
|
}
|
|
|
|
int
|
|
fhandler_pty_master::tcgetattr (struct termios *t)
|
|
{
|
|
*t = cygwin_shared->tty[get_minor ()]->ti;
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fhandler_pty_master::tcsetattr (int, const struct termios *t)
|
|
{
|
|
cygwin_shared->tty[get_minor ()]->ti = *t;
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fhandler_pty_master::tcflush (int queue)
|
|
{
|
|
int ret = 0;
|
|
|
|
termios_printf ("tcflush(%d) handle %p", queue, get_handle ());
|
|
|
|
if (queue == TCIFLUSH || queue == TCIOFLUSH)
|
|
ret = process_slave_output (NULL, OUT_BUFFER_SIZE, 0);
|
|
else if (queue == TCIFLUSH || queue == TCIOFLUSH)
|
|
{
|
|
/* do nothing for now. */
|
|
}
|
|
|
|
termios_printf ("%d=tcflush(%d)", ret, queue);
|
|
return ret;
|
|
}
|
|
|
|
int
|
|
fhandler_pty_master::ioctl (unsigned int cmd, void *arg)
|
|
{
|
|
int res = fhandler_termios::ioctl (cmd, arg);
|
|
if (res <= 0)
|
|
return res;
|
|
|
|
switch (cmd)
|
|
{
|
|
case TIOCPKT:
|
|
pktmode = *(int *) arg;
|
|
break;
|
|
case TIOCGWINSZ:
|
|
*(struct winsize *) arg = get_ttyp ()->winsize;
|
|
break;
|
|
case TIOCSWINSZ:
|
|
/* FIXME: Pseudo console can be accessed via its handle
|
|
only in the process which created it. What else can we do? */
|
|
if (getPseudoConsole () && get_ttyp ()->master_pid == myself->pid)
|
|
{
|
|
HMODULE hModule = GetModuleHandle ("kernel32.dll");
|
|
FARPROC func = GetProcAddress (hModule, "ResizePseudoConsole");
|
|
HRESULT (WINAPI *ResizePseudoConsole) (HPCON, COORD) = NULL;
|
|
ResizePseudoConsole = (HRESULT (WINAPI *) (HPCON, COORD)) func;
|
|
COORD size;
|
|
size.X = ((struct winsize *) arg)->ws_col;
|
|
size.Y = ((struct winsize *) arg)->ws_row;
|
|
ResizePseudoConsole (getPseudoConsole (), size);
|
|
}
|
|
if (get_ttyp ()->winsize.ws_row != ((struct winsize *) arg)->ws_row
|
|
|| get_ttyp ()->winsize.ws_col != ((struct winsize *) arg)->ws_col)
|
|
{
|
|
get_ttyp ()->winsize = *(struct winsize *) arg;
|
|
get_ttyp ()->kill_pgrp (SIGWINCH);
|
|
}
|
|
break;
|
|
case TIOCGPGRP:
|
|
*((pid_t *) arg) = this->tcgetpgrp ();
|
|
break;
|
|
case TIOCSPGRP:
|
|
return this->tcsetpgrp ((pid_t) (intptr_t) arg);
|
|
case FIONREAD:
|
|
{
|
|
DWORD n;
|
|
if (!bytes_available (n))
|
|
{
|
|
set_errno (EINVAL);
|
|
return -1;
|
|
}
|
|
*(int *) arg = (int) n;
|
|
}
|
|
break;
|
|
default:
|
|
return fhandler_base::ioctl (cmd, arg);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fhandler_pty_master::ptsname_r (char *buf, size_t buflen)
|
|
{
|
|
char tmpbuf[TTY_NAME_MAX];
|
|
|
|
__ptsname (tmpbuf, get_minor ());
|
|
if (buflen <= strlen (tmpbuf))
|
|
{
|
|
set_errno (ERANGE);
|
|
return ERANGE;
|
|
}
|
|
strcpy (buf, tmpbuf);
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
fhandler_pty_common::set_close_on_exec (bool val)
|
|
{
|
|
// Cygwin processes will handle this specially on exec.
|
|
close_on_exec (val);
|
|
}
|
|
|
|
/* This table is borrowed from mintty: charset.c */
|
|
static const struct {
|
|
UINT cp;
|
|
const char *name;
|
|
}
|
|
cs_names[] = {
|
|
{ CP_UTF8, "UTF-8"},
|
|
{ CP_UTF8, "UTF8"},
|
|
{ 20127, "ASCII"},
|
|
{ 20127, "US-ASCII"},
|
|
{ 20127, "ANSI_X3.4-1968"},
|
|
{ 20866, "KOI8-R"},
|
|
{ 20866, "KOI8R"},
|
|
{ 20866, "KOI8"},
|
|
{ 21866, "KOI8-U"},
|
|
{ 21866, "KOI8U"},
|
|
{ 20932, "EUCJP"},
|
|
{ 20932, "EUC-JP"},
|
|
{ 874, "TIS620"},
|
|
{ 874, "TIS-620"},
|
|
{ 932, "SJIS"},
|
|
{ 936, "GBK"},
|
|
{ 936, "GB2312"},
|
|
{ 936, "EUCCN"},
|
|
{ 936, "EUC-CN"},
|
|
{ 949, "EUCKR"},
|
|
{ 949, "EUC-KR"},
|
|
{ 950, "BIG5"},
|
|
{ 0, "NULL"}
|
|
};
|
|
|
|
static void
|
|
get_locale_from_env (char *locale)
|
|
{
|
|
const char *env = NULL;
|
|
char lang[ENCODING_LEN + 1] = {0, }, country[ENCODING_LEN + 1] = {0, };
|
|
env = getenv ("LC_ALL");
|
|
if (env == NULL || !*env)
|
|
env = getenv("LC_CTYPE");
|
|
if (env == NULL || !*env)
|
|
env = getenv("LANG");
|
|
if (env == NULL || !*env)
|
|
{
|
|
if (GetLocaleInfo (LOCALE_CUSTOM_UI_DEFAULT,
|
|
LOCALE_SISO639LANGNAME,
|
|
lang, sizeof (lang)))
|
|
GetLocaleInfo (LOCALE_CUSTOM_UI_DEFAULT,
|
|
LOCALE_SISO3166CTRYNAME,
|
|
country, sizeof (country));
|
|
else if (GetLocaleInfo (LOCALE_CUSTOM_DEFAULT,
|
|
LOCALE_SISO639LANGNAME,
|
|
lang, sizeof (lang)))
|
|
GetLocaleInfo (LOCALE_CUSTOM_DEFAULT,
|
|
LOCALE_SISO3166CTRYNAME,
|
|
country, sizeof (country));
|
|
else if (GetLocaleInfo (LOCALE_USER_DEFAULT,
|
|
LOCALE_SISO639LANGNAME,
|
|
lang, sizeof (lang)))
|
|
GetLocaleInfo (LOCALE_USER_DEFAULT,
|
|
LOCALE_SISO3166CTRYNAME,
|
|
country, sizeof (country));
|
|
else if (GetLocaleInfo (LOCALE_SYSTEM_DEFAULT,
|
|
LOCALE_SISO639LANGNAME,
|
|
lang, sizeof (lang)))
|
|
GetLocaleInfo (LOCALE_SYSTEM_DEFAULT,
|
|
LOCALE_SISO3166CTRYNAME,
|
|
country, sizeof (country));
|
|
if (strlen (lang) && strlen (country))
|
|
__small_sprintf (lang + strlen(lang), "_%s.UTF-8", country);
|
|
else
|
|
strcpy (lang , "C.UTF-8");
|
|
env = lang;
|
|
}
|
|
strcpy (locale, env);
|
|
}
|
|
|
|
#if USE_OWN_NLS_FUNC
|
|
static LCID
|
|
get_langinfo (char *locale_out, char *charset_out)
|
|
{
|
|
/* Get locale from environment */
|
|
char new_locale[ENCODING_LEN + 1];
|
|
get_locale_from_env (new_locale);
|
|
|
|
/* The following code is borrowed from __loadlocale() in
|
|
newlib/libc/locale/locale.c */
|
|
|
|
/* At this point a full-featured system would just load the locale
|
|
specific data from the locale files.
|
|
What we do here for now is to check the incoming string for correctness.
|
|
The string must be in one of the allowed locale strings, either
|
|
one in POSIX-style, or one in the old newlib style to maintain
|
|
backward compatibility. If the local string is correct, the charset
|
|
is extracted and stored in ctype_codeset or message_charset
|
|
dependent on the cateogry. */
|
|
char *locale = NULL;
|
|
char charset[ENCODING_LEN + 1];
|
|
long val = 0;
|
|
char *end, *c = NULL;
|
|
|
|
/* This additional code handles the case that the incoming locale string
|
|
is not valid. If so, it calls the function __set_locale_from_locale_alias,
|
|
which is only available on Cygwin right now. The function reads the
|
|
file /usr/share/locale/locale.alias. The file contains locale aliases
|
|
and their replacement locale. For instance, the alias "french" is
|
|
translated to "fr_FR.ISO-8859-1", the alias "thai" is translated to
|
|
"th_TH.TIS-620". If successful, the function returns with LCID
|
|
correspoding to the locale. */
|
|
char tmp_locale[ENCODING_LEN + 1];
|
|
|
|
restart:
|
|
if (!locale)
|
|
locale = new_locale;
|
|
else if (locale != tmp_locale)
|
|
{
|
|
locale = __set_locale_from_locale_alias (locale, tmp_locale);
|
|
if (!locale)
|
|
return 0;
|
|
}
|
|
# define FAIL goto restart
|
|
|
|
/* "POSIX" is translated to "C", as on Linux. */
|
|
if (!strcmp (locale, "POSIX"))
|
|
strcpy (locale, "C");
|
|
if (!strcmp (locale, "C")) /* Default "C" locale */
|
|
strcpy (charset, "ASCII");
|
|
else if (locale[0] == 'C'
|
|
&& (locale[1] == '-' /* Old newlib style */
|
|
|| locale[1] == '.')) /* Extension for the C locale to allow
|
|
specifying different charsets while
|
|
sticking to the C locale in terms
|
|
of sort order, etc. Proposed in
|
|
the Debian project. */
|
|
{
|
|
char *chp;
|
|
|
|
c = locale + 2;
|
|
strcpy (charset, c);
|
|
if ((chp = strchr (charset, '@')))
|
|
/* Strip off modifier */
|
|
*chp = '\0';
|
|
c += strlen (charset);
|
|
}
|
|
else /* POSIX style */
|
|
{
|
|
c = locale;
|
|
|
|
/* Don't use ctype macros here, they might be localized. */
|
|
/* Language */
|
|
if (c[0] < 'a' || c[0] > 'z'
|
|
|| c[1] < 'a' || c[1] > 'z')
|
|
FAIL;
|
|
c += 2;
|
|
/* Allow three character Language per ISO 639-3 */
|
|
if (c[0] >= 'a' && c[0] <= 'z')
|
|
++c;
|
|
if (c[0] == '_')
|
|
{
|
|
/* Territory */
|
|
++c;
|
|
if (c[0] < 'A' || c[0] > 'Z'
|
|
|| c[1] < 'A' || c[1] > 'Z')
|
|
FAIL;
|
|
c += 2;
|
|
}
|
|
if (c[0] == '.')
|
|
{
|
|
/* Charset */
|
|
char *chp;
|
|
|
|
++c;
|
|
strcpy (charset, c);
|
|
if ((chp = strchr (charset, '@')))
|
|
/* Strip off modifier */
|
|
*chp = '\0';
|
|
c += strlen (charset);
|
|
}
|
|
else if (c[0] == '\0' || c[0] == '@')
|
|
/* End of string or just a modifier */
|
|
|
|
/* The Cygwin-only function __set_charset_from_locale checks
|
|
for the default charset which is connected to the given locale.
|
|
The function uses Windows functions in turn so it can't be easily
|
|
adapted to other targets. However, if any other target provides
|
|
equivalent functionality, preferrably using the same function name
|
|
it would be sufficient to change the guarding #ifdef. */
|
|
__set_charset_from_locale (locale, charset);
|
|
else
|
|
/* Invalid string */
|
|
FAIL;
|
|
}
|
|
/* We only support this subset of charsets. */
|
|
switch (charset[0])
|
|
{
|
|
case 'U':
|
|
case 'u':
|
|
if (strcasecmp (charset, "UTF-8") && strcasecmp (charset, "UTF8"))
|
|
FAIL;
|
|
strcpy (charset, "UTF-8");
|
|
break;
|
|
case 'E':
|
|
case 'e':
|
|
if (strncasecmp (charset, "EUC", 3))
|
|
FAIL;
|
|
c = charset + 3;
|
|
if (*c == '-')
|
|
++c;
|
|
if (!strcasecmp (c, "JP"))
|
|
strcpy (charset, "EUCJP");
|
|
/* Newlib does neither provide EUC-KR nor EUC-CN, and Cygwin's
|
|
implementation requires Windows support. */
|
|
else if (!strcasecmp (c, "KR"))
|
|
strcpy (charset, "EUCKR");
|
|
else if (!strcasecmp (c, "CN"))
|
|
strcpy (charset, "EUCCN");
|
|
else
|
|
FAIL;
|
|
break;
|
|
case 'S':
|
|
case 's':
|
|
if (strcasecmp (charset, "SJIS"))
|
|
FAIL;
|
|
strcpy (charset, "SJIS");
|
|
break;
|
|
case 'I':
|
|
case 'i':
|
|
/* Must be exactly one of ISO-8859-1, [...] ISO-8859-16, except for
|
|
ISO-8859-12. This code also recognizes the aliases without dashes. */
|
|
if (strncasecmp (charset, "ISO", 3))
|
|
FAIL;
|
|
c = charset + 3;
|
|
if (*c == '-')
|
|
++c;
|
|
if (strncasecmp (c, "8859", 4))
|
|
FAIL;
|
|
c += 4;
|
|
if (*c == '-')
|
|
++c;
|
|
val = strtol (c, &end, 10);
|
|
if (val < 1 || val > 16 || val == 12 || *end)
|
|
FAIL;
|
|
strcpy (charset, "ISO-8859-");
|
|
c = charset + 9;
|
|
if (val > 10)
|
|
*c++ = '1';
|
|
*c++ = val % 10 + '0';
|
|
*c = '\0';
|
|
break;
|
|
case 'C':
|
|
case 'c':
|
|
if (charset[1] != 'P' && charset[1] != 'p')
|
|
FAIL;
|
|
strncpy (charset, "CP", 2);
|
|
val = strtol (charset + 2, &end, 10);
|
|
if (*end)
|
|
FAIL;
|
|
switch (val)
|
|
{
|
|
case 437:
|
|
case 720:
|
|
case 737:
|
|
case 775:
|
|
case 850:
|
|
case 852:
|
|
case 855:
|
|
case 857:
|
|
case 858:
|
|
case 862:
|
|
case 866:
|
|
case 874:
|
|
case 1125:
|
|
case 1250:
|
|
case 1251:
|
|
case 1252:
|
|
case 1253:
|
|
case 1254:
|
|
case 1255:
|
|
case 1256:
|
|
case 1257:
|
|
case 1258:
|
|
case 932:
|
|
break;
|
|
default:
|
|
FAIL;
|
|
}
|
|
break;
|
|
case 'K':
|
|
case 'k':
|
|
/* KOI8-R, KOI8-U and the aliases without dash */
|
|
if (strncasecmp (charset, "KOI8", 4))
|
|
FAIL;
|
|
c = charset + 4;
|
|
if (*c == '-')
|
|
++c;
|
|
if (*c == 'R' || *c == 'r')
|
|
{
|
|
val = 20866;
|
|
strcpy (charset, "CP20866");
|
|
}
|
|
else if (*c == 'U' || *c == 'u')
|
|
{
|
|
val = 21866;
|
|
strcpy (charset, "CP21866");
|
|
}
|
|
else
|
|
FAIL;
|
|
break;
|
|
case 'A':
|
|
case 'a':
|
|
if (strcasecmp (charset, "ASCII"))
|
|
FAIL;
|
|
strcpy (charset, "ASCII");
|
|
break;
|
|
case 'G':
|
|
case 'g':
|
|
/* Newlib does not provide GBK/GB2312 and Cygwin's implementation
|
|
requires Windows support. */
|
|
if (!strcasecmp (charset, "GBK")
|
|
|| !strcasecmp (charset, "GB2312"))
|
|
strcpy (charset, charset[2] == '2' ? "GB2312" : "GBK");
|
|
else
|
|
/* GEORGIAN-PS and the alias without dash */
|
|
if (!strncasecmp (charset, "GEORGIAN", 8))
|
|
{
|
|
c = charset + 8;
|
|
if (*c == '-')
|
|
++c;
|
|
if (strcasecmp (c, "PS"))
|
|
FAIL;
|
|
val = 101;
|
|
strcpy (charset, "CP101");
|
|
}
|
|
else
|
|
FAIL;
|
|
break;
|
|
case 'P':
|
|
case 'p':
|
|
/* PT154 */
|
|
if (strcasecmp (charset, "PT154"))
|
|
FAIL;
|
|
val = 102;
|
|
strcpy (charset, "CP102");
|
|
break;
|
|
case 'T':
|
|
case 't':
|
|
if (strncasecmp (charset, "TIS", 3))
|
|
FAIL;
|
|
c = charset + 3;
|
|
if (*c == '-')
|
|
++c;
|
|
if (strcasecmp (c, "620"))
|
|
FAIL;
|
|
val = 874;
|
|
strcpy (charset, "CP874");
|
|
break;
|
|
/* Newlib does not provide Big5 and Cygwin's implementation
|
|
requires Windows support. */
|
|
case 'B':
|
|
case 'b':
|
|
if (strcasecmp (charset, "BIG5"))
|
|
FAIL;
|
|
strcpy (charset, "BIG5");
|
|
break;
|
|
default:
|
|
FAIL;
|
|
}
|
|
|
|
/* The following code is borrowed from nl_langinfo()
|
|
in newlib/libc/locale/nl_langinfo.c */
|
|
/* Convert charset to Linux compatible codeset string. */
|
|
const char *ret = charset;
|
|
if (ret[0] == 'A'/*SCII*/)
|
|
ret = "ANSI_X3.4-1968";
|
|
else if (ret[0] == 'E')
|
|
{
|
|
if (strcmp (ret, "EUCJP") == 0)
|
|
ret = "EUC-JP";
|
|
else if (strcmp (ret, "EUCKR") == 0)
|
|
ret = "EUC-KR";
|
|
else if (strcmp (ret, "EUCCN") == 0)
|
|
ret = "GB2312";
|
|
}
|
|
else if (ret[0] == 'C'/*Pxxxx*/)
|
|
{
|
|
if (strcmp (ret + 2, "874") == 0)
|
|
ret = "TIS-620";
|
|
else if (strcmp (ret + 2, "20866") == 0)
|
|
ret = "KOI8-R";
|
|
else if (strcmp (ret + 2, "21866") == 0)
|
|
ret = "KOI8-U";
|
|
else if (strcmp (ret + 2, "101") == 0)
|
|
ret = "GEORGIAN-PS";
|
|
else if (strcmp (ret + 2, "102") == 0)
|
|
ret = "PT154";
|
|
}
|
|
else if (ret[0] == 'S'/*JIS*/)
|
|
{
|
|
/* Cygwin uses MSFT's implementation of SJIS, which differs
|
|
in some codepoints from the real thing, especially
|
|
0x5c: yen sign instead of backslash,
|
|
0x7e: overline instead of tilde.
|
|
We can't use the real SJIS since otherwise Win32
|
|
pathnames would become invalid. OTOH, if we return
|
|
"SJIS" here, then libiconv will do mb<->wc conversion
|
|
differently to our internal functions. Therefore we
|
|
return what we really implement, CP932. This is handled
|
|
fine by libiconv. */
|
|
ret = "CP932";
|
|
}
|
|
|
|
wchar_t lc[ENCODING_LEN + 1];
|
|
wchar_t *p;
|
|
mbstowcs (lc, locale, ENCODING_LEN);
|
|
p = wcschr (lc, L'.');
|
|
if (p)
|
|
*p = L'\0';
|
|
p = wcschr (lc, L'_');
|
|
if (p)
|
|
*p = L'-';
|
|
LCID lcid = LocaleNameToLCID (lc, 0);
|
|
if (!lcid && !strcmp (charset, "ASCII"))
|
|
return 0;
|
|
|
|
/* Set results */
|
|
strcpy(locale_out, new_locale);
|
|
strcpy(charset_out, ret);
|
|
return lcid;
|
|
}
|
|
#endif /* USE_OWN_NLS_FUNC */
|
|
|
|
void
|
|
fhandler_pty_slave::fixup_after_attach (bool native_maybe)
|
|
{
|
|
if (getPseudoConsole ())
|
|
{
|
|
if (fhandler_console::get_console_process_id (getHelperProcessId (),
|
|
true))
|
|
{
|
|
if (pcon_attached_to != get_minor ())
|
|
{
|
|
pcon_attached_to = get_minor ();
|
|
init_console_handler (true);
|
|
#if USE_OWN_NLS_FUNC
|
|
char locale[ENCODING_LEN + 1] = "C";
|
|
char charset[ENCODING_LEN + 1] = "ASCII";
|
|
LCID lcid = get_langinfo (locale, charset);
|
|
#else /* USE_OWN_NLS_FUNC */
|
|
char env[ENCODING_LEN + 1];
|
|
get_locale_from_env (env);
|
|
setlocale (LC_CTYPE, env);
|
|
const char *locale = setlocale (LC_CTYPE, NULL);
|
|
#if 0
|
|
char tmp_locale[ENCODING_LEN + 1];
|
|
char *ret = __set_locale_from_locale_alias (locale, tmp_locale);
|
|
if (ret)
|
|
locale = tmp_locale;
|
|
#endif
|
|
wchar_t lc[ENCODING_LEN + 1];
|
|
wchar_t *p;
|
|
mbstowcs (lc, locale, ENCODING_LEN);
|
|
p = wcschr (lc, L'.');
|
|
if (p)
|
|
*p = L'\0';
|
|
p = wcschr (lc, L'@');
|
|
if (p)
|
|
*p = L'\0';
|
|
p = wcschr (lc, L'_');
|
|
if (p)
|
|
*p = L'-';
|
|
LCID lcid = LocaleNameToLCID (lc, 0);
|
|
const char *charset = nl_langinfo (CODESET);
|
|
#endif /* USE_OWN_NLS_FUNC */
|
|
|
|
/* Set console code page form locale */
|
|
UINT CodePage;
|
|
if (lcid == 0 || lcid == (LCID) -1)
|
|
CodePage = 20127; /* ASCII */
|
|
else if (!GetLocaleInfo (lcid,
|
|
LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
|
|
(char *) &CodePage, sizeof (CodePage)))
|
|
CodePage = 20127; /* ASCII */
|
|
SetConsoleCP (CodePage);
|
|
SetConsoleOutputCP (CodePage);
|
|
|
|
if (get_ttyp ()->num_pcon_attached_slaves == 0)
|
|
{
|
|
/* Set terminal code page from locale */
|
|
/* This code is borrowed from mintty: charset.c */
|
|
char charset_u[ENCODING_LEN + 1] = {0, };
|
|
for (int i=0; charset[i] && i<ENCODING_LEN; i++)
|
|
charset_u[i] = toupper (charset[i]);
|
|
unsigned int iso;
|
|
UINT cp = 20127; /* Default for fallback */
|
|
if (sscanf (charset_u, "ISO-8859-%u", &iso) == 1 ||
|
|
sscanf (charset_u, "ISO8859-%u", &iso) == 1 ||
|
|
sscanf (charset_u, "ISO8859%u", &iso) == 1)
|
|
{
|
|
if (iso && iso <= 16 && iso !=12)
|
|
get_ttyp ()->TermCodePage = 28590 + iso;
|
|
}
|
|
else if (sscanf (charset_u, "CP%u", &cp) == 1)
|
|
get_ttyp ()->TermCodePage = cp;
|
|
else
|
|
for (int i=0; cs_names[i].cp; i++)
|
|
if (strcasecmp (charset_u, cs_names[i].name) == 0)
|
|
{
|
|
get_ttyp ()->TermCodePage = cs_names[i].cp;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Clear screen to synchronize pseudo console screen buffer
|
|
with real terminal. This is necessary because pseudo
|
|
console screen buffer is empty at start. */
|
|
if (get_ttyp ()->num_pcon_attached_slaves == 0
|
|
&& !ALWAYS_USE_PCON)
|
|
/* Assume this is the first process using this pty slave. */
|
|
get_ttyp ()->need_clear_screen = true;
|
|
|
|
get_ttyp ()->num_pcon_attached_slaves ++;
|
|
}
|
|
}
|
|
}
|
|
if (pcon_attached_to == get_minor () && (native_maybe || ALWAYS_USE_PCON))
|
|
{
|
|
FlushConsoleInputBuffer (get_handle ());
|
|
DWORD mode;
|
|
GetConsoleMode (get_handle (), &mode);
|
|
SetConsoleMode (get_handle (),
|
|
(mode & ~ENABLE_VIRTUAL_TERMINAL_INPUT) |
|
|
ENABLE_ECHO_INPUT |
|
|
ENABLE_LINE_INPUT |
|
|
ENABLE_PROCESSED_INPUT);
|
|
Sleep (20);
|
|
if (get_ttyp ()->pcon_pid == 0 ||
|
|
kill (get_ttyp ()->pcon_pid, 0) != 0)
|
|
get_ttyp ()->pcon_pid = myself->pid;
|
|
get_ttyp ()->switch_to_pcon = true;
|
|
}
|
|
}
|
|
|
|
void
|
|
fhandler_pty_slave::fixup_after_fork (HANDLE parent)
|
|
{
|
|
fixup_after_attach (false);
|
|
// fork_fixup (parent, inuse, "inuse");
|
|
// fhandler_pty_common::fixup_after_fork (parent);
|
|
report_tty_counts (this, "inherited", "");
|
|
}
|
|
|
|
void
|
|
fhandler_pty_slave::fixup_after_exec ()
|
|
{
|
|
reset_switch_to_pcon ();
|
|
|
|
if (!close_on_exec ())
|
|
fixup_after_fork (NULL);
|
|
else if (getPseudoConsole ())
|
|
{
|
|
int used = 0;
|
|
int attached = 0;
|
|
cygheap_fdenum cfd (false);
|
|
while (cfd.next () >= 0)
|
|
{
|
|
if (cfd->get_major () == DEV_PTYS_MAJOR ||
|
|
cfd->get_major () == DEV_CONS_MAJOR)
|
|
used ++;
|
|
if (cfd->get_major () == DEV_PTYS_MAJOR &&
|
|
cfd->get_minor () == pcon_attached_to)
|
|
attached ++;
|
|
}
|
|
|
|
/* Call FreeConsole() if no tty is opened and the process
|
|
is attached to console corresponding to tty. This is
|
|
needed to make GNU screen and tmux work in Windows 10
|
|
1903. */
|
|
if (attached == 1 && get_minor () == pcon_attached_to)
|
|
pcon_attached_to = -1;
|
|
if (used == 1 /* About to close this tty */)
|
|
{
|
|
init_console_handler (false);
|
|
FreeConsole ();
|
|
}
|
|
}
|
|
|
|
#if USE_API_HOOK
|
|
/* Hook Console API */
|
|
if (getPseudoConsole ())
|
|
{
|
|
#define DO_HOOK(module, name) \
|
|
if (!name##_Orig) \
|
|
{ \
|
|
void *api = hook_api (module, #name, (void *) name##_Hooked); \
|
|
name##_Orig = (__typeof__ (name) *) api; \
|
|
/*if (api) system_printf(#name " hooked.");*/ \
|
|
}
|
|
DO_HOOK (NULL, WriteFile);
|
|
DO_HOOK (NULL, WriteConsoleA);
|
|
DO_HOOK (NULL, WriteConsoleW);
|
|
DO_HOOK (NULL, ReadFile);
|
|
DO_HOOK (NULL, ReadConsoleA);
|
|
DO_HOOK (NULL, ReadConsoleW);
|
|
DO_HOOK (NULL, WriteConsoleOutputA);
|
|
DO_HOOK (NULL, WriteConsoleOutputW);
|
|
DO_HOOK (NULL, WriteConsoleOutputCharacterA);
|
|
DO_HOOK (NULL, WriteConsoleOutputCharacterW);
|
|
DO_HOOK (NULL, WriteConsoleOutputAttribute);
|
|
DO_HOOK (NULL, SetConsoleCursorPosition);
|
|
DO_HOOK (NULL, SetConsoleTextAttribute);
|
|
DO_HOOK (NULL, WriteConsoleInputA);
|
|
DO_HOOK (NULL, WriteConsoleInputW);
|
|
DO_HOOK (NULL, ReadConsoleInputA);
|
|
DO_HOOK (NULL, ReadConsoleInputW);
|
|
DO_HOOK (NULL, PeekConsoleInputA);
|
|
DO_HOOK (NULL, PeekConsoleInputW);
|
|
}
|
|
#endif /* USE_API_HOOK */
|
|
}
|
|
|
|
/* This thread function handles the master control pipe. It waits for a
|
|
client to connect. Then it checks if the client process has permissions
|
|
to access the tty handles. If so, it opens the client process and
|
|
duplicates the handles into that process. If that fails, it sends a reply
|
|
with at least one handle set to NULL and an error code. Last but not
|
|
least, the client is disconnected and the thread waits for the next client.
|
|
|
|
A special case is when the master side of the tty is about to be closed.
|
|
The client side is the fhandler_pty_master::close function and it sends
|
|
a PID -1 in that case. A check is performed that the request to leave
|
|
really comes from the master process itself.
|
|
|
|
Since there's always only one pipe instance, there's a chance that clients
|
|
have to wait to connect to the master control pipe. Therefore the client
|
|
calls to CallNamedPipe should have a big enough timeout value. For now this
|
|
is 500ms. Hope that's enough. */
|
|
|
|
DWORD
|
|
fhandler_pty_master::pty_master_thread ()
|
|
{
|
|
bool exit = false;
|
|
GENERIC_MAPPING map = { EVENT_QUERY_STATE, EVENT_MODIFY_STATE, 0,
|
|
EVENT_QUERY_STATE | EVENT_MODIFY_STATE };
|
|
pipe_request req;
|
|
DWORD len;
|
|
security_descriptor sd;
|
|
HANDLE token;
|
|
PRIVILEGE_SET ps;
|
|
DWORD pid;
|
|
NTSTATUS status;
|
|
|
|
termios_printf ("Entered");
|
|
while (!exit && (ConnectNamedPipe (master_ctl, NULL)
|
|
|| GetLastError () == ERROR_PIPE_CONNECTED))
|
|
{
|
|
pipe_reply repl = { NULL, NULL, NULL, 0 };
|
|
bool deimp = false;
|
|
NTSTATUS allow = STATUS_ACCESS_DENIED;
|
|
ACCESS_MASK access = EVENT_MODIFY_STATE;
|
|
HANDLE client = NULL;
|
|
|
|
if (!ReadFile (master_ctl, &req, sizeof req, &len, NULL))
|
|
{
|
|
termios_printf ("ReadFile, %E");
|
|
goto reply;
|
|
}
|
|
if (!GetNamedPipeClientProcessId (master_ctl, &pid))
|
|
pid = req.pid;
|
|
if (get_object_sd (input_available_event, sd))
|
|
{
|
|
termios_printf ("get_object_sd, %E");
|
|
goto reply;
|
|
}
|
|
cygheap->user.deimpersonate ();
|
|
deimp = true;
|
|
if (!ImpersonateNamedPipeClient (master_ctl))
|
|
{
|
|
termios_printf ("ImpersonateNamedPipeClient, %E");
|
|
goto reply;
|
|
}
|
|
status = NtOpenThreadToken (GetCurrentThread (), TOKEN_QUERY, TRUE,
|
|
&token);
|
|
if (!NT_SUCCESS (status))
|
|
{
|
|
termios_printf ("NtOpenThreadToken, %y", status);
|
|
SetLastError (RtlNtStatusToDosError (status));
|
|
goto reply;
|
|
}
|
|
len = sizeof ps;
|
|
status = NtAccessCheck (sd, token, access, &map, &ps, &len, &access,
|
|
&allow);
|
|
NtClose (token);
|
|
if (!NT_SUCCESS (status))
|
|
{
|
|
termios_printf ("NtAccessCheck, %y", status);
|
|
SetLastError (RtlNtStatusToDosError (status));
|
|
goto reply;
|
|
}
|
|
if (!RevertToSelf ())
|
|
{
|
|
termios_printf ("RevertToSelf, %E");
|
|
goto reply;
|
|
}
|
|
if (req.pid == (DWORD) -1) /* Request to finish thread. */
|
|
{
|
|
/* Check if the requesting process is the master process itself. */
|
|
if (pid == GetCurrentProcessId ())
|
|
exit = true;
|
|
goto reply;
|
|
}
|
|
if (NT_SUCCESS (allow))
|
|
{
|
|
client = OpenProcess (PROCESS_DUP_HANDLE, FALSE, pid);
|
|
if (!client)
|
|
{
|
|
termios_printf ("OpenProcess, %E");
|
|
goto reply;
|
|
}
|
|
if (!DuplicateHandle (GetCurrentProcess (), from_master,
|
|
client, &repl.from_master,
|
|
0, TRUE, DUPLICATE_SAME_ACCESS))
|
|
{
|
|
termios_printf ("DuplicateHandle (from_master), %E");
|
|
goto reply;
|
|
}
|
|
if (!DuplicateHandle (GetCurrentProcess (), from_master_cyg,
|
|
client, &repl.from_master_cyg,
|
|
0, TRUE, DUPLICATE_SAME_ACCESS))
|
|
{
|
|
termios_printf ("DuplicateHandle (from_master_cyg), %E");
|
|
goto reply;
|
|
}
|
|
if (!DuplicateHandle (GetCurrentProcess (), to_master,
|
|
client, &repl.to_master,
|
|
0, TRUE, DUPLICATE_SAME_ACCESS))
|
|
{
|
|
termios_printf ("DuplicateHandle (to_master), %E");
|
|
goto reply;
|
|
}
|
|
if (!DuplicateHandle (GetCurrentProcess (), to_master_cyg,
|
|
client, &repl.to_master_cyg,
|
|
0, TRUE, DUPLICATE_SAME_ACCESS))
|
|
{
|
|
termios_printf ("DuplicateHandle (to_master_cyg), %E");
|
|
goto reply;
|
|
}
|
|
}
|
|
reply:
|
|
repl.error = GetLastError ();
|
|
if (client)
|
|
CloseHandle (client);
|
|
if (deimp)
|
|
cygheap->user.reimpersonate ();
|
|
sd.free ();
|
|
termios_printf ("Reply: from %p, to %p, error %u",
|
|
repl.from_master, repl.to_master, repl.error );
|
|
if (!WriteFile (master_ctl, &repl, sizeof repl, &len, NULL))
|
|
termios_printf ("WriteFile, %E");
|
|
if (!DisconnectNamedPipe (master_ctl))
|
|
termios_printf ("DisconnectNamedPipe, %E");
|
|
}
|
|
termios_printf ("Leaving");
|
|
return 0;
|
|
}
|
|
|
|
static DWORD WINAPI
|
|
pty_master_thread (VOID *arg)
|
|
{
|
|
return ((fhandler_pty_master *) arg)->pty_master_thread ();
|
|
}
|
|
|
|
DWORD
|
|
fhandler_pty_master::pty_master_fwd_thread ()
|
|
{
|
|
DWORD rlen;
|
|
char outbuf[65536];
|
|
|
|
termios_printf ("Started.");
|
|
for (;;)
|
|
{
|
|
if (!ReadFile (from_slave, outbuf, sizeof outbuf, &rlen, NULL))
|
|
{
|
|
termios_printf ("ReadFile for forwarding failed, %E");
|
|
break;
|
|
}
|
|
ssize_t wlen = rlen;
|
|
char *ptr = outbuf;
|
|
if (getPseudoConsole ())
|
|
{
|
|
/* Avoid duplicating slave output which is already sent to
|
|
to_master_cyg */
|
|
if (!get_ttyp ()->switch_to_pcon)
|
|
continue;
|
|
|
|
/* Avoid setting window title to "cygwin-console-helper.exe" */
|
|
int state = 0;
|
|
int start_at = 0;
|
|
for (DWORD i=0; i<rlen; i++)
|
|
if (outbuf[i] == '\033')
|
|
{
|
|
start_at = i;
|
|
state = 1;
|
|
continue;
|
|
}
|
|
else if ((state == 1 && outbuf[i] == ']') ||
|
|
(state == 2 && outbuf[i] == '0') ||
|
|
(state == 3 && outbuf[i] == ';'))
|
|
{
|
|
state ++;
|
|
continue;
|
|
}
|
|
else if (state == 4 && outbuf[i] == '\a')
|
|
{
|
|
memmove (&outbuf[start_at], &outbuf[i+1], rlen-i-1);
|
|
state = 0;
|
|
rlen = wlen = start_at + rlen - i - 1;
|
|
continue;
|
|
}
|
|
else if (outbuf[i] == '\a')
|
|
{
|
|
state = 0;
|
|
continue;
|
|
}
|
|
|
|
/* Remove ESC sequence which returns results to console
|
|
input buffer. Without this, cursor position report
|
|
is put into the input buffer as a garbage. */
|
|
/* Remove ESC sequence to report cursor position. */
|
|
char *p0;
|
|
while ((p0 = (char *) memmem (outbuf, rlen, "\033[6n", 4)))
|
|
{
|
|
memmove (p0, p0+4, rlen - (p0+4 - outbuf));
|
|
rlen -= 4;
|
|
}
|
|
/* Remove ESC sequence to report terminal identity. */
|
|
while ((p0 = (char *) memmem (outbuf, rlen, "\033[0c", 4)))
|
|
{
|
|
memmove (p0, p0+4, rlen - (p0+4 - outbuf));
|
|
rlen -= 4;
|
|
}
|
|
wlen = rlen;
|
|
|
|
char *buf;
|
|
size_t nlen;
|
|
if (get_ttyp ()->TermCodePage != CP_UTF8)
|
|
{
|
|
size_t wlen2 =
|
|
MultiByteToWideChar (CP_UTF8, 0,
|
|
(char *)ptr, wlen, NULL, 0);
|
|
wchar_t *wbuf = (wchar_t *)
|
|
HeapAlloc (GetProcessHeap (), 0, wlen2 * sizeof (wchar_t));
|
|
wlen2 =
|
|
MultiByteToWideChar (CP_UTF8, 0,
|
|
(char *)ptr, wlen, wbuf, wlen2);
|
|
nlen = WideCharToMultiByte (get_ttyp ()->TermCodePage, 0,
|
|
wbuf, wlen2, NULL, 0, NULL, NULL);
|
|
buf = (char *) HeapAlloc (GetProcessHeap (), 0, nlen);
|
|
nlen = WideCharToMultiByte (get_ttyp ()->TermCodePage, 0,
|
|
wbuf, wlen2, buf, nlen, NULL, NULL);
|
|
HeapFree (GetProcessHeap (), 0, wbuf);
|
|
}
|
|
else
|
|
{
|
|
/* Just copy */
|
|
buf = (char *) HeapAlloc (GetProcessHeap (), 0, wlen);
|
|
memcpy (buf, (char *)ptr, wlen);
|
|
nlen = wlen;
|
|
}
|
|
ptr = buf;
|
|
wlen = rlen = nlen;
|
|
|
|
/* OPOST processing was already done in pseudo console,
|
|
so just write it to to_master_cyg. */
|
|
DWORD written;
|
|
acquire_output_mutex (INFINITE);
|
|
while (rlen>0)
|
|
{
|
|
if (!WriteFile (to_master_cyg, ptr, wlen, &written, NULL))
|
|
{
|
|
termios_printf ("WriteFile for forwarding failed, %E");
|
|
break;
|
|
}
|
|
ptr += written;
|
|
wlen = (rlen -= written);
|
|
}
|
|
release_output_mutex ();
|
|
HeapFree (GetProcessHeap (), 0, buf);
|
|
continue;
|
|
}
|
|
acquire_output_mutex (INFINITE);
|
|
while (rlen>0)
|
|
{
|
|
if (!process_opost_output (to_master_cyg, ptr, wlen, false))
|
|
{
|
|
termios_printf ("WriteFile for forwarding failed, %E");
|
|
break;
|
|
}
|
|
ptr += wlen;
|
|
wlen = (rlen -= wlen);
|
|
}
|
|
release_output_mutex ();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static DWORD WINAPI
|
|
pty_master_fwd_thread (VOID *arg)
|
|
{
|
|
return ((fhandler_pty_master *) arg)->pty_master_fwd_thread ();
|
|
}
|
|
|
|
/* If master process is running as service, attaching to
|
|
pseudo console should be done in fork. If attaching
|
|
is done in spawn for inetd or sshd, it fails because
|
|
the helper process is running as privileged user while
|
|
slave process is not. This function is used to determine
|
|
if the process is running as a srvice or not. */
|
|
static bool
|
|
is_running_as_service (void)
|
|
{
|
|
DWORD dwSize = 0;
|
|
PTOKEN_GROUPS pGroupInfo;
|
|
tmp_pathbuf tp;
|
|
pGroupInfo = (PTOKEN_GROUPS) tp.w_get ();
|
|
NtQueryInformationToken (hProcToken, TokenGroups, pGroupInfo,
|
|
2 * NT_MAX_PATH, &dwSize);
|
|
for (DWORD i=0; i<pGroupInfo->GroupCount; i++)
|
|
if (RtlEqualSid (well_known_service_sid, pGroupInfo->Groups[i].Sid))
|
|
return true;
|
|
for (DWORD i=0; i<pGroupInfo->GroupCount; i++)
|
|
if (RtlEqualSid (well_known_interactive_sid, pGroupInfo->Groups[i].Sid))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
fhandler_pty_master::setup_pseudoconsole ()
|
|
{
|
|
/* Pseudo console supprot is realized using a tricky technic.
|
|
PTY need the pseudo console handles, however, they cannot
|
|
be retrieved by normal procedure. Therefore, run a helper
|
|
process in a pseudo console and get them from the helper.
|
|
Slave process will attach to the pseudo console in the
|
|
helper process using AttachConsole(). */
|
|
HMODULE hModule = GetModuleHandle ("kernel32.dll");
|
|
FARPROC func = GetProcAddress (hModule, "CreatePseudoConsole");
|
|
HRESULT (WINAPI *CreatePseudoConsole)
|
|
(COORD, HANDLE, HANDLE, DWORD, HPCON *) = NULL;
|
|
if (!func)
|
|
return false;
|
|
CreatePseudoConsole =
|
|
(HRESULT (WINAPI *) (COORD, HANDLE, HANDLE, DWORD, HPCON *)) func;
|
|
COORD size = {80, 25};
|
|
CreatePipe (&from_master, &to_slave, &sec_none, 0);
|
|
HRESULT res = CreatePseudoConsole (size, from_master, to_master,
|
|
0, &get_ttyp ()->hPseudoConsole);
|
|
if (res != S_OK)
|
|
{
|
|
system_printf ("CreatePseudoConsole() failed. %08x\n",
|
|
GetLastError());
|
|
CloseHandle (from_master);
|
|
CloseHandle (to_slave);
|
|
from_master = from_master_cyg;
|
|
to_slave = NULL;
|
|
get_ttyp ()->hPseudoConsole = NULL;
|
|
return false;
|
|
}
|
|
|
|
/* If master process is running as service, attaching to
|
|
pseudo console should be done in fork. If attaching
|
|
is done in spawn for inetd or sshd, it fails because
|
|
the helper process is running as privileged user while
|
|
slave process is not. */
|
|
if (is_running_as_service ())
|
|
get_ttyp ()->attach_pcon_in_fork = true;
|
|
|
|
SIZE_T bytesRequired;
|
|
InitializeProcThreadAttributeList (NULL, 1, 0, &bytesRequired);
|
|
STARTUPINFOEXW si_helper;
|
|
ZeroMemory (&si_helper, sizeof (si_helper));
|
|
si_helper.StartupInfo.cb = sizeof (STARTUPINFOEXW);
|
|
si_helper.lpAttributeList = (PPROC_THREAD_ATTRIBUTE_LIST)
|
|
HeapAlloc (GetProcessHeap (), 0, bytesRequired);
|
|
InitializeProcThreadAttributeList (si_helper.lpAttributeList,
|
|
1, 0, &bytesRequired);
|
|
UpdateProcThreadAttribute (si_helper.lpAttributeList,
|
|
0,
|
|
PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE,
|
|
get_ttyp ()->hPseudoConsole,
|
|
sizeof (get_ttyp ()->hPseudoConsole),
|
|
NULL, NULL);
|
|
HANDLE hello = CreateEvent (&sec_none, true, false, NULL);
|
|
HANDLE goodbye = CreateEvent (&sec_none, true, false, NULL);
|
|
/* Create a pipe for receiving pseudo console handles */
|
|
HANDLE hr, hw;
|
|
CreatePipe (&hr, &hw, &sec_none, 0);
|
|
/* Create helper process */
|
|
WCHAR cmd[MAX_PATH];
|
|
path_conv helper ("/bin/cygwin-console-helper.exe");
|
|
size_t len = helper.get_wide_win32_path_len ();
|
|
helper.get_wide_win32_path (cmd);
|
|
__small_swprintf (cmd + len, L" %p %p %p", hello, goodbye, hw);
|
|
si_helper.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
|
|
si_helper.StartupInfo.hStdInput = NULL;
|
|
si_helper.StartupInfo.hStdOutput = NULL;
|
|
si_helper.StartupInfo.hStdError = NULL;
|
|
PROCESS_INFORMATION pi_helper;
|
|
CreateProcessW (NULL, cmd, &sec_none, &sec_none,
|
|
TRUE, EXTENDED_STARTUPINFO_PRESENT,
|
|
NULL, NULL, &si_helper.StartupInfo, &pi_helper);
|
|
WaitForSingleObject (hello, INFINITE);
|
|
/* Retrieve pseudo console handles */
|
|
DWORD rLen;
|
|
char buf[64];
|
|
ReadFile (hr, buf, sizeof (buf), &rLen, NULL);
|
|
buf[rLen] = '\0';
|
|
HANDLE hpConIn, hpConOut;
|
|
sscanf (buf, "StdHandles=%p,%p", &hpConIn, &hpConOut);
|
|
DuplicateHandle (pi_helper.hProcess, hpConIn,
|
|
GetCurrentProcess (), &hpConIn, 0,
|
|
TRUE, DUPLICATE_SAME_ACCESS);
|
|
DuplicateHandle (pi_helper.hProcess, hpConOut,
|
|
GetCurrentProcess (), &hpConOut, 0,
|
|
TRUE, DUPLICATE_SAME_ACCESS);
|
|
CloseHandle (hr);
|
|
CloseHandle (hw);
|
|
/* Clean up */
|
|
DeleteProcThreadAttributeList (si_helper.lpAttributeList);
|
|
HeapFree (GetProcessHeap (), 0, si_helper.lpAttributeList);
|
|
/* Setting information of stuffs regarding pseudo console */
|
|
get_ttyp ()->hHelperGoodbye = goodbye;
|
|
get_ttyp ()->hHelperProcess = pi_helper.hProcess;
|
|
get_ttyp ()->HelperProcessId = pi_helper.dwProcessId;
|
|
CloseHandle (from_master);
|
|
CloseHandle (to_master);
|
|
from_master = hpConIn;
|
|
to_master = hpConOut;
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
fhandler_pty_master::setup ()
|
|
{
|
|
int res;
|
|
security_descriptor sd;
|
|
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 ());
|
|
if (unit < 0)
|
|
return false;
|
|
|
|
/* from_master should be used for pseudo console.
|
|
Just copy from_master_cyg here for the case that
|
|
pseudo console is not available. */
|
|
from_master = from_master_cyg;
|
|
|
|
ProtectHandle1 (get_output_handle (), to_pty);
|
|
|
|
tty& t = *cygwin_shared->tty[unit];
|
|
_tc = (tty_min *) &t;
|
|
|
|
tcinit (true); /* Set termios information. Force initialization. */
|
|
|
|
const char *errstr = NULL;
|
|
DWORD pipe_mode = PIPE_NOWAIT;
|
|
|
|
if (!SetNamedPipeHandleState (get_output_handle (), &pipe_mode, NULL, NULL))
|
|
termios_printf ("can't set output_handle(%p) to non-blocking mode",
|
|
get_output_handle ());
|
|
|
|
char pipename[sizeof("ptyNNNN-to-master-cyg")];
|
|
__small_sprintf (pipename, "pty%d-to-master", unit);
|
|
res = fhandler_pipe::create (&sec_none, &from_slave, &to_master,
|
|
fhandler_pty_common::pipesize, pipename, 0);
|
|
if (res)
|
|
{
|
|
errstr = "output pipe";
|
|
goto err;
|
|
}
|
|
|
|
__small_sprintf (pipename, "pty%d-to-master-cyg", unit);
|
|
res = fhandler_pipe::create (&sec_none, &get_handle (), &to_master_cyg,
|
|
fhandler_pty_common::pipesize, pipename, 0);
|
|
if (res)
|
|
{
|
|
errstr = "output pipe for cygwin";
|
|
goto err;
|
|
}
|
|
|
|
ProtectHandle1 (from_slave, from_pty);
|
|
|
|
__small_sprintf (pipename, "pty%d-echoloop", unit);
|
|
res = fhandler_pipe::create (&sec_none, &echo_r, &echo_w,
|
|
fhandler_pty_common::pipesize, pipename, 0);
|
|
if (res)
|
|
{
|
|
errstr = "echo pipe";
|
|
goto err;
|
|
}
|
|
|
|
/* Create security attribute. Default permissions are 0620. */
|
|
sd.malloc (sizeof (SECURITY_DESCRIPTOR));
|
|
RtlCreateSecurityDescriptor (sd, SECURITY_DESCRIPTOR_REVISION);
|
|
if (!create_object_sd_from_attribute (myself->uid, myself->gid,
|
|
S_IFCHR | S_IRUSR | S_IWUSR | S_IWGRP,
|
|
sd))
|
|
sa.lpSecurityDescriptor = (PSECURITY_DESCRIPTOR) sd;
|
|
|
|
/* Carefully check that the input_available_event didn't already exist.
|
|
This is a measure to make sure that the event security descriptor
|
|
isn't occupied by a malicious process. We must make sure that the
|
|
event's security descriptor is what we expect it to be. */
|
|
if (!(input_available_event = t.get_event (errstr = INPUT_AVAILABLE_EVENT,
|
|
&sa, TRUE))
|
|
|| GetLastError () == ERROR_ALREADY_EXISTS)
|
|
goto err;
|
|
|
|
char buf[MAX_PATH];
|
|
errstr = shared_name (buf, OUTPUT_MUTEX, unit);
|
|
if (!(output_mutex = CreateMutex (&sa, FALSE, buf)))
|
|
goto err;
|
|
|
|
errstr = shared_name (buf, INPUT_MUTEX, unit);
|
|
if (!(input_mutex = CreateMutex (&sa, FALSE, buf)))
|
|
goto err;
|
|
|
|
/* Create master control pipe which allows the master to duplicate
|
|
the pty pipe handles to processes which deserve it. */
|
|
__small_sprintf (buf, "\\\\.\\pipe\\cygwin-%S-pty%d-master-ctl",
|
|
&cygheap->installation_key, unit);
|
|
master_ctl = CreateNamedPipe (buf, PIPE_ACCESS_DUPLEX
|
|
| FILE_FLAG_FIRST_PIPE_INSTANCE,
|
|
PIPE_WAIT | PIPE_TYPE_MESSAGE
|
|
| PIPE_READMODE_MESSAGE
|
|
| PIPE_REJECT_REMOTE_CLIENTS,
|
|
1, 4096, 4096, 0, &sec_all_nih);
|
|
if (master_ctl == INVALID_HANDLE_VALUE)
|
|
{
|
|
errstr = "pty master control pipe";
|
|
goto err;
|
|
}
|
|
master_thread = new cygthread (::pty_master_thread, this, "ptym");
|
|
if (!master_thread)
|
|
{
|
|
errstr = "pty master control thread";
|
|
goto err;
|
|
}
|
|
master_fwd_thread = new cygthread (::pty_master_fwd_thread, this, "ptymf");
|
|
if (!master_fwd_thread)
|
|
{
|
|
errstr = "pty master forwarding thread";
|
|
goto err;
|
|
}
|
|
|
|
setup_pseudoconsole ();
|
|
|
|
t.set_from_master (from_master);
|
|
t.set_from_master_cyg (from_master_cyg);
|
|
t.set_to_master (to_master);
|
|
t.set_to_master_cyg (to_master_cyg);
|
|
t.winsize.ws_col = 80;
|
|
t.winsize.ws_row = 25;
|
|
t.master_pid = myself->pid;
|
|
|
|
dev ().parse (DEV_PTYM_MAJOR, unit);
|
|
|
|
termios_printf ("this %p, pty%d opened - from_pty <%p,%p>, to_pty %p",
|
|
this, unit, from_slave, get_handle (),
|
|
get_output_handle ());
|
|
return true;
|
|
|
|
err:
|
|
__seterrno ();
|
|
close_maybe (from_slave);
|
|
close_maybe (get_handle ());
|
|
close_maybe (get_output_handle ());
|
|
close_maybe (input_available_event);
|
|
close_maybe (output_mutex);
|
|
close_maybe (input_mutex);
|
|
close_maybe (from_master);
|
|
close_maybe (from_master_cyg);
|
|
close_maybe (to_master);
|
|
close_maybe (to_master_cyg);
|
|
close_maybe (echo_r);
|
|
close_maybe (echo_w);
|
|
close_maybe (master_ctl);
|
|
termios_printf ("pty%d open failed - failed to create %s", unit, errstr);
|
|
return false;
|
|
}
|
|
|
|
void
|
|
fhandler_pty_master::fixup_after_fork (HANDLE parent)
|
|
{
|
|
DWORD wpid = GetCurrentProcessId ();
|
|
fhandler_pty_master *arch = (fhandler_pty_master *) archetype;
|
|
if (arch->dwProcessId != wpid)
|
|
{
|
|
tty& t = *get_ttyp ();
|
|
if (myself->pid == t.master_pid)
|
|
{
|
|
t.set_from_master (arch->from_master);
|
|
t.set_from_master_cyg (arch->from_master_cyg);
|
|
t.set_to_master (arch->to_master);
|
|
t.set_to_master_cyg (arch->to_master_cyg);
|
|
}
|
|
arch->dwProcessId = wpid;
|
|
}
|
|
from_master = arch->from_master;
|
|
from_master_cyg = arch->from_master_cyg;
|
|
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;
|
|
#endif
|
|
report_tty_counts (this, "inherited master", "");
|
|
}
|
|
|
|
void
|
|
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;
|
|
}
|
|
|
|
BOOL
|
|
fhandler_pty_common::process_opost_output (HANDLE h, const void *ptr, ssize_t& len, bool is_echo)
|
|
{
|
|
ssize_t towrite = len;
|
|
BOOL res = TRUE;
|
|
BOOL (WINAPI *WriteFunc)
|
|
(HANDLE, LPCVOID, DWORD, LPDWORD, LPOVERLAPPED);
|
|
WriteFunc = WriteFile_Orig ? WriteFile_Orig : WriteFile;
|
|
while (towrite)
|
|
{
|
|
if (!is_echo)
|
|
{
|
|
if (tc ()->output_stopped && is_nonblocking ())
|
|
{
|
|
if (towrite < len)
|
|
break;
|
|
else
|
|
{
|
|
set_errno(EAGAIN);
|
|
len = -1;
|
|
return TRUE;
|
|
}
|
|
}
|
|
while (tc ()->output_stopped)
|
|
cygwait (10);
|
|
}
|
|
|
|
if (!(get_ttyp ()->ti.c_oflag & OPOST)) // raw output mode
|
|
{
|
|
DWORD n = MIN (OUT_BUFFER_SIZE, towrite);
|
|
res = WriteFunc (h, ptr, n, &n, NULL);
|
|
if (!res)
|
|
break;
|
|
ptr = (char *) ptr + n;
|
|
towrite -= n;
|
|
}
|
|
else // post-process output
|
|
{
|
|
char outbuf[OUT_BUFFER_SIZE + 1];
|
|
char *buf = (char *)ptr;
|
|
DWORD n = 0;
|
|
ssize_t rc = 0;
|
|
while (n < OUT_BUFFER_SIZE && rc < towrite)
|
|
{
|
|
switch (buf[rc])
|
|
{
|
|
case '\r':
|
|
if ((get_ttyp ()->ti.c_oflag & ONOCR)
|
|
&& get_ttyp ()->column == 0)
|
|
{
|
|
rc++;
|
|
continue;
|
|
}
|
|
if (get_ttyp ()->ti.c_oflag & OCRNL)
|
|
{
|
|
outbuf[n++] = '\n';
|
|
rc++;
|
|
}
|
|
else
|
|
{
|
|
outbuf[n++] = buf[rc++];
|
|
get_ttyp ()->column = 0;
|
|
}
|
|
break;
|
|
case '\n':
|
|
if (get_ttyp ()->ti.c_oflag & ONLCR)
|
|
{
|
|
outbuf[n++] = '\r';
|
|
get_ttyp ()->column = 0;
|
|
}
|
|
if (get_ttyp ()->ti.c_oflag & ONLRET)
|
|
get_ttyp ()->column = 0;
|
|
outbuf[n++] = buf[rc++];
|
|
break;
|
|
default:
|
|
outbuf[n++] = buf[rc++];
|
|
get_ttyp ()->column++;
|
|
break;
|
|
}
|
|
}
|
|
res = WriteFunc (h, outbuf, n, &n, NULL);
|
|
if (!res)
|
|
break;
|
|
ptr = (char *) ptr + rc;
|
|
towrite -= rc;
|
|
}
|
|
}
|
|
len -= towrite;
|
|
return res;
|
|
}
|