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;
+}
+