poll.c

poll_compat.c (6908B)

---

 /*
  * Public domain
  *
  * poll(2) emulation for Windows
  *
  * This emulates just-enough poll functionality on Windows to work in the
  * context of this program. This is not a replacement for POSIX.1-2001 poll(2),
  * though it may come closer than I care to admit.
  *
  * Dongsheng Song <dongsheng.song@gmail.com>
  * Brent Cook <bcook@openbsd.org>
  */
 
 #ifdef _WIN32
 
 #include <conio.h>
 #include <errno.h>
 #include <io.h>
 #include <ws2tcpip.h>
 
 #include "poll_compat.h"
 
 static int
 conn_is_closed(int fd)
 {
 	char buf[1];
 	int ret = recv(fd, buf, 1, MSG_PEEK);
 	if (ret == -1) {
 		switch (WSAGetLastError()) {
 		case WSAECONNABORTED:
 		case WSAECONNRESET:
 		case WSAENETRESET:
 		case WSAESHUTDOWN:
 			return 1;
 		}
 	}
 	return 0;
 }
 
 static int
 conn_has_oob_data(int fd)
 {
 	char buf[1];
 	return (recv(fd, buf, 1, MSG_PEEK | MSG_OOB) == 1);
 }
 
 static int
 is_socket(int fd)
 {
 	WSANETWORKEVENTS events;
 	return (WSAEnumNetworkEvents((SOCKET)fd, NULL, &events) == 0);
 }
 
 static int
 compute_select_revents(int fd, short events,
     fd_set *rfds, fd_set *wfds, fd_set *efds)
 {
 	int rc = 0;
 
 	if ((events & (POLLIN | POLLRDNORM | POLLRDBAND)) &&
 			FD_ISSET(fd, rfds)) {
 		if (conn_is_closed(fd))
 			rc |= POLLHUP;
 		else
 			rc |= POLLIN | POLLRDNORM;
 	}
 
 	if ((events & (POLLOUT | POLLWRNORM | POLLWRBAND)) &&
 			FD_ISSET(fd, wfds))
 		rc |= POLLOUT;
 
 	if (FD_ISSET(fd, efds)) {
 		if (conn_is_closed(fd))
 			rc |= POLLHUP;
 		else if (conn_has_oob_data(fd))
 			rc |= POLLRDBAND | POLLPRI;
 	}
 
 	return rc;
 }
 
 static int
 compute_wait_revents(HANDLE h, short events, int object, int wait_rc)
 {
 	int rc = 0;
 	INPUT_RECORD record;
 	DWORD num_read;
 
 	/*
 	 * Assume we can always write to file handles (probably a bad
 	 * assumption but works for now, at least it doesn't block).
 	 */
 	if (events & (POLLOUT | POLLWRNORM))
 		rc |= POLLOUT;
 
 	/*
 	 * Check if this handle was signaled by WaitForMultipleObjects
 	 */
 	if (wait_rc >= WAIT_OBJECT_0 && (object == (wait_rc - WAIT_OBJECT_0))
 	    && (events & (POLLIN | POLLRDNORM))) {
 
 		/*
 		 * Check if this file is stdin, and if so, if it is a console.
 		 */
 		if (h == GetStdHandle(STD_INPUT_HANDLE) &&
 		    PeekConsoleInput(h, &record, 1, &num_read) == 1) {
 
 			/*
 			 * Handle the input console buffer differently,
 			 * since it can signal on other events like
 			 * window and mouse, but read can still block.
 			 */
 			if (record.EventType == KEY_EVENT &&
 			    record.Event.KeyEvent.bKeyDown) {
 				rc |= POLLIN;
 			} else {
 				/*
 				 * Flush non-character events from the
 				 * console buffer.
 				 */
 				ReadConsoleInput(h, &record, 1, &num_read);
 			}
 		} else {
 			rc |= POLLIN;
 		}
 	}
 
 	return rc;
 }
 
 static int
 wsa_select_errno(int err)
 {
 	switch (err) {
 	case WSAEINTR:
 	case WSAEINPROGRESS:
 		errno = EINTR;
 		break;
 	case WSAEFAULT:
 		/*
 		 * Windows uses WSAEFAULT for both resource allocation failures
 		 * and arguments not being contained in the user's address
 		 * space. So, we have to choose EFAULT or ENOMEM.
 		 */
 		errno = EFAULT;
 		break;
 	case WSAEINVAL:
 		errno = EINVAL;
 		break;
 	case WSANOTINITIALISED:
 		errno = EPERM;
 		break;
 	case WSAENETDOWN:
 		errno = ENOMEM;
 		break;
 	}
 	return -1;
 }
 
 int
 poll(struct pollfd *pfds, nfds_t nfds, int timeout_ms)
 {
 	nfds_t i;
 	int timespent_ms, looptime_ms;
 
 #define FD_IS_SOCKET (1 << 0)
 	int fd_state[FD_SETSIZE];
 	int num_fds;
 
 	/*
 	 * select machinery
 	 */
 	fd_set rfds, wfds, efds;
 	int rc;
 	int num_sockets;
 
 	/*
 	 * wait machinery
 	 */
 	DWORD wait_rc;
 	HANDLE handles[FD_SETSIZE];
 	int num_handles;
 
 	if (pfds == NULL) {
 		errno = EINVAL;
 		return -1;
 	}
 
 	if (nfds <= 0) {
 		return 0;
 	}
 
 	FD_ZERO(&rfds);
 	FD_ZERO(&wfds);
 	FD_ZERO(&efds);
 	num_fds = 0;
 	num_sockets = 0;
 	num_handles = 0;
 
 	for (i = 0; i < nfds; i++) {
 		if ((int)pfds[i].fd < 0) {
 			continue;
 		}
 
 		if (is_socket(pfds[i].fd)) {
 			if (num_sockets >= FD_SETSIZE) {
 				errno = EINVAL;
 				return -1;
 			}
 
 			fd_state[num_fds] = FD_IS_SOCKET;
 
 			FD_SET(pfds[i].fd, &efds);
 
 			if (pfds[i].events &
 			    (POLLIN | POLLRDNORM | POLLRDBAND)) {
 				FD_SET(pfds[i].fd, &rfds);
 			}
 
 			if (pfds[i].events &
 			    (POLLOUT | POLLWRNORM | POLLWRBAND)) {
 				FD_SET(pfds[i].fd, &wfds);
 			}
 			num_sockets++;
 
 		} else {
 			if (num_handles >= FD_SETSIZE) {
 				errno = EINVAL;
 				return -1;
 			}
 
 			handles[num_handles++] =
 			    (HANDLE)_get_osfhandle(pfds[i].fd);
 		}
 
 		num_fds++;
 	}
 
 	/*
 	 * Determine if the files, pipes, sockets, consoles, etc. have signaled.
 	 *
 	 * Do this by alternating a loop between WaitForMultipleObjects for
 	 * non-sockets and and select for sockets.
 	 *
 	 * I tried to implement this all in terms of WaitForMultipleObjects
 	 * with a select-based 'poll' of the sockets at the end to get extra
 	 * specific socket status.
 	 *
 	 * However, the cost of setting up an event handle for each socket and
 	 * cleaning them up reliably was pretty high. Since the event handle
 	 * associated with a socket is also global, creating a new one here
 	 * cancels one that may exist externally to this function.
 	 *
 	 * At any rate, even if global socket event handles were not an issue,
 	 * the 'FD_WRITE' status of a socket event handle does not behave in an
 	 * expected fashion, being triggered by an edge on a write buffer rather
 	 * than simply triggering if there is space available.
 	 */
 	timespent_ms = 0;
 	wait_rc = 0;
 
 	if (timeout_ms < 0) {
 		timeout_ms = INFINITE;
 	}
 	looptime_ms = timeout_ms > 100 ? 100 : timeout_ms;
 
 	do {
 		struct timeval tv = {0, looptime_ms * 1000};
 
 		/*
 		 * Check if any file handles have signaled
 		 */
 		if (num_handles) {
 			wait_rc = WaitForMultipleObjects(num_handles, handles, FALSE, 0);
 			if (wait_rc == WAIT_FAILED) {
 				/*
 				 * The documentation for WaitForMultipleObjects
 				 * does not specify what values GetLastError
 				 * may return here. Rather than enumerate
 				 * badness like for wsa_select_errno, assume a
 				 * general errno value.
 				 */
 				errno = ENOMEM;
 				return 0;
 			}
 		}
 
 		/*
 		 * If we signaled on a file handle, don't wait on the sockets.
 		 */
 		if (wait_rc >= WAIT_OBJECT_0)
 			tv.tv_usec = 0;
 
 		/*
 		 * Check if any sockets have signaled
 		 */
 		rc = select(0, &rfds, &wfds, &efds, &tv);
 		if (rc == SOCKET_ERROR) {
 			return wsa_select_errno(WSAGetLastError());
 		}
 
 		if (wait_rc >= WAIT_OBJECT_0 || (num_sockets && rc > 0))
 			break;
 
 		timespent_ms += looptime_ms;
 
 	} while (timespent_ms < timeout_ms);
 
 	rc = 0;
 	num_handles = 0;
 	num_fds = 0;
 	for (i = 0; i < nfds; i++) {
 		pfds[i].revents = 0;
 
 		if ((int)pfds[i].fd < 0)
 			continue;
 
 		if (fd_state[num_fds] & FD_IS_SOCKET) {
 			pfds[i].revents = compute_select_revents(pfds[i].fd,
 			    pfds[i].events, &rfds, &wfds, &efds);
 
 		} else {
 			pfds[i].revents = compute_wait_revents(
 			    handles[num_handles], pfds[i].events, num_handles,
 			    wait_rc);
 			num_handles++;
 		}
 
 		num_fds++;
 
 		if (pfds[i].revents)
 			rc++;
 	}
 
 	return rc;
 }
 
 #endif // _WIN32