1 files changed, 185 insertions, 183 deletions

diff --git a/src/lib/daemon_poll.c b/src/lib/daemon_poll.c
index 80599e93..1fea9fd6 100644
--- a/src/lib/daemon_poll.c
+++ b/src/lib/daemon_poll.c
@@ -45,7 +45,7 @@
  */
 static void
 urh_update_pollfd (struct MHD_UpgradeResponseHandle *urh,
-                   struct pollfd p[2])
+                   struct pollfd p[2])
 {
   p[0].events = 0;
   p[1].events = 0;
@@ -86,12 +86,12 @@ urh_update_pollfd (struct MHD_UpgradeResponseHandle *urh,
  */
 static void
 urh_to_pollfd (struct MHD_UpgradeResponseHandle *urh,
-               struct pollfd p[2])
+               struct pollfd p[2])
 {
   p[0].fd = urh->connection->socket_fd;
   p[1].fd = urh->mhd.socket;
   urh_update_pollfd (urh,
-                     p);
+                     p);
 }
 
 
@@ -102,7 +102,7 @@ urh_to_pollfd (struct MHD_UpgradeResponseHandle *urh,
  */
 static void
 urh_from_pollfd (struct MHD_UpgradeResponseHandle *urh,
-                 struct pollfd p[2])
+                 struct pollfd p[2])
 {
   /* Reset read/write ready, preserve error state. */
   urh->app.celi &= (~MHD_EPOLL_STATE_READ_READY & ~MHD_EPOLL_STATE_WRITE_READY);
@@ -138,7 +138,7 @@ urh_from_pollfd (struct MHD_UpgradeResponseHandle *urh,
  */
 enum MHD_StatusCode
 MHD_daemon_poll_all_ (struct MHD_Daemon *daemon,
-                      bool may_block)
+                      bool may_block)
 {
   unsigned int num_connections;
   struct MHD_Connection *pos;
@@ -171,103 +171,103 @@ MHD_daemon_poll_all_ (struct MHD_Daemon *daemon,
     MHD_socket ls;
 
     p = MHD_calloc_ ((2 + num_connections),
-                     sizeof (struct pollfd));
+                     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));
+      MHD_DLOG (daemon,
+                MHD_SC_POLL_MALLOC_FAILURE,
+                _ ("Error allocating memory: %s\n"),
+                MHD_strerror_ (errno));
 #endif
-        return MHD_SC_POLL_MALLOC_FAILURE;
-      }
+      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->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++;
-      }
+    {
+      /* 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 (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_mode) ||
-              (MHD_SC_OK != /* FIXME: distinguish between NO_TIMEOUT and errors! */
-               MHD_daemon_get_timeout (daemon,
-                                       &ltimeout)) )
+              (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)
       {
-        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++;
+      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;
-      }
+    {
+      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;
       }
-    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));
+      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;
-      }
+      free (p);
+      return MHD_SC_UNEXPECTED_POLL_ERROR;
+    }
 
     /* Reset. New value will be set when connections are processed. */
     daemon->data_already_pending = false;
@@ -281,67 +281,69 @@ MHD_daemon_poll_all_ (struct MHD_Daemon *daemon,
 
     /* handle shutdown */
     if (daemon->shutdown)
-      {
-        free(p);
-        return MHD_SC_DAEMON_ALREADY_SHUTDOWN;
-      }
+    {
+      free (p);
+      return MHD_SC_DAEMON_ALREADY_SHUTDOWN;
+    }
     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 ... */
-        MHD_connection_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++;
-      }
+    {
+      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 ... */
+      MHD_connection_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;
+      MHD_upgrade_response_handle_process_ (urh);
+      /* Finished forwarding? */
+      if ( (0 == urh->in_buffer_size) &&
+           (0 == urh->out_buffer_size) &&
+           (0 == urh->in_buffer_used) &&
+           (0 == urh->out_buffer_used) )
       {
-        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;
-        MHD_upgrade_response_handle_process_ (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_request_resume (&urh->connection->request);
-          }
+        /* 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_request_resume (&urh->connection->request);
       }
+    }
 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
     /* handle 'listen' FD */
     if ( (-1 != poll_listen) &&
-         (0 != (p[poll_listen].revents & POLLIN)) )
+         (0 != (p[poll_listen].revents & POLLIN)) )
       (void) MHD_accept_connection_ (daemon);
 
-    free(p);
+    free (p);
   }
   return MHD_SC_OK;
 }
