1 files changed, 607 insertions, 597 deletions

diff --git a/src/lib/connection_add.c b/src/lib/connection_add.c
index cd933d06..aaf04712 100644
--- a/src/lib/connection_add.c
+++ b/src/lib/connection_add.c
@@ -53,14 +53,14 @@ thread_main_connection_upgrade (struct MHD_Connection *con)
      with the socket; */
   if ( (NULL != daemon->tls_api) &&
        (MHD_ELS_POLL != daemon->event_loop_syscall) )
-    {
-      MHD_daemon_upgrade_connection_with_select_ (con);
-    }
+  {
+    MHD_daemon_upgrade_connection_with_select_ (con);
+  }
 #ifdef HAVE_POLL
   else if (NULL != daemon->tls_api)
-    {
-      MHD_daemon_upgrade_connection_with_poll_ (con);
-    }
+  {
+    MHD_daemon_upgrade_connection_with_poll_ (con);
+  }
 #endif
   /* end HTTPS */
 #endif /* HTTPS_SUPPORT */
@@ -111,342 +111,344 @@ thread_main_handle_connection (void *data)
 #endif /* ! HAVE_POLL */
   bool was_suspended = false;
 
-  MHD_thread_init_(&con->pid);
+  MHD_thread_init_ (&con->pid);
 
   while ( (! daemon->shutdown) &&
-          (MHD_REQUEST_CLOSED != con->request.state) )
-    {
-      const time_t timeout = daemon->connection_default_timeout;
+          (MHD_REQUEST_CLOSED != con->request.state) )
+  {
+    const time_t timeout = daemon->connection_default_timeout;
 #ifdef UPGRADE_SUPPORT
-      struct MHD_UpgradeResponseHandle * const urh = con->request.urh;
+    struct MHD_UpgradeResponseHandle *const urh = con->request.urh;
 #else  /* ! UPGRADE_SUPPORT */
-      static const void * const urh = NULL;
+    static const void *const urh = NULL;
 #endif /* ! UPGRADE_SUPPORT */
 
-      if ( (con->suspended) &&
-           (NULL == urh) )
+    if ( (con->suspended) &&
+         (NULL == urh) )
+    {
+      /* Connection was suspended, wait for resume. */
+      was_suspended = true;
+      if (! use_poll)
+      {
+        FD_ZERO (&rs);
+        if (! MHD_add_to_fd_set_ (MHD_itc_r_fd_ (daemon->itc),
+                                  &rs,
+                                  NULL,
+                                  FD_SETSIZE))
         {
-          /* Connection was suspended, wait for resume. */
-          was_suspended = true;
-          if (! use_poll)
-            {
-              FD_ZERO (&rs);
-              if (! MHD_add_to_fd_set_ (MHD_itc_r_fd_ (daemon->itc),
-                                        &rs,
-                                        NULL,
-                                        FD_SETSIZE))
-                {
   #ifdef HAVE_MESSAGES
-                  MHD_DLOG (con->daemon,
-                            MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE,
-                            _("Failed to add FD to fd_set\n"));
+          MHD_DLOG (con->daemon,
+                    MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE,
+                    _ ("Failed to add FD to fd_set\n"));
   #endif
-                  goto exit;
-                }
-              if (0 > MHD_SYS_select_ (MHD_itc_r_fd_ (daemon->itc) + 1,
-                                       &rs,
-                                       NULL,
-                                       NULL,
-                                       NULL))
-                {
-                  const int err = MHD_socket_get_error_();
+          goto exit;
+        }
+        if (0 > MHD_SYS_select_ (MHD_itc_r_fd_ (daemon->itc) + 1,
+                                 &rs,
+                                 NULL,
+                                 NULL,
+                                 NULL))
+        {
+          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_SELECT_ERROR,
-                            _("Error during select (%d): `%s'\n"),
-                            err,
-                            MHD_socket_strerr_ (err));
+          MHD_DLOG (con->daemon,
+                    MHD_SC_UNEXPECTED_SELECT_ERROR,
+                    _ ("Error during select (%d): `%s'\n"),
+                    err,
+                    MHD_socket_strerr_ (err));
 #endif
-                  break;
-                }
-            }
+          break;
+        }
+      }
 #ifdef HAVE_POLL
-          else /* use_poll */
-            {
-              p[0].events = POLLIN;
-              p[0].fd = MHD_itc_r_fd_ (daemon->itc);
-              p[0].revents = 0;
-              if (0 > MHD_sys_poll_ (p,
-                                     1,
-                                     -1))
-                {
-                  if (MHD_SCKT_LAST_ERR_IS_(MHD_SCKT_EINTR_))
-                    continue;
+      else     /* use_poll */
+      {
+        p[0].events = POLLIN;
+        p[0].fd = MHD_itc_r_fd_ (daemon->itc);
+        p[0].revents = 0;
+        if (0 > MHD_sys_poll_ (p,
+                               1,
+                               -1))
+        {
+          if (MHD_SCKT_LAST_ERR_IS_ (MHD_SCKT_EINTR_))
+            continue;
 #ifdef HAVE_MESSAGES
-                  MHD_DLOG (con->daemon,
-                            MHD_SC_UNEXPECTED_POLL_ERROR,
-                            _("Error during poll: `%s'\n"),
-                            MHD_socket_last_strerr_ ());
+          MHD_DLOG (con->daemon,
+                    MHD_SC_UNEXPECTED_POLL_ERROR,
+                    _ ("Error during poll: `%s'\n"),
+                    MHD_socket_last_strerr_ ());
 #endif
-                  break;
-                }
-            }
+          break;
+        }
+      }
 #endif /* HAVE_POLL */
-          MHD_itc_clear_ (daemon->itc);
-          continue; /* Check again for resume. */
-        } /* End of "suspended" branch. */
+      MHD_itc_clear_ (daemon->itc);
+      continue;     /* Check again for resume. */
+    }     /* End of "suspended" branch. */
 
-      if (was_suspended)
-        {
-          MHD_connection_update_last_activity_ (con); /* Reset timeout timer. */
-          /* Process response queued during suspend and update states. */
-          MHD_request_handle_idle_ (&con->request);
-          was_suspended = false;
-        }
+    if (was_suspended)
+    {
+      MHD_connection_update_last_activity_ (con);     /* Reset timeout timer. */
+      /* Process response queued during suspend and update states. */
+      MHD_request_handle_idle_ (&con->request);
+      was_suspended = false;
+    }
 
-      tvp = NULL;
+    tvp = NULL;
 
