343 lines
10 KiB
C
343 lines
10 KiB
C
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/*
|
|
* This file implements _PR_MD_PR_POLL for Win32.
|
|
*/
|
|
|
|
/* The default value of FD_SETSIZE is 64. */
|
|
#define FD_SETSIZE 1024
|
|
|
|
#include "primpl.h"
|
|
|
|
#if !defined(_PR_GLOBAL_THREADS_ONLY)
|
|
|
|
struct select_data_s {
|
|
PRInt32 status;
|
|
PRInt32 error;
|
|
fd_set *rd, *wt, *ex;
|
|
const struct timeval *tv;
|
|
};
|
|
|
|
static void
|
|
_PR_MD_select_thread(void *cdata)
|
|
{
|
|
struct select_data_s *cd = (struct select_data_s *)cdata;
|
|
|
|
cd->status = select(0, cd->rd, cd->wt, cd->ex, cd->tv);
|
|
|
|
if (cd->status == SOCKET_ERROR) {
|
|
cd->error = WSAGetLastError();
|
|
}
|
|
}
|
|
|
|
int _PR_NTFiberSafeSelect(
|
|
int nfds,
|
|
fd_set *readfds,
|
|
fd_set *writefds,
|
|
fd_set *exceptfds,
|
|
const struct timeval *timeout)
|
|
{
|
|
PRThread *me = _PR_MD_CURRENT_THREAD();
|
|
int ready;
|
|
|
|
if (_PR_IS_NATIVE_THREAD(me)) {
|
|
ready = _MD_SELECT(nfds, readfds, writefds, exceptfds, timeout);
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
** Creating a new thread on each call!!
|
|
** I guess web server doesn't use non-block I/O.
|
|
*/
|
|
PRThread *selectThread;
|
|
struct select_data_s data;
|
|
data.status = 0;
|
|
data.error = 0;
|
|
data.rd = readfds;
|
|
data.wt = writefds;
|
|
data.ex = exceptfds;
|
|
data.tv = timeout;
|
|
|
|
selectThread = PR_CreateThread(
|
|
PR_USER_THREAD, _PR_MD_select_thread, &data,
|
|
PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0);
|
|
if (selectThread == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
PR_JoinThread(selectThread);
|
|
ready = data.status;
|
|
if (ready == SOCKET_ERROR) {
|
|
WSASetLastError(data.error);
|
|
}
|
|
}
|
|
return ready;
|
|
}
|
|
|
|
#endif /* !defined(_PR_GLOBAL_THREADS_ONLY) */
|
|
|
|
PRInt32 _PR_MD_PR_POLL(PRPollDesc *pds, PRIntn npds, PRIntervalTime timeout)
|
|
{
|
|
int ready, err;
|
|
fd_set rd, wt, ex;
|
|
fd_set *rdp, *wtp, *exp;
|
|
int nrd, nwt, nex;
|
|
PRFileDesc *bottom;
|
|
PRPollDesc *pd, *epd;
|
|
PRThread *me = _PR_MD_CURRENT_THREAD();
|
|
|
|
struct timeval tv, *tvp = NULL;
|
|
|
|
if (_PR_PENDING_INTERRUPT(me))
|
|
{
|
|
me->flags &= ~_PR_INTERRUPT;
|
|
PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
** Is it an empty set? If so, just sleep for the timeout and return
|
|
*/
|
|
if (0 == npds)
|
|
{
|
|
PR_Sleep(timeout);
|
|
return 0;
|
|
}
|
|
|
|
nrd = nwt = nex = 0;
|
|
FD_ZERO(&rd);
|
|
FD_ZERO(&wt);
|
|
FD_ZERO(&ex);
|
|
|
|
ready = 0;
|
|
for (pd = pds, epd = pd + npds; pd < epd; pd++)
|
|
{
|
|
SOCKET osfd;
|
|
PRInt16 in_flags_read = 0, in_flags_write = 0;
|
|
PRInt16 out_flags_read = 0, out_flags_write = 0;
|
|
|
|
if ((NULL != pd->fd) && (0 != pd->in_flags))
|
|
{
|
|
if (pd->in_flags & PR_POLL_READ)
|
|
{
|
|
in_flags_read = (pd->fd->methods->poll)(
|
|
pd->fd, (PRInt16)(pd->in_flags & ~PR_POLL_WRITE),
|
|
&out_flags_read);
|
|
}
|
|
if (pd->in_flags & PR_POLL_WRITE)
|
|
{
|
|
in_flags_write = (pd->fd->methods->poll)(
|
|
pd->fd, (PRInt16)(pd->in_flags & ~PR_POLL_READ),
|
|
&out_flags_write);
|
|
}
|
|
if ((0 != (in_flags_read & out_flags_read))
|
|
|| (0 != (in_flags_write & out_flags_write)))
|
|
{
|
|
/* this one's ready right now (buffered input) */
|
|
if (0 == ready)
|
|
{
|
|
/*
|
|
* We will have to return without calling the
|
|
* system poll/select function. So zero the
|
|
* out_flags fields of all the poll descriptors
|
|
* before this one.
|
|
*/
|
|
PRPollDesc *prev;
|
|
for (prev = pds; prev < pd; prev++)
|
|
{
|
|
prev->out_flags = 0;
|
|
}
|
|
}
|
|
ready += 1;
|
|
pd->out_flags = out_flags_read | out_flags_write;
|
|
}
|
|
else
|
|
{
|
|
pd->out_flags = 0; /* pre-condition */
|
|
/* make sure this is an NSPR supported stack */
|
|
bottom = PR_GetIdentitiesLayer(pd->fd, PR_NSPR_IO_LAYER);
|
|
/* ignore a socket without PR_NSPR_IO_LAYER available */
|
|
|
|
if ((NULL != bottom)
|
|
&& (_PR_FILEDESC_OPEN == bottom->secret->state))
|
|
{
|
|
if (0 == ready)
|
|
{
|
|
osfd = (SOCKET) bottom->secret->md.osfd;
|
|
if (in_flags_read & PR_POLL_READ)
|
|
{
|
|
pd->out_flags |= _PR_POLL_READ_SYS_READ;
|
|
FD_SET(osfd, &rd);
|
|
nrd++;
|
|
}
|
|
if (in_flags_read & PR_POLL_WRITE)
|
|
{
|
|
pd->out_flags |= _PR_POLL_READ_SYS_WRITE;
|
|
FD_SET(osfd, &wt);
|
|
nwt++;
|
|
}
|
|
if (in_flags_write & PR_POLL_READ)
|
|
{
|
|
pd->out_flags |= _PR_POLL_WRITE_SYS_READ;
|
|
FD_SET(osfd, &rd);
|
|
nrd++;
|
|
}
|
|
if (in_flags_write & PR_POLL_WRITE)
|
|
{
|
|
pd->out_flags |= _PR_POLL_WRITE_SYS_WRITE;
|
|
FD_SET(osfd, &wt);
|
|
nwt++;
|
|
}
|
|
if (pd->in_flags & PR_POLL_EXCEPT) {
|
|
FD_SET(osfd, &ex);
|
|
nex++;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (0 == ready)
|
|
{
|
|
PRPollDesc *prev;
|
|
for (prev = pds; prev < pd; prev++)
|
|
{
|
|
prev->out_flags = 0;
|
|
}
|
|
}
|
|
ready += 1; /* this will cause an abrupt return */
|
|
pd->out_flags = PR_POLL_NVAL; /* bogii */
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pd->out_flags = 0;
|
|
}
|
|
}
|
|
|
|
if (0 != ready) {
|
|
return ready; /* no need to block */
|
|
}
|
|
|
|
/*
|
|
* FD_SET does nothing if the fd_set's internal fd_array is full. If
|
|
* nrd, nwt, or nex is greater than FD_SETSIZE, we know FD_SET must
|
|
* have failed to insert an osfd into the corresponding fd_set, and
|
|
* therefore we should fail.
|
|
*/
|
|
if ((nrd > FD_SETSIZE) || (nwt > FD_SETSIZE) || (nex > FD_SETSIZE)) {
|
|
PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
|
|
return -1;
|
|
}
|
|
|
|
rdp = (0 == nrd) ? NULL : &rd;
|
|
wtp = (0 == nwt) ? NULL : &wt;
|
|
exp = (0 == nex) ? NULL : &ex;
|
|
|
|
if ((NULL == rdp) && (NULL == wtp) && (NULL == exp)) {
|
|
PR_Sleep(timeout);
|
|
return 0;
|
|
}
|
|
|
|
if (timeout != PR_INTERVAL_NO_TIMEOUT)
|
|
{
|
|
PRInt32 ticksPerSecond = PR_TicksPerSecond();
|
|
tv.tv_sec = timeout / ticksPerSecond;
|
|
tv.tv_usec = PR_IntervalToMicroseconds( timeout % ticksPerSecond );
|
|
tvp = &tv;
|
|
}
|
|
|
|
#if defined(_PR_GLOBAL_THREADS_ONLY)
|
|
ready = _MD_SELECT(0, rdp, wtp, exp, tvp);
|
|
#else
|
|
ready = _PR_NTFiberSafeSelect(0, rdp, wtp, exp, tvp);
|
|
#endif
|
|
|
|
/*
|
|
** Now to unravel the select sets back into the client's poll
|
|
** descriptor list. Is this possibly an area for pissing away
|
|
** a few cycles or what?
|
|
*/
|
|
if (ready > 0)
|
|
{
|
|
ready = 0;
|
|
for (pd = pds, epd = pd + npds; pd < epd; pd++)
|
|
{
|
|
PRInt16 out_flags = 0;
|
|
if ((NULL != pd->fd) && (0 != pd->in_flags))
|
|
{
|
|
SOCKET osfd;
|
|
bottom = PR_GetIdentitiesLayer(pd->fd, PR_NSPR_IO_LAYER);
|
|
PR_ASSERT(NULL != bottom);
|
|
|
|
osfd = (SOCKET) bottom->secret->md.osfd;
|
|
|
|
if (FD_ISSET(osfd, &rd))
|
|
{
|
|
if (pd->out_flags & _PR_POLL_READ_SYS_READ) {
|
|
out_flags |= PR_POLL_READ;
|
|
}
|
|
if (pd->out_flags & _PR_POLL_WRITE_SYS_READ) {
|
|
out_flags |= PR_POLL_WRITE;
|
|
}
|
|
}
|
|
if (FD_ISSET(osfd, &wt))
|
|
{
|
|
if (pd->out_flags & _PR_POLL_READ_SYS_WRITE) {
|
|
out_flags |= PR_POLL_READ;
|
|
}
|
|
if (pd->out_flags & _PR_POLL_WRITE_SYS_WRITE) {
|
|
out_flags |= PR_POLL_WRITE;
|
|
}
|
|
}
|
|
if (FD_ISSET(osfd, &ex)) {
|
|
out_flags |= PR_POLL_EXCEPT;
|
|
}
|
|
}
|
|
pd->out_flags = out_flags;
|
|
if (out_flags) {
|
|
ready++;
|
|
}
|
|
}
|
|
PR_ASSERT(ready > 0);
|
|
}
|
|
else if (ready == SOCKET_ERROR)
|
|
{
|
|
err = WSAGetLastError();
|
|
if (err == WSAENOTSOCK)
|
|
{
|
|
/* Find the bad fds */
|
|
int optval;
|
|
int optlen = sizeof(optval);
|
|
ready = 0;
|
|
for (pd = pds, epd = pd + npds; pd < epd; pd++)
|
|
{
|
|
pd->out_flags = 0;
|
|
if ((NULL != pd->fd) && (0 != pd->in_flags))
|
|
{
|
|
bottom = PR_GetIdentitiesLayer(pd->fd, PR_NSPR_IO_LAYER);
|
|
if (getsockopt(bottom->secret->md.osfd, SOL_SOCKET,
|
|
SO_TYPE, (char *) &optval, &optlen) == -1)
|
|
{
|
|
PR_ASSERT(WSAGetLastError() == WSAENOTSOCK);
|
|
if (WSAGetLastError() == WSAENOTSOCK)
|
|
{
|
|
pd->out_flags = PR_POLL_NVAL;
|
|
ready++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
PR_ASSERT(ready > 0);
|
|
}
|
|
else {
|
|
_PR_MD_MAP_SELECT_ERROR(err);
|
|
}
|
|
}
|
|
|
|
return ready;
|
|
}
|