@@ -356,7 +358,7 @@ MHD_daemon_poll_all_ (struct MHD_Daemon *daemon,
  */
 enum MHD_StatusCode
 MHD_daemon_poll_listen_socket_ (struct MHD_Daemon *daemon,
-                                bool may_block)
+                                bool may_block)
 {
   struct pollfd p[2];
   int timeout;
@@ -374,21 +376,21 @@ MHD_daemon_poll_listen_socket_ (struct MHD_Daemon *daemon,
   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++;
-    }
+  {
+    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) MHD_resume_suspended_connections_ (daemon);
@@ -399,22 +401,22 @@ MHD_daemon_poll_listen_socket_ (struct MHD_Daemon *daemon,
     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_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;
+    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));
+    MHD_DLOG (daemon,
+              MHD_SC_UNEXPECTED_POLL_ERROR,
+              _ ("poll failed: %s\n"),
+              MHD_socket_strerr_ (err));
 #endif
-      return MHD_SC_UNEXPECTED_POLL_ERROR;
-    }
+    return MHD_SC_UNEXPECTED_POLL_ERROR;
+  }
   if ( (-1 != poll_itc_idx) &&
        (0 != (p[poll_itc_idx].revents & POLLIN)) )
     MHD_itc_clear_ (daemon->itc);
@@ -439,16 +441,16 @@ MHD_daemon_poll_listen_socket_ (struct MHD_Daemon *daemon,
  */
 enum MHD_StatusCode
 MHD_daemon_poll_ (struct MHD_Daemon *daemon,
-                  bool may_block)
+                  bool may_block)
 {
 #ifdef HAVE_POLL
   if (daemon->shutdown)
     return MHD_SC_DAEMON_ALREADY_SHUTDOWN;
   if (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_mode)
     return MHD_daemon_poll_all_ (daemon,
-                                 may_block);
+                                 may_block);
   return MHD_daemon_poll_listen_socket_ (daemon,
-                                         may_block);
+                                         may_block);
 #else
   /* This code should be dead, as we should have checked
      this earlier... */
@@ -472,47 +474,47 @@ MHD_daemon_upgrade_connection_with_poll_ (struct MHD_Connection *con)
   struct pollfd p[2];
 
   memset (p,
-          0,
-          sizeof (p));
+          0,
+          sizeof (p));
   p[0].fd = urh->connection->socket_fd;
   p[1].fd = urh->mhd.socket;
 
   while ( (0 != urh->in_buffer_size) ||
-          (0 != urh->out_buffer_size) ||
-          (0 != urh->in_buffer_used) ||
-          (0 != urh->out_buffer_used) )
-    {
-      int timeout;
+          (0 != urh->out_buffer_size) ||
+          (0 != urh->in_buffer_used) ||
+          (0 != urh->out_buffer_used) )
+  {
+    int timeout;
 
-      urh_update_pollfd (urh,
-                         p);
+    urh_update_pollfd (urh,
+                       p);
 
-      if ( (con->tls_read_ready) &&
-           (urh->in_buffer_used < urh->in_buffer_size))
-        timeout = 0; /* No need to wait if incoming data is already pending in TLS buffers. */
-      else
-        timeout = -1;
+    if ( (con->tls_read_ready) &&
+         (urh->in_buffer_used < urh->in_buffer_size))
+      timeout = 0; /* No need to wait if incoming data is already pending in TLS buffers. */
+    else
+      timeout = -1;
 
-      if (MHD_sys_poll_ (p,
-                         2,
-                         timeout) < 0)
-        {
-          const int err = MHD_socket_get_error_ ();
+    if (MHD_sys_poll_ (p,
+                       2,
+                       timeout) < 0)
+    {
+      const int err = MHD_socket_get_error_ ();
 
-          if (MHD_SCKT_ERR_IS_EINTR_ (err))
-            continue;
+      if (MHD_SCKT_ERR_IS_EINTR_ (err))
+        continue;
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (con->daemon,
-                    MHD_SC_UNEXPECTED_POLL_ERROR,
-                    _("Error during poll: `%s'\n"),
-                    MHD_socket_strerr_ (err));
+      MHD_DLOG (con->daemon,
+                MHD_SC_UNEXPECTED_POLL_ERROR,
+                _ ("Error during poll: `%s'\n"),
+                MHD_socket_strerr_ (err));
 #endif
-          break;
-        }
-      urh_from_pollfd (urh,
-                       p);
-      MHD_upgrade_response_handle_process_ (urh);
+      break;
     }
+    urh_from_pollfd (urh,
+                     p);
+    MHD_upgrade_response_handle_process_ (urh);
+  }
 }
 #endif
 #endif