-      if ( (MHD_EVENT_LOOP_INFO_BLOCK == con->request.event_loop_info)
+    if ( (MHD_EVENT_LOOP_INFO_BLOCK == con->request.event_loop_info)
 #ifdef HTTPS_SUPPORT
-           || ( (con->tls_read_ready) &&
-                (MHD_EVENT_LOOP_INFO_READ == con->request.event_loop_info) )
+         || ( (con->tls_read_ready) &&
+              (MHD_EVENT_LOOP_INFO_READ == con->request.event_loop_info) )
 #endif /* HTTPS_SUPPORT */
          )
-        {
-          /* do not block: more data may be inside of TLS buffers waiting or
-           * application must provide response data */
-          tv.tv_sec = 0;
-          tv.tv_usec = 0;
-          tvp = &tv;
-        }
-      if ( (NULL == tvp) &&
-           (timeout > 0) )
-        {
-          now = MHD_monotonic_sec_counter();
-          if (now - con->last_activity > timeout)
-            tv.tv_sec = 0;
-          else
-            {
-              const time_t seconds_left = timeout - (now - con->last_activity);
-#if !defined(_WIN32) || defined(__CYGWIN__)
-              tv.tv_sec = seconds_left;
+    {
+      /* do not block: more data may be inside of TLS buffers waiting or
+       * application must provide response data */
+      tv.tv_sec = 0;
+      tv.tv_usec = 0;
+      tvp = &tv;
+    }
+    if ( (NULL == tvp) &&
+         (timeout > 0) )
+    {
+      now = MHD_monotonic_sec_counter ();
+      if (now - con->last_activity > timeout)
+        tv.tv_sec = 0;
+      else
+      {
+        const time_t seconds_left = timeout - (now - con->last_activity);
+#if ! defined(_WIN32) || defined(__CYGWIN__)
+        tv.tv_sec = seconds_left;
 #else  /* _WIN32 && !__CYGWIN__ */
-              if (seconds_left > TIMEVAL_TV_SEC_MAX)
-                tv.tv_sec = TIMEVAL_TV_SEC_MAX;
-              else
-                tv.tv_sec = (_MHD_TIMEVAL_TV_SEC_TYPE) seconds_left;
+        if (seconds_left > TIMEVAL_TV_SEC_MAX)
+          tv.tv_sec = TIMEVAL_TV_SEC_MAX;
+        else
+          tv.tv_sec = (_MHD_TIMEVAL_TV_SEC_TYPE) seconds_left;
 #endif /* _WIN32 && ! __CYGWIN__  */
-            }
-          tv.tv_usec = 0;
-          tvp = &tv;
-        }
-      if (! use_poll)
-        {
-          /* use select */
-          bool err_state = false;
+      }
+      tv.tv_usec = 0;
+      tvp = &tv;
+    }
+    if (! use_poll)
+    {
+      /* use select */
+      bool err_state = false;
 
-          FD_ZERO (&rs);
-          FD_ZERO (&ws);
-          FD_ZERO (&es);
-          maxsock = MHD_INVALID_SOCKET;
-          switch (con->request.event_loop_info)
-            {
-            case MHD_EVENT_LOOP_INFO_READ:
-              if (! MHD_add_to_fd_set_ (con->socket_fd,
-                                        &rs,
-                                        &maxsock,
-                                        FD_SETSIZE))
-                err_state = true;
-              break;
-            case MHD_EVENT_LOOP_INFO_WRITE:
-              if (! MHD_add_to_fd_set_ (con->socket_fd,
-                                        &ws,
-                                        &maxsock,
-                                        FD_SETSIZE))
-                err_state = true;
-              break;
-            case MHD_EVENT_LOOP_INFO_BLOCK:
-              if (! MHD_add_to_fd_set_ (con->socket_fd,
-                                        &es,
-                                        &maxsock,
-                                        FD_SETSIZE))
-                err_state = true;
-              break;
-            case MHD_EVENT_LOOP_INFO_CLEANUP:
-              /* how did we get here!? */
-              goto exit;
-            }
+      FD_ZERO (&rs);
+      FD_ZERO (&ws);
+      FD_ZERO (&es);
+      maxsock = MHD_INVALID_SOCKET;
+      switch (con->request.event_loop_info)
+      {
+      case MHD_EVENT_LOOP_INFO_READ:
+        if (! MHD_add_to_fd_set_ (con->socket_fd,
+                                  &rs,
+                                  &maxsock,
+                                  FD_SETSIZE))
+          err_state = true;
+        break;
+      case MHD_EVENT_LOOP_INFO_WRITE:
+        if (! MHD_add_to_fd_set_ (con->socket_fd,
+                                  &ws,
+                                  &maxsock,
+                                  FD_SETSIZE))
+          err_state = true;
+        break;
+      case MHD_EVENT_LOOP_INFO_BLOCK:
+        if (! MHD_add_to_fd_set_ (con->socket_fd,
+                                  &es,
+                                  &maxsock,
+                                  FD_SETSIZE))
+          err_state = true;
+        break;
+      case MHD_EVENT_LOOP_INFO_CLEANUP:
+        /* how did we get here!? */
+        goto exit;
+      }
 #if WINDOWS
-          if (MHD_ITC_IS_VALID_(daemon->itc) )
-            {
-              if (! MHD_add_to_fd_set_ (MHD_itc_r_fd_ (daemon->itc),
-                                        &rs,
-                                        &maxsock,
-                                        FD_SETSIZE))
-                err_state = 1;
-            }
+      if (MHD_ITC_IS_VALID_ (daemon->itc) )
+      {
+        if (! MHD_add_to_fd_set_ (MHD_itc_r_fd_ (daemon->itc),
+                                  &rs,
+                                  &maxsock,
+                                  FD_SETSIZE))
+          err_state = 1;
+      }
 #endif
-            if (err_state)
-              {
+      if (err_state)
+      {
 #ifdef HAVE_MESSAGES
-                MHD_DLOG (con->daemon,
-                          MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE,
-                          _("Failed to add FD to fd_set\n"));
+        MHD_DLOG (con->daemon,
+                  MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE,
+                  _ ("Failed to add FD to fd_set\n"));
 #endif
-                goto exit;
-              }
+        goto exit;
+      }
 
-          num_ready = MHD_SYS_select_ (maxsock + 1,
-                                       &rs,
-                                       &ws,
-                                       &es,
-                                       tvp);
-          if (num_ready < 0)
-            {
-              const int err = MHD_socket_get_error_();
+      num_ready = MHD_SYS_select_ (maxsock + 1,
+                                   &rs,
+                                   &ws,
+                                   &es,
+                                   tvp);
+      if (num_ready < 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_SELECT_ERROR,
-                        _("Error during select (%d): `%s'\n"),
-                        err,
-                        MHD_socket_strerr_ (err));
+        MHD_DLOG (con->daemon,
+                  MHD_SC_UNEXPECTED_SELECT_ERROR,
+                  _ ("Error during select (%d): `%s'\n"),
+                  err,
+                  MHD_socket_strerr_ (err));
 #endif
-              break;
-            }
+        break;
+      }
 #if WINDOWS
-          /* Clear ITC before other processing so additional
-           * signals will trigger select() again */
-          if ( (MHD_ITC_IS_VALID_(daemon->itc)) &&
-               (FD_ISSET (MHD_itc_r_fd_ (daemon->itc),
-                          &rs)) )
-            MHD_itc_clear_ (daemon->itc);
+      /* Clear ITC before other processing so additional
+       * signals will trigger select() again */
+      if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
+           (FD_ISSET (MHD_itc_r_fd_ (daemon->itc),
+                      &rs)) )
+        MHD_itc_clear_ (daemon->itc);
 #endif
-          if (MHD_NO ==
-              MHD_connection_call_handlers_ (con,
-                                             FD_ISSET (con->socket_fd,
-                                                       &rs),
-                                             FD_ISSET (con->socket_fd,
-                                                       &ws),
-                                             FD_ISSET (con->socket_fd,
-                                                       &es)) )
-            goto exit;
-        }
+      if (MHD_NO ==
+          MHD_connection_call_handlers_ (con,
+                                         FD_ISSET (con->socket_fd,
+                                                   &rs),
+                                         FD_ISSET (con->socket_fd,
+                                                   &ws),
+                                         FD_ISSET (con->socket_fd,
+                                                   &es)) )
+        goto exit;
+    }
 #ifdef HAVE_POLL
