JehanneOS/newlib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Cygwin: FIFO: re-implement duplexers

Browse Source 
When opening a duplexer, open a client connection to the first client
handler.  Previously we gave the duplexer a bogus write handle, which
was just a duplicate of the first client handler's handle.  This meant
that we had a pipe server with no clients connected, and all I/O
attempts failed with STATUS_PIPE_LISTENING.

Extend the last fcntl change to duplexers.

Remove a now unused fifo_client_handler constructor, as well as the
long unusued method fifo_client_handler::connect.

Don't create the pipe in duplex mode; the server handle will only be
used for reading.
This commit is contained in:
Ken Brown 2019-05-09 11:23:44 -04:00
parent f3d1fe2ff8
commit 00b2e56d31
2 changed files with 13 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
winsup/cygwin/fhandler.h
View File

@ -1251,10 +1251,6 @@ struct fifo_client_handler
fifo_client_connect_state state; fifo_client_connect_state state;
HANDLE connect_evt; HANDLE connect_evt;
fifo_client_handler () : fh (NULL), state (fc_unknown), connect_evt (NULL) {} fifo_client_handler () : fh (NULL), state (fc_unknown), connect_evt (NULL) {}
fifo_client_handler (fhandler_base *_fh, fifo_client_connect_state _state,
HANDLE _connect_evt)
: fh (_fh), state (_state), connect_evt (_connect_evt) {}
int connect ();
int close (); int close ();
}; };

45
winsup/cygwin/fhandler_fifo.cc
View File

@ -175,8 +175,6 @@ fhandler_fifo::create_pipe_instance (bool first)
} }
access = GENERIC_READ | FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES access = GENERIC_READ | FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES
| SYNCHRONIZE; | SYNCHRONIZE;
if (first && duplexer)
access |= GENERIC_WRITE;
sharing = FILE_SHARE_READ | FILE_SHARE_WRITE; sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
hattr = OBJ_INHERIT; hattr = OBJ_INHERIT;
if (first) if (first)
@ -474,41 +472,23 @@ fhandler_fifo::open (int flags, mode_t)
/* If we're a duplexer, create the pipe and the first client handler. */ /* If we're a duplexer, create the pipe and the first client handler. */
if (duplexer) if (duplexer)
{ {
HANDLE ph, connect_evt; if (add_client_handler () < 0)
fhandler_base *fh;
ph = create_pipe_instance (true);
if (!ph)
{ {
res = error_errno_set; res = error_errno_set;
goto out; goto out;
} }
set_handle (ph); NTSTATUS status = open_pipe ();
set_pipe_non_blocking (ph, true); if (NT_SUCCESS (status))
if (!(fh = build_fh_dev (dev ())))
{ {
set_errno (EMFILE); record_connection (fc_handler[0]);
set_pipe_non_blocking (get_handle (), flags & O_NONBLOCK);
}
else
{
__seterrno_from_nt_status (status);
res = error_errno_set; res = error_errno_set;
goto out; goto out;
} }
if (!DuplicateHandle (GetCurrentProcess (), ph, GetCurrentProcess (),
&fh->get_handle (), 0, true, DUPLICATE_SAME_ACCESS))
{
res = error_set_errno;
fh->close ();
delete fh;
goto out;
}
fh->set_flags (flags);
if (!(connect_evt = create_event ()))
{
res = error_errno_set;
fh->close ();
delete fh;
goto out;
}
fc_handler[0] = fifo_client_handler (fh, fc_connected, connect_evt);
nconnected = nhandlers = 1;
} }
/* If we're reading, start the listen_client thread (which should /* If we're reading, start the listen_client thread (which should
@ -889,12 +869,13 @@ fhandler_fifo::close ()
return fhandler_base::close () || ret; return fhandler_base::close () || ret;
} }
/* If we're a writer, keep the nonblocking state of the windows pipe /* If we have a write handle (i.e., we're a duplexer or a writer),
in sync with our nonblocking state. */ keep the nonblocking state of the windows pipe in sync with our
nonblocking state. */
int int
fhandler_fifo::fcntl (int cmd, intptr_t arg) fhandler_fifo::fcntl (int cmd, intptr_t arg)
{ {
if (cmd != F_SETFL || !writer) if (cmd != F_SETFL || nohandle ())
return fhandler_base::fcntl (cmd, arg); return fhandler_base::fcntl (cmd, arg);
const bool was_nonblocking = is_nonblocking (); const bool was_nonblocking = is_nonblocking ();