add minimal poll(2) implementation for Windows

This provides sufficient functionality to run openssl(1) from a Windows
console. This is based on the original select-based version from from
songdongsheng@live.cn. Changes:

 * use nfds_t directly for iterating the fds.
 * add WSAGetLastError -> errno mappings
 * handle POLLHUP and the OOB data cases for revents
 * handle sparse arrays of fds correctly
 * KNF style updates
 * teach poll how to handle file handles as well as sockets

This handles the socket/non-socket issue  by alternating a loop between
WaitForMultipleObjects for non-sockets and and select for sockets. One
would think this would be terrible for performance, but as of this
writing, poll consumes about 6% of the time doing a bulk transfer
between a Linux box and 'openssl.exe s_server'.

I tried to implement this all in terms of WaitForMultipleObjects with a
select 'poll' at the end to get extra specific socket status. However,
the cost of setting up an event handle for each socket, setting the
WSAEventSelect attributes, and cleaning them up reliably was pretty
high. Since the event handle associated with a socket is also global,
creating a new one cancels the previous one or can be disabled
externally.

In addition, the 'FD_WRITE' status of a socket event handle does not
behave in an expected fashion, being triggered by an edge on a write
event rather than being level triggered.

Another fun horror story is how stdin in windows might be a console, it
might be a pipe, it might be something else. If these all worked in the
same way, it would be great. But, since a console-stdin can also signal
on a mouse or window event, it means we can easily get stuck in a
blocking read (you can't make stdin non-blocking) if the non-character
events are not filtered out. So, poll does that too.

See here for various additional horror stories:

http://www.postgresql.org/message-id/4351.1336927207@sss.pgh.pa.us

2 files changed, 339 insertions, 0 deletions

diff --git a/apps/Makefile.am.tpl b/apps/Makefile.am.tpl
index deae953..16b3d8b 100644
--- a/apps/Makefile.am.tpl
+++ b/apps/Makefile.am.tpl
@@ -14,3 +14,8 @@ if !HAVE_STRTONUM
 openssl_SOURCES += strtonum.c
 endif
 
+if !HAVE_POLL
+if HOST_WIN
+openssl_SOURCES += poll.c
+endif
+endif
diff --git a/apps/poll.c b/apps/poll.c
new file mode 100644
index 0000000..bf30ccf
--- /dev/null
+++ b/apps/poll.c
@@ -0,0 +1,334 @@
+/*
+ * Public domain
+ *
+ * poll(2) emulation for Windows
+ *
+ * This emulates just-enough poll functionality on Windows to work in the
+ * context of the openssl(1) 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>
+ */
+
+#include <conio.h>
+#include <errno.h>
+#include <io.h>
+#include <poll.h>
+#include <ws2tcpip.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;
+}
+