-      else
-        {
-          /* use poll */
-          memset (&p,
-                  0,
-                  sizeof (p));
-          p[0].fd = con->socket_fd;
-          switch (con->request.event_loop_info)
-            {
-            case MHD_EVENT_LOOP_INFO_READ:
-              p[0].events |= POLLIN | MHD_POLL_EVENTS_ERR_DISC;
-              break;
-            case MHD_EVENT_LOOP_INFO_WRITE:
-              p[0].events |= POLLOUT | MHD_POLL_EVENTS_ERR_DISC;
-              break;
-            case MHD_EVENT_LOOP_INFO_BLOCK:
-              p[0].events |= MHD_POLL_EVENTS_ERR_DISC;
-              break;
-            case MHD_EVENT_LOOP_INFO_CLEANUP:
-              /* how did we get here!? */
-              goto exit;
-            }
+    else
+    {
+      /* use poll */
+      memset (&p,
+              0,
+              sizeof (p));
+      p[0].fd = con->socket_fd;
+      switch (con->request.event_loop_info)
+      {
+      case MHD_EVENT_LOOP_INFO_READ:
+        p[0].events |= POLLIN | MHD_POLL_EVENTS_ERR_DISC;
+        break;
+      case MHD_EVENT_LOOP_INFO_WRITE:
+        p[0].events |= POLLOUT | MHD_POLL_EVENTS_ERR_DISC;
+        break;
+      case MHD_EVENT_LOOP_INFO_BLOCK:
+        p[0].events |= MHD_POLL_EVENTS_ERR_DISC;
+        break;
+      case MHD_EVENT_LOOP_INFO_CLEANUP:
+        /* how did we get here!? */
+        goto exit;
+      }
 #if WINDOWS
-          extra_slot = 0;
-          if (MHD_ITC_IS_VALID_(daemon->itc))
-            {
-              p[1].events |= POLLIN;
-              p[1].fd = MHD_itc_r_fd_ (daemon->itc);
-              p[1].revents = 0;
-              extra_slot = 1;
-            }
+      extra_slot = 0;
+      if (MHD_ITC_IS_VALID_ (daemon->itc))
+      {
+        p[1].events |= POLLIN;
+        p[1].fd = MHD_itc_r_fd_ (daemon->itc);
+        p[1].revents = 0;
+        extra_slot = 1;
+      }
 #endif
-          if (MHD_sys_poll_ (p,
+      if (MHD_sys_poll_ (p,
 #if WINDOWS
-                             1 + extra_slot,
+                         1 + extra_slot,
 #else
-                             1,
+                         1,
 #endif
-                             (NULL == tvp) ? -1 : tv.tv_sec * 1000) < 0)
-            {
-              if (MHD_SCKT_LAST_ERR_IS_(MHD_SCKT_EINTR_))
-                continue;
+                         (NULL == tvp) ? -1 : tv.tv_sec * 1000) < 0)
+      {
+        if (MHD_SCKT_LAST_ERR_IS_ (MHD_SCKT_EINTR_))
+          continue;
 #ifdef HAVE_MESSAGES
-              MHD_DLOG (con->daemon,
-                        MHD_SC_UNEXPECTED_POLL_ERROR,
-                        _("Error during poll: `%s'\n"),
-                        MHD_socket_last_strerr_ ());
+        MHD_DLOG (con->daemon,
+                  MHD_SC_UNEXPECTED_POLL_ERROR,
+                  _ ("Error during poll: `%s'\n"),
+                  MHD_socket_last_strerr_ ());
 #endif
-              break;
-            }
+        break;
+      }
 #if WINDOWS
-          /* Clear ITC before other processing so additional
-           * signals will trigger poll() again */
-          if ( (MHD_ITC_IS_VALID_(daemon->itc)) &&
-               (0 != (p[1].revents & (POLLERR | POLLHUP | POLLIN))) )
-            MHD_itc_clear_ (daemon->itc);
+      /* Clear ITC before other processing so additional
+       * signals will trigger poll() again */
+      if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
+           (0 != (p[1].revents & (POLLERR | POLLHUP | POLLIN))) )
+        MHD_itc_clear_ (daemon->itc);
 #endif
-          if (MHD_NO ==
-              MHD_connection_call_handlers_ (con,
-                                             0 != (p[0].revents & POLLIN),
-                                             0 != (p[0].revents & POLLOUT),
-                                             0 != (p[0].revents & (POLLERR | MHD_POLL_REVENTS_ERR_DISC))))
-            goto exit;
-        }
+      if (MHD_NO ==
+          MHD_connection_call_handlers_ (con,
+                                         (0 != (p[0].revents & POLLIN)),
+                                         (0 != (p[0].revents & POLLOUT)),
+                                         (0 != (p[0].revents & (POLLERR
+                                                                |
+                                                                MHD_POLL_REVENTS_ERR_DISC))) ))
+        goto exit;
+    }
 #endif
 #ifdef UPGRADE_SUPPORT
-      if (MHD_REQUEST_UPGRADE == con->request.state)
-        {
-          /* Normal HTTP processing is finished,
-           * notify application. */
-          if (NULL != con->request.response->termination_cb)
-            con->request.response->termination_cb
-              (con->request.response->termination_cb_cls,
-               MHD_REQUEST_TERMINATED_COMPLETED_OK,
-               con->request.client_context);
-          thread_main_connection_upgrade (con);
-          /* MHD_connection_finish_forward_() was called by thread_main_connection_upgrade(). */
+    if (MHD_REQUEST_UPGRADE == con->request.state)
+    {
+      /* Normal HTTP processing is finished,
+       * notify application. */
+      if (NULL != con->request.response->termination_cb)
+        con->request.response->termination_cb
+          (con->request.response->termination_cb_cls,
+          MHD_REQUEST_TERMINATED_COMPLETED_OK,
+          con->request.client_context);
+      thread_main_connection_upgrade (con);
+      /* MHD_connection_finish_forward_() was called by thread_main_connection_upgrade(). */
 
-          /* "Upgraded" data will not be used in this thread from this point. */
-          con->request.urh->clean_ready = true;
-          /* If 'urh->was_closed' 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 (&con->request);
+      /* "Upgraded" data will not be used in this thread from this point. */
+      con->request.urh->clean_ready = true;
+      /* If 'urh->was_closed' 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 (&con->request);
 
-          /* skip usual clean up  */
-          return (MHD_THRD_RTRN_TYPE_) 0;
-        }
-#endif /* UPGRADE_SUPPORT */
+      /* skip usual clean up  */
+      return (MHD_THRD_RTRN_TYPE_) 0;
     }
+#endif /* UPGRADE_SUPPORT */
+  }
 #if DEBUG_CLOSE
 #ifdef HAVE_MESSAGES
   MHD_DLOG (con->daemon,
             MHD_SC_THREAD_TERMINATING,
-            _("Processing thread terminating. Closing connection\n"));
+            _ ("Processing thread terminating. Closing connection\n"));
 #endif
 #endif
   if (MHD_REQUEST_CLOSED != con->request.state)
     MHD_connection_close_ (con,
                            (daemon->shutdown) ?
-                           MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN:
+                           MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN :
                            MHD_REQUEST_TERMINATED_WITH_ERROR);
   MHD_request_handle_idle_ (&con->request);
 exit:
   if (NULL != con->request.response)
-    {
-      MHD_response_queue_for_destroy (con->request.response);
-      con->request.response = NULL;
-    }
+  {
+    MHD_response_queue_for_destroy (con->request.response);
+    con->request.response = NULL;
+  }
 
   if (MHD_INVALID_SOCKET != con->socket_fd)
-    {
-      shutdown (con->socket_fd,
-                SHUT_WR);
-      /* 'socket_fd' can be used in other thread to signal shutdown.
-       * To avoid data races, do not close socket here. Daemon will
-       * use more connections only after cleanup anyway. */
-    }
+  {
+    shutdown (con->socket_fd,
+              SHUT_WR);
+    /* 'socket_fd' can be used in other thread to signal shutdown.
+     * To avoid data races, do not close socket here. Daemon will
+     * use more connections only after cleanup anyway. */
+  }
   return (MHD_THRD_RTRN_TYPE_) 0;
 }
 
@@ -469,9 +471,9 @@ recv_param_adapter (struct MHD_Connection *connection,
 
   if ( (MHD_INVALID_SOCKET == connection->socket_fd) ||
        (MHD_REQUEST_CLOSED == connection->request.state) )
-    {
-      return MHD_ERR_NOTCONN_;
-    }
+  {
+    return MHD_ERR_NOTCONN_;
+  }
   if (i > MHD_SCKT_SEND_MAX_SIZE_)
     i = MHD_SCKT_SEND_MAX_SIZE_; /* return value limit */
 
@@ -479,25 +481,25 @@ recv_param_adapter (struct MHD_Connection *connection,
                    other,
                    i);
   if (0 > ret)
+  {
+    const int err = MHD_socket_get_error_ ();
+    if (MHD_SCKT_ERR_IS_EAGAIN_ (err))
     {
-      const int err = MHD_socket_get_error_ ();
-      if (MHD_SCKT_ERR_IS_EAGAIN_ (err))
-        {
 #ifdef EPOLL_SUPPORT
-          /* Got EAGAIN --- no longer read-ready */
-          connection->epoll_state &= ~MHD_EPOLL_STATE_READ_READY;
+      /* Got EAGAIN --- no longer read-ready */
+      connection->epoll_state &= ~MHD_EPOLL_STATE_READ_READY;
 #endif /* EPOLL_SUPPORT */
-          return MHD_ERR_AGAIN_;
-        }
-      if (MHD_SCKT_ERR_IS_EINTR_ (err))
-        return MHD_ERR_AGAIN_;
-      if (MHD_SCKT_ERR_IS_ (err, MHD_SCKT_ECONNRESET_))
-        return MHD_ERR_CONNRESET_;
-      /* Treat any other error as hard error. */
-      return MHD_ERR_NOTCONN_;
+      return MHD_ERR_AGAIN_;
     }
+    if (MHD_SCKT_ERR_IS_EINTR_ (err))
+      return MHD_ERR_AGAIN_;
+    if (MHD_SCKT_ERR_IS_ (err, MHD_SCKT_ECONNRESET_))
+      return MHD_ERR_CONNRESET_;
+    /* Treat any other error as hard error. */
+    return MHD_ERR_NOTCONN_;
+  }
 #ifdef EPOLL_SUPPORT
-  else if (i > (size_t)ret)
+  else if (i > (size_t) ret)
     connection->epoll_state &= ~MHD_EPOLL_STATE_READ_READY;
 #endif /* EPOLL_SUPPORT */
   return ret;
@@ -522,9 +524,9 @@ send_param_adapter (struct MHD_Connection *connection,
 
   if ( (MHD_INVALID_SOCKET == connection->socket_fd) ||
        (MHD_REQUEST_CLOSED == connection->request.state) )
-    {
-      return MHD_ERR_NOTCONN_;
-    }
+  {
+    return MHD_ERR_NOTCONN_;
+  }
   if (i > MHD_SCKT_SEND_MAX_SIZE_)
     i = MHD_SCKT_SEND_MAX_SIZE_; /* return value limit */
 
@@ -532,26 +534,26 @@ send_param_adapter (struct MHD_Connection *connection,
                    other,
                    i);
   if (0 > ret)
-    {
-      const int err = MHD_socket_get_error_();
+  {
+    const int err = MHD_socket_get_error_ ();
 
-      if (MHD_SCKT_ERR_IS_EAGAIN_(err))
-        {
+    if (MHD_SCKT_ERR_IS_EAGAIN_ (err))
+    {
 #ifdef EPOLL_SUPPORT
-          /* EAGAIN --- no longer write-ready */
-          connection->epoll_state &= ~MHD_EPOLL_STATE_WRITE_READY;
+      /* EAGAIN --- no longer write-ready */
+      connection->epoll_state &= ~MHD_EPOLL_STATE_WRITE_READY;
 #endif /* EPOLL_SUPPORT */
-          return MHD_ERR_AGAIN_;
-        }
-      if (MHD_SCKT_ERR_IS_EINTR_ (err))
-        return MHD_ERR_AGAIN_;
-      if (MHD_SCKT_ERR_IS_ (err, MHD_SCKT_ECONNRESET_))
-        return MHD_ERR_CONNRESET_;
-      /* Treat any other error as hard error. */
-      return MHD_ERR_NOTCONN_;
+      return MHD_ERR_AGAIN_;
     }
+    if (MHD_SCKT_ERR_IS_EINTR_ (err))
+      return MHD_ERR_AGAIN_;
+    if (MHD_SCKT_ERR_IS_ (err, MHD_SCKT_ECONNRESET_))
+      return MHD_ERR_CONNRESET_;
+    /* Treat any other error as hard error. */
+    return MHD_ERR_NOTCONN_;
+  }
 #ifdef EPOLL_SUPPORT
-  else if (i > (size_t)ret)
+  else if (i > (size_t) ret)
     connection->epoll_state &= ~MHD_EPOLL_STATE_WRITE_READY;
 #endif /* EPOLL_SUPPORT */
   return ret;
@@ -582,11 +584,11 @@ send_param_adapter (struct MHD_Connection *connection,
  */
 static enum MHD_StatusCode
 internal_add_connection (struct MHD_Daemon *daemon,
-                         MHD_socket client_socket,
-                         const struct sockaddr *addr,
-                         socklen_t addrlen,
-                         bool external_add,
-                         bool non_blck)
+                         MHD_socket client_socket,
+                         const struct sockaddr *addr,
+                         socklen_t addrlen,
+                         bool external_add,
+                         bool non_blck)
 {
   enum MHD_StatusCode sc;
   struct MHD_Connection *connection;
@@ -594,78 +596,78 @@ internal_add_connection (struct MHD_Daemon *daemon,
 
   /* Direct add to master daemon could happen only with "external" add mode. */
   mhd_assert ( (NULL == daemon->worker_pool) ||
-               (external_add) );
+               (external_add) );
   if ( (external_add) &&
        (NULL != daemon->worker_pool) )
-    {
-      unsigned int i;
+  {
+    unsigned int i;
 
-      /* have a pool, try to find a pool with capacity; we use the
-         socket as the initial offset into the pool for load
-         balancing */
-      for (i = 0; i < daemon->worker_pool_size; ++i)
-        {
-          struct MHD_Daemon * const worker =
-                &daemon->worker_pool[(i + client_socket) % daemon->worker_pool_size];
-          if (worker->connections < worker->global_connection_limit)
-            return internal_add_connection (worker,
-                                            client_socket,
-                                            addr,
-                                            addrlen,
-                                            true,
-                                            non_blck);
-        }
-      /* all pools are at their connection limit, must refuse */
-      MHD_socket_close_chk_ (client_socket);
+    /* have a pool, try to find a pool with capacity; we use the
+ socket as the initial offset into the pool for load
+ balancing */
+    for (i = 0; i < daemon->worker_pool_size; ++i)
+    {
+      struct MHD_Daemon *const worker =
+        &daemon->worker_pool[(i + client_socket) % daemon->worker_pool_size];
+      if (worker->connections < worker->global_connection_limit)
+        return internal_add_connection (worker,
+                                        client_socket,
+                                        addr,
+                                        addrlen,
+                                        true,
+                                        non_blck);
+    }
+    /* all pools are at their connection limit, must refuse */
+    MHD_socket_close_chk_ (client_socket);
 #if ENFILE
-      errno = ENFILE;
+    errno = ENFILE;
 #endif
-      return MHD_SC_LIMIT_CONNECTIONS_REACHED;
-    }
+    return MHD_SC_LIMIT_CONNECTIONS_REACHED;
+  }
 
-  if ( (! MHD_SCKT_FD_FITS_FDSET_(client_socket,
-                                  NULL)) &&
+  if ( (! MHD_SCKT_FD_FITS_FDSET_ (client_socket,
+                                   NULL)) &&
        (MHD_ELS_SELECT == daemon->event_loop_syscall) )
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE,
-                _("Socket descriptor larger than FD_SETSIZE: %d > %d\n"),
-                (int) client_socket,
-                (int) FD_SETSIZE);
+    MHD_DLOG (daemon,
+              MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE,
+              _ ("Socket descriptor larger than FD_SETSIZE: %d > %d\n"),
+              (int) client_socket,
+              (int) FD_SETSIZE);
 #endif
-      MHD_socket_close_chk_ (client_socket);
+    MHD_socket_close_chk_ (client_socket);
 #if EINVAL
-      errno = EINVAL;
+    errno = EINVAL;
 #endif
-      return MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
-    }
+    return MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
+  }
 
 #ifdef MHD_socket_nosignal_
   if (! MHD_socket_nosignal_ (client_socket))
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_ACCEPT_CONFIGURE_NOSIGPIPE_FAILED,
-                _("Failed to set SO_NOSIGPIPE on accepted socket: %s\n"),
-                MHD_socket_last_strerr_());
+    MHD_DLOG (daemon,
+              MHD_SC_ACCEPT_CONFIGURE_NOSIGPIPE_FAILED,
+              _ ("Failed to set SO_NOSIGPIPE on accepted socket: %s\n"),
+              MHD_socket_last_strerr_ ());
 #endif
 #ifndef MSG_NOSIGNAL
-      /* Cannot use socket as it can produce SIGPIPE. */
+    /* Cannot use socket as it can produce SIGPIPE. */
 #ifdef ENOTSOCK
-      errno = ENOTSOCK;
+    errno = ENOTSOCK;
 #endif /* ENOTSOCK */
-      return MHD_SC_ACCEPT_CONFIGURE_NOSIGPIPE_FAILED;
+    return MHD_SC_ACCEPT_CONFIGURE_NOSIGPIPE_FAILED;
 #endif /* ! MSG_NOSIGNAL */
-    }
+  }
 #endif /* MHD_socket_nosignal_ */
 
 
 #ifdef HAVE_MESSAGES
 #if DEBUG_CONNECT
   MHD_DLOG (daemon,
-            MHD_SC_CONNECTION_ACCEPTED,
-            _("Accepted connection on socket %d\n"),
+            MHD_SC_CONNECTION_ACCEPTED,
+            _ ("Accepted connection on socket %d\n"),
             client_socket);
 #endif
 #endif
