1 files changed, 453 insertions, 0 deletions

diff --git a/src/lib/daemon_poll.c b/src/lib/daemon_poll.c
new file mode 100644
index 00000000..118c0579
--- /dev/null
+++ b/src/lib/daemon_poll.c
@@ -0,0 +1,453 @@
+/*
+  This file is part of libmicrohttpd
+  Copyright (C) 2007-2018 Daniel Pittman and Christian Grothoff
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+/**
+ * @file lib/daemon_poll.c
+ * @brief functions to run poll-based event loop
+ * @author Christian Grothoff
+ */
+#include "internal.h"
+#include "daemon_poll.h"
+
+#ifdef HAVE_POLL
+
+
+#if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
+
+/**
+ * Set required 'event' members in 'pollfd' elements,
+ * assuming that @a p[0].fd is MHD side of socketpair
+ * and @a p[1].fd is TLS connected socket.
+ *
+ * @param urh upgrade handle to watch for
+ * @param p pollfd array to update
+ */
+static void
+urh_update_pollfd (struct MHD_UpgradeResponseHandle *urh,
+                   struct pollfd p[2])
+{
+  p[0].events = 0;
+  p[1].events = 0;
+
+  if (urh->in_buffer_used < urh->in_buffer_size)
+    p[0].events |= POLLIN;
+  if (0 != urh->out_buffer_used)
+    p[0].events |= POLLOUT;
+
+  /* Do not monitor again for errors if error was detected before as
+   * error state is remembered. */
+  if ((0 == (urh->app.celi & MHD_EPOLL_STATE_ERROR)) &&
+      ((0 != urh->in_buffer_size) ||
+       (0 != urh->out_buffer_size) ||
+       (0 != urh->out_buffer_used)))
+    p[0].events |= MHD_POLL_EVENTS_ERR_DISC;
+
+  if (urh->out_buffer_used < urh->out_buffer_size)
+    p[1].events |= POLLIN;
+  if (0 != urh->in_buffer_used)
+    p[1].events |= POLLOUT;
+
+  /* Do not monitor again for errors if error was detected before as
+   * error state is remembered. */
+  if ((0 == (urh->mhd.celi & MHD_EPOLL_STATE_ERROR)) &&
+      ((0 != urh->out_buffer_size) ||
+       (0 != urh->in_buffer_size) ||
+       (0 != urh->in_buffer_used)))
+    p[1].events |= MHD_POLL_EVENTS_ERR_DISC;
+}
+ 
+
+/**
+ * Set @a p to watch for @a urh.
+ *
+ * @param urh upgrade handle to watch for
+ * @param p pollfd array to set
+ */
+static void
+urh_to_pollfd (struct MHD_UpgradeResponseHandle *urh,
+               struct pollfd p[2])
+{
+  p[0].fd = urh->connection->socket_fd;
+  p[1].fd = urh->mhd.socket;
+  urh_update_pollfd (urh,
+                     p);
+}
+
+
+/**
+ * Update ready state in @a urh based on pollfd.
+ * @param urh upgrade handle to update
+ * @param p 'poll()' processed pollfd.
+ */
+static void
+urh_from_pollfd (struct MHD_UpgradeResponseHandle *urh,
+                 struct pollfd p[2])
+{
+  /* Reset read/write ready, preserve error state. */
+  urh->app.celi &= (~MHD_EPOLL_STATE_READ_READY & ~MHD_EPOLL_STATE_WRITE_READY);
+  urh->mhd.celi &= (~MHD_EPOLL_STATE_READ_READY & ~MHD_EPOLL_STATE_WRITE_READY);
+
+  if (0 != (p[0].revents & POLLIN))
+    urh->app.celi |= MHD_EPOLL_STATE_READ_READY;
+  if (0 != (p[0].revents & POLLOUT))
+    urh->app.celi |= MHD_EPOLL_STATE_WRITE_READY;
+  if (0 != (p[0].revents & POLLHUP))
+    urh->app.celi |= MHD_EPOLL_STATE_READ_READY | MHD_EPOLL_STATE_WRITE_READY;
+  if (0 != (p[0].revents & MHD_POLL_REVENTS_ERRROR))
+    urh->app.celi |= MHD_EPOLL_STATE_ERROR;
+  if (0 != (p[1].revents & POLLIN))
+    urh->mhd.celi |= MHD_EPOLL_STATE_READ_READY;
+  if (0 != (p[1].revents & POLLOUT))
+    urh->mhd.celi |= MHD_EPOLL_STATE_WRITE_READY;
+  if (0 != (p[1].revents & POLLHUP))
+    urh->mhd.celi |= MHD_EPOLL_STATE_ERROR;
+  if (0 != (p[1].revents & MHD_POLL_REVENTS_ERRROR))
+    urh->mhd.celi |= MHD_EPOLL_STATE_READ_READY | MHD_EPOLL_STATE_WRITE_READY;
+}
+#endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
+
+
+/**
+ * Process all of our connections and possibly the server
+ * socket using poll().
+ *
+ * @param daemon daemon to run poll loop for
+ * @param may_block #MHD_YES if blocking, #MHD_NO if non-blocking
+ * @return #MHD_SC_OK on success
+ */
+enum MHD_StatusCode
+MHD_daemon_poll_all_ (struct MHD_Daemon *daemon,
+                      bool may_block)
+{
+  unsigned int num_connections;
+  struct MHD_Connection *pos;
+  struct MHD_Connection *prev;
+#if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
+  struct MHD_UpgradeResponseHandle *urh;
+  struct MHD_UpgradeResponseHandle *urhn;
+#endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
+
+  if ( (! daemon->disallow_suspend_resume) &&
+       (MHD_YES == resume_suspended_connections (daemon)) )
+    may_block = false;
+
+  /* count number of connections and thus determine poll set size */
+  num_connections = 0;
+  for (pos = daemon->connections_head; NULL != pos; pos = pos->next)
+    num_connections++;
+#if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
+  for (urh = daemon->urh_head; NULL != urh; urh = urh->next)
+    num_connections += 2;
+#endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
+  {
+    MHD_UNSIGNED_LONG_LONG ltimeout;
+    unsigned int i;
+    int timeout;
+    unsigned int poll_server;
+    int poll_listen;
+    int poll_itc_idx;
+    struct pollfd *p;
+    MHD_socket ls;
+
+    p = MHD_calloc_ ((2 + num_connections),
+                     sizeof (struct pollfd));
+    if (NULL == p)
+      {
+#ifdef HAVE_MESSAGES
+        MHD_DLOG (daemon,
+                  MHD_SC_POLL_MALLOC_FAILURE,
+                  _("Error allocating memory: %s\n"),
+                  MHD_strerror_(errno));
+#endif
+        return MHD_SC_POLL_MALLOC_FAILURE;
+      }
+    poll_server = 0;
+    poll_listen = -1;
+    if ( (MHD_INVALID_SOCKET != (ls = daemon->listen_socket)) &&
+         (! daemon->was_quiesced) &&
+         (daemon->connections < daemon->global_connection_limit) &&
+         (! daemon->at_limit) )
+      {
+        /* only listen if we are not at the connection limit */
+        p[poll_server].fd = ls;
+        p[poll_server].events = POLLIN;
+        p[poll_server].revents = 0;
+        poll_listen = (int) poll_server;
+        poll_server++;
+      }
+    poll_itc_idx = -1;
+    if (MHD_ITC_IS_VALID_(daemon->itc))
+      {
+        p[poll_server].fd = MHD_itc_r_fd_ (daemon->itc);
+        p[poll_server].events = POLLIN;
+        p[poll_server].revents = 0;
+        poll_itc_idx = (int) poll_server;
+        poll_server++;
+      }
+    if (! may_block)
+      timeout = 0;
+    else if ( (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_model) ||
+              (MHD_SC_OK != /* FIXME: distinguish between NO_TIMEOUT and errors! */
+               MHD_daemon_get_timeout (daemon,
+                                       &ltimeout)) )
+      timeout = -1;
+    else
+      timeout = (ltimeout > INT_MAX) ? INT_MAX : (int) ltimeout;
+
+    i = 0;
+    for (pos = daemon->connections_tail; NULL != pos; pos = pos->prev)
+      {
+        p[poll_server+i].fd = pos->socket_fd;
+        switch (pos->request.event_loop_info)
+          {
+          case MHD_EVENT_LOOP_INFO_READ:
+            p[poll_server+i].events |= POLLIN | MHD_POLL_EVENTS_ERR_DISC;
+            break;
+          case MHD_EVENT_LOOP_INFO_WRITE:
+            p[poll_server+i].events |= POLLOUT | MHD_POLL_EVENTS_ERR_DISC;
+            break;
+          case MHD_EVENT_LOOP_INFO_BLOCK:
+            p[poll_server+i].events |=  MHD_POLL_EVENTS_ERR_DISC;
+            break;
+          case MHD_EVENT_LOOP_INFO_CLEANUP:
+            timeout = 0; /* clean up "pos" immediately */
+            break;
+          }
+        i++;
+      }
+#if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
+    for (urh = daemon->urh_tail; NULL != urh; urh = urh->prev)
+      {
+        urh_to_pollfd (urh,
+                       &(p[poll_server+i]));
+        i += 2;
+      }
+#endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
+    if (0 == poll_server + num_connections)
+      {
+        free (p);
+        return MHD_SC_OK;
+      }
+    if (MHD_sys_poll_(p,
+                      poll_server + num_connections,
+                      timeout) < 0)
+      {
+        const int err = MHD_socket_get_error_ ();
+        if (MHD_SCKT_ERR_IS_EINTR_ (err))
+      {
+        free(p);
+        return MHD_SC_OK;
+      }
+#ifdef HAVE_MESSAGES
+        MHD_DLOG (daemon,
+                  MHD_SC_UNEXPECTED_POLL_ERROR,
+                  _("poll failed: %s\n"),
+                  MHD_socket_strerr_ (err));
+#endif
+        free(p);
+        return MHD_SC_UNEXPECTED_POLL_ERROR;
+      }
+
+    /* Reset. New value will be set when connections are processed. */
+    daemon->data_already_pending = false;
+
+    /* handle ITC FD */
+    /* do it before any other processing so
+       new signals will be processed in next loop */
+    if ( (-1 != poll_itc_idx) &&
+         (0 != (p[poll_itc_idx].revents & POLLIN)) )
+      MHD_itc_clear_ (daemon->itc);
+
+    /* handle shutdown */
+    if (daemon->shutdown)
+      {
+        free(p);
+        return MHD_NO;
+      }
+    i = 0;
+    prev = daemon->connections_tail;
+    while (NULL != (pos = prev))
+      {
+        prev = pos->prev;
+        /* first, sanity checks */
+        if (i >= num_connections)
+          break; /* connection list changed somehow, retry later ... */
+        if (p[poll_server+i].fd != pos->socket_fd)
+          continue; /* fd mismatch, something else happened, retry later ... */
+        call_handlers (pos,
+                       0 != (p[poll_server+i].revents & POLLIN),
+                       0 != (p[poll_server+i].revents & POLLOUT),
+                       0 != (p[poll_server+i].revents & MHD_POLL_REVENTS_ERR_DISC));
+        i++;
+      }
+#if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
+    for (urh = daemon->urh_tail; NULL != urh; urh = urhn)
+      {
+        if (i >= num_connections)
+          break; /* connection list changed somehow, retry later ... */
+
+        /* Get next connection here as connection can be removed
+         * from 'daemon->urh_head' list. */
+        urhn = urh->prev;
+        /* Check for fd mismatch. FIXME: required for safety? */
+        if ((p[poll_server+i].fd != urh->connection->socket_fd) ||
+            (p[poll_server+i+1].fd != urh->mhd.socket))
+          break;
+        urh_from_pollfd (urh,
+                         &(p[poll_server+i]));
+        i += 2;
+        process_urh (urh);
+        /* Finished forwarding? */
+        if ( (0 == urh->in_buffer_size) &&
+             (0 == urh->out_buffer_size) &&
+             (0 == urh->in_buffer_used) &&
+             (0 == urh->out_buffer_used) )
+          {
+            /* MHD_connection_finish_forward_() will remove connection from
+             * 'daemon->urh_head' list. */
+            MHD_connection_finish_forward_ (urh->connection);
+            urh->clean_ready = true;
+            /* If 'urh->was_closed' already was set to true, connection will be
+             * moved immediately to cleanup list. Otherwise connection
+             * will stay in suspended list until 'urh' will be marked
+             * with 'was_closed' by application. */
+            MHD_resume_connection(urh->connection);
+          }
+      }
+#endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
+    /* handle 'listen' FD */
+    if ( (-1 != poll_listen) &&
+         (0 != (p[poll_listen].revents & POLLIN)) )
+      (void) MHD_accept_connection (daemon);
+
+    free(p);
+  }
+  return MHD_YES;
+}
+
+
+/**
+ * Process only the listen socket using poll().
+ *
+ * @param daemon daemon to run poll loop for
+ * @param may_block true if blocking, false if non-blocking
+ * @return #MHD_SC_OK on success
+ */
+enum MHD_StatusCode
+MHD_daemon_poll_listen_socket_ (struct MHD_Daemon *daemon,
+                                bool may_block)
+{
+  struct pollfd p[2];
+  int timeout;
+  unsigned int poll_count;
+  int poll_listen;
+  int poll_itc_idx;
+  MHD_socket ls;
+
+  memset (&p,
+          0,
+          sizeof (p));
+  poll_count = 0;
+  poll_listen = -1;
+  poll_itc_idx = -1;
+  if ( (MHD_INVALID_SOCKET != (ls = daemon->listen_socket)) &&
+       (! daemon->was_quiesced) )
+
+    {
+      p[poll_count].fd = ls;
+      p[poll_count].events = POLLIN;
+      p[poll_count].revents = 0;
+      poll_listen = poll_count;
+      poll_count++;
+    }
+  if (MHD_ITC_IS_VALID_(daemon->itc))
+    {
+      p[poll_count].fd = MHD_itc_r_fd_ (daemon->itc);
+      p[poll_count].events = POLLIN;
+      p[poll_count].revents = 0;
+      poll_itc_idx = poll_count;
+      poll_count++;
+    }
+
+  if (! daemon->disallow_suspend_resume)
+    (void) resume_suspended_connections (daemon);
+
+  if (! may_block)
+    timeout = 0;
+  else
+    timeout = -1;
+  if (0 == poll_count)
+    return MHD_SC_OK;
+  if (MHD_sys_poll_(p,
+                    poll_count,
+                    timeout) < 0)
+    {
+      const int err = MHD_socket_get_error_ ();
+
+      if (MHD_SCKT_ERR_IS_EINTR_ (err))
+        return MHD_SC_OK;
+#ifdef HAVE_MESSAGES
+      MHD_DLOG (daemon,
+                MHD_SC_UNEXPECTED_POLL_ERROR,
+                _("poll failed: %s\n"),
+                MHD_socket_strerr_ (err));
+#endif
+      return MHD_SC_UNEXPECTED_POLL_ERROR;
+    }
+  if ( (-1 != poll_itc_idx) &&
+       (0 != (p[poll_itc_idx].revents & POLLIN)) )
+    MHD_itc_clear_ (daemon->itc);
+
+  /* handle shutdown */
+  if (daemon->shutdown)
+    return MHD_SC_DAEMON_ALREADY_SHUTDOWN;
+  if ( (-1 != poll_listen) &&
+       (0 != (p[poll_listen].revents & POLLIN)) )
+    (void) MHD_accept_connection (daemon);
+  return MHD_SC_OK;
+}
+#endif
+
+
+/**
+ * Do poll()-based processing.
+ *
+ * @param daemon daemon to run poll()-loop for
+ * @param may_block true if blocking, false if non-blocking
+ * @return #MHD_SC_OK on success
+ */
+enum MHD_StatusCode
+MHD_daemon_poll_ (struct MHD_Daemon *daemon,
+                  bool may_block)
+{
+#ifdef HAVE_POLL
+  if (daemon->shutdown)
+    return MHD_SC_DAEMON_ALREADY_SHUTDOWN;
+  if (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_model)
+    return MHD_daemon_poll_all_ (daemon,
+                                 may_block);
+  return MHD_daemon_poll_listen_socket_ (daemon,
+                                         may_block);
+#else
+  /* This code should be dead, as we should have checked
+     this earlier... */
+  return MHD_SC_POLL_NOT_SUPPORTED;
+#endif
+}
+
+/* end of daemon_poll.c */