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

5 files changed, 398 insertions, 2 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;
+}
+
diff --git a/configure.ac b/configure.ac
index dfa59b5..b434190 100644
--- a/configure.ac
+++ b/configure.ac
@@ -77,7 +77,7 @@ CFLAGS="$CFLAGS $CLANG_CFLAGS"
 LDFLAGS="$LDFLAGS $CLANG_FLAGS"
 
 AC_CHECK_FUNCS([arc4random_buf asprintf explicit_bzero funopen getauxval])
-AC_CHECK_FUNCS([getentropy issetugid memmem reallocarray])
+AC_CHECK_FUNCS([getentropy issetugid memmem poll reallocarray])
 AC_CHECK_FUNCS([strlcat strlcpy strndup strnlen strtonum])
 AC_CHECK_FUNCS([timingsafe_bcmp timingsafe_memcmp])
 
@@ -88,6 +88,7 @@ AM_CONDITIONAL([HAVE_EXPLICIT_BZERO], [test "x$ac_cv_func_explicit_bzero" = xyes
 AM_CONDITIONAL([HAVE_GETENTROPY], [test "x$ac_cv_func_getentropy" = xyes])
 AM_CONDITIONAL([HAVE_ISSETUGID], [test "x$ac_cv_func_issetugid" = xyes])
 AM_CONDITIONAL([HAVE_MEMMEM], [test "x$ac_cv_func_memmem" = xyes])
+AM_CONDITIONAL([HAVE_POLL], [test "x$ac_cv_func_poll" = xyes])
 AM_CONDITIONAL([HAVE_REALLOCARRAY], [test "x$ac_cv_func_reallocarray" = xyes])
 AM_CONDITIONAL([HAVE_STRLCAT], [test "x$ac_cv_func_strlcat" = xyes])
 AM_CONDITIONAL([HAVE_STRLCPY], [test "x$ac_cv_func_strlcpy" = xyes])
diff --git a/include/poll.h b/include/poll.h
new file mode 100644
index 0000000..37f32cd
--- /dev/null
+++ b/include/poll.h
@@ -0,0 +1,56 @@
+/*
+ * poll(2) emulation for Windows
+ * Public domain
+ * from Dongsheng Song <dongsheng.song@gmail.com>
+ */
+
+#ifndef LIBCRYPTOCOMPAT_POLL_H
+#define LIBCRYPTOCOMPAT_POLL_H
+
+#ifdef HAVE_POLL
+#include_next <poll.h>
+#else
+
+#include <winsock2.h>
+
+/* Type used for the number of file descriptors. */
+typedef unsigned long int nfds_t;
+
+#if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0600)
+/* Data structure describing a polling request. */
+struct pollfd {
+        int fd; /* file descriptor */
+        short events; /* requested events */
+        short revents; /* returned events */
+};
+
+/* Event types that can be polled */
+#define POLLIN 0x001 /* There is data to read. */
+#define POLLPRI 0x002 /* There is urgent data to read. */
+#define POLLOUT 0x004 /* Writing now will not block. */
+
+# define POLLRDNORM 0x040 /* Normal data may be read. */
+# define POLLRDBAND 0x080 /* Priority data may be read. */
+# define POLLWRNORM 0x100 /* Writing now will not block. */
+# define POLLWRBAND 0x200 /* Priority data may be written. */
+
+/* Event types always implicitly polled. */
+#define POLLERR 0x008 /* Error condition. */
+#define POLLHUP 0x010 /* Hung up. */
+#define POLLNVAL 0x020 /* Invalid polling request. */
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int poll(struct pollfd *pfds, nfds_t nfds, int timeout);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HAVE_POLL */
+
+#endif /* LIBCRYPTOCOMPAT_POLL_H */
diff --git a/update.sh b/update.sh
index cda2766..1038bb3 100755
--- a/update.sh
+++ b/update.sh
@@ -283,7 +283,6 @@ copy_crypto x509v3 "v3_bcons.c v3_bitst.c v3_conf.c v3_extku.c v3_ia5.c v3_lib.c
         pcy_cache.c pcy_node.c pcy_data.c pcy_map.c pcy_tree.c pcy_lib.c
         pcy_int.h ext_dat.h"
 
-rm -f apps/*.c apps/*.h
 for i in $openssl_cmd_src/*; do
         cp $i apps
 done
@@ -444,6 +443,7 @@ crypto_win32_only=(
 # conditional compiles
 $CP $libc_src/stdlib/strtonum.c apps/
 apps_excludes=(
+        poll.c
         strtonum.c
         )
 apps_posix_only=(