@@ -673,82 +675,83 @@ internal_add_connection (struct MHD_Daemon *daemon,
        (MHD_NO == MHD_ip_limit_add (daemon,
                                     addr,
                                     addrlen)) )
-    {
-      /* above connection limit - reject */
+  {
+    /* above connection limit - reject */
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_LIMIT_CONNECTIONS_REACHED,
-                _("Server reached connection limit. Closing inbound connection.\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_LIMIT_CONNECTIONS_REACHED,
+              _ (
+                "Server reached connection limit. Closing inbound connection.\n"));
 #endif
-      MHD_socket_close_chk_ (client_socket);
+    MHD_socket_close_chk_ (client_socket);
 #if ENFILE
-      errno = ENFILE;
+    errno = ENFILE;
 #endif
-      return MHD_SC_LIMIT_CONNECTIONS_REACHED;
-    }
+    return MHD_SC_LIMIT_CONNECTIONS_REACHED;
+  }
 
   /* apply connection acceptance policy if present */
   if ( (NULL != daemon->accept_policy_cb) &&
        (MHD_NO ==
-        daemon->accept_policy_cb (daemon->accept_policy_cb_cls,
-                                  addr,
-                                  addrlen)) )
-    {
+        daemon->accept_policy_cb (daemon->accept_policy_cb_cls,
+                                  addr,
+                                  addrlen)) )
+  {
 #if DEBUG_CLOSE
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_ACCEPT_POLICY_REJECTED,
-                _("Connection rejected by application. Closing connection.\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_ACCEPT_POLICY_REJECTED,
+              _ ("Connection rejected by application. Closing connection.\n"));
 #endif
 #endif
-      MHD_socket_close_chk_ (client_socket);
-      MHD_ip_limit_del (daemon,
-                        addr,
-                        addrlen);
+    MHD_socket_close_chk_ (client_socket);
+    MHD_ip_limit_del (daemon,
+                      addr,
+                      addrlen);
 #if EACCESS
-      errno = EACCESS;
+    errno = EACCESS;
 #endif
-      return MHD_SC_ACCEPT_POLICY_REJECTED;
-    }
+    return MHD_SC_ACCEPT_POLICY_REJECTED;
+  }
 
   if (NULL ==
       (connection = MHD_calloc_ (1,
-                                 sizeof (struct MHD_Connection))))
-    {
-      eno = errno;
+                                 sizeof (struct MHD_Connection))))
+  {
+    eno = errno;
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_CONNECTION_MALLOC_FAILURE,
-                "Error allocating memory: %s\n",
-                MHD_strerror_ (errno));
+    MHD_DLOG (daemon,
+              MHD_SC_CONNECTION_MALLOC_FAILURE,
+              "Error allocating memory: %s\n",
+              MHD_strerror_ (errno));
 #endif
