static apr_status_t impl_pollset_poll(apr_pollset_t *pollset,
apr_interval_time_t timeout,
apr_int32_t *num,
const apr_pollfd_t **descriptors)
{
int rs;
apr_uint32_t i, j;
struct timeval tv, *tvptr;
fd_set readset, writeset, exceptset;
apr_status_t rv = APR_SUCCESS;
#ifdef WIN32
/* On Win32, select() must be presented with at least one socket to
* poll on, or select() will return WSAEINVAL. So, we'll just
* short-circuit and bail now.
*/
if (pollset->nelts == 0) {
(*num) = 0;
if (timeout > 0) {
apr_sleep(timeout);
return APR_TIMEUP;
}
return APR_SUCCESS;
}
#endif
if (timeout < 0) {
tvptr = NULL;
}
else {
tv.tv_sec = (long) apr_time_sec(timeout);
tv.tv_usec = (long) apr_time_usec(timeout);
tvptr = &tv;
}
memcpy(&readset, &(pollset->p->readset), sizeof(fd_set));
memcpy(&writeset, &(pollset->p->writeset), sizeof(fd_set));
memcpy(&exceptset, &(pollset->p->exceptset), sizeof(fd_set));
#ifdef NETWARE
if (HAS_PIPES(pollset->p->set_type)) {
rs = pipe_select(pollset->p->maxfd + 1, &readset, &writeset, &exceptset,
tvptr);
}
else
#endif
rs = select(pollset->p->maxfd + 1, &readset, &writeset, &exceptset,
tvptr);
(*num) = rs;
if (rs < 0) {
return apr_get_netos_error();
}
if (rs == 0) {
return APR_TIMEUP;
}
j = 0;
for (i = 0; i < pollset->nelts; i++) {
apr_os_sock_t fd;
if (pollset->p->query_set[i].desc_type == APR_POLL_SOCKET) {
fd = pollset->p->query_set[i].desc.s->socketdes;
}
else {
if ((pollset->flags & APR_POLLSET_WAKEABLE) &&
pollset->p->query_set[i].desc.f == pollset->wakeup_pipe[0]) {
apr_pollset_drain_wakeup_pipe(pollset);
rv = APR_EINTR;
continue;
}
else {
#if !APR_FILES_AS_SOCKETS
return APR_EBADF;
#else
fd = pollset->p->query_set[i].desc.f->filedes;
#endif
}
}
if (FD_ISSET(fd, &readset) || FD_ISSET(fd, &writeset) ||
FD_ISSET(fd, &exceptset)) {
pollset->p->result_set[j] = pollset->p->query_set[i];
pollset->p->result_set[j].rtnevents = 0;
if (FD_ISSET(fd, &readset)) {
pollset->p->result_set[j].rtnevents |= APR_POLLIN;
}
if (FD_ISSET(fd, &writeset)) {
pollset->p->result_set[j].rtnevents |= APR_POLLOUT;
}
if (FD_ISSET(fd, &exceptset)) {
pollset->p->result_set[j].rtnevents |= APR_POLLERR;
}
j++;
}
}
if (((*num) = j) != 0)
rv = APR_SUCCESS;
if (descriptors)
*descriptors = pollset->p->result_set;
return rv;
}
APR_DECLARE(apr_status_t) apr_poll(apr_pollfd_t *aprset, int num,
apr_int32_t *nsds,
apr_interval_time_t timeout)
{
fd_set readset, writeset, exceptset;
int rv, i;
int maxfd = -1;
struct timeval tv, *tvptr;
#ifdef NETWARE
apr_datatype_e set_type = APR_NO_DESC;
#endif
#ifdef WIN32
/* On Win32, select() must be presented with at least one socket to
* poll on, or select() will return WSAEINVAL. So, we'll just
* short-circuit and bail now.
*/
if (num == 0) {
(*nsds) = 0;
if (timeout > 0) {
apr_sleep(timeout);
return APR_TIMEUP;
}
return APR_SUCCESS;
}
#endif
if (timeout < 0) {
tvptr = NULL;
}
else {
tv.tv_sec = (long) apr_time_sec(timeout);
tv.tv_usec = (long) apr_time_usec(timeout);
tvptr = &tv;
}
FD_ZERO(&readset);
FD_ZERO(&writeset);
FD_ZERO(&exceptset);
for (i = 0; i < num; i++) {
apr_os_sock_t fd;
aprset[i].rtnevents = 0;
if (aprset[i].desc_type == APR_POLL_SOCKET) {
#ifdef NETWARE
if (HAS_PIPES(set_type)) {
return APR_EBADF;
}
else {
set_type = APR_POLL_SOCKET;
}
#endif
fd = aprset[i].desc.s->socketdes;
}
else if (aprset[i].desc_type == APR_POLL_FILE) {
#if !APR_FILES_AS_SOCKETS
return APR_EBADF;
#else
#ifdef NETWARE
if (aprset[i].desc.f->is_pipe && !HAS_SOCKETS(set_type)) {
set_type = APR_POLL_FILE;
}
else
return APR_EBADF;
#endif /* NETWARE */
fd = aprset[i].desc.f->filedes;
#endif /* APR_FILES_AS_SOCKETS */
}
else {
break;
}
#if !defined(WIN32) && !defined(NETWARE) /* socket sets handled with array of handles */
if (fd >= FD_SETSIZE) {
/* XXX invent new error code so application has a clue */
return APR_EBADF;
}
#endif
if (aprset[i].reqevents & APR_POLLIN) {
FD_SET(fd, &readset);
}
if (aprset[i].reqevents & APR_POLLOUT) {
FD_SET(fd, &writeset);
}
if (aprset[i].reqevents &
(APR_POLLPRI | APR_POLLERR | APR_POLLHUP | APR_POLLNVAL)) {
FD_SET(fd, &exceptset);
}
if ((int) fd > maxfd) {
maxfd = (int) fd;
}
}
#ifdef NETWARE
if (HAS_PIPES(set_type)) {
rv = pipe_select(maxfd + 1, &readset, &writeset, &exceptset, tvptr);
}
else {
#endif
rv = select(maxfd + 1, &readset, &writeset, &exceptset, tvptr);
#ifdef NETWARE
}
#endif
(*nsds) = rv;
if ((*nsds) == 0) {
return APR_TIMEUP;
}
if ((*nsds) < 0) {
return apr_get_netos_error();
}
(*nsds) = 0;
for (i = 0; i < num; i++) {
apr_os_sock_t fd;
if (aprset[i].desc_type == APR_POLL_SOCKET) {
fd = aprset[i].desc.s->socketdes;
}
else if (aprset[i].desc_type == APR_POLL_FILE) {
#if !APR_FILES_AS_SOCKETS
return APR_EBADF;
#else
fd = aprset[i].desc.f->filedes;
#endif
}
else {
break;
}
if (FD_ISSET(fd, &readset)) {
aprset[i].rtnevents |= APR_POLLIN;
}
if (FD_ISSET(fd, &writeset)) {
aprset[i].rtnevents |= APR_POLLOUT;
}
if (FD_ISSET(fd, &exceptset)) {
aprset[i].rtnevents |= APR_POLLERR;
}
if (aprset[i].rtnevents) {
(*nsds)++;
}
}
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) apr_pollset_poll(apr_pollset_t *pollset,
apr_interval_time_t timeout,
apr_int32_t *num,
const apr_pollfd_t **descriptors)
{
int rv;
apr_uint32_t i, j;
struct timeval tv, *tvptr;
fd_set readset, writeset, exceptset;
if (timeout < 0) {
tvptr = NULL;
}
else {
tv.tv_sec = (long) apr_time_sec(timeout);
tv.tv_usec = (long) apr_time_usec(timeout);
tvptr = &tv;
}
memcpy(&readset, &(pollset->readset), sizeof(fd_set));
memcpy(&writeset, &(pollset->writeset), sizeof(fd_set));
memcpy(&exceptset, &(pollset->exceptset), sizeof(fd_set));
#ifdef NETWARE
if (HAS_PIPES(pollset->set_type)) {
rv = pipe_select(pollset->maxfd + 1, &readset, &writeset, &exceptset,
tvptr);
}
else
#endif
rv = select(pollset->maxfd + 1, &readset, &writeset, &exceptset,
tvptr);
(*num) = rv;
if (rv < 0) {
return apr_get_netos_error();
}
if (rv == 0) {
return APR_TIMEUP;
}
j = 0;
for (i = 0; i < pollset->nelts; i++) {
apr_os_sock_t fd;
if (pollset->query_set[i].desc_type == APR_POLL_SOCKET) {
fd = pollset->query_set[i].desc.s->socketdes;
}
else {
#if !APR_FILES_AS_SOCKETS
return APR_EBADF;
#else
fd = pollset->query_set[i].desc.f->filedes;
#endif
}
if (FD_ISSET(fd, &readset) || FD_ISSET(fd, &writeset) ||
FD_ISSET(fd, &exceptset)) {
pollset->result_set[j] = pollset->query_set[i];
pollset->result_set[j].rtnevents = 0;
if (FD_ISSET(fd, &readset)) {
pollset->result_set[j].rtnevents |= APR_POLLIN;
}
if (FD_ISSET(fd, &writeset)) {
pollset->result_set[j].rtnevents |= APR_POLLOUT;
}
if (FD_ISSET(fd, &exceptset)) {
pollset->result_set[j].rtnevents |= APR_POLLERR;
}
j++;
}
}
(*num) = j;
if (descriptors)
*descriptors = pollset->result_set;
return APR_SUCCESS;
}
static apr_status_t impl_pollset_add(apr_pollset_t *pollset,
const apr_pollfd_t *descriptor)
{
apr_os_sock_t fd;
if (pollset->nelts == pollset->nalloc) {
return APR_ENOMEM;
}
pollset->p->query_set[pollset->nelts] = *descriptor;
if (descriptor->desc_type == APR_POLL_SOCKET) {
#ifdef NETWARE
/* NetWare can't handle mixed descriptor types in select() */
if (HAS_PIPES(pollset->p->set_type)) {
return APR_EBADF;
}
else {
pollset->p->set_type = APR_POLL_SOCKET;
}
#endif
fd = descriptor->desc.s->socketdes;
}
else {
#if !APR_FILES_AS_SOCKETS
if ((pollset->flags & APR_POLLSET_WAKEABLE) &&
descriptor->desc.f == pollset->wakeup_pipe[0])
fd = (apr_os_sock_t)descriptor->desc.f->filedes;
else
return APR_EBADF;
#else
#ifdef NETWARE
/* NetWare can't handle mixed descriptor types in select() */
if (descriptor->desc.f->is_pipe && !HAS_SOCKETS(pollset->p->set_type)) {
pollset->p->set_type = APR_POLL_FILE;
fd = descriptor->desc.f->filedes;
}
else {
return APR_EBADF;
}
#else
fd = descriptor->desc.f->filedes;
#endif
#endif
}
#if !defined(WIN32) && !defined(NETWARE) /* socket sets handled with array of handles */
if (fd >= FD_SETSIZE) {
/* XXX invent new error code so application has a clue */
return APR_EBADF;
}
#endif
if (descriptor->reqevents & APR_POLLIN) {
FD_SET(fd, &(pollset->p->readset));
}
if (descriptor->reqevents & APR_POLLOUT) {
FD_SET(fd, &(pollset->p->writeset));
}
if (descriptor->reqevents &
(APR_POLLPRI | APR_POLLERR | APR_POLLHUP | APR_POLLNVAL)) {
FD_SET(fd, &(pollset->p->exceptset));
}
if ((int) fd > pollset->p->maxfd) {
pollset->p->maxfd = (int) fd;
}
pollset->nelts++;
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) apr_pollset_poll(apr_pollset_t *pollset,
apr_interval_time_t timeout,
apr_int32_t *num,
const apr_pollfd_t **descriptors)
{
int rv;
apr_uint32_t i, j;
struct timeval tv, *tvptr;
fd_set readset, writeset, exceptset;
if (timeout < 0) {
tvptr = NULL;
}
else {
tv.tv_sec = (long)apr_time_sec(timeout);
tv.tv_usec = (long)apr_time_usec(timeout);
tvptr = &tv;
}
memcpy(&readset, &(pollset->readset), sizeof(fd_set));
memcpy(&writeset, &(pollset->writeset), sizeof(fd_set));
memcpy(&exceptset, &(pollset->exceptset), sizeof(fd_set));
#ifdef NETWARE
if (HAS_PIPES(pollset->set_type)) {
rv = pipe_select(pollset->maxfd + 1, &readset, &writeset, &exceptset, tvptr);
}
else
#endif
rv = select(pollset->maxfd + 1, &readset, &writeset, &exceptset, tvptr);
/* Set initial *num now for expected -1 / 0 failures, or errors below */
(*num) = rv;
if (rv < 0) {
return apr_get_netos_error();
}
if (rv == 0) {
return APR_TIMEUP;
}
j = 0;
for (i = 0; i < pollset->nelts; i++) {
apr_os_sock_t fd;
if (pollset->query_set[i].desc_type == APR_POLL_SOCKET) {
fd = pollset->query_set[i].desc.s->socketdes;
}
else {
#if !APR_FILES_AS_SOCKETS
return APR_EBADF;
#else
fd = pollset->query_set[i].desc.f->filedes;
#endif
}
if (FD_ISSET(fd, &readset) || FD_ISSET(fd, &writeset) ||
FD_ISSET(fd, &exceptset)) {
pollset->result_set[j] = pollset->query_set[i];
pollset->result_set[j].rtnevents = 0;
if (FD_ISSET(fd, &readset)) {
pollset->result_set[j].rtnevents |= APR_POLLIN;
}
if (FD_ISSET(fd, &writeset)) {
pollset->result_set[j].rtnevents |= APR_POLLOUT;
}
if (FD_ISSET(fd, &exceptset)) {
pollset->result_set[j].rtnevents |= APR_POLLERR;
}
j++;
}
}
/* Reset computed *num to account for multiply-polled fd's which
* select() - on some platforms, treats as a single fd result.
* The *num returned must match the size of result_set[]
*/
(*num) = j;
*descriptors = pollset->result_set;
return APR_SUCCESS;
}