-      MHD_socket_close_chk_ (client_socket);
-      MHD_ip_limit_del (daemon,
-                        addr,
-                        addrlen);
-      errno = eno;
-      return MHD_SC_CONNECTION_MALLOC_FAILURE;
-    }
+    MHD_socket_close_chk_ (client_socket);
+    MHD_ip_limit_del (daemon,
+                      addr,
+                      addrlen);
+    errno = eno;
+    return MHD_SC_CONNECTION_MALLOC_FAILURE;
+  }
   connection->pool
     = MHD_pool_create (daemon->connection_memory_limit_b);
   if (NULL == connection->pool)
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_POOL_MALLOC_FAILURE,
-                _("Error allocating memory: %s\n"),
-                MHD_strerror_ (errno));
+    MHD_DLOG (daemon,
+              MHD_SC_POOL_MALLOC_FAILURE,
+              _ ("Error allocating memory: %s\n"),
+              MHD_strerror_ (errno));
 #endif
-      MHD_socket_close_chk_ (client_socket);
-      MHD_ip_limit_del (daemon,
-                        addr,
-                        addrlen);
-      free (connection);
+    MHD_socket_close_chk_ (client_socket);
+    MHD_ip_limit_del (daemon,
+                      addr,
+                      addrlen);
+    free (connection);
 #if ENOMEM
-      errno = ENOMEM;
+    errno = ENOMEM;
 #endif
-      return MHD_SC_POOL_MALLOC_FAILURE;
-    }
+    return MHD_SC_POOL_MALLOC_FAILURE;
+  }
 
   connection->connection_timeout = daemon->connection_default_timeout;
   memcpy (&connection->addr,
@@ -758,148 +761,151 @@ internal_add_connection (struct MHD_Daemon *daemon,
   connection->socket_fd = client_socket;
   connection->sk_nonblck = non_blck;
   connection->daemon = daemon;
-  connection->last_activity = MHD_monotonic_sec_counter();
+  connection->last_activity = MHD_monotonic_sec_counter ();
 
 #ifdef HTTPS_SUPPORT
   if (NULL != daemon->tls_api)
+  {
+    connection->tls_cs
+      = daemon->tls_api->setup_connection (daemon->tls_api->cls,
+                                           NULL /* FIXME */);
+    if (NULL == connection->tls_cs)
     {
-      connection->tls_cs
-        = daemon->tls_api->setup_connection (daemon->tls_api->cls,
-                                             NULL /* FIXME */);
-      if (NULL == connection->tls_cs)
-        {
-          eno = EINVAL;
-          sc = -1; // FIXME!
-          goto cleanup;
-        }
+      eno = EINVAL;
+      sc = -1; // FIXME!
+      goto cleanup;
     }
+  }
   else
 #endif /* ! HTTPS_SUPPORT */
-    {
-      /* set default connection handlers  */
-      connection->recv_cls = &recv_param_adapter;
-      connection->send_cls = &send_param_adapter;
-    }
+  {
+    /* set default connection handlers  */
+    connection->recv_cls = &recv_param_adapter;
+    connection->send_cls = &send_param_adapter;
+  }
   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   /* Firm check under lock. */
   if (daemon->connections >= daemon->global_connection_limit)
-    {
-      MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
-      /* above connection limit - reject */
+  {
+    MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
+    /* above connection limit - reject */
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_LIMIT_CONNECTIONS_REACHED,
-                _("Server reached connection limit. Closing inbound connection.\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_LIMIT_CONNECTIONS_REACHED,
+              _ (
+                "Server reached connection limit. Closing inbound connection.\n"));
 #endif
 #if ENFILE
-      eno = ENFILE;
+    eno = ENFILE;
 #endif
-      sc = MHD_SC_LIMIT_CONNECTIONS_REACHED;
-      goto cleanup;
-    }
+    sc = MHD_SC_LIMIT_CONNECTIONS_REACHED;
+    goto cleanup;
+  }
   daemon->connections++;
   if (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_mode)
-    {
-      XDLL_insert (daemon->normal_timeout_head,
-                   daemon->normal_timeout_tail,
-                   connection);
-    }
+  {
+    XDLL_insert (daemon->normal_timeout_head,
+                 daemon->normal_timeout_tail,
+                 connection);
+  }
   DLL_insert (daemon->connections_head,
-              daemon->connections_tail,
-              connection);
+              daemon->connections_tail,
+              connection);
   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
 
   if (NULL != daemon->notify_connection_cb)
     daemon->notify_connection_cb (daemon->notify_connection_cb_cls,
-                                  connection,
-                                  MHD_CONNECTION_NOTIFY_STARTED);
+                                  connection,
+                                  MHD_CONNECTION_NOTIFY_STARTED);
 
   /* attempt to create handler thread */
   if (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode)
+  {
+    if (! MHD_create_named_thread_ (&connection->pid,
+                                    "MHD-connection",
+                                    daemon->thread_stack_limit_b,
+                                    &thread_main_handle_connection,
+                                    connection))
     {
-      if (! MHD_create_named_thread_ (&connection->pid,
-                                      "MHD-connection",
-                                      daemon->thread_stack_limit_b,
-                                      &thread_main_handle_connection,
-                                      connection))
-        {
-          eno = errno;
+      eno = errno;
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    MHD_SC_THREAD_LAUNCH_FAILURE,
-                    "Failed to create a thread: %s\n",
-                    MHD_strerror_ (eno));
+      MHD_DLOG (daemon,
+                MHD_SC_THREAD_LAUNCH_FAILURE,
+                "Failed to create a thread: %s\n",
+                MHD_strerror_ (eno));
 #endif
-          sc = MHD_SC_THREAD_LAUNCH_FAILURE;
-          goto cleanup;
-        }
+      sc = MHD_SC_THREAD_LAUNCH_FAILURE;
+      goto cleanup;
     }
+  }
   else
-    {
-      connection->pid = daemon->pid;
-    }
+  {
+    connection->pid = daemon->pid;
+  }
 #ifdef EPOLL_SUPPORT
   if (MHD_ELS_EPOLL == daemon->event_loop_syscall)
-    {
-      if ( (! daemon->enable_turbo) ||
-           (external_add))
-        { /* Do not manipulate EReady DL-list in 'external_add' mode. */
-          struct epoll_event event;
+  {
+    if ( (! daemon->enable_turbo) ||
+         (external_add))
+    { /* Do not manipulate EReady DL-list in 'external_add' mode. */
+      struct epoll_event event;
 
-          event.events = EPOLLIN | EPOLLOUT | EPOLLPRI | EPOLLET;
-          event.data.ptr = connection;
-          if (0 != epoll_ctl (daemon->epoll_fd,
-                              EPOLL_CTL_ADD,
-                              client_socket,
-                              &event))
-            {
-              eno = errno;
+      event.events = EPOLLIN | EPOLLOUT | EPOLLPRI | EPOLLET;
+      event.data.ptr = connection;
+      if (0 != epoll_ctl (daemon->epoll_fd,
+                          EPOLL_CTL_ADD,
+                          client_socket,
+                          &event))
+      {
+        eno = errno;
 #ifdef HAVE_MESSAGES
-              MHD_DLOG (daemon,
-                        MHD_SC_EPOLL_CTL_ADD_FAILED,
-                        _("Call to epoll_ctl failed: %s\n"),
-                        MHD_socket_last_strerr_ ());
+        MHD_DLOG (daemon,
+                  MHD_SC_EPOLL_CTL_ADD_FAILED,
+                  _ ("Call to epoll_ctl failed: %s\n"),
+                  MHD_socket_last_strerr_ ());
 #endif
-              sc = MHD_SC_EPOLL_CTL_ADD_FAILED;
-              goto cleanup;
-            }
-          connection->epoll_state |= MHD_EPOLL_STATE_IN_EPOLL_SET;
-        }
-      else
-        {
-          connection->epoll_state |= MHD_EPOLL_STATE_READ_READY | MHD_EPOLL_STATE_WRITE_READY
-            | MHD_EPOLL_STATE_IN_EREADY_EDLL;
-          EDLL_insert (daemon->eready_head,
-                       daemon->eready_tail,
-                       connection);
-        }
+        sc = MHD_SC_EPOLL_CTL_ADD_FAILED;
+        goto cleanup;
+      }
+      connection->epoll_state |= MHD_EPOLL_STATE_IN_EPOLL_SET;
+    }
+    else
+    {
+      connection->epoll_state |= MHD_EPOLL_STATE_READ_READY
+                                 | MHD_EPOLL_STATE_WRITE_READY
+                                 | MHD_EPOLL_STATE_IN_EREADY_EDLL;
+      EDLL_insert (daemon->eready_head,
+                   daemon->eready_tail,
+                   connection);
     }
+  }
   else /* This 'else' is combined with next 'if'. */
 #endif
   if ( (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_mode) &&
        (external_add) &&
-       (MHD_ITC_IS_VALID_(daemon->itc)) &&
+       (MHD_ITC_IS_VALID_ (daemon->itc)) &&
        (! MHD_itc_activate_ (daemon->itc,
-                             "n")) )
-    {
+                             "n")) )
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_ITC_USE_FAILED,
-                _("Failed to signal new connection via inter-thread communication channel (not necessarily fatal, continuing anyway)."));
+    MHD_DLOG (daemon,
+              MHD_SC_ITC_USE_FAILED,
+              _ (
+                "Failed to signal new connection via inter-thread communication channel (not necessarily fatal, continuing anyway)."));
 #endif
-    }
+  }
   return MHD_SC_OK;
 
- cleanup:
+cleanup:
   if (NULL != daemon->notify_connection_cb)
     daemon->notify_connection_cb (daemon->notify_connection_cb_cls,
-                                  connection,
-                                  MHD_CONNECTION_NOTIFY_CLOSED);
+                                  connection,
+                                  MHD_CONNECTION_NOTIFY_CLOSED);
 #ifdef HTTPS_SUPPORT
   if ( (NULL != daemon->tls_api) &&
        (NULL != connection->tls_cs) )
-   daemon->tls_api->teardown_connection (daemon->tls_api->cls,
-                                         connection->tls_cs);
+    daemon->tls_api->teardown_connection (daemon->tls_api->cls,
+                                          connection->tls_cs);
 #endif /* HTTPS_SUPPORT */
   MHD_socket_close_chk_ (client_socket);
   MHD_ip_limit_del (daemon,
@@ -907,14 +913,14 @@ internal_add_connection (struct MHD_Daemon *daemon,
                     addrlen);
   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   if (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_mode)
-    {
-      XDLL_remove (daemon->normal_timeout_head,
-                   daemon->normal_timeout_tail,
-                   connection);
-    }
+  {
+    XDLL_remove (daemon->normal_timeout_head,
+                 daemon->normal_timeout_tail,
+                 connection);
+  }
   DLL_remove (daemon->connections_head,
-              daemon->connections_tail,
-              connection);
+              daemon->connections_tail,
+              connection);
   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   MHD_pool_destroy (connection->pool);
   free (connection);
@@ -954,42 +960,42 @@ internal_add_connection (struct MHD_Daemon *daemon,
  */
 enum MHD_StatusCode
 MHD_daemon_add_connection (struct MHD_Daemon *daemon,
-                           MHD_socket client_socket,
-                           const struct sockaddr *addr,
-                           socklen_t addrlen)
+                           MHD_socket client_socket,
+                           const struct sockaddr *addr,
+                           socklen_t addrlen)
 {
   bool sk_nonbl;
 
   if (! MHD_socket_nonblocking_ (client_socket))
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_ACCEPT_CONFIGURE_NONBLOCKING_FAILED,
-                _("Failed to set nonblocking mode on new client socket: %s\n"),
-                MHD_socket_last_strerr_());
+    MHD_DLOG (daemon,
+              MHD_SC_ACCEPT_CONFIGURE_NONBLOCKING_FAILED,
+              _ ("Failed to set nonblocking mode on new client socket: %s\n"),
+              MHD_socket_last_strerr_ ());
 #endif
-      sk_nonbl = false;
-    }
+    sk_nonbl = false;
+  }
   else
-    {
-      sk_nonbl = true;
-    }
+  {
+    sk_nonbl = true;
+  }
 
   if ( (daemon->enable_turbo) &&
        (! MHD_socket_noninheritable_ (client_socket)) )
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_ACCEPT_CONFIGURE_NOINHERIT_FAILED,
-                _("Failed to set noninheritable mode on new client socket.\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_ACCEPT_CONFIGURE_NOINHERIT_FAILED,
+              _ ("Failed to set noninheritable mode on new client socket.\n"));
 #endif
-    }
+  }
   return internal_add_connection (daemon,
-                                  client_socket,
-                                  addr,
+                                  client_socket,
+                                  addr,
                                   addrlen,
-                                  true,
-                                  sk_nonbl);
+                                  true,
+                                  sk_nonbl);
 }
 
 
@@ -1033,94 +1039,98 @@ MHD_accept_connection_ (struct MHD_Daemon *daemon)
 #endif /* ! USE_ACCEPT4 */
   if ( (MHD_INVALID_SOCKET == s) ||
        (addrlen <= 0) )
-    {
-      const int err = MHD_socket_get_error_ ();
+  {
+    const int err = MHD_socket_get_error_ ();
 
-      /* This could be a common occurance with multiple worker threads */
-      if (MHD_SCKT_ERR_IS_ (err,
-                            MHD_SCKT_EINVAL_))
-        return MHD_SC_DAEMON_ALREADY_SHUTDOWN; /* can happen during shutdown, let's hope this is the cause... */
-      if (MHD_SCKT_ERR_IS_DISCNN_BEFORE_ACCEPT_(err))
-        return MHD_SC_ACCEPT_FAST_DISCONNECT; /* do not print error if client just disconnected early */
-      if (MHD_SCKT_ERR_IS_EAGAIN_ (err) )
-        return MHD_SC_ACCEPT_FAILED_EAGAIN;
-      if (MHD_INVALID_SOCKET != s)
-        {
-          MHD_socket_close_chk_ (s);
-        }
-      if ( MHD_SCKT_ERR_IS_LOW_RESOURCES_ (err) )
-        {
-          /* system/process out of resources */
-          if (0 == daemon->connections)
-            {
+    /* This could be a common occurance with multiple worker threads */
+    if (MHD_SCKT_ERR_IS_ (err,
+                          MHD_SCKT_EINVAL_))
+      return MHD_SC_DAEMON_ALREADY_SHUTDOWN;   /* can happen during shutdown, let's hope this is the cause... */
+    if (MHD_SCKT_ERR_IS_DISCNN_BEFORE_ACCEPT_ (err))
+      return MHD_SC_ACCEPT_FAST_DISCONNECT;   /* do not print error if client just disconnected early */
+    if (MHD_SCKT_ERR_IS_EAGAIN_ (err) )
+      return MHD_SC_ACCEPT_FAILED_EAGAIN;
+    if (MHD_INVALID_SOCKET != s)
+    {
+      MHD_socket_close_chk_ (s);
+    }
+    if ( MHD_SCKT_ERR_IS_LOW_RESOURCES_ (err) )
+    {
+      /* system/process out of resources */
+      if (0 == daemon->connections)
+      {
 #ifdef HAVE_MESSAGES
-              /* Not setting 'at_limit' flag, as there is no way it
-                 would ever be cleared.  Instead trying to produce
-                 bit fat ugly warning. */
-              MHD_DLOG (daemon,
-                        MHD_SC_ACCEPT_SYSTEM_LIMIT_REACHED_INSTANTLY,
-                        _("Hit process or system resource limit at FIRST connection. This is really bad as there is no sane way to proceed. Will try busy waiting for system resources to become magically available.\n"));
+        /* Not setting 'at_limit' flag, as there is no way it
+           would ever be cleared.  Instead trying to produce
+           bit fat ugly warning. */
+        MHD_DLOG (daemon,
+                  MHD_SC_ACCEPT_SYSTEM_LIMIT_REACHED_INSTANTLY,
+                  _ (
+                    "Hit process or system resource limit at FIRST connection. This is really bad as there is no sane way to proceed. Will try busy waiting for system resources to become magically available.\n"));
 #endif
-              return MHD_SC_ACCEPT_SYSTEM_LIMIT_REACHED_INSTANTLY;
-            }
-          else
-            {
-              MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
-              daemon->at_limit = true;
-              MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
+        return MHD_SC_ACCEPT_SYSTEM_LIMIT_REACHED_INSTANTLY;
+      }
+      else
+      {
+        MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
+        daemon->at_limit = true;
+        MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
 #ifdef HAVE_MESSAGES
-              MHD_DLOG (daemon,
-                        MHD_SC_ACCEPT_SYSTEM_LIMIT_REACHED,
-                        _("Hit process or system resource limit at %u connections, temporarily suspending accept(). Consider setting a lower MHD_OPTION_CONNECTION_LIMIT.\n"),
-                        (unsigned int) daemon->connections);
+        MHD_DLOG (daemon,
+                  MHD_SC_ACCEPT_SYSTEM_LIMIT_REACHED,
+                  _ (
+                    "Hit process or system resource limit at %u connections, temporarily suspending accept(). Consider setting a lower MHD_OPTION_CONNECTION_LIMIT.\n"),
+                  (unsigned int) daemon->connections);
 #endif
-              return MHD_SC_ACCEPT_SYSTEM_LIMIT_REACHED;
-            }
-        }
+        return MHD_SC_ACCEPT_SYSTEM_LIMIT_REACHED;
+      }
+    }
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_ACCEPT_FAILED_UNEXPECTEDLY,
-                _("Error accepting connection: %s\n"),
-                MHD_socket_strerr_(err));
+    MHD_DLOG (daemon,
+              MHD_SC_ACCEPT_FAILED_UNEXPECTEDLY,
+              _ ("Error accepting connection: %s\n"),
+              MHD_socket_strerr_ (err));
 #endif
-      return MHD_SC_ACCEPT_FAILED_UNEXPECTEDLY;
-    }
-#if !defined(USE_ACCEPT4) || !defined(HAVE_SOCK_NONBLOCK)
+    return MHD_SC_ACCEPT_FAILED_UNEXPECTEDLY;
+  }
+#if ! defined(USE_ACCEPT4) || ! defined(HAVE_SOCK_NONBLOCK)
   if (! MHD_socket_nonblocking_ (s))
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_ACCEPT_CONFIGURE_NONBLOCKING_FAILED,
-                _("Failed to set nonblocking mode on incoming connection socket: %s\n"),
-                MHD_socket_last_strerr_());
+    MHD_DLOG (daemon,
+              MHD_SC_ACCEPT_CONFIGURE_NONBLOCKING_FAILED,
+              _ (
+                "Failed to set nonblocking mode on incoming connection socket: %s\n"),
+              MHD_socket_last_strerr_ ());
 #endif
-    }
+  }
   else
     sk_nonbl = true;
 #endif /* !USE_ACCEPT4 || !HAVE_SOCK_NONBLOCK */
-#if !defined(USE_ACCEPT4) || !defined(SOCK_CLOEXEC)
+#if ! defined(USE_ACCEPT4) || ! defined(SOCK_CLOEXEC)
   if (! MHD_socket_noninheritable_ (s))
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_ACCEPT_CONFIGURE_NOINHERIT_FAILED,
-                _("Failed to set noninheritable mode on incoming connection socket.\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_ACCEPT_CONFIGURE_NOINHERIT_FAILED,
+              _ (
+                "Failed to set noninheritable mode on incoming connection socket.\n"));
 #endif
-    }
+  }
 #endif /* !USE_ACCEPT4 || !SOCK_CLOEXEC */
 #ifdef HAVE_MESSAGES
 #if DEBUG_CONNECT
   MHD_DLOG (daemon,
-            MHD_SC_CONNECTION_ACCEPTED,
-            _("Accepted connection on socket %d\n"),
+            MHD_SC_CONNECTION_ACCEPTED,
+            _ ("Accepted connection on socket %d\n"),
             s);
 #endif
 #endif
   return internal_add_connection (daemon,
                                   s,
-                                  addr,
+                                  addr,
                                   addrlen,
-                                  false,
+                                  false,
                                   sk_nonbl);
 }