81 files changed, 6732 insertions, 6555 deletions

diff --git a/src/lib/action_continue.c b/src/lib/action_continue.c
index 20c351ad..9d98940b 100644
--- a/src/lib/action_continue.c
+++ b/src/lib/action_continue.c
@@ -35,11 +35,11 @@
  */
 static enum MHD_StatusCode
 cont_action (void *cls,
-             struct MHD_Request *request)
+             struct MHD_Request *request)
 {
   (void) cls;
   (void) request;
-  /* not sure yet, but this function body may 
+  /* not sure yet, but this function body may
      just legitimately stay empty... */
   return MHD_SC_OK;
 }
diff --git a/src/lib/action_from_response.c b/src/lib/action_from_response.c
index 43f33cb5..6253fb22 100644
--- a/src/lib/action_from_response.c
+++ b/src/lib/action_from_response.c
@@ -36,7 +36,7 @@
  */
 static enum MHD_StatusCode
 response_action (void *cls,
-                 struct MHD_Request *request)
+                 struct MHD_Request *request)
 {
   struct MHD_Response *response = cls;
   struct MHD_Daemon *daemon = request->daemon;
@@ -49,14 +49,15 @@ response_action (void *cls,
 #ifdef UPGRADE_SUPPORT
   if ( (NULL != response->upgrade_handler) &&
        daemon->disallow_upgrade )
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_UPGRADE_ON_DAEMON_WITH_UPGRADE_DISALLOWED,
-                _("Attempted 'upgrade' connection on daemon without MHD_ALLOW_UPGRADE option!\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_UPGRADE_ON_DAEMON_WITH_UPGRADE_DISALLOWED,
+              _ (
+                "Attempted 'upgrade' connection on daemon without MHD_ALLOW_UPGRADE option!\n"));
 #endif
-      return MHD_SC_UPGRADE_ON_DAEMON_WITH_UPGRADE_DISALLOWED;
-    }
+    return MHD_SC_UPGRADE_ON_DAEMON_WITH_UPGRADE_DISALLOWED;
+  }
 #endif /* UPGRADE_SUPPORT */
   request->response = response;
 #if defined(_MHD_HAVE_SENDFILE)
@@ -74,21 +75,21 @@ response_action (void *cls,
        (MHD_HTTP_OK > response->status_code) ||
        (MHD_HTTP_NO_CONTENT == response->status_code) ||
        (MHD_HTTP_NOT_MODIFIED == response->status_code) )
-    {
-      /* if this is a "HEAD" request, or a status code for
-         which a body is not allowed, pretend that we
-         have already sent the full message body. */
-      request->response_write_position = response->total_size;
-    }
+  {
+    /* if this is a "HEAD" request, or a status code for
+       which a body is not allowed, pretend that we
+       have already sent the full message body. */
+    request->response_write_position = response->total_size;
+  }
   if ( (MHD_REQUEST_HEADERS_PROCESSED == request->state) &&
        ( (MHD_METHOD_POST == request->method) ||
-         (MHD_METHOD_PUT == request->method) ) )
-    {
-      /* response was queued "early", refuse to read body / footers or
-         further requests! */
-      request->connection->read_closed = true;
-      request->state = MHD_REQUEST_FOOTERS_RECEIVED;
-    }
+         (MHD_METHOD_PUT == request->method) ) )
+  {
+    /* response was queued "early", refuse to read body / footers or
+       further requests! */
+    request->connection->read_closed = true;
+    request->state = MHD_REQUEST_FOOTERS_RECEIVED;
+  }
   if (! request->in_idle)
     (void) MHD_request_handle_idle_ (request);
   return MHD_SC_OK;
@@ -114,16 +115,16 @@ response_action (void *cls,
  */
 _MHD_EXTERN const struct MHD_Action *
 MHD_action_from_response (struct MHD_Response *response,
-                          enum MHD_Bool destroy_after_use)
+                          enum MHD_Bool destroy_after_use)
 {
   response->action.action = &response_action;
   response->action.action_cls = response;
   if (! destroy_after_use)
-    {
-      MHD_mutex_lock_chk_ (&response->mutex);
-      response->reference_count++;
-      MHD_mutex_unlock_chk_ (&response->mutex);
-    }
+  {
+    MHD_mutex_lock_chk_ (&response->mutex);
+    response->reference_count++;
+    MHD_mutex_unlock_chk_ (&response->mutex);
+  }
   return &response->action;
 }
 
diff --git a/src/lib/action_parse_post.c b/src/lib/action_parse_post.c
index c60e793d..53757933 100644
--- a/src/lib/action_parse_post.c
+++ b/src/lib/action_parse_post.c
@@ -52,8 +52,8 @@
  */
 const struct MHD_Action *
 MHD_action_parse_post (size_t buffer_size,
-                       MHD_PostDataIterator iter,
-                       void *iter_cls)
+                       MHD_PostDataIterator iter,
+                       void *iter_cls)
 {
   return NULL; /* not yet implemented */
 }
diff --git a/src/lib/action_process_upload.c b/src/lib/action_process_upload.c
index cafd5d3c..0e9722cd 100644
--- a/src/lib/action_process_upload.c
+++ b/src/lib/action_process_upload.c
@@ -49,13 +49,13 @@ struct UploadAction
  *
  * @param cls the `struct UploadAction` with the
  *    function we are to call for upload data
- * @param request the request for which we are to process 
+ * @param request the request for which we are to process
  *    upload data
  * @return #MHD_SC_OK on success
  */
 static enum MHD_StatusCode
 upload_action (void *cls,
-               struct MHD_Request *request)
+               struct MHD_Request *request)
 {
   struct UploadAction *ua = cls;
 
@@ -75,7 +75,7 @@ upload_action (void *cls,
  */
 const struct MHD_Action *
 MHD_action_process_upload (MHD_UploadCallback uc,
-                           void *uc_cls)
+                           void *uc_cls)
 {
   struct UploadAction *ua;
 
@@ -90,5 +90,3 @@ MHD_action_process_upload (MHD_UploadCallback uc,
 
 
 /* end of action_process_upload.c */
-
-
diff --git a/src/lib/action_suspend.c b/src/lib/action_suspend.c
index bf5adc34..c176e494 100644
--- a/src/lib/action_suspend.c
+++ b/src/lib/action_suspend.c
@@ -35,7 +35,7 @@
  */
 static enum MHD_StatusCode
 suspend_action (void *cls,
-                struct MHD_Request *request)
+                struct MHD_Request *request)
 {
   (void) cls;
   struct MHD_Connection *connection = request->connection;
@@ -43,24 +43,24 @@ suspend_action (void *cls,
 
   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   if (connection->resuming)
-    {
-      /* suspending again while we didn't even complete resuming yet */
-      connection->resuming = false;
-      MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
-      return MHD_SC_OK;
-    }
+  {
+    /* suspending again while we didn't even complete resuming yet */
+    connection->resuming = false;
+    MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
+    return MHD_SC_OK;
+  }
   if (daemon->threading_mode != MHD_TM_THREAD_PER_CONNECTION)
-    {
-      if (connection->connection_timeout ==
-          daemon->connection_default_timeout)
-        XDLL_remove (daemon->normal_timeout_head,
-                     daemon->normal_timeout_tail,
-                     connection);
-      else
-        XDLL_remove (daemon->manual_timeout_head,
-                     daemon->manual_timeout_tail,
-                     connection);
-    }
+  {
+    if (connection->connection_timeout ==
+        daemon->connection_default_timeout)
+      XDLL_remove (daemon->normal_timeout_head,
+                   daemon->normal_timeout_tail,
+                   connection);
+    else
+      XDLL_remove (daemon->manual_timeout_head,
+                   daemon->manual_timeout_tail,
+                   connection);
+  }
   DLL_remove (daemon->connections_head,
               daemon->connections_tail,
               connection);
@@ -71,25 +71,25 @@ suspend_action (void *cls,
   connection->suspended = true;
 #ifdef EPOLL_SUPPORT
   if (MHD_ELS_EPOLL == daemon->event_loop_syscall)
+  {
+    if (0 != (connection->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL))
+    {
+      EDLL_remove (daemon->eready_head,
+                   daemon->eready_tail,
+                   connection);
+      connection->epoll_state &= ~MHD_EPOLL_STATE_IN_EREADY_EDLL;
+    }
+    if (0 != (connection->epoll_state & MHD_EPOLL_STATE_IN_EPOLL_SET))
     {
-      if (0 != (connection->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL))
-        {
-          EDLL_remove (daemon->eready_head,
-                       daemon->eready_tail,
-                       connection);
-          connection->epoll_state &= ~MHD_EPOLL_STATE_IN_EREADY_EDLL;
-        }
-      if (0 != (connection->epoll_state & MHD_EPOLL_STATE_IN_EPOLL_SET))
-        {
-          if (0 != epoll_ctl (daemon->epoll_fd,
-                              EPOLL_CTL_DEL,
-                              connection->socket_fd,
-                              NULL))
-            MHD_PANIC (_("Failed to remove FD from epoll set\n"));
-          connection->epoll_state &= ~MHD_EPOLL_STATE_IN_EPOLL_SET;
-        }
-      connection->epoll_state |= MHD_EPOLL_STATE_SUSPENDED;
+      if (0 != epoll_ctl (daemon->epoll_fd,
+                          EPOLL_CTL_DEL,
+                          connection->socket_fd,
+                          NULL))
+        MHD_PANIC (_ ("Failed to remove FD from epoll set\n"));
+      connection->epoll_state &= ~MHD_EPOLL_STATE_IN_EPOLL_SET;
     }
+    connection->epoll_state |= MHD_EPOLL_STATE_SUSPENDED;
+  }
 #endif
   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   return MHD_SC_OK;
diff --git a/src/lib/base64.c b/src/lib/base64.c
index 3dc7a142..d7d1ec92 100644
--- a/src/lib/base64.c
+++ b/src/lib/base64.c
@@ -9,45 +9,46 @@
 #include "base64.h"
 
 static const char base64_digits[] =
-  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 62, 0, 0, 0, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
-    0, 0, 0, -1, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
-    14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 26,
-    27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
-    45, 46, 47, 48, 49, 50, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 62, 0, 0, 0, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
+  0, 0, 0, -1, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+  14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 26,
+  27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
+  45, 46, 47, 48, 49, 50, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
 
 char *
-BASE64Decode(const char* src)
+BASE64Decode (const char*src)
 {
   size_t in_len = strlen (src);
-  char* dest;
-  char* result;
+  char*dest;
+  char*result;
 
   if (in_len % 4)
-    {
-      /* Wrong base64 string length */
-      return NULL;
-    }
-  result = dest = malloc(in_len / 4 * 3 + 1);
+  {
+    /* Wrong base64 string length */
+    return NULL;
+  }
+  result = dest = malloc (in_len / 4 * 3 + 1);
   if (NULL == result)
     return NULL; /* out of memory */
-  while (*src) {
-    char a = base64_digits[(unsigned char)*(src++)];
-    char b = base64_digits[(unsigned char)*(src++)];
-    char c = base64_digits[(unsigned char)*(src++)];
-    char d = base64_digits[(unsigned char)*(src++)];
+  while (*src)
+  {
+    char a = base64_digits[(unsigned char) *(src++)];
+    char b = base64_digits[(unsigned char) *(src++)];
+    char c = base64_digits[(unsigned char) *(src++)];
+    char d = base64_digits[(unsigned char) *(src++)];
     *(dest++) = (a << 2) | ((b & 0x30) >> 4);
-    if (c == (char)-1)
+    if (c == (char) -1)
       break;
     *(dest++) = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2);
-    if (d == (char)-1)
+    if (d == (char) -1)
       break;
     *(dest++) = ((c & 0x03) << 6) | d;
   }
diff --git a/src/lib/base64.h b/src/lib/base64.h
index ba96ca0c..65042c0b 100644
--- a/src/lib/base64.h
+++ b/src/lib/base64.h
@@ -12,6 +12,6 @@
 #include "platform.h"
 
 char *
-BASE64Decode(const char* src);
+BASE64Decode (const char*src);
 
 #endif /* !BASE64_H */
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);
 }
 
diff --git a/src/lib/connection_add.h b/src/lib/connection_add.h
index 6957fd77..de8abd9a 100644
--- a/src/lib/connection_add.h
+++ b/src/lib/connection_add.h
@@ -32,10 +32,10 @@
  * that process daemon's select()/poll()/etc.
  *
  * @param daemon handle with the listen socket
- * @return #MHD_SC_OK on success 
+ * @return #MHD_SC_OK on success
  */
 enum MHD_StatusCode
 MHD_accept_connection_ (struct MHD_Daemon *daemon)
-  MHD_NONNULL (1);
+MHD_NONNULL (1);
 
 #endif
diff --git a/src/lib/connection_call_handlers.c b/src/lib/connection_call_handlers.c
index af8860d6..c4fb448e 100644
--- a/src/lib/connection_call_handlers.c
+++ b/src/lib/connection_call_handlers.c
@@ -56,7 +56,8 @@
  * minimal.
  */
 #ifdef HAVE_MESSAGES
-#define REQUEST_TOO_BIG "<html><head><title>Request too big</title></head><body>Your HTTP header was too big for the memory constraints of this webserver.</body></html>"
+#define REQUEST_TOO_BIG \
+  "<html><head><title>Request too big</title></head><body>Your HTTP header was too big for the memory constraints of this webserver.</body></html>"
 #else
 #define REQUEST_TOO_BIG ""
 #endif
@@ -69,7 +70,8 @@
  * minimal.
  */
 #ifdef HAVE_MESSAGES
-#define REQUEST_LACKS_HOST "<html><head><title>&quot;Host:&quot; header required</title></head><body>In HTTP 1.1, requests must include a &quot;Host:&quot; header, and your HTTP 1.1 request lacked such a header.</body></html>"
+#define REQUEST_LACKS_HOST \
+  "<html><head><title>&quot;Host:&quot; header required</title></head><body>In HTTP 1.1, requests must include a &quot;Host:&quot; header, and your HTTP 1.1 request lacked such a header.</body></html>"
 #else
 #define REQUEST_LACKS_HOST ""
 #endif
@@ -82,7 +84,8 @@
  * minimal.
  */
 #ifdef HAVE_MESSAGES
-#define REQUEST_MALFORMED "<html><head><title>Request malformed</title></head><body>Your HTTP request was syntactically incorrect.</body></html>"
+#define REQUEST_MALFORMED \
+  "<html><head><title>Request malformed</title></head><body>Your HTTP request was syntactically incorrect.</body></html>"
 #else
 #define REQUEST_MALFORMED ""
 #endif
@@ -94,7 +97,8 @@
  * minimal.
  */
 #ifdef HAVE_MESSAGES
-#define INTERNAL_ERROR "<html><head><title>Internal server error</title></head><body>Please ask the developer of this Web server to carefully read the GNU libmicrohttpd documentation about connection management and blocking.</body></html>"
+#define INTERNAL_ERROR \
+  "<html><head><title>Internal server error</title></head><body>Please ask the developer of this Web server to carefully read the GNU libmicrohttpd documentation about connection management and blocking.</body></html>"
 #else
 #define INTERNAL_ERROR ""
 #endif
@@ -128,17 +132,18 @@ MHD_conn_init_static_ (void)
 #ifdef SF_FLAGS
   long sys_page_size = sysconf (_SC_PAGESIZE);
   if (0 > sys_page_size)
-    { /* Failed to get page size. */
-      freebsd_sendfile_flags_ = SF_NODISKIO;
-      freebsd_sendfile_flags_thd_p_c_ = SF_NODISKIO;
-    }
+  {   /* Failed to get page size. */
+    freebsd_sendfile_flags_ = SF_NODISKIO;
+    freebsd_sendfile_flags_thd_p_c_ = SF_NODISKIO;
+  }
   else
-    {
-      freebsd_sendfile_flags_ =
-          SF_FLAGS((uint16_t)(MHD_SENFILE_CHUNK_ / sys_page_size), SF_NODISKIO);
-      freebsd_sendfile_flags_thd_p_c_ =
-          SF_FLAGS((uint16_t)(MHD_SENFILE_CHUNK_THR_P_C_ / sys_page_size), SF_NODISKIO);
-    }
+  {
+    freebsd_sendfile_flags_ =
+      SF_FLAGS ((uint16_t) (MHD_SENFILE_CHUNK_ / sys_page_size), SF_NODISKIO);
+    freebsd_sendfile_flags_thd_p_c_ =
+      SF_FLAGS ((uint16_t) (MHD_SENFILE_CHUNK_THR_P_C_ / sys_page_size),
+                SF_NODISKIO);
+  }
 #endif /* SF_FLAGS */
 }
 #endif /* HAVE_FREEBSD_SENDFILE */
@@ -161,13 +166,13 @@ MHD_conn_init_static_ (void)
  */
 static void
 connection_close_error (struct MHD_Connection *connection,
-                        enum MHD_StatusCode sc,
-                        const char *emsg)
+                        enum MHD_StatusCode sc,
+                        const char *emsg)
 {
 #ifdef HAVE_MESSAGES
   if (NULL != emsg)
     MHD_DLOG (connection->daemon,
-              sc,
+              sc,
               emsg);
 #else  /* ! HAVE_MESSAGES */
   (void) emsg; /* Mute compiler warning. */
@@ -209,8 +214,8 @@ try_grow_read_buffer (struct MHD_Request *request)
   if (0 == request->read_buffer_size)
     new_size = daemon->connection_memory_limit_b / 2;
   else
-    new_size = request->read_buffer_size +
-      daemon->connection_memory_increment_b;
+    new_size = request->read_buffer_size
+               + daemon->connection_memory_increment_b;
   buf = MHD_pool_reallocate (request->connection->pool,
                              request->read_buffer,
                              request->read_buffer_size,
@@ -245,16 +250,16 @@ MHD_request_handle_read_ (struct MHD_Request *request)
     struct MHD_TLS_Plugin *tls;
 
     if ( (NULL != (tls = daemon->tls_api)) &&
-         (! tls->handshake (tls->cls,
-                            connection->tls_cs)) )
+         (! tls->handshake (tls->cls,
+                            connection->tls_cs)) )
       return;
   }
 #endif /* HTTPS_SUPPORT */
 
   /* make sure "read" has a reasonable number of bytes
      in buffer to use per system call (if possible) */
-  if (request->read_buffer_offset +
-      daemon->connection_memory_increment_b >
+  if (request->read_buffer_offset
+      + daemon->connection_memory_increment_b >
       request->read_buffer_size)
     try_grow_read_buffer (request);
 
@@ -263,82 +268,84 @@ MHD_request_handle_read_ (struct MHD_Request *request)
   bytes_read = connection->recv_cls (connection,
                                      &request->read_buffer
                                      [request->read_buffer_offset],
-                                     request->read_buffer_size -
-                                     request->read_buffer_offset);
+                                     request->read_buffer_size
+                                     - request->read_buffer_offset);
   if (bytes_read < 0)
+  {
+    if (MHD_ERR_AGAIN_ == bytes_read)
+      return;     /* No new data to process. */
+    if (MHD_ERR_CONNRESET_ == bytes_read)
     {
-      if (MHD_ERR_AGAIN_ == bytes_read)
-          return; /* No new data to process. */
-      if (MHD_ERR_CONNRESET_ == bytes_read)
-        {
-          CONNECTION_CLOSE_ERROR (connection,
-                                  (MHD_REQUEST_INIT == request->state)
-                                  ? MHD_SC_CONNECTION_CLOSED
-                                  : MHD_SC_CONNECTION_RESET_CLOSED,
-                                  (MHD_REQUEST_INIT == request->state)
-                                  ? NULL
-                                  : _("Socket disconnected while reading request.\n"));
-           return;
-        }
       CONNECTION_CLOSE_ERROR (connection,
-                              (MHD_REQUEST_INIT == request->state)
-                              ? MHD_SC_CONNECTION_CLOSED
-                              : MHD_SC_CONNECTION_READ_FAIL_CLOSED,
                               (MHD_REQUEST_INIT == request->state)
-                              ? NULL
-                              : _("Connection socket is closed due to error when reading request.\n"));
+                              ? MHD_SC_CONNECTION_CLOSED
+                              : MHD_SC_CONNECTION_RESET_CLOSED,
+                              (MHD_REQUEST_INIT == request->state)
+                              ? NULL
+                              : _ (
+                                "Socket disconnected while reading request.\n"));
       return;
     }
+    CONNECTION_CLOSE_ERROR (connection,
+                            (MHD_REQUEST_INIT == request->state)
+                            ? MHD_SC_CONNECTION_CLOSED
+                            : MHD_SC_CONNECTION_READ_FAIL_CLOSED,
+                            (MHD_REQUEST_INIT == request->state)
+                            ? NULL
+                            : _ (
+                              "Connection socket is closed due to error when reading request.\n"));
+    return;
+  }
 
   if (0 == bytes_read)
-    { /* Remote side closed connection. */
-      connection->read_closed = true;
-      MHD_connection_close_ (connection,
-                             MHD_REQUEST_TERMINATED_CLIENT_ABORT);
-      return;
-    }
+  {   /* Remote side closed connection. */
+    connection->read_closed = true;
+    MHD_connection_close_ (connection,
+                           MHD_REQUEST_TERMINATED_CLIENT_ABORT);
+    return;
+  }
   request->read_buffer_offset += bytes_read;
   MHD_connection_update_last_activity_ (connection);
 #if DEBUG_STATES
   MHD_DLOG (daemon,
-            MHD_SC_STATE_MACHINE_STATUS_REPORT,
-            _("In function %s handling connection at state: %s\n"),
+            MHD_SC_STATE_MACHINE_STATUS_REPORT,
+            _ ("In function %s handling connection at state: %s\n"),
             __FUNCTION__,
             MHD_state_to_string (request->state));
 #endif
   switch (request->state)
+  {
+  case MHD_REQUEST_INIT:
+  case MHD_REQUEST_URL_RECEIVED:
+  case MHD_REQUEST_HEADER_PART_RECEIVED:
+  case MHD_REQUEST_HEADERS_RECEIVED:
+  case MHD_REQUEST_HEADERS_PROCESSED:
+  case MHD_REQUEST_CONTINUE_SENDING:
+  case MHD_REQUEST_CONTINUE_SENT:
+  case MHD_REQUEST_BODY_RECEIVED:
+  case MHD_REQUEST_FOOTER_PART_RECEIVED:
+    /* nothing to do but default action */
+    if (connection->read_closed)
     {
-    case MHD_REQUEST_INIT:
-    case MHD_REQUEST_URL_RECEIVED:
-    case MHD_REQUEST_HEADER_PART_RECEIVED:
-    case MHD_REQUEST_HEADERS_RECEIVED:
-    case MHD_REQUEST_HEADERS_PROCESSED:
-    case MHD_REQUEST_CONTINUE_SENDING:
-    case MHD_REQUEST_CONTINUE_SENT:
-    case MHD_REQUEST_BODY_RECEIVED:
-    case MHD_REQUEST_FOOTER_PART_RECEIVED:
-      /* nothing to do but default action */
-      if (connection->read_closed)
-        {
-          MHD_connection_close_ (connection,
-                                 MHD_REQUEST_TERMINATED_READ_ERROR);
-        }
-      return;
-    case MHD_REQUEST_CLOSED:
-      return;
+      MHD_connection_close_ (connection,
+                             MHD_REQUEST_TERMINATED_READ_ERROR);
+    }
+    return;
+  case MHD_REQUEST_CLOSED:
+    return;
 #ifdef UPGRADE_SUPPORT
-    case MHD_REQUEST_UPGRADE:
-      mhd_assert (0);
-      return;
+  case MHD_REQUEST_UPGRADE:
+    mhd_assert (0);
+    return;
 #endif /* UPGRADE_SUPPORT */
-    default:
-      /* shrink read buffer to how much is actually used */
-      MHD_pool_reallocate (connection->pool,
-                           request->read_buffer,
-                           request->read_buffer_size + 1,
-                           request->read_buffer_offset);
-      break;
-    }
+  default:
+    /* shrink read buffer to how much is actually used */
+    MHD_pool_reallocate (connection->pool,
+                         request->read_buffer,
+                         request->read_buffer_size + 1,
+                         request->read_buffer_offset);
+    break;
+  }
   return;
 }
 
@@ -361,9 +368,9 @@ sendfile_adapter (struct MHD_Connection *connection)
   uint64_t left;
   uint64_t offsetu64;
 #ifndef HAVE_SENDFILE64
-  const uint64_t max_off_t = (uint64_t)OFF_T_MAX;
+  const uint64_t max_off_t = (uint64_t) OFF_T_MAX;
 #else  /* HAVE_SENDFILE64 */
-  const uint64_t max_off_t = (uint64_t)OFF64_T_MAX;
+  const uint64_t max_off_t = (uint64_t) OFF64_T_MAX;
 #endif /* HAVE_SENDFILE64 */
 #ifdef MHD_LINUX_SOLARIS_SENDFILE
 #ifndef HAVE_SENDFILE64
@@ -379,8 +386,10 @@ sendfile_adapter (struct MHD_Connection *connection)
 #ifdef HAVE_DARWIN_SENDFILE
   off_t len;
 #endif /* HAVE_DARWIN_SENDFILE */
-  const bool used_thr_p_c = (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode);
-  const size_t chunk_size = used_thr_p_c ? MHD_SENFILE_CHUNK_THR_P_C_ : MHD_SENFILE_CHUNK_;
+  const bool used_thr_p_c = (MHD_TM_THREAD_PER_CONNECTION ==
+                             daemon->threading_mode);
+  const size_t chunk_size = used_thr_p_c ? MHD_SENFILE_CHUNK_THR_P_C_ :
+                            MHD_SENFILE_CHUNK_;
   size_t send_size = 0;
 
   mhd_assert (MHD_resp_sender_sendfile == request->resp_sender);
@@ -390,10 +399,10 @@ sendfile_adapter (struct MHD_Connection *connection)
    * use 128KiB chunks (2MiB for thread-per-connection). */
   send_size = (left > chunk_size) ? chunk_size : (size_t) left;
   if (max_off_t < offsetu64)
-    { /* Retry to send with standard 'send()'. */
-      request->resp_sender = MHD_resp_sender_std;
-      return MHD_ERR_AGAIN_;
-    }
+  {   /* Retry to send with standard 'send()'. */
+    request->resp_sender = MHD_resp_sender_std;
+    return MHD_ERR_AGAIN_;
+  }
 #ifdef MHD_LINUX_SOLARIS_SENDFILE
 #ifndef HAVE_SENDFILE64
   offset = (off_t) offsetu64;
@@ -409,54 +418,54 @@ sendfile_adapter (struct MHD_Connection *connection)
                     send_size);
 #endif /* HAVE_SENDFILE64 */
   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_;
+      return MHD_ERR_AGAIN_;
+    }
+    if (MHD_SCKT_ERR_IS_EINTR_ (err))
+      return MHD_ERR_AGAIN_;
 #ifdef HAVE_LINUX_SENDFILE
-      if (MHD_SCKT_ERR_IS_(err,
-                           MHD_SCKT_EBADF_))
-        return MHD_ERR_BADF_;
-      /* sendfile() failed with EINVAL if mmap()-like operations are not
-         supported for FD or other 'unusual' errors occurred, so we should try
-         to fall back to 'SEND'; see also this thread for info on
-         odd libc/Linux behavior with sendfile:
-         http://lists.gnu.org/archive/html/libmicrohttpd/2011-02/msg00015.html */
+    if (MHD_SCKT_ERR_IS_ (err,
+                          MHD_SCKT_EBADF_))
+      return MHD_ERR_BADF_;
+    /* sendfile() failed with EINVAL if mmap()-like operations are not
+       supported for FD or other 'unusual' errors occurred, so we should try
+       to fall back to 'SEND'; see also this thread for info on
+       odd libc/Linux behavior with sendfile:
+       http://lists.gnu.org/archive/html/libmicrohttpd/2011-02/msg00015.html */
+    request->resp_sender = MHD_resp_sender_std;
+    return MHD_ERR_AGAIN_;
+#else  /* HAVE_SOLARIS_SENDFILE */
+    if ( (EAFNOSUPPORT == err) ||
+         (EINVAL == err) ||
+         (EOPNOTSUPP == err) )
+    {     /* Retry with standard file reader. */
       request->resp_sender = MHD_resp_sender_std;
       return MHD_ERR_AGAIN_;
-#else  /* HAVE_SOLARIS_SENDFILE */
-      if ( (EAFNOSUPPORT == err) ||
-           (EINVAL == err) ||
-           (EOPNOTSUPP == err) )
-        { /* Retry with standard file reader. */
-          request->resp_sender = MHD_resp_sender_std;
-          return MHD_ERR_AGAIN_;
-        }
-      if ( (ENOTCONN == err) ||
-           (EPIPE == err) )
-        {
-          return MHD_ERR_CONNRESET_;
-        }
-      return MHD_ERR_BADF_; /* Fail hard */
-#endif /* HAVE_SOLARIS_SENDFILE */
     }
+    if ( (ENOTCONN == err) ||
+         (EPIPE == err) )
+    {
+      return MHD_ERR_CONNRESET_;
+    }
+    return MHD_ERR_BADF_;   /* Fail hard */
+#endif /* HAVE_SOLARIS_SENDFILE */
+  }
 #ifdef EPOLL_SUPPORT
-  else if (send_size > (size_t)ret)
-        connection->epoll_state &= ~MHD_EPOLL_STATE_WRITE_READY;
+  else if (send_size > (size_t) ret)
+    connection->epoll_state &= ~MHD_EPOLL_STATE_WRITE_READY;
 #endif /* EPOLL_SUPPORT */
 #elif defined(HAVE_FREEBSD_SENDFILE)
 #ifdef SF_FLAGS
   flags = used_thr_p_c ?
-      freebsd_sendfile_flags_thd_p_c_ : freebsd_sendfile_flags_;
+          freebsd_sendfile_flags_thd_p_c_ : freebsd_sendfile_flags_;
 #endif /* SF_FLAGS */
   if (0 != sendfile (file_fd,
                      connection->socket_fd,
@@ -465,26 +474,26 @@ sendfile_adapter (struct MHD_Connection *connection)
                      NULL,
                      &sent_bytes,
                      flags))
+  {
+    const int err = MHD_socket_get_error_ ();
+    if (MHD_SCKT_ERR_IS_EAGAIN_ (err) ||
+        MHD_SCKT_ERR_IS_EINTR_ (err) ||
+        (EBUSY == err) )
     {
-      const int err = MHD_socket_get_error_();
-      if (MHD_SCKT_ERR_IS_EAGAIN_(err) ||
-          MHD_SCKT_ERR_IS_EINTR_(err) ||
-          EBUSY == err)
-        {
-          mhd_assert (SSIZE_MAX >= sent_bytes);
-          if (0 != sent_bytes)
-            return (ssize_t)sent_bytes;
+      mhd_assert (SSIZE_MAX >= sent_bytes);
+      if (0 != sent_bytes)
+        return (ssize_t) sent_bytes;
 
-          return MHD_ERR_AGAIN_;
-        }
-      /* Some unrecoverable error. Possibly file FD is not suitable
-       * for sendfile(). Retry with standard send(). */
-      request->resp_sender = MHD_resp_sender_std;
       return MHD_ERR_AGAIN_;
     }
+    /* Some unrecoverable error. Possibly file FD is not suitable
+     * for sendfile(). Retry with standard send(). */
+    request->resp_sender = MHD_resp_sender_std;
+    return MHD_ERR_AGAIN_;
+  }
   mhd_assert (0 < sent_bytes);
   mhd_assert (SSIZE_MAX >= sent_bytes);
-  ret = (ssize_t)sent_bytes;
+  ret = (ssize_t) sent_bytes;
 #elif defined(HAVE_DARWIN_SENDFILE)
   len = (off_t) send_size; /* chunk always fit */
   if (0 != sendfile (file_fd,
@@ -493,35 +502,35 @@ sendfile_adapter (struct MHD_Connection *connection)
                      &len,
                      NULL,
                      0))
+  {
+    const int err = MHD_socket_get_error_ ();
+    if (MHD_SCKT_ERR_IS_EAGAIN_ (err) ||
+        MHD_SCKT_ERR_IS_EINTR_ (err))
     {
-      const int err = MHD_socket_get_error_();
-      if (MHD_SCKT_ERR_IS_EAGAIN_(err) ||
-          MHD_SCKT_ERR_IS_EINTR_(err))
-        {
-          mhd_assert (0 <= len);
-          mhd_assert (SSIZE_MAX >= len);
-          mhd_assert (send_size >= (size_t)len);
-          if (0 != len)
-            return (ssize_t)len;
+      mhd_assert (0 <= len);
+      mhd_assert (SSIZE_MAX >= len);
+      mhd_assert (send_size >= (size_t) len);
+      if (0 != len)
+        return (ssize_t) len;
 
-          return MHD_ERR_AGAIN_;
-        }
-      if (ENOTCONN == err ||
-          EPIPE == err)
-        return MHD_ERR_CONNRESET_;
-      if (ENOTSUP == err ||
-          EOPNOTSUPP == err)
-        { /* This file FD is not suitable for sendfile().
+      return MHD_ERR_AGAIN_;
+    }
+    if ((ENOTCONN == err) ||
+        (EPIPE == err) )
+      return MHD_ERR_CONNRESET_;
+    if ((ENOTSUP == err) ||
+        (EOPNOTSUPP == err) )
+    {     /* This file FD is not suitable for sendfile().
            * Retry with standard send(). */
-          request->resp_sender = MHD_resp_sender_std;
-          return MHD_ERR_AGAIN_;
-        }
-      return MHD_ERR_BADF_; /* Return hard error. */
+      request->resp_sender = MHD_resp_sender_std;
+      return MHD_ERR_AGAIN_;
     }
+    return MHD_ERR_BADF_;   /* Return hard error. */
+  }
   mhd_assert (0 <= len);
   mhd_assert (SSIZE_MAX >= len);
-  mhd_assert (send_size >= (size_t)len);
-  ret = (ssize_t)len;
+  mhd_assert (send_size >= (size_t) len);
+  ret = (ssize_t) len;
 #endif /* HAVE_FREEBSD_SENDFILE */
   return ret;
 }
@@ -547,7 +556,7 @@ check_write_done (struct MHD_Request *request,
   request->write_buffer_send_offset = 0;
   request->state = next_state;
   MHD_pool_reallocate (request->connection->pool,
-                       request->write_buffer,
+                       request->write_buffer,
                        request->write_buffer_size,
                        0);
   request->write_buffer = NULL;
@@ -579,47 +588,48 @@ try_ready_normal_body (struct MHD_Request *request)
        (request->response_write_position == response->total_size) )
     return true; /* 0-byte response is always ready */
   if ( (response->data_start <=
-        request->response_write_position) &&
+        request->response_write_position) &&
        (response->data_size + response->data_start >
-        request->response_write_position) )
+        request->response_write_position) )
     return true; /* response already ready */
 #if defined(_MHD_HAVE_SENDFILE)
   if (MHD_resp_sender_sendfile == request->resp_sender)
-    {
-      /* will use sendfile, no need to bother response crc */
-      return true;
-    }
+  {
+    /* will use sendfile, no need to bother response crc */
+    return true;
+  }
 #endif /* _MHD_HAVE_SENDFILE */
 
   ret = response->crc (response->crc_cls,
                        request->response_write_position,
                        response->data,
                        (size_t) MHD_MIN ((uint64_t) response->data_buffer_size,
-                                         response->total_size -
-                                         request->response_write_position));
+                                         response->total_size
+                                         - request->response_write_position));
   if ( (((ssize_t) MHD_CONTENT_READER_END_OF_STREAM) == ret) ||
        (((ssize_t) MHD_CONTENT_READER_END_WITH_ERROR) == ret) )
-    {
-      /* either error or http 1.0 transfer, close socket! */
-      response->total_size = request->response_write_position;
-      MHD_mutex_unlock_chk_ (&response->mutex);
-      if ( ((ssize_t)MHD_CONTENT_READER_END_OF_STREAM) == ret)
-        MHD_connection_close_ (connection,
-                               MHD_REQUEST_TERMINATED_COMPLETED_OK);
-      else
-        CONNECTION_CLOSE_ERROR (connection,
-                                MHD_SC_APPLICATION_DATA_GENERATION_FAILURE_CLOSED,
-                                _("Closing connection (application reported error generating data)\n"));
-      return false;
-    }
+  {
+    /* either error or http 1.0 transfer, close socket! */
+    response->total_size = request->response_write_position;
+    MHD_mutex_unlock_chk_ (&response->mutex);
+    if ( ((ssize_t) MHD_CONTENT_READER_END_OF_STREAM) == ret)
+      MHD_connection_close_ (connection,
+                             MHD_REQUEST_TERMINATED_COMPLETED_OK);
+    else
+      CONNECTION_CLOSE_ERROR (connection,
+                              MHD_SC_APPLICATION_DATA_GENERATION_FAILURE_CLOSED,
+                              _ (
+                                "Closing connection (application reported error generating data)\n"));
+    return false;
+  }
   response->data_start = request->response_write_position;
   response->data_size = ret;
   if (0 == ret)
-    {
-      request->state = MHD_REQUEST_NORMAL_BODY_UNREADY;
-      MHD_mutex_unlock_chk_ (&response->mutex);
-      return false;
-    }
+  {
+    request->state = MHD_REQUEST_NORMAL_BODY_UNREADY;
+    MHD_mutex_unlock_chk_ (&response->mutex);
+    return false;
+  }
   return true;
 }
 
@@ -647,93 +657,94 @@ try_ready_chunked_body (struct MHD_Request *request)
   if (NULL == response->crc)
     return true;
   if (0 == request->write_buffer_size)
-    {
-      size = MHD_MIN (daemon->connection_memory_limit_b,
-                      2 * (0xFFFFFF + sizeof(cbuf) + 2));
-      do
-        {
-          size /= 2;
-          if (size < 128)
-            {
-              MHD_mutex_unlock_chk_ (&response->mutex);
-              /* not enough memory */
-              CONNECTION_CLOSE_ERROR (connection,
-                                      MHD_SC_CONNECTION_POOL_MALLOC_FAILURE,
-                                      _("Closing connection (out of memory)\n"));
-              return false;
-            }
-          buf = MHD_pool_allocate (connection->pool,
-                                   size,
-                                   MHD_NO);
-        }
-      while (NULL == buf);
-      request->write_buffer_size = size;
-      request->write_buffer = buf;
-    }
+  {
+    size = MHD_MIN (daemon->connection_memory_limit_b,
+                    2 * (0xFFFFFF + sizeof(cbuf) + 2));
+    do
+    {
+      size /= 2;
+      if (size < 128)
+      {
+        MHD_mutex_unlock_chk_ (&response->mutex);
+        /* not enough memory */
+        CONNECTION_CLOSE_ERROR (connection,
+                                MHD_SC_CONNECTION_POOL_MALLOC_FAILURE,
+                                _ ("Closing connection (out of memory)\n"));
+        return false;
+      }
+      buf = MHD_pool_allocate (connection->pool,
+                               size,
+                               MHD_NO);
+    }
+    while (NULL == buf);
+    request->write_buffer_size = size;
+    request->write_buffer = buf;
+  }
 
   if (0 == response->total_size)
     ret = 0; /* response must be empty, don't bother calling crc */
   else if ( (response->data_start <=
-        request->response_write_position) &&
-       (response->data_start + response->data_size >
-        request->response_write_position) )
-    {
-      /* difference between response_write_position and data_start is less
-         than data_size which is size_t type, no need to check for overflow */
-      const size_t data_write_offset
-        = (size_t)(request->response_write_position - response->data_start);
-      /* buffer already ready, use what is there for the chunk */
-      ret = response->data_size - data_write_offset;
-      if ( ((size_t) ret) > request->write_buffer_size - sizeof (cbuf) - 2 )
-        ret = request->write_buffer_size - sizeof (cbuf) - 2;
-      memcpy (&request->write_buffer[sizeof (cbuf)],
-              &response->data[data_write_offset],
-              ret);
-    }
+             request->response_write_position) &&
+            (response->data_start + response->data_size >
+             request->response_write_position) )
+  {
+    /* difference between response_write_position and data_start is less
+       than data_size which is size_t type, no need to check for overflow */
+    const size_t data_write_offset
+      = (size_t) (request->response_write_position - response->data_start);
+    /* buffer already ready, use what is there for the chunk */
+    ret = response->data_size - data_write_offset;
+    if ( ((size_t) ret) > request->write_buffer_size - sizeof (cbuf) - 2 )
+      ret = request->write_buffer_size - sizeof (cbuf) - 2;
+    memcpy (&request->write_buffer[sizeof (cbuf)],
+            &response->data[data_write_offset],
+            ret);
+  }
   else
-    {
-      /* buffer not in range, try to fill it */
-      ret = response->crc (response->crc_cls,
-                           request->response_write_position,
-                           &request->write_buffer[sizeof (cbuf)],
-                           request->write_buffer_size - sizeof (cbuf) - 2);
-    }
+  {
+    /* buffer not in range, try to fill it */
+    ret = response->crc (response->crc_cls,
+                         request->response_write_position,
+                         &request->write_buffer[sizeof (cbuf)],
+                         request->write_buffer_size - sizeof (cbuf) - 2);
+  }
   if ( ((ssize_t) MHD_CONTENT_READER_END_WITH_ERROR) == ret)
-    {
-      /* error, close socket! */
-      response->total_size = request->response_write_position;
-      MHD_mutex_unlock_chk_ (&response->mutex);
-      CONNECTION_CLOSE_ERROR (connection,
-                              MHD_SC_APPLICATION_DATA_GENERATION_FAILURE_CLOSED,
-                              _("Closing connection (application error generating response)\n"));
-      return false;
-    }
+  {
+    /* error, close socket! */
+    response->total_size = request->response_write_position;
+    MHD_mutex_unlock_chk_ (&response->mutex);
+    CONNECTION_CLOSE_ERROR (connection,
+                            MHD_SC_APPLICATION_DATA_GENERATION_FAILURE_CLOSED,
+                            _ (
+                              "Closing connection (application error generating response)\n"));
+    return false;
+  }
   if ( (((ssize_t) MHD_CONTENT_READER_END_OF_STREAM) == ret) ||
        (0 == response->total_size) )
-    {
-      /* end of message, signal other side! */
-      memcpy (request->write_buffer,
-              "0\r\n",
-              3);
-      request->write_buffer_append_offset = 3;
-      request->write_buffer_send_offset = 0;
-      response->total_size = request->response_write_position;
-      return true;
-    }
+  {
+    /* end of message, signal other side! */
+    memcpy (request->write_buffer,
+            "0\r\n",
+            3);
+    request->write_buffer_append_offset = 3;
+    request->write_buffer_send_offset = 0;
+    response->total_size = request->response_write_position;
+    return true;
+  }
   if (0 == ret)
-    {
-      request->state = MHD_REQUEST_CHUNKED_BODY_UNREADY;
-      MHD_mutex_unlock_chk_ (&response->mutex);
-      return false;
-    }
+  {
+    request->state = MHD_REQUEST_CHUNKED_BODY_UNREADY;
+    MHD_mutex_unlock_chk_ (&response->mutex);
+    return false;
+  }
   if (ret > 0xFFFFFF)
     ret = 0xFFFFFF;
-  cblen = MHD_snprintf_(cbuf,
-                        sizeof (cbuf),
-                        "%X\r\n",
-                        (unsigned int) ret);
-  mhd_assert(cblen > 0);
-  mhd_assert((size_t)cblen < sizeof(cbuf));
+  cblen = MHD_snprintf_ (cbuf,
+                         sizeof (cbuf),
+                         "%X\r\n",
+                         (unsigned int) ret);
+  mhd_assert (cblen > 0);
+  mhd_assert ((size_t) cblen < sizeof(cbuf));
   memcpy (&request->write_buffer[sizeof (cbuf) - cblen],
           cbuf,
           cblen);
@@ -768,221 +779,224 @@ MHD_request_handle_write_ (struct MHD_Request *request)
     struct MHD_TLS_Plugin *tls;
 
     if ( (NULL != (tls = daemon->tls_api)) &&
-         (! tls->handshake (tls->cls,
-                            connection->tls_cs)) )
+         (! tls->handshake (tls->cls,
+                            connection->tls_cs)) )
       return;
   }
 #endif /* HTTPS_SUPPORT */
 
 #if DEBUG_STATES
   MHD_DLOG (daemon,
-            MHD_SC_STATE_MACHINE_STATUS_REPORT,
-            _("In function %s handling connection at state: %s\n"),
+            MHD_SC_STATE_MACHINE_STATUS_REPORT,
+            _ ("In function %s handling connection at state: %s\n"),
             __FUNCTION__,
             MHD_state_to_string (request->state));
 #endif
   switch (request->state)
-    {
-    case MHD_REQUEST_INIT:
-    case MHD_REQUEST_URL_RECEIVED:
-    case MHD_REQUEST_HEADER_PART_RECEIVED:
-    case MHD_REQUEST_HEADERS_RECEIVED:
-      mhd_assert (0);
-      return;
-    case MHD_REQUEST_HEADERS_PROCESSED:
-      return;
-    case MHD_REQUEST_CONTINUE_SENDING:
-      ret = connection->send_cls (connection,
-                                  &HTTP_100_CONTINUE
-                                  [request->continue_message_write_offset],
-                                  MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE) -
-                                  request->continue_message_write_offset);
-      if (ret < 0)
-        {
-          if (MHD_ERR_AGAIN_ == ret)
-            return;
+  {
+  case MHD_REQUEST_INIT:
+  case MHD_REQUEST_URL_RECEIVED:
+  case MHD_REQUEST_HEADER_PART_RECEIVED:
+  case MHD_REQUEST_HEADERS_RECEIVED:
+    mhd_assert (0);
+    return;
+  case MHD_REQUEST_HEADERS_PROCESSED:
+    return;
+  case MHD_REQUEST_CONTINUE_SENDING:
+    ret = connection->send_cls (connection,
+                                &HTTP_100_CONTINUE
+                                [request->continue_message_write_offset],
+                                MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE)
+                                - request->continue_message_write_offset);
+    if (ret < 0)
+    {
+      if (MHD_ERR_AGAIN_ == ret)
+        return;
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    MHD_SC_CONNECTION_WRITE_FAIL_CLOSED,
-                    _("Failed to send data in request for %s.\n"),
-                    request->url);
+      MHD_DLOG (daemon,
+                MHD_SC_CONNECTION_WRITE_FAIL_CLOSED,
+                _ ("Failed to send data in request for %s.\n"),
+                request->url);
 #endif
-          CONNECTION_CLOSE_ERROR (connection,
-                                  MHD_SC_CONNECTION_WRITE_FAIL_CLOSED,
-                                  NULL);
-          return;
-        }
-      request->continue_message_write_offset += ret;
-      MHD_connection_update_last_activity_ (connection);
-      return;
-    case MHD_REQUEST_CONTINUE_SENT:
-    case MHD_REQUEST_BODY_RECEIVED:
-    case MHD_REQUEST_FOOTER_PART_RECEIVED:
-    case MHD_REQUEST_FOOTERS_RECEIVED:
-      mhd_assert (0);
+      CONNECTION_CLOSE_ERROR (connection,
+                              MHD_SC_CONNECTION_WRITE_FAIL_CLOSED,
+                              NULL);
       return;
-    case MHD_REQUEST_HEADERS_SENDING:
-      ret = connection->send_cls (connection,
-                                  &request->write_buffer
-                                  [request->write_buffer_send_offset],
-                                  request->write_buffer_append_offset -
-                                    request->write_buffer_send_offset);
-      if (ret < 0)
-        {
-          if (MHD_ERR_AGAIN_ == ret)
-            return;
-          CONNECTION_CLOSE_ERROR (connection,
-                                  MHD_SC_CONNECTION_WRITE_FAIL_CLOSED,
-                                  _("Connection was closed while sending response headers.\n"));
-          return;
-        }
-      request->write_buffer_send_offset += ret;
-      MHD_connection_update_last_activity_ (connection);
-      if (MHD_REQUEST_HEADERS_SENDING != request->state)
+    }
+    request->continue_message_write_offset += ret;
+    MHD_connection_update_last_activity_ (connection);
+    return;
+  case MHD_REQUEST_CONTINUE_SENT:
+  case MHD_REQUEST_BODY_RECEIVED:
+  case MHD_REQUEST_FOOTER_PART_RECEIVED:
+  case MHD_REQUEST_FOOTERS_RECEIVED:
+    mhd_assert (0);
+    return;
+  case MHD_REQUEST_HEADERS_SENDING:
+    ret = connection->send_cls (connection,
+                                &request->write_buffer
+                                [request->write_buffer_send_offset],
+                                request->write_buffer_append_offset
+                                - request->write_buffer_send_offset);
+    if (ret < 0)
+    {
+      if (MHD_ERR_AGAIN_ == ret)
         return;
-      check_write_done (request,
-                        MHD_REQUEST_HEADERS_SENT);
+      CONNECTION_CLOSE_ERROR (connection,
+                              MHD_SC_CONNECTION_WRITE_FAIL_CLOSED,
+                              _ (
+                                "Connection was closed while sending response headers.\n"));
       return;
-    case MHD_REQUEST_HEADERS_SENT:
+    }
+    request->write_buffer_send_offset += ret;
+    MHD_connection_update_last_activity_ (connection);
+    if (MHD_REQUEST_HEADERS_SENDING != request->state)
       return;
-    case MHD_REQUEST_NORMAL_BODY_READY:
-      response = request->response;
-      if (request->response_write_position <
-          request->response->total_size)
-        {
-          uint64_t data_write_offset;
-
-          if (NULL != response->crc)
-            MHD_mutex_lock_chk_ (&response->mutex);
-          if (! try_ready_normal_body (request))
-            {
-              /* mutex was already unlocked by try_ready_normal_body */
-              return;
-            }
+    check_write_done (request,
+                      MHD_REQUEST_HEADERS_SENT);
+    return;
+  case MHD_REQUEST_HEADERS_SENT:
+    return;
+  case MHD_REQUEST_NORMAL_BODY_READY:
+    response = request->response;
+    if (request->response_write_position <
+        request->response->total_size)
+    {
+      uint64_t data_write_offset;
+
+      if (NULL != response->crc)
+        MHD_mutex_lock_chk_ (&response->mutex);
+      if (! try_ready_normal_body (request))
+      {
+        /* mutex was already unlocked by try_ready_normal_body */
+        return;
+      }
 #if defined(_MHD_HAVE_SENDFILE)
-          if (MHD_resp_sender_sendfile == request->resp_sender)
-            {
-              ret = sendfile_adapter (connection);
-            }
-          else
+      if (MHD_resp_sender_sendfile == request->resp_sender)
+      {
+        ret = sendfile_adapter (connection);
+      }
+      else
 #else  /* ! _MHD_HAVE_SENDFILE */
-          if (1)
+      if (1)
 #endif /* ! _MHD_HAVE_SENDFILE */
-            {
-              data_write_offset = request->response_write_position
-                                  - response->data_start;
-              if (data_write_offset > (uint64_t)SIZE_MAX)
-                MHD_PANIC (_("Data offset exceeds limit"));
-              ret = connection->send_cls (connection,
-                                          &response->data
-                                          [(size_t)data_write_offset],
-                                          response->data_size -
-                                          (size_t)data_write_offset);
+      {
+        data_write_offset = request->response_write_position
+                            - response->data_start;
+        if (data_write_offset > (uint64_t) SIZE_MAX)
+          MHD_PANIC (_ ("Data offset exceeds limit"));
+        ret = connection->send_cls (connection,
+                                    &response->data
+                                    [(size_t) data_write_offset],
+                                    response->data_size
+                                    - (size_t) data_write_offset);
 #if DEBUG_SEND_DATA
-              if (ret > 0)
-                fprintf (stderr,
-                         _("Sent %d-byte DATA response: `%.*s'\n"),
-                         (int) ret,
-                         (int) ret,
-                         &response->data[request->response_write_position -
-                                         response->data_start]);
+        if (ret > 0)
+          fprintf (stderr,
+                   _ ("Sent %d-byte DATA response: `%.*s'\n"),
+                   (int) ret,
+                   (int) ret,
+                   &response->data[request->response_write_position
+                                   - response->data_start]);
 #endif
-            }
-          if (NULL != response->crc)
-            MHD_mutex_unlock_chk_ (&response->mutex);
-          if (ret < 0)
-            {
-              if (MHD_ERR_AGAIN_ == ret)
-                return;
-#ifdef HAVE_MESSAGES
-              MHD_DLOG (daemon,
-                        MHD_SC_CONNECTION_WRITE_FAIL_CLOSED,
-                        _("Failed to send data in request for `%s'.\n"),
-                        request->url);
-#endif
-              CONNECTION_CLOSE_ERROR (connection,
-                                      MHD_SC_CONNECTION_WRITE_FAIL_CLOSED,
-                                      NULL);
-              return;
-            }
-          request->response_write_position += ret;
-          MHD_connection_update_last_activity_ (connection);
-        }
-      if (request->response_write_position ==
-          request->response->total_size)
-        request->state = MHD_REQUEST_FOOTERS_SENT; /* have no footers */
-      return;
-    case MHD_REQUEST_NORMAL_BODY_UNREADY:
-      mhd_assert (0);
-      return;
-    case MHD_REQUEST_CHUNKED_BODY_READY:
-      ret = connection->send_cls (connection,
-                                  &request->write_buffer
-                                  [request->write_buffer_send_offset],
-                                  request->write_buffer_append_offset -
-                                    request->write_buffer_send_offset);
+      }
+      if (NULL != response->crc)
+        MHD_mutex_unlock_chk_ (&response->mutex);
       if (ret < 0)
-        {
-          if (MHD_ERR_AGAIN_ == ret)
-            return;
-          CONNECTION_CLOSE_ERROR (connection,
-                                  MHD_SC_CONNECTION_WRITE_FAIL_CLOSED,
-                                  _("Connection was closed while sending response body.\n"));
+      {
+        if (MHD_ERR_AGAIN_ == ret)
           return;
-        }
-      request->write_buffer_send_offset += ret;
+#ifdef HAVE_MESSAGES
+        MHD_DLOG (daemon,
+                  MHD_SC_CONNECTION_WRITE_FAIL_CLOSED,
+                  _ ("Failed to send data in request for `%s'.\n"),
+                  request->url);
+#endif
+        CONNECTION_CLOSE_ERROR (connection,
+                                MHD_SC_CONNECTION_WRITE_FAIL_CLOSED,
+                                NULL);
+        return;
+      }
+      request->response_write_position += ret;
       MHD_connection_update_last_activity_ (connection);
-      if (MHD_REQUEST_CHUNKED_BODY_READY != request->state)
+    }
+    if (request->response_write_position ==
+        request->response->total_size)
+      request->state = MHD_REQUEST_FOOTERS_SENT;   /* have no footers */
+    return;
+  case MHD_REQUEST_NORMAL_BODY_UNREADY:
+    mhd_assert (0);
+    return;
+  case MHD_REQUEST_CHUNKED_BODY_READY:
+    ret = connection->send_cls (connection,
+                                &request->write_buffer
+                                [request->write_buffer_send_offset],
+                                request->write_buffer_append_offset
+                                - request->write_buffer_send_offset);
+    if (ret < 0)
+    {
+      if (MHD_ERR_AGAIN_ == ret)
         return;
-      check_write_done (request,
-                        (request->response->total_size ==
-                         request->response_write_position) ?
-                        MHD_REQUEST_BODY_SENT :
-                        MHD_REQUEST_CHUNKED_BODY_UNREADY);
+      CONNECTION_CLOSE_ERROR (connection,
+                              MHD_SC_CONNECTION_WRITE_FAIL_CLOSED,
+                              _ (
+                                "Connection was closed while sending response body.\n"));
       return;
-    case MHD_REQUEST_CHUNKED_BODY_UNREADY:
-    case MHD_REQUEST_BODY_SENT:
-      mhd_assert (0);
+    }
+    request->write_buffer_send_offset += ret;
+    MHD_connection_update_last_activity_ (connection);
+    if (MHD_REQUEST_CHUNKED_BODY_READY != request->state)
       return;
-    case MHD_REQUEST_FOOTERS_SENDING:
-      ret = connection->send_cls (connection,
-                                  &request->write_buffer
-                                  [request->write_buffer_send_offset],
-                                  request->write_buffer_append_offset -
-                                    request->write_buffer_send_offset);
-      if (ret < 0)
-        {
-          if (MHD_ERR_AGAIN_ == ret)
-            return;
-          CONNECTION_CLOSE_ERROR (connection,
-                                  MHD_SC_CONNECTION_WRITE_FAIL_CLOSED,
-                                  _("Connection was closed while sending response body.\n"));
-          return;
-        }
-      request->write_buffer_send_offset += ret;
-      MHD_connection_update_last_activity_ (connection);
-      if (MHD_REQUEST_FOOTERS_SENDING != request->state)
+    check_write_done (request,
+                      (request->response->total_size ==
+                       request->response_write_position) ?
+                      MHD_REQUEST_BODY_SENT :
+                      MHD_REQUEST_CHUNKED_BODY_UNREADY);
+    return;
+  case MHD_REQUEST_CHUNKED_BODY_UNREADY:
+  case MHD_REQUEST_BODY_SENT:
+    mhd_assert (0);
+    return;
+  case MHD_REQUEST_FOOTERS_SENDING:
+    ret = connection->send_cls (connection,
+                                &request->write_buffer
+                                [request->write_buffer_send_offset],
+                                request->write_buffer_append_offset
+                                - request->write_buffer_send_offset);
+    if (ret < 0)
+    {
+      if (MHD_ERR_AGAIN_ == ret)
         return;
-      check_write_done (request,
-                        MHD_REQUEST_FOOTERS_SENT);
-      return;
-    case MHD_REQUEST_FOOTERS_SENT:
-      mhd_assert (0);
+      CONNECTION_CLOSE_ERROR (connection,
+                              MHD_SC_CONNECTION_WRITE_FAIL_CLOSED,
+                              _ (
+                                "Connection was closed while sending response body.\n"));
       return;
-    case MHD_REQUEST_CLOSED:
+    }
+    request->write_buffer_send_offset += ret;
+    MHD_connection_update_last_activity_ (connection);
+    if (MHD_REQUEST_FOOTERS_SENDING != request->state)
       return;
+    check_write_done (request,
+                      MHD_REQUEST_FOOTERS_SENT);
+    return;
+  case MHD_REQUEST_FOOTERS_SENT:
+    mhd_assert (0);
+    return;
+  case MHD_REQUEST_CLOSED:
+    return;
 #ifdef UPGRADE_SUPPORT
-    case MHD_REQUEST_UPGRADE:
-      mhd_assert (0);
-      return;
+  case MHD_REQUEST_UPGRADE:
+    mhd_assert (0);
+    return;
 #endif /* UPGRADE_SUPPORT */
-    default:
-      mhd_assert (0);
-      CONNECTION_CLOSE_ERROR (connection,
-                              MHD_SC_STATEMACHINE_FAILURE_CONNECTION_CLOSED,
-                              _("Internal error\n"));
-      break;
-    }
+  default:
+    mhd_assert (0);
+    CONNECTION_CLOSE_ERROR (connection,
+                            MHD_SC_STATEMACHINE_FAILURE_CONNECTION_CLOSED,
+                            _ ("Internal error\n"));
+    break;
+  }
 }
 
 
@@ -1001,9 +1015,9 @@ MHD_request_handle_write_ (struct MHD_Request *request)
  */
 static bool
 MHD_lookup_header_token_ci (const struct MHD_Request *request,
-                            const char *header,
-                            const char *token,
-                            size_t token_len)
+                            const char *header,
+                            const char *token,
+                            size_t token_len)
 {
   struct MHD_HTTP_Header *pos;
 
@@ -1014,16 +1028,16 @@ MHD_lookup_header_token_ci (const struct MHD_Request *request,
        (0 == token[0]) )
     return false;
   for (pos = request->headers_received; NULL != pos; pos = pos->next)
-    {
-      if ( (0 != (pos->kind & MHD_HEADER_KIND)) &&
-           ( (header == pos->header) ||
-             (MHD_str_equal_caseless_(header,
-                                      pos->header)) ) &&
-           (MHD_str_has_token_caseless_ (pos->value,
-                                         token,
-                                         token_len)) )
-        return true;
-    }
+  {
+    if ( (0 != (pos->kind & MHD_HEADER_KIND)) &&
+         ( (header == pos->header) ||
+           (MHD_str_equal_caseless_ (header,
+                                     pos->header)) ) &&
+         (MHD_str_has_token_caseless_ (pos->value,
+                                       token,
+                                       token_len)) )
+      return true;
+  }
   return false;
 }
 
@@ -1040,7 +1054,7 @@ MHD_lookup_header_token_ci (const struct MHD_Request *request,
  *         false otherwise
  */
 #define MHD_lookup_header_s_token_ci(r,h,tkn) \
-    MHD_lookup_header_token_ci((r),(h),(tkn),MHD_STATICSTR_LEN_(tkn))
+  MHD_lookup_header_token_ci ((r),(h),(tkn),MHD_STATICSTR_LEN_ (tkn))
 
 
 /**
@@ -1071,27 +1085,27 @@ keepalive_possible (struct MHD_Request *request)
     return false;
 
   if (MHD_str_equal_caseless_ (request->version_s,
-                               MHD_HTTP_VERSION_1_1))
-    {
-      if (MHD_lookup_header_s_token_ci (request,
-                                        MHD_HTTP_HEADER_CONNECTION,
-                                        "upgrade"))
-        return false;
-      if (MHD_lookup_header_s_token_ci (request,
-                                        MHD_HTTP_HEADER_CONNECTION,
-                                        "close"))
-        return false;
-      return true;
-    }
-  if (MHD_str_equal_caseless_ (request->version_s,
-                               MHD_HTTP_VERSION_1_0))
-    {
-      if (MHD_lookup_header_s_token_ci (request,
-                                        MHD_HTTP_HEADER_CONNECTION,
-                                        "Keep-Alive"))
-        return true;
+                               MHD_HTTP_VERSION_1_1))
+  {
+    if (MHD_lookup_header_s_token_ci (request,
+                                      MHD_HTTP_HEADER_CONNECTION,
+                                      "upgrade"))
       return false;
-    }
+    if (MHD_lookup_header_s_token_ci (request,
+                                      MHD_HTTP_HEADER_CONNECTION,
+                                      "close"))
+      return false;
+    return true;
+  }
+  if (MHD_str_equal_caseless_ (request->version_s,
+                               MHD_HTTP_VERSION_1_0))
+  {
+    if (MHD_lookup_header_s_token_ci (request,
+                                      MHD_HTTP_HEADER_CONNECTION,
+                                      "Keep-Alive"))
+      return true;
+    return false;
+  }
   return false;
 }
 
@@ -1105,7 +1119,7 @@ keepalive_possible (struct MHD_Request *request)
  */
 static void
 get_date_string (char *date,
-                 size_t date_len)
+                 size_t date_len)
 {
   static const char *const days[] = {
     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
@@ -1116,8 +1130,9 @@ get_date_string (char *date,
   };
   struct tm now;
   time_t t;
-#if !defined(HAVE_C11_GMTIME_S) && !defined(HAVE_W32_GMTIME_S) && !defined(HAVE_GMTIME_R)
-  struct tm* pNow;
+#if ! defined(HAVE_C11_GMTIME_S) && ! defined(HAVE_W32_GMTIME_S) && \
+  ! defined(HAVE_GMTIME_R)
+  struct tm*pNow;
 #endif
 
   date[0] = 0;
@@ -1131,25 +1146,25 @@ get_date_string (char *date,
                      &t))
     return;
 #elif defined(HAVE_GMTIME_R)
-  if (NULL == gmtime_r(&t,
-                       &now))
+  if (NULL == gmtime_r (&t,
+                        &now))
     return;
 #else
-  pNow = gmtime(&t);
+  pNow = gmtime (&t);
   if (NULL == pNow)
     return;
   now = *pNow;
 #endif
   MHD_snprintf_ (date,
-                 date_len,
-                 "Date: %3s, %02u %3s %04u %02u:%02u:%02u GMT\r\n",
-                 days[now.tm_wday % 7],
-                 (unsigned int) now.tm_mday,
-                 mons[now.tm_mon % 12],
-                 (unsigned int) (1900 + now.tm_year),
-                 (unsigned int) now.tm_hour,
-                 (unsigned int) now.tm_min,
-                 (unsigned int) now.tm_sec);
+                 date_len,
+                 "Date: %3s, %02u %3s %04u %02u:%02u:%02u GMT\r\n",
+                 days[now.tm_wday % 7],
+                 (unsigned int) now.tm_mday,
+                 mons[now.tm_mon % 12],
+                 (unsigned int) (1900 + now.tm_year),
+                 (unsigned int) now.tm_hour,
+                 (unsigned int) now.tm_min,
+                 (unsigned int) now.tm_sec);
 }
 
 
@@ -1168,9 +1183,9 @@ get_date_string (char *date,
  */
 static bool
 check_response_header_token_ci (const struct MHD_Response *response,
-                                const char *key,
-                                const char *token,
-                                size_t token_len)
+                                const char *key,
+                                const char *token,
+                                size_t token_len)
 {
   struct MHD_HTTP_Header *pos;
 
@@ -1183,15 +1198,15 @@ check_response_header_token_ci (const struct MHD_Response *response,
   for (pos = response->first_header;
        NULL != pos;
        pos = pos->next)
-    {
-      if ( (pos->kind == MHD_HEADER_KIND) &&
-           MHD_str_equal_caseless_ (pos->header,
-                                    key) &&
-           MHD_str_has_token_caseless_ (pos->value,
-                                        token,
-                                        token_len) )
-        return true;
-    }
+  {
+    if ( (pos->kind == MHD_HEADER_KIND) &&
+         MHD_str_equal_caseless_ (pos->header,
+                                  key) &&
+         MHD_str_has_token_caseless_ (pos->value,
+                                      token,
+                                      token_len) )
+      return true;
+  }
   return false;
 }
 
@@ -1208,7 +1223,7 @@ check_response_header_token_ci (const struct MHD_Response *response,
  *         false otherwise
  */
 #define check_response_header_s_token_ci(r,k,tkn) \
-    check_response_header_token_ci((r),(k),(tkn),MHD_STATICSTR_LEN_(tkn))
+  check_response_header_token_ci ((r),(k),(tkn),MHD_STATICSTR_LEN_ (tkn))
 
 
 /**
@@ -1248,58 +1263,58 @@ build_header_response (struct MHD_Request *request)
 
   mhd_assert (NULL != request->version_s);
   if (0 == request->version_s[0])
-    {
-      data = MHD_pool_allocate (connection->pool,
-                                0,
-                                MHD_YES);
-      request->write_buffer = data;
-      request->write_buffer_append_offset = 0;
-      request->write_buffer_send_offset = 0;
-      request->write_buffer_size = 0;
-      return true;
-    }
+  {
+    data = MHD_pool_allocate (connection->pool,
+                              0,
+                              MHD_YES);
+    request->write_buffer = data;
+    request->write_buffer_append_offset = 0;
+    request->write_buffer_send_offset = 0;
+    request->write_buffer_size = 0;
+    return true;
+  }
   if (MHD_REQUEST_FOOTERS_RECEIVED == request->state)
-    {
-      const char *reason_phrase;
-      const char *version;
-
-      reason_phrase
-        = MHD_get_reason_phrase_for (response->status_code);
-      version
-        = (response->icy)
-        ? "ICY"
-        : ( (MHD_str_equal_caseless_ (MHD_HTTP_VERSION_1_0,
-                                      request->version_s))
-            ? MHD_HTTP_VERSION_1_0
-            : MHD_HTTP_VERSION_1_1);
-      MHD_snprintf_ (code,
-                     sizeof (code),
-                     "%s %u %s\r\n",
-                     version,
-                     response->status_code,
-                     reason_phrase);
-      off = strlen (code);
-      /* estimate size */
-      size = off + 2;           /* +2 for extra "\r\n" at the end */
-      kind = MHD_HEADER_KIND;
-      if ( (! daemon->suppress_date) &&
-           (NULL == MHD_response_get_header (response,
-                                             MHD_HTTP_HEADER_DATE)) )
-        get_date_string (date,
-                         sizeof (date));
-      else
-        date[0] = '\0';
-      datelen = strlen (date);
-      size += datelen;
-    }
+  {
+    const char *reason_phrase;
+    const char *version;
+
+    reason_phrase
+      = MHD_get_reason_phrase_for (response->status_code);
+    version
+      = (response->icy)
+        ? "ICY"
+        : ( (MHD_str_equal_caseless_ (MHD_HTTP_VERSION_1_0,
+                                      request->version_s))
+            ? MHD_HTTP_VERSION_1_0
+            : MHD_HTTP_VERSION_1_1);
+    MHD_snprintf_ (code,
+                   sizeof (code),
+                   "%s %u %s\r\n",
+                   version,
+                   response->status_code,
+                   reason_phrase);
+    off = strlen (code);
+    /* estimate size */
+    size = off + 2;             /* +2 for extra "\r\n" at the end */
+    kind = MHD_HEADER_KIND;
+    if ( (! daemon->suppress_date) &&
+         (NULL == MHD_response_get_header (response,
+                                           MHD_HTTP_HEADER_DATE)) )
+      get_date_string (date,
+                       sizeof (date));
+    else
+      date[0] = '\0';
+    datelen = strlen (date);
+    size += datelen;
+  }
   else
-    {
-      /* 2 bytes for final CRLF of a Chunked-Body */
-      size = 2;
-      kind = MHD_FOOTER_KIND;
-      off = 0;
-      datelen = 0;
-    }
+  {
+    /* 2 bytes for final CRLF of a Chunked-Body */
+    size = 2;
+    kind = MHD_FOOTER_KIND;
+    off = 0;
+    datelen = 0;
+  }
 
   /* calculate extra headers we need to add, such as 'Connection: close',
      first see what was explicitly requested by the application */
@@ -1309,153 +1324,154 @@ build_header_response (struct MHD_Request *request)
   must_add_content_length = false;
   response_has_close = false;
   switch (request->state)
-    {
-    case MHD_REQUEST_FOOTERS_RECEIVED:
-      response_has_close
-        = check_response_header_s_token_ci (response,
-                                            MHD_HTTP_HEADER_CONNECTION,
-                                            "close");
-      response_has_keepalive
-        = check_response_header_s_token_ci (response,
-                                            MHD_HTTP_HEADER_CONNECTION,
-                                            "Keep-Alive");
-      client_requested_close
-        = MHD_lookup_header_s_token_ci (request,
-                                        MHD_HTTP_HEADER_CONNECTION,
-                                        "close");
-
-      if (response->v10_only)
-        request->keepalive = MHD_CONN_MUST_CLOSE;
+  {
+  case MHD_REQUEST_FOOTERS_RECEIVED:
+    response_has_close
+      = check_response_header_s_token_ci (response,
+                                          MHD_HTTP_HEADER_CONNECTION,
+                                          "close");
+    response_has_keepalive
+      = check_response_header_s_token_ci (response,
+                                          MHD_HTTP_HEADER_CONNECTION,
+                                          "Keep-Alive");
+    client_requested_close
+      = MHD_lookup_header_s_token_ci (request,
+                                      MHD_HTTP_HEADER_CONNECTION,
+                                      "close");
+
+    if (response->v10_only)
+      request->keepalive = MHD_CONN_MUST_CLOSE;
 #ifdef UPGRADE_SUPPORT
-      else if (NULL != response->upgrade_handler)
-        /* If this connection will not be "upgraded", it must be closed. */
-        request->keepalive = MHD_CONN_MUST_CLOSE;
+    else if (NULL != response->upgrade_handler)
+      /* If this connection will not be "upgraded", it must be closed. */
+      request->keepalive = MHD_CONN_MUST_CLOSE;
 #endif /* UPGRADE_SUPPORT */
 
-      /* now analyze chunked encoding situation */
-      request->have_chunked_upload = false;
+    /* now analyze chunked encoding situation */
+    request->have_chunked_upload = false;
 
-      if ( (MHD_SIZE_UNKNOWN == response->total_size) &&
+    if ( (MHD_SIZE_UNKNOWN == response->total_size) &&
 #ifdef UPGRADE_SUPPORT
-           (NULL == response->upgrade_handler) &&
+         (NULL == response->upgrade_handler) &&
 #endif /* UPGRADE_SUPPORT */
-           (! response_has_close) &&
-           (! client_requested_close) )
+         (! response_has_close) &&
+         (! client_requested_close) )
+    {
+      /* size is unknown, and close was not explicitly requested;
+         need to either to HTTP 1.1 chunked encoding or
+         close the connection */
+      /* 'close' header doesn't exist yet, see if we need to add one;
+         if the client asked for a close, no need to start chunk'ing */
+      if ( (keepalive_possible (request)) &&
+           (MHD_str_equal_caseless_ (MHD_HTTP_VERSION_1_1,
+                                     request->version_s)) )
+      {
+        have_encoding
+          = MHD_response_get_header (response,
+                                     MHD_HTTP_HEADER_TRANSFER_ENCODING);
+        if (NULL == have_encoding)
         {
-          /* size is unknown, and close was not explicitly requested;
-             need to either to HTTP 1.1 chunked encoding or
-             close the connection */
-          /* 'close' header doesn't exist yet, see if we need to add one;
-             if the client asked for a close, no need to start chunk'ing */
-          if ( (keepalive_possible (request)) &&
-               (MHD_str_equal_caseless_ (MHD_HTTP_VERSION_1_1,
-                                         request->version_s)) )
-            {
-              have_encoding
-                = MHD_response_get_header (response,
-                                           MHD_HTTP_HEADER_TRANSFER_ENCODING);
-              if (NULL == have_encoding)
-                {
-                  must_add_chunked_encoding = true;
-                  request->have_chunked_upload = true;
-                }
-              else if (MHD_str_equal_caseless_ (have_encoding,
-                                                "identity"))
-                {
-                  /* application forced identity encoding, can't do 'chunked' */
-                  must_add_close = true;
-                }
-              else
-                {
-                  request->have_chunked_upload = true;
-                }
-            }
-          else
-            {
-              /* Keep alive or chunking not possible
-                 => set close header if not present */
-              if (! response_has_close)
-                must_add_close = true;
-            }
+          must_add_chunked_encoding = true;
+          request->have_chunked_upload = true;
         }
-
-      /* check for other reasons to add 'close' header */
-      if ( ( (client_requested_close) ||
-             (connection->read_closed) ||
-             (MHD_CONN_MUST_CLOSE == request->keepalive)) &&
-           (! response_has_close) &&
-#ifdef UPGRADE_SUPPORT
-           (NULL == response->upgrade_handler) &&
-#endif /* UPGRADE_SUPPORT */
-           (! response->v10_only) )
-        must_add_close = true;
-
-      /* check if we should add a 'content length' header */
-      have_content_length
-        = MHD_response_get_header (response,
-                                   MHD_HTTP_HEADER_CONTENT_LENGTH);
-
-      /* MHD_HTTP_NO_CONTENT, MHD_HTTP_NOT_MODIFIED and 1xx-status
-         codes SHOULD NOT have a Content-Length according to spec;
-         also chunked encoding / unknown length or CONNECT... */
-      if ( (MHD_SIZE_UNKNOWN != response->total_size) &&
-           (MHD_HTTP_NO_CONTENT != response->status_code) &&
-           (MHD_HTTP_NOT_MODIFIED != response->status_code) &&
-           (MHD_HTTP_OK <= response->status_code) &&
-           (NULL == have_content_length) &&
-           (request->method != MHD_METHOD_CONNECT) )
+        else if (MHD_str_equal_caseless_ (have_encoding,
+                                          "identity"))
         {
-          /*
-            Here we add a content-length if one is missing; however,
-            for 'connect' methods, the responses MUST NOT include a
-            content-length header *if* the response code is 2xx (in
-            which case we expect there to be no body).  Still,
-            as we don't know the response code here in some cases, we
-            simply only force adding a content-length header if this
-            is not a 'connect' or if the response is not empty
-            (which is kind of more sane, because if some crazy
-            application did return content with a 2xx status code,
-            then having a content-length might again be a good idea).
-
-            Note that the change from 'SHOULD NOT' to 'MUST NOT' is
-            a recent development of the HTTP 1.1 specification.
-          */
-          content_length_len
-            = MHD_snprintf_ (content_length_buf,
-                             sizeof (content_length_buf),
-                             MHD_HTTP_HEADER_CONTENT_LENGTH ": " MHD_UNSIGNED_LONG_LONG_PRINTF "\r\n",
-                             (MHD_UNSIGNED_LONG_LONG) response->total_size);
-          must_add_content_length = true;
+          /* application forced identity encoding, can't do 'chunked' */
+          must_add_close = true;
         }
-
-      /* check for adding keep alive */
-      if ( (! response_has_keepalive) &&
-           (! response_has_close) &&
-           (! must_add_close) &&
-           (MHD_CONN_MUST_CLOSE != request->keepalive) &&
+        else
+        {
+          request->have_chunked_upload = true;
+        }
+      }
+      else
+      {
+        /* Keep alive or chunking not possible
+           => set close header if not present */
+        if (! response_has_close)
+          must_add_close = true;
+      }
+    }
+
+    /* check for other reasons to add 'close' header */
+    if ( ( (client_requested_close) ||
+           (connection->read_closed) ||
+           (MHD_CONN_MUST_CLOSE == request->keepalive)) &&
+         (! response_has_close) &&
 #ifdef UPGRADE_SUPPORT
-           (NULL == response->upgrade_handler) &&
+         (NULL == response->upgrade_handler) &&
 #endif /* UPGRADE_SUPPORT */
-           (keepalive_possible (request)) )
-        must_add_keep_alive = true;
-      break;
-    case MHD_REQUEST_BODY_SENT:
-      response_has_keepalive = false;
-      break;
-    default:
-      mhd_assert (0);
-      return MHD_NO;
-    }
+         (! response->v10_only) )
+      must_add_close = true;
+
+    /* check if we should add a 'content length' header */
+    have_content_length
+      = MHD_response_get_header (response,
+                                 MHD_HTTP_HEADER_CONTENT_LENGTH);
+
+    /* MHD_HTTP_NO_CONTENT, MHD_HTTP_NOT_MODIFIED and 1xx-status
+       codes SHOULD NOT have a Content-Length according to spec;
+       also chunked encoding / unknown length or CONNECT... */
+    if ( (MHD_SIZE_UNKNOWN != response->total_size) &&
+         (MHD_HTTP_NO_CONTENT != response->status_code) &&
+         (MHD_HTTP_NOT_MODIFIED != response->status_code) &&
+         (MHD_HTTP_OK <= response->status_code) &&
+         (NULL == have_content_length) &&
+         (request->method != MHD_METHOD_CONNECT) )
+    {
+      /*
+        Here we add a content-length if one is missing; however,
+        for 'connect' methods, the responses MUST NOT include a
+        content-length header *if* the response code is 2xx (in
+        which case we expect there to be no body).  Still,
+        as we don't know the response code here in some cases, we
+        simply only force adding a content-length header if this
+        is not a 'connect' or if the response is not empty
+        (which is kind of more sane, because if some crazy
+        application did return content with a 2xx status code,
+        then having a content-length might again be a good idea).
+
+        Note that the change from 'SHOULD NOT' to 'MUST NOT' is
+        a recent development of the HTTP 1.1 specification.
+      */
+      content_length_len
+        = MHD_snprintf_ (content_length_buf,
+                         sizeof (content_length_buf),
+                         MHD_HTTP_HEADER_CONTENT_LENGTH ": "
+                         MHD_UNSIGNED_LONG_LONG_PRINTF "\r\n",
+                         (MHD_UNSIGNED_LONG_LONG) response->total_size);
+      must_add_content_length = true;
+    }
+
+    /* check for adding keep alive */
+    if ( (! response_has_keepalive) &&
+         (! response_has_close) &&
+         (! must_add_close) &&
+         (MHD_CONN_MUST_CLOSE != request->keepalive) &&
+#ifdef UPGRADE_SUPPORT
+         (NULL == response->upgrade_handler) &&
+#endif /* UPGRADE_SUPPORT */
+         (keepalive_possible (request)) )
+      must_add_keep_alive = true;
+    break;
+  case MHD_REQUEST_BODY_SENT:
+    response_has_keepalive = false;
+    break;
+  default:
+    mhd_assert (0);
+    return MHD_NO;
+  }
 
   if (MHD_CONN_MUST_CLOSE != request->keepalive)
-    {
-      if ( (must_add_close) ||
-           (response_has_close) )
-        request->keepalive = MHD_CONN_MUST_CLOSE;
-      else if ( (must_add_keep_alive) ||
-                (response_has_keepalive) )
-        request->keepalive = MHD_CONN_USE_KEEPALIVE;
-    }
+  {
+    if ( (must_add_close) ||
+         (response_has_close) )
+      request->keepalive = MHD_CONN_MUST_CLOSE;
+    else if ( (must_add_keep_alive) ||
+              (response_has_keepalive) )
+      request->keepalive = MHD_CONN_USE_KEEPALIVE;
+  }
 
   if (must_add_close)
     size += MHD_STATICSTR_LEN_ ("Connection: close\r\n");
@@ -1469,91 +1485,91 @@ build_header_response (struct MHD_Request *request)
   mhd_assert (! (must_add_chunked_encoding && must_add_content_length) );
 
   for (pos = response->first_header; NULL != pos; pos = pos->next)
-    {
-      /* TODO: add proper support for excluding "Keep-Alive" token. */
-      if ( (pos->kind == kind) &&
-           (! ( (must_add_close) &&
-                (response_has_keepalive) &&
-                (MHD_str_equal_caseless_(pos->header,
-                                         MHD_HTTP_HEADER_CONNECTION)) &&
-                (MHD_str_equal_caseless_(pos->value,
-                                         "Keep-Alive")) ) ) )
-        size += strlen (pos->header) + strlen (pos->value) + 4; /* colon, space, linefeeds */
-    }
+  {
+    /* TODO: add proper support for excluding "Keep-Alive" token. */
+    if ( (pos->kind == kind) &&
+         (! ( (must_add_close) &&
+              (response_has_keepalive) &&
+              (MHD_str_equal_caseless_ (pos->header,
+                                        MHD_HTTP_HEADER_CONNECTION)) &&
+              (MHD_str_equal_caseless_ (pos->value,
+                                        "Keep-Alive")) ) ) )
+      size += strlen (pos->header) + strlen (pos->value) + 4;   /* colon, space, linefeeds */
+  }
   /* produce data */
   data = MHD_pool_allocate (connection->pool,
                             size + 1,
                             MHD_NO);
   if (NULL == data)
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_CONNECTION_POOL_MALLOC_FAILURE,
-                "Not enough memory for write!\n");
+    MHD_DLOG (daemon,
+              MHD_SC_CONNECTION_POOL_MALLOC_FAILURE,
+              "Not enough memory for write!\n");
 #endif
-      return false;
-    }
+    return false;
+  }
   if (MHD_REQUEST_FOOTERS_RECEIVED == request->state)
-    {
-      memcpy (data,
-              code,
-              off);
-    }
+  {
+    memcpy (data,
+            code,
+            off);
+  }
   if (must_add_close)
-    {
-      /* we must add the 'Connection: close' header */
-      memcpy (&data[off],
-              "Connection: close\r\n",
-              MHD_STATICSTR_LEN_ ("Connection: close\r\n"));
-      off += MHD_STATICSTR_LEN_ ("Connection: close\r\n");
-    }
+  {
+    /* we must add the 'Connection: close' header */
+    memcpy (&data[off],
+            "Connection: close\r\n",
+            MHD_STATICSTR_LEN_ ("Connection: close\r\n"));
+    off += MHD_STATICSTR_LEN_ ("Connection: close\r\n");
+  }
   if (must_add_keep_alive)
-    {
-      /* we must add the 'Connection: Keep-Alive' header */
-      memcpy (&data[off],
-              "Connection: Keep-Alive\r\n",
-              MHD_STATICSTR_LEN_ ("Connection: Keep-Alive\r\n"));
-      off += MHD_STATICSTR_LEN_ ("Connection: Keep-Alive\r\n");
-    }
+  {
+    /* we must add the 'Connection: Keep-Alive' header */
+    memcpy (&data[off],
+            "Connection: Keep-Alive\r\n",
+            MHD_STATICSTR_LEN_ ("Connection: Keep-Alive\r\n"));
+    off += MHD_STATICSTR_LEN_ ("Connection: Keep-Alive\r\n");
+  }
   if (must_add_chunked_encoding)
-    {
-      /* we must add the 'Transfer-Encoding: chunked' header */
-      memcpy (&data[off],
-              "Transfer-Encoding: chunked\r\n",
-              MHD_STATICSTR_LEN_ ("Transfer-Encoding: chunked\r\n"));
-      off += MHD_STATICSTR_LEN_ ("Transfer-Encoding: chunked\r\n");
-    }
+  {
+    /* we must add the 'Transfer-Encoding: chunked' header */
+    memcpy (&data[off],
+            "Transfer-Encoding: chunked\r\n",
+            MHD_STATICSTR_LEN_ ("Transfer-Encoding: chunked\r\n"));
+    off += MHD_STATICSTR_LEN_ ("Transfer-Encoding: chunked\r\n");
+  }
   if (must_add_content_length)
-    {
-      /* we must add the 'Content-Length' header */
-      memcpy (&data[off],
-              content_length_buf,
-              content_length_len);
-      off += content_length_len;
-    }
+  {
+    /* we must add the 'Content-Length' header */
+    memcpy (&data[off],
+            content_length_buf,
+            content_length_len);
+    off += content_length_len;
+  }
   for (pos = response->first_header; NULL != pos; pos = pos->next)
-    {
-      /* TODO: add proper support for excluding "Keep-Alive" token. */
-      if ( (pos->kind == kind) &&
-           (! ( (must_add_close) &&
-                (response_has_keepalive) &&
-                (MHD_str_equal_caseless_(pos->header,
-                                         MHD_HTTP_HEADER_CONNECTION)) &&
-                (MHD_str_equal_caseless_(pos->value,
-                                         "Keep-Alive")) ) ) )
-        off += MHD_snprintf_ (&data[off],
-                              size - off,
-                              "%s: %s\r\n",
-                              pos->header,
-                              pos->value);
-    }
+  {
+    /* TODO: add proper support for excluding "Keep-Alive" token. */
+    if ( (pos->kind == kind) &&
+         (! ( (must_add_close) &&
+              (response_has_keepalive) &&
+              (MHD_str_equal_caseless_ (pos->header,
+                                        MHD_HTTP_HEADER_CONNECTION)) &&
+              (MHD_str_equal_caseless_ (pos->value,
+                                        "Keep-Alive")) ) ) )
+      off += MHD_snprintf_ (&data[off],
+                            size - off,
+                            "%s: %s\r\n",
+                            pos->header,
+                            pos->value);
+  }
   if (MHD_REQUEST_FOOTERS_RECEIVED == request->state)
-    {
-      memcpy (&data[off],
-              date,
-              datelen);
-      off += datelen;
-    }
+  {
+    memcpy (&data[off],
+            date,
+            datelen);
+    off += datelen;
+  }
   memcpy (&data[off],
           "\r\n",
           2);
@@ -1584,50 +1600,52 @@ build_header_response (struct MHD_Request *request)
  */
 static void
 transmit_error_response (struct MHD_Request *request,
-                         enum MHD_StatusCode ec,
+                         enum MHD_StatusCode ec,
                          enum MHD_HTTP_StatusCode status_code,
-                         const char *message)
+                         const char *message)
 {
   struct MHD_Response *response;
 
   if (NULL == request->version_s)
-    {
-      /* we were unable to process the full header line, so we don't
-         really know what version the client speaks; assume 1.0 */
-      request->version_s = MHD_HTTP_VERSION_1_0;
-    }
+  {
+    /* we were unable to process the full header line, so we don't
+ really know what version the client speaks; assume 1.0 */
+    request->version_s = MHD_HTTP_VERSION_1_0;
+  }
   request->state = MHD_REQUEST_FOOTERS_RECEIVED;
   request->connection->read_closed = true;
 #ifdef HAVE_MESSAGES
   MHD_DLOG (request->daemon,
-            ec,
-            _("Error processing request (HTTP response code is %u (`%s')). Closing connection.\n"),
+            ec,
+            _ (
+              "Error processing request (HTTP response code is %u (`%s')). Closing connection.\n"),
             status_code,
             message);
 #endif
   if (NULL != request->response)
-    {
-      MHD_response_queue_for_destroy (request->response);
-      request->response = NULL;
-    }
+  {
+    MHD_response_queue_for_destroy (request->response);
+    request->response = NULL;
+  }
   response = MHD_response_from_buffer (status_code,
-                                       strlen (message),
-                                       (void *) message,
-                                       MHD_RESPMEM_PERSISTENT);
+                                       strlen (message),
+                                       (void *) message,
+                                       MHD_RESPMEM_PERSISTENT);
   request->response = response;
   /* Do not reuse this connection. */
   request->keepalive = MHD_CONN_MUST_CLOSE;
   if (! build_header_response (request))
-    {
-      /* oops - close! */
-      CONNECTION_CLOSE_ERROR (request->connection,
-                              ec,
-                              _("Closing connection (failed to create response header)\n"));
-    }
+  {
+    /* oops - close! */
+    CONNECTION_CLOSE_ERROR (request->connection,
+                            ec,
+                            _ (
+                              "Closing connection (failed to create response header)\n"));
+  }
   else
-    {
-      request->state = MHD_REQUEST_HEADERS_SENDING;
-    }
+  {
+    request->state = MHD_REQUEST_HEADERS_SENDING;
+  }
 }
 
 
@@ -1640,7 +1658,8 @@ transmit_error_response (struct MHD_Request *request,
 static enum MHD_Method
 method_string_to_enum (const char *method)
 {
-  static const struct {
+  static const struct
+  {
     const char *key;
     enum MHD_Method value;
   } methods[] = {
@@ -1685,10 +1704,10 @@ method_string_to_enum (const char *method)
   };
   unsigned int i;
 
-  for (i=0;NULL != methods[i].key;i++)
+  for (i = 0; NULL != methods[i].key; i++)
     if (0 ==
-        MHD_str_equal_caseless_ (method,
-                                 methods[i].key))
+        MHD_str_equal_caseless_ (method,
+                                 methods[i].key))
       return methods[i].value;
   return MHD_METHOD_UNKNOWN;
 }
@@ -1706,27 +1725,27 @@ method_string_to_enum (const char *method)
  */
 static bool
 request_add_header (struct MHD_Request *request,
-                    const char *key,
-                    const char *value,
-                    enum MHD_ValueKind kind)
+                    const char *key,
+                    const char *value,
+                    enum MHD_ValueKind kind)
 {
   if (MHD_NO ==
       MHD_request_set_value (request,
-                             kind,
-                             key,
-                             value))
-    {
+                             kind,
+                             key,
+                             value))
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (request->daemon,
-                MHD_SC_CONNECTION_POOL_MALLOC_FAILURE,
-                _("Not enough memory in pool to allocate header record!\n"));
+    MHD_DLOG (request->daemon,
+              MHD_SC_CONNECTION_POOL_MALLOC_FAILURE,
+              _ ("Not enough memory in pool to allocate header record!\n"));
 #endif
-      transmit_error_response (request,
-                               MHD_SC_CLIENT_HEADER_TOO_BIG,
-                               MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE,
-                               REQUEST_TOO_BIG);
-      return false;
-    }
+    transmit_error_response (request,
+                             MHD_SC_CLIENT_HEADER_TOO_BIG,
+                             MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE,
+                             REQUEST_TOO_BIG);
+    return false;
+  }
   return true;
 }
 
@@ -1763,76 +1782,76 @@ parse_initial_message_line (struct MHD_Request *request,
   /* Skip any spaces. Not required by standard but allow
      to be more tolerant. */
   while ( (' ' == uri[0]) &&
-          ( (size_t)(uri - line) < line_len) )
+          ( (size_t) (uri - line) < line_len) )
     uri++;
-  if ((size_t)(uri - line) == line_len)
-    {
-      curi = "";
-      uri = NULL;
-      request->version_s = "";
-      args = NULL;
-      url_end = line_len - (line - uri); // EH, this is garbage. FIXME!
-    }
+  if ((size_t) (uri - line) == line_len)
+  {
+    curi = "";
+    uri = NULL;
+    request->version_s = "";
+    args = NULL;
+    url_end = line_len - (line - uri);   // EH, this is garbage. FIXME!
+  }
   else
+  {
+    curi = uri;
+    /* Search from back to accept misformed URI with space */
+    http_version = line + line_len - 1;
+    /* Skip any trailing spaces */
+    while ( (' ' == http_version[0]) &&
+            (http_version > uri) )
+      http_version--;
+    /* Find first space in reverse direction */
+    while ( (' ' != http_version[0]) &&
+            (http_version > uri) )
+      http_version--;
+    if (http_version > uri)
+    {
+      http_version[0] = '\0';
+      request->version_s = http_version + 1;
+      args = memchr (uri,
+                     '?',
+                     http_version - uri);
+    }
+    else
     {
-      curi = uri;
-      /* Search from back to accept misformed URI with space */
-      http_version = line + line_len - 1;
-      /* Skip any trailing spaces */
-      while ( (' ' == http_version[0]) &&
-              (http_version > uri) )
-        http_version--;
-      /* Find first space in reverse direction */
-      while ( (' ' != http_version[0]) &&
-              (http_version > uri) )
-        http_version--;
-      if (http_version > uri)
-        {
-          http_version[0] = '\0';
-          request->version_s = http_version + 1;
-          args = memchr (uri,
-                         '?',
-                         http_version - uri);
-        }
-      else
-        {
-          request->version_s = "";
-          args = memchr (uri,
-                         '?',
-                         line_len - (uri - line));
-        }
-      url_end = http_version - uri;
+      request->version_s = "";
+      args = memchr (uri,
+                     '?',
+                     line_len - (uri - line));
     }
+    url_end = http_version - uri;
+  }
   if ( (MHD_PSL_STRICT == daemon->protocol_strict_level) &&
        (NULL != memchr (curi,
                         ' ',
                         url_end)) )
-    {
-      /* space exists in URI and we are supposed to be strict, reject */
-      return MHD_NO;
-    }
+  {
+    /* space exists in URI and we are supposed to be strict, reject */
+    return MHD_NO;
+  }
   if (NULL != daemon->early_uri_logger_cb)
-    {
-      request->client_context
-        = daemon->early_uri_logger_cb (daemon->early_uri_logger_cb_cls,
-                                       curi,
-                                       request);
-    }
+  {
+    request->client_context
+      = daemon->early_uri_logger_cb (daemon->early_uri_logger_cb_cls,
+                                     curi,
+                                     request);
+  }
   if (NULL != args)
-    {
-      args[0] = '\0';
-      args++;
-      /* note that this call clobbers 'args' */
-      MHD_parse_arguments_ (request,
-                            MHD_GET_ARGUMENT_KIND,
-                            args,
-                            &request_add_header,
-                            &unused_num_headers);
-    }
+  {
+    args[0] = '\0';
+    args++;
+    /* note that this call clobbers 'args' */
+    MHD_parse_arguments_ (request,
+                          MHD_GET_ARGUMENT_KIND,
+                          args,
+                          &request_add_header,
+                          &unused_num_headers);
+  }
   if (NULL != uri)
     daemon->unescape_cb (daemon->unescape_cb_cls,
-                         request,
-                         uri);
+                         request,
+                         uri);
   request->url = curi;
   return true;
 }
@@ -1856,43 +1875,46 @@ process_header_line (struct MHD_Request *request,
 
   /* line should be normal header line, find colon */
   colon = strchr (line,
-                  ':');
+                  ':');
   if (NULL == colon)
+  {
+    /* error in header line, die hard */
+    CONNECTION_CLOSE_ERROR (connection,
+                            MHD_SC_CONNECTION_PARSE_FAIL_CLOSED,
+                            _ (
+                              "Received malformed line (no colon). Closing connection.\n"));
+    return false;
+  }
+  if (MHD_PSL_PERMISSIVE != request->daemon->protocol_strict_level)
+  {
+    /* check for whitespace before colon, which is not allowed
+ by RFC 7230 section 3.2.4; we count space ' ' and
+ tab '\t', but not '\r\n' as those would have ended the line. */
+    const char *white;
+
+    white = strchr (line,
+                    (unsigned char) ' ');
+    if ( (NULL != white) &&
+         (white < colon) )
     {
-      /* error in header line, die hard */
       CONNECTION_CLOSE_ERROR (connection,
-                              MHD_SC_CONNECTION_PARSE_FAIL_CLOSED,
-                              _("Received malformed line (no colon). Closing connection.\n"));
+                              MHD_SC_CONNECTION_PARSE_FAIL_CLOSED,
+                              _ (
+                                "Whitespace before colon forbidden by RFC 7230. Closing connection.\n"));
       return false;
     }
-  if (MHD_PSL_PERMISSIVE != request->daemon->protocol_strict_level)
+    white = strchr (line,
+                    (unsigned char) '\t');
+    if ( (NULL != white) &&
+         (white < colon) )
     {
-      /* check for whitespace before colon, which is not allowed
-         by RFC 7230 section 3.2.4; we count space ' ' and
-         tab '\t', but not '\r\n' as those would have ended the line. */
-      const char *white;
-
-      white = strchr (line,
-                      (unsigned char) ' ');
-      if ( (NULL != white) &&
-           (white < colon) )
-        {
-          CONNECTION_CLOSE_ERROR (connection,
-                                  MHD_SC_CONNECTION_PARSE_FAIL_CLOSED,
-                                  _("Whitespace before colon forbidden by RFC 7230. Closing connection.\n"));
-          return false;
-        }
-      white = strchr (line,
-                      (unsigned char) '\t');
-      if ( (NULL != white) &&
-           (white < colon) )
-        {
-          CONNECTION_CLOSE_ERROR (connection,
-                                  MHD_SC_CONNECTION_PARSE_FAIL_CLOSED,
-                                  _("Tab before colon forbidden by RFC 7230. Closing connection.\n"));
-          return false;
-        }
+      CONNECTION_CLOSE_ERROR (connection,
+                              MHD_SC_CONNECTION_PARSE_FAIL_CLOSED,
+                              _ (
+                                "Tab before colon forbidden by RFC 7230. Closing connection.\n"));
+      return false;
     }
+  }
   /* zero-terminate header */
   colon[0] = '\0';
   colon++;                      /* advance to value */
@@ -1935,69 +1957,69 @@ process_broken_line (struct MHD_Request *request,
   last = request->last;
   if ( (' ' == line[0]) ||
        ('\t' == line[0]) )
-    {
-      /* value was continued on the next line, see
-         http://www.jmarshall.com/easy/http/ */
-      last_len = strlen (last);
-      /* skip whitespace at start of 2nd line */
-      tmp = line;
-      while ( (' ' == tmp[0]) ||
-              ('\t' == tmp[0]) )
-        tmp++;
-      tmp_len = strlen (tmp);
-      /* FIXME: we might be able to do this better (faster!), as most
-         likely 'last' and 'line' should already be adjacent in
-         memory; however, doing this right gets tricky if we have a
-         value continued over multiple lines (in which case we need to
-         record how often we have done this so we can check for
-         adjacency); also, in the case where these are not adjacent
-         (not sure how it can happen!), we would want to allocate from
-         the end of the pool, so as to not destroy the read-buffer's
-         ability to grow nicely. */
-      last = MHD_pool_reallocate (connection->pool,
-                                  last,
-                                  last_len + 1,
-                                  last_len + tmp_len + 1);
-      if (NULL == last)
-        {
-          transmit_error_response (request,
-                                   MHD_SC_CLIENT_HEADER_TOO_BIG,
-                                   MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE,
-                                   REQUEST_TOO_BIG);
-          return MHD_NO;
-        }
-      memcpy (&last[last_len],
-              tmp,
-              tmp_len + 1);
-      request->last = last;
-      return MHD_YES;           /* possibly more than 2 lines... */
-    }
-  mhd_assert ( (NULL != last) &&
-                (NULL != request->colon) );
-  if (! request_add_header (request,
-                            last,
-                            request->colon,
-                            kind))
+  {
+    /* value was continued on the next line, see
+       http://www.jmarshall.com/easy/http/ */
+    last_len = strlen (last);
+    /* skip whitespace at start of 2nd line */
+    tmp = line;
+    while ( (' ' == tmp[0]) ||
+            ('\t' == tmp[0]) )
+      tmp++;
+    tmp_len = strlen (tmp);
+    /* FIXME: we might be able to do this better (faster!), as most
+ likely 'last' and 'line' should already be adjacent in
+ memory; however, doing this right gets tricky if we have a
+ value continued over multiple lines (in which case we need to
+ record how often we have done this so we can check for
+ adjacency); also, in the case where these are not adjacent
+ (not sure how it can happen!), we would want to allocate from
+ the end of the pool, so as to not destroy the read-buffer's
+ ability to grow nicely. */
+    last = MHD_pool_reallocate (connection->pool,
+                                last,
+                                last_len + 1,
+                                last_len + tmp_len + 1);
+    if (NULL == last)
     {
       transmit_error_response (request,
-                               MHD_SC_CLIENT_HEADER_TOO_BIG,
+                               MHD_SC_CLIENT_HEADER_TOO_BIG,
                                MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE,
                                REQUEST_TOO_BIG);
-      return false;
+      return MHD_NO;
     }
+    memcpy (&last[last_len],
+            tmp,
+            tmp_len + 1);
+    request->last = last;
+    return MHD_YES;             /* possibly more than 2 lines... */
+  }
+  mhd_assert ( (NULL != last) &&
+               (NULL != request->colon) );
+  if (! request_add_header (request,
+                            last,
+                            request->colon,
+                            kind))
+  {
+    transmit_error_response (request,
+                             MHD_SC_CLIENT_HEADER_TOO_BIG,
+                             MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE,
+                             REQUEST_TOO_BIG);
+    return false;
+  }
   /* we still have the current line to deal with... */
   if ('\0' != line[0])
+  {
+    if (! process_header_line (request,
+                               line))
     {
-      if (! process_header_line (request,
-                                 line))
-        {
-          transmit_error_response (request,
-                                   MHD_SC_CONNECTION_PARSE_FAIL_CLOSED,
-                                   MHD_HTTP_BAD_REQUEST,
-                                   REQUEST_MALFORMED);
-          return false;
-        }
+      transmit_error_response (request,
+                               MHD_SC_CONNECTION_PARSE_FAIL_CLOSED,
+                               MHD_HTTP_BAD_REQUEST,
+                               REQUEST_MALFORMED);
+      return false;
     }
+  }
   return true;
 }
 
@@ -2032,22 +2054,22 @@ get_next_header_line (struct MHD_Request *request,
     pos++;
   if ( (pos == request->read_buffer_offset - 1) &&
        ('\n' != rbuf[pos]) )
+  {
+    /* not found, consider growing... */
+    if ( (request->read_buffer_offset == request->read_buffer_size) &&
+         (! try_grow_read_buffer (request)) )
     {
-      /* not found, consider growing... */
-      if ( (request->read_buffer_offset == request->read_buffer_size) &&
-           (! try_grow_read_buffer (request)) )
-        {
-          transmit_error_response (request,
-                                   MHD_SC_CLIENT_HEADER_TOO_BIG,
-                                   (NULL != request->url)
-                                   ? MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE
-                                   : MHD_HTTP_URI_TOO_LONG,
-                                   REQUEST_TOO_BIG);
-        }
-      if (line_len)
-        *line_len = 0;
-      return NULL;
+      transmit_error_response (request,
+                               MHD_SC_CLIENT_HEADER_TOO_BIG,
+                               (NULL != request->url)
+                               ? MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE
+                               : MHD_HTTP_URI_TOO_LONG,
+                               REQUEST_TOO_BIG);
     }
+    if (line_len)
+      *line_len = 0;
+    return NULL;
+  }
 
   if (line_len)
     *line_len = pos;
@@ -2083,7 +2105,7 @@ get_next_header_line (struct MHD_Request *request,
  * @return true if force push is possible, false otherwise
  */
 static bool
-socket_flush_possible(struct MHD_Connection *connection)
+socket_flush_possible (struct MHD_Connection *connection)
 {
   (void) connection; /* Mute compiler warning. */
 #if defined(TCP_CORK) || defined(TCP_PUSH)
@@ -2105,21 +2127,21 @@ static bool
 socket_start_extra_buffering (struct MHD_Connection *connection)
 {
   bool res = false;
-  (void)connection; /* Mute compiler warning. */
+  (void) connection; /* Mute compiler warning. */
 #if defined(TCP_CORK) || defined(TCP_NOPUSH)
   const MHD_SCKT_OPT_BOOL_ on_val = 1;
 #if defined(TCP_NODELAY)
   const MHD_SCKT_OPT_BOOL_ off_val = 0;
 #endif /* TCP_NODELAY */
-  mhd_assert(NULL != connection);
-#if defined(TCP_NOPUSH) && !defined(TCP_CORK)
+  mhd_assert (NULL != connection);
+#if defined(TCP_NOPUSH) && ! defined(TCP_CORK)
   /* Buffer data before sending */
   res = (0 == setsockopt (connection->socket_fd,
                           IPPROTO_TCP,
                           TCP_NOPUSH,
                           (const void *) &on_val,
                           sizeof (on_val)))
-    ? true : false;
+        ? true : false;
 #if defined(TCP_NODELAY)
   /* Enable Nagle's algorithm */
   /* TCP_NODELAY may interfere with TCP_NOPUSH */
@@ -2128,7 +2150,7 @@ socket_start_extra_buffering (struct MHD_Connection *connection)
                            TCP_NODELAY,
                            (const void *) &off_val,
                            sizeof (off_val)))
-    ? true : false;
+         ? true : false;
 #endif /* TCP_NODELAY */
 #else /* TCP_CORK */
 #if defined(TCP_NODELAY)
@@ -2147,7 +2169,7 @@ socket_start_extra_buffering (struct MHD_Connection *connection)
                           TCP_CORK,
                           (const void *) &on_val,
                           sizeof (on_val)))
-    ? true : false;
+        ? true : false;
 #endif /* TCP_CORK */
 #endif /* TCP_CORK || TCP_NOPUSH */
   return res;
@@ -2170,8 +2192,8 @@ socket_start_no_buffering (struct MHD_Connection *connection)
   const MHD_SCKT_OPT_BOOL_ off_val = 0;
 #endif /* TCP_CORK || TCP_NOPUSH */
 
-  (void)connection; /* Mute compiler warning. */
-  mhd_assert(NULL != connection);
+  (void) connection; /* Mute compiler warning. */
+  mhd_assert (NULL != connection);
 #if defined(TCP_CORK)
   /* Allow partial packets */
   res &= (0 == setsockopt (connection->socket_fd,
@@ -2179,7 +2201,7 @@ socket_start_no_buffering (struct MHD_Connection *connection)
                            TCP_CORK,
                            (const void *) &off_val,
                            sizeof (off_val)))
-    ? true : false;
+         ? true : false;
 #endif /* TCP_CORK */
 #if defined(TCP_NODELAY)
   /* Disable Nagle's algorithm for sending packets without delay */
@@ -2188,16 +2210,16 @@ socket_start_no_buffering (struct MHD_Connection *connection)
                            TCP_NODELAY,
                            (const void *) &on_val,
                            sizeof (on_val)))
-    ? true : false;
+         ? true : false;
 #endif /* TCP_NODELAY */
-#if defined(TCP_NOPUSH) && !defined(TCP_CORK)
+#if defined(TCP_NOPUSH) && ! defined(TCP_CORK)
   /* Disable extra buffering */
   res &= (0 == setsockopt (connection->socket_fd,
                            IPPROTO_TCP,
                            TCP_NOPUSH,
                            (const void *) &off_val,
                            sizeof (off_val)))
-    ? true : false;
+         ? true : false;
 #endif /* TCP_NOPUSH  && !TCP_CORK */
   return res;
 #else  /* !TCP_NODELAY */
@@ -2217,21 +2239,21 @@ static bool
 socket_start_no_buffering_flush (struct MHD_Connection *connection)
 {
   bool res = true;
-#if defined(TCP_NOPUSH) && !defined(TCP_CORK)
+#if defined(TCP_NOPUSH) && ! defined(TCP_CORK)
   const int dummy = 0;
 #endif /* !TCP_CORK */
 
   if (NULL == connection)
     return false; /* FIXME: use MHD_NONNULL? */
   res = socket_start_no_buffering (connection);
-#if defined(TCP_NOPUSH) && !defined(TCP_CORK)
+#if defined(TCP_NOPUSH) && ! defined(TCP_CORK)
   /* Force flush data with zero send otherwise Darwin and some BSD systems
      will add 5 seconds delay. Not required with TCP_CORK as switching off
      TCP_CORK always flushes socket buffer. */
   res &= (0 <= MHD_send_ (connection->socket_fd,
                           &dummy,
                           0))
-    ? true : false;
+         ? true : false;
 #endif /* TCP_NOPUSH && !TCP_CORK*/
   return res;
 }
@@ -2254,7 +2276,7 @@ socket_start_normal_buffering (struct MHD_Connection *connection)
   socklen_t param_size = sizeof (cork_val);
 #endif /* TCP_CORK */
 
-  mhd_assert(NULL != connection);
+  mhd_assert (NULL != connection);
 #if defined(TCP_CORK)
   /* Allow partial packets */
   /* Disabling TCP_CORK will flush partial packet even if TCP_CORK wasn't enabled before
@@ -2262,7 +2284,7 @@ socket_start_normal_buffering (struct MHD_Connection *connection)
   if ( (0 != getsockopt (connection->socket_fd,
                          IPPROTO_TCP,
                          TCP_CORK,
-                         (void*)&cork_val,
+                         (void*) &cork_val,
                          &param_size)) ||
        (0 != cork_val))
     res &= (0 == setsockopt (connection->socket_fd,
@@ -2270,7 +2292,7 @@ socket_start_normal_buffering (struct MHD_Connection *connection)
                              TCP_CORK,
                              (const void *) &off_val,
                              sizeof (off_val)))
-      ? true : false;
+           ? true : false;
 #elif defined(TCP_NOPUSH)
   /* Disable extra buffering */
   /* No need to check current value as disabling TCP_NOPUSH will not flush partial
@@ -2280,7 +2302,7 @@ socket_start_normal_buffering (struct MHD_Connection *connection)
                            TCP_NOPUSH,
                            (const void *) &off_val,
                            sizeof (off_val)))
-    ? true : false;
+         ? true : false;
 #endif /* TCP_NOPUSH && !TCP_CORK */
   /* Enable Nagle's algorithm for normal buffering */
   res &= (0 == setsockopt (connection->socket_fd,
@@ -2288,7 +2310,7 @@ socket_start_normal_buffering (struct MHD_Connection *connection)
                            TCP_NODELAY,
                            (const void *) &off_val,
                            sizeof (off_val)))
-    ? true : false;
+         ? true : false;
   return res;
 #else  /* !TCP_NODELAY */
   return false;
@@ -2309,16 +2331,17 @@ need_100_continue (struct MHD_Request *request)
   const char *expect;
 
   return ( (NULL == request->response) &&
-           (NULL != request->version_s) &&
-       (MHD_str_equal_caseless_(request->version_s,
-                                MHD_HTTP_VERSION_1_1)) &&
-           (NULL != (expect = MHD_request_lookup_value (request,
-                                                        MHD_HEADER_KIND,
-                                                        MHD_HTTP_HEADER_EXPECT))) &&
-           (MHD_str_equal_caseless_(expect,
-                                    "100-continue")) &&
-           (request->continue_message_write_offset <
-            MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE)) );
+           (NULL != request->version_s) &&
+           (MHD_str_equal_caseless_ (request->version_s,
+                                     MHD_HTTP_VERSION_1_1)) &&
+           (NULL != (expect = MHD_request_lookup_value (request,
+                                                        MHD_HEADER_KIND,
+                                                        MHD_HTTP_HEADER_EXPECT)))
+           &&
+           (MHD_str_equal_caseless_ (expect,
+                                     "100-continue")) &&
+           (request->continue_message_write_offset <
+            MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE)) );
 }
 
 
@@ -2342,94 +2365,94 @@ parse_cookie_header (struct MHD_Request *request)
   int quotes;
 
   hdr = MHD_request_lookup_value (request,
-                                  MHD_HEADER_KIND,
-                                  MHD_HTTP_HEADER_COOKIE);
+                                  MHD_HEADER_KIND,
+                                  MHD_HTTP_HEADER_COOKIE);
   if (NULL == hdr)
     return true;
   cpy = MHD_pool_allocate (request->connection->pool,
                            strlen (hdr) + 1,
                            MHD_YES);
   if (NULL == cpy)
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (request->daemon,
-                MHD_SC_COOKIE_POOL_ALLOCATION_FAILURE,
-                _("Not enough memory in pool to parse cookies!\n"));
+    MHD_DLOG (request->daemon,
+              MHD_SC_COOKIE_POOL_ALLOCATION_FAILURE,
+              _ ("Not enough memory in pool to parse cookies!\n"));
 #endif
-      transmit_error_response (request,
-                               MHD_SC_COOKIE_POOL_ALLOCATION_FAILURE,
-                               MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE,
-                               REQUEST_TOO_BIG);
-      return false;
-    }
+    transmit_error_response (request,
+                             MHD_SC_COOKIE_POOL_ALLOCATION_FAILURE,
+                             MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE,
+                             REQUEST_TOO_BIG);
+    return false;
+  }
   memcpy (cpy,
           hdr,
           strlen (hdr) + 1);
   pos = cpy;
   while (NULL != pos)
-    {
-      while (' ' == *pos)
-        pos++;                  /* skip spaces */
-
-      sce = pos;
-      while ( ((*sce) != '\0') &&
-              ((*sce) != ',') &&
-              ((*sce) != ';') &&
-              ((*sce) != '=') )
-        sce++;
-      /* remove tailing whitespace (if any) from key */
-      ekill = sce - 1;
-      while ( (*ekill == ' ') &&
-              (ekill >= pos) )
-        *(ekill--) = '\0';
-      old = *sce;
-      *sce = '\0';
-      if (old != '=')
-        {
-          /* value part omitted, use empty string... */
-          if (! request_add_header (request,
-                                    pos,
-                                    "",
-                                    MHD_COOKIE_KIND))
-            return false;
-          if (old == '\0')
-            break;
-          pos = sce + 1;
-          continue;
-        }
-      equals = sce + 1;
-      quotes = 0;
-      semicolon = equals;
-      while ( ('\0' != semicolon[0]) &&
-              ( (0 != quotes) ||
-                ( (';' != semicolon[0]) &&
-                  (',' != semicolon[0]) ) ) )
-        {
-          if ('"' == semicolon[0])
-            quotes = (quotes + 1) & 1;
-          semicolon++;
-        }
-      if ('\0' == semicolon[0])
-        semicolon = NULL;
-      if (NULL != semicolon)
-        {
-          semicolon[0] = '\0';
-          semicolon++;
-        }
-      /* remove quotes */
-      if ( ('"' == equals[0]) &&
-           ('"' == equals[strlen (equals) - 1]) )
-        {
-          equals[strlen (equals) - 1] = '\0';
-          equals++;
-        }
+  {
+    while (' ' == *pos)
+      pos++;                    /* skip spaces */
+
+    sce = pos;
+    while ( ((*sce) != '\0') &&
+            ((*sce) != ',') &&
+            ((*sce) != ';') &&
+            ((*sce) != '=') )
+      sce++;
+    /* remove tailing whitespace (if any) from key */
+    ekill = sce - 1;
+    while ( (*ekill == ' ') &&
+            (ekill >= pos) )
+      *(ekill--) = '\0';
+    old = *sce;
+    *sce = '\0';
+    if (old != '=')
+    {
+      /* value part omitted, use empty string... */
       if (! request_add_header (request,
-                                pos,
-                                equals,
-                                MHD_COOKIE_KIND))
+                                pos,
+                                "",
+                                MHD_COOKIE_KIND))
         return false;
-      pos = semicolon;
-    }
+      if (old == '\0')
+        break;
+      pos = sce + 1;
+      continue;
+    }
+    equals = sce + 1;
+    quotes = 0;
+    semicolon = equals;
+    while ( ('\0' != semicolon[0]) &&
+            ( (0 != quotes) ||
+              ( (';' != semicolon[0]) &&
+                (',' != semicolon[0]) ) ) )
+    {
+      if ('"' == semicolon[0])
+        quotes = (quotes + 1) & 1;
+      semicolon++;
+    }
+    if ('\0' == semicolon[0])
+      semicolon = NULL;
+    if (NULL != semicolon)
+    {
+      semicolon[0] = '\0';
+      semicolon++;
+    }
+    /* remove quotes */
+    if ( ('"' == equals[0]) &&
+         ('"' == equals[strlen (equals) - 1]) )
+    {
+      equals[strlen (equals) - 1] = '\0';
+      equals++;
+    }
+    if (! request_add_header (request,
+                              pos,
+                              equals,
+                              MHD_COOKIE_KIND))
+      return false;
+    pos = semicolon;
+  }
   return true;
 }
 
@@ -2454,64 +2477,64 @@ parse_request_headers (struct MHD_Request *request)
   parse_cookie_header (request); /* FIXME: return value ignored! */
   if ( (MHD_PSL_STRICT == daemon->protocol_strict_level) &&
        (NULL != request->version_s) &&
-       (MHD_str_equal_caseless_(MHD_HTTP_VERSION_1_1,
-                                request->version_s)) &&
+       (MHD_str_equal_caseless_ (MHD_HTTP_VERSION_1_1,
+                                 request->version_s)) &&
        (NULL ==
         MHD_request_lookup_value (request,
-                                  MHD_HEADER_KIND,
-                                  MHD_HTTP_HEADER_HOST)) )
-    {
-      /* die, http 1.1 request without host and we are pedantic */
-      request->state = MHD_REQUEST_FOOTERS_RECEIVED;
-      connection->read_closed = true;
+                                  MHD_HEADER_KIND,
+                                  MHD_HTTP_HEADER_HOST)) )
+  {
+    /* die, http 1.1 request without host and we are pedantic */
+    request->state = MHD_REQUEST_FOOTERS_RECEIVED;
+    connection->read_closed = true;
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_HOST_HEADER_MISSING,
-                _("Received HTTP 1.1 request without `Host' header.\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_HOST_HEADER_MISSING,
+              _ ("Received HTTP 1.1 request without `Host' header.\n"));
 #endif
-      mhd_assert (NULL == request->response);
-      response =
-        MHD_response_from_buffer (MHD_HTTP_BAD_REQUEST,
-                                  MHD_STATICSTR_LEN_ (REQUEST_LACKS_HOST),
-                                  REQUEST_LACKS_HOST,
-                                  MHD_RESPMEM_PERSISTENT);
-      request->response = response;
-      // FIXME: state machine advance?
-      return;
-    }
+    mhd_assert (NULL == request->response);
+    response =
+      MHD_response_from_buffer (MHD_HTTP_BAD_REQUEST,
+                                MHD_STATICSTR_LEN_ (REQUEST_LACKS_HOST),
+                                REQUEST_LACKS_HOST,
+                                MHD_RESPMEM_PERSISTENT);
+    request->response = response;
+    // FIXME: state machine advance?
+    return;
+  }
 
   request->remaining_upload_size = 0;
   enc = MHD_request_lookup_value (request,
-                                  MHD_HEADER_KIND,
-                                  MHD_HTTP_HEADER_TRANSFER_ENCODING);
+                                  MHD_HEADER_KIND,
+                                  MHD_HTTP_HEADER_TRANSFER_ENCODING);
   if (NULL != enc)
-    {
-      request->remaining_upload_size = MHD_SIZE_UNKNOWN;
-      if (MHD_str_equal_caseless_ (enc,
-                                   "chunked"))
-        request->have_chunked_upload = true;
-      return;
-    }
+  {
+    request->remaining_upload_size = MHD_SIZE_UNKNOWN;
+    if (MHD_str_equal_caseless_ (enc,
+                                 "chunked"))
+      request->have_chunked_upload = true;
+    return;
+  }
   clen = MHD_request_lookup_value (request,
-                                   MHD_HEADER_KIND,
-                                   MHD_HTTP_HEADER_CONTENT_LENGTH);
+                                   MHD_HEADER_KIND,
+                                   MHD_HTTP_HEADER_CONTENT_LENGTH);
   if (NULL == clen)
     return;
   end = clen + MHD_str_to_uint64_ (clen,
-                                   &request->remaining_upload_size);
+                                   &request->remaining_upload_size);
   if ( (clen == end) ||
        ('\0' != *end) )
-    {
-      request->remaining_upload_size = 0;
+  {
+    request->remaining_upload_size = 0;
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (request->daemon,
-                MHD_SC_CONTENT_LENGTH_MALFORMED,
-                "Failed to parse `Content-Length' header. Closing connection.\n");
+    MHD_DLOG (request->daemon,
+              MHD_SC_CONTENT_LENGTH_MALFORMED,
+              "Failed to parse `Content-Length' header. Closing connection.\n");
 #endif
-      CONNECTION_CLOSE_ERROR (connection,
-                              MHD_SC_CONTENT_LENGTH_MALFORMED,
-                              NULL);
-    }
+    CONNECTION_CLOSE_ERROR (connection,
+                            MHD_SC_CONTENT_LENGTH_MALFORMED,
+                            NULL);
+  }
 }
 
 
@@ -2531,19 +2554,20 @@ call_request_handler (struct MHD_Request *request)
   if (NULL != request->response)
     return;                     /* already queued a response */
   if (NULL == (action =
-               daemon->rc (daemon->rc_cls,
-                           request,
-                           request->url,
-                           request->method)))
-    {
-      /* serious internal error, close connection */
-      CONNECTION_CLOSE_ERROR (connection,
-                              MHD_SC_APPLICATION_CALLBACK_FAILURE_CLOSED,
-                              _("Application reported internal error, closing connection.\n"));
-      return;
-    }
+                 daemon->rc (daemon->rc_cls,
+                             request,
+                             request->url,
+                             request->method)))
+  {
+    /* serious internal error, close connection */
+    CONNECTION_CLOSE_ERROR (connection,
+                            MHD_SC_APPLICATION_CALLBACK_FAILURE_CLOSED,
+                            _ (
+                              "Application reported internal error, closing connection.\n"));
+    return;
+  }
   action->action (action->action_cls,
-                  request);
+                  request);
 }
 
 
@@ -2568,208 +2592,212 @@ process_request_body (struct MHD_Request *request)
   buffer_head = request->read_buffer;
   available = request->read_buffer_offset;
   do
-    {
-      size_t to_be_processed;
-      size_t left_unprocessed;
-      size_t processed_size;
-
-      instant_retry = false;
-      if ( (request->have_chunked_upload) &&
-           (MHD_SIZE_UNKNOWN == request->remaining_upload_size) )
+  {
+    size_t to_be_processed;
+    size_t left_unprocessed;
+    size_t processed_size;
+
+    instant_retry = false;
+    if ( (request->have_chunked_upload) &&
+         (MHD_SIZE_UNKNOWN == request->remaining_upload_size) )
+    {
+      if ( (request->current_chunk_offset == request->current_chunk_size) &&
+           (0LLU != request->current_chunk_offset) &&
+           (available >= 2) )
+      {
+        size_t i;
+
+        /* skip new line at the *end* of a chunk */
+        i = 0;
+        if ( ('\r' == buffer_head[i]) ||
+             ('\n' == buffer_head[i]) )
+          i++;                  /* skip 1st part of line feed */
+        if ( ('\r' == buffer_head[i]) ||
+             ('\n' == buffer_head[i]) )
+          i++;                  /* skip 2nd part of line feed */
+        if (0 == i)
         {
-          if ( (request->current_chunk_offset == request->current_chunk_size) &&
-               (0LLU != request->current_chunk_offset) &&
-               (available >= 2) )
-            {
-              size_t i;
-
-              /* skip new line at the *end* of a chunk */
-              i = 0;
-              if ( ('\r' == buffer_head[i]) ||
-                   ('\n' == buffer_head[i]) )
-                i++;            /* skip 1st part of line feed */
-              if ( ('\r' == buffer_head[i]) ||
-                   ('\n' == buffer_head[i]) )
-                i++;            /* skip 2nd part of line feed */
-              if (0 == i)
-                {
-                  /* malformed encoding */
-                  CONNECTION_CLOSE_ERROR (connection,
-                                          MHD_SC_CHUNKED_ENCODING_MALFORMED,
-                                          _("Received malformed HTTP request (bad chunked encoding). Closing connection.\n"));
-                  return;
-                }
-              available -= i;
-              buffer_head += i;
-              request->current_chunk_offset = 0;
-              request->current_chunk_size = 0;
-            }
-          if (request->current_chunk_offset <
-              request->current_chunk_size)
-            {
-              uint64_t cur_chunk_left;
-
-              /* we are in the middle of a chunk, give
-                 as much as possible to the client (without
-                 crossing chunk boundaries) */
-              cur_chunk_left
-                = request->current_chunk_size - request->current_chunk_offset;
-              if (cur_chunk_left > available)
-                {
-                  to_be_processed = available;
-                }
-              else
-                { /* cur_chunk_left <= (size_t)available */
-                  to_be_processed = (size_t)cur_chunk_left;
-                  if (available > to_be_processed)
-                    instant_retry = true;
-                }
-            }
-          else
-            {
-              size_t i;
-              size_t end_size;
-              bool malformed;
-
-              /* we need to read chunk boundaries */
-              i = 0;
-              while (i < available)
-                {
-                  if ( ('\r' == buffer_head[i]) ||
-                       ('\n' == buffer_head[i]) ||
-                       (';' == buffer_head[i]) )
-                    break;
-                  i++;
-                  if (i >= 16)
-                    break;
-                }
-              end_size = i;
-              /* find beginning of CRLF (skip over chunk extensions) */
-              if (';' == buffer_head[i])
-                {
-                  while (i < available)
-                  {
-                    if ( ('\r' == buffer_head[i]) ||
-                         ('\n' == buffer_head[i]) )
-                      break;
-                    i++;
-                  }
-                }
-              /* take '\n' into account; if '\n' is the unavailable
-                 character, we will need to wait until we have it
-                 before going further */
-              if ( (i + 1 >= available) &&
-                   ! ( (1 == i) &&
-                       (2 == available) &&
-                       ('0' == buffer_head[0]) ) )
-                break;          /* need more data... */
-              i++;
-              malformed = (end_size >= 16);
-              if (! malformed)
-                {
-                  size_t num_dig = MHD_strx_to_uint64_n_ (buffer_head,
-                                                          end_size,
-                                                          &request->current_chunk_size);
-                  malformed = (end_size != num_dig);
-                }
-              if (malformed)
-                {
-                  /* malformed encoding */
-                  CONNECTION_CLOSE_ERROR (connection,
-                                          MHD_SC_CHUNKED_ENCODING_MALFORMED,
-                                          _("Received malformed HTTP request (bad chunked encoding). Closing connection.\n"));
-                  return;
-                }
-              /* skip 2nd part of line feed */
-              if ( (i < available) &&
-                   ( ('\r' == buffer_head[i]) ||
-                     ('\n' == buffer_head[i]) ) )
-                i++;
-
-              buffer_head += i;
-              available -= i;
-              request->current_chunk_offset = 0;
-
-              if (available > 0)
-                instant_retry = true;
-              if (0LLU == request->current_chunk_size)
-                {
-                  request->remaining_upload_size = 0;
-                  break;
-                }
-              continue;
-            }
+          /* malformed encoding */
+          CONNECTION_CLOSE_ERROR (connection,
+                                  MHD_SC_CHUNKED_ENCODING_MALFORMED,
+                                  _ (
+                                    "Received malformed HTTP request (bad chunked encoding). Closing connection.\n"));
+          return;
         }
+        available -= i;
+        buffer_head += i;
+        request->current_chunk_offset = 0;
+        request->current_chunk_size = 0;
+      }
+      if (request->current_chunk_offset <
+          request->current_chunk_size)
+      {
+        uint64_t cur_chunk_left;
+
+        /* we are in the middle of a chunk, give
+           as much as possible to the client (without
+           crossing chunk boundaries) */
+        cur_chunk_left
+          = request->current_chunk_size - request->current_chunk_offset;
+        if (cur_chunk_left > available)
+        {
+          to_be_processed = available;
+        }
+        else
+        {         /* cur_chunk_left <= (size_t)available */
+          to_be_processed = (size_t) cur_chunk_left;
+          if (available > to_be_processed)
+            instant_retry = true;
+        }
+      }
       else
+      {
+        size_t i;
+        size_t end_size;
+        bool malformed;
+
+        /* we need to read chunk boundaries */
+        i = 0;
+        while (i < available)
         {
-          /* no chunked encoding, give all to the client */
-          if ( (0 != request->remaining_upload_size) &&
-               (MHD_SIZE_UNKNOWN != request->remaining_upload_size) &&
-               (request->remaining_upload_size < available) )
-            {
-              to_be_processed = (size_t)request->remaining_upload_size;
-            }
-          else
-            {
-              /**
-               * 1. no chunked encoding, give all to the client
-               * 2. client may send large chunked data, but only a smaller part is available at one time.
-               */
-              to_be_processed = available;
-            }
+          if ( ('\r' == buffer_head[i]) ||
+               ('\n' == buffer_head[i]) ||
+               (';' == buffer_head[i]) )
+            break;
+          i++;
+          if (i >= 16)
+            break;
         }
-      left_unprocessed = to_be_processed;
-#if FIXME_OLD_STYLE
-      if (MHD_NO ==
-          daemon->rc (daemon->rc_cls,
-                      request,
-                      request->url,
-                      request->method,
-                      request->version,
-                      buffer_head,
-                      &left_unprocessed,
-                      &request->client_context))
+        end_size = i;
+        /* find beginning of CRLF (skip over chunk extensions) */
+        if (';' == buffer_head[i])
+        {
+          while (i < available)
+          {
+            if ( ('\r' == buffer_head[i]) ||
+                 ('\n' == buffer_head[i]) )
+              break;
+            i++;
+          }
+        }
+        /* take '\n' into account; if '\n' is the unavailable
+           character, we will need to wait until we have it
+           before going further */
+        if ( (i + 1 >= available) &&
+             ! ( (1 == i) &&
+                 (2 == available) &&
+                 ('0' == buffer_head[0]) ) )
+          break;                /* need more data... */
+        i++;
+        malformed = (end_size >= 16);
+        if (! malformed)
+        {
+          size_t num_dig = MHD_strx_to_uint64_n_ (buffer_head,
+                                                  end_size,
+                                                  &request->current_chunk_size);
+          malformed = (end_size != num_dig);
+        }
+        if (malformed)
         {
-          /* serious internal error, close connection */
+          /* malformed encoding */
           CONNECTION_CLOSE_ERROR (connection,
-                                  MHD_SC_APPLICATION_CALLBACK_FAILURE_CLOSED,
-                                  _("Application reported internal error, closing connection.\n"));
+                                  MHD_SC_CHUNKED_ENCODING_MALFORMED,
+                                  _ (
+                                    "Received malformed HTTP request (bad chunked encoding). Closing connection.\n"));
           return;
         }
+        /* skip 2nd part of line feed */
+        if ( (i < available) &&
+             ( ('\r' == buffer_head[i]) ||
+               ('\n' == buffer_head[i]) ) )
+          i++;
+
+        buffer_head += i;
+        available -= i;
+        request->current_chunk_offset = 0;
+
+        if (available > 0)
+          instant_retry = true;
+        if (0LLU == request->current_chunk_size)
+        {
+          request->remaining_upload_size = 0;
+          break;
+        }
+        continue;
+      }
+    }
+    else
+    {
+      /* no chunked encoding, give all to the client */
+      if ( (0 != request->remaining_upload_size) &&
+           (MHD_SIZE_UNKNOWN != request->remaining_upload_size) &&
+           (request->remaining_upload_size < available) )
+      {
+        to_be_processed = (size_t) request->remaining_upload_size;
+      }
+      else
+      {
+        /**
+         * 1. no chunked encoding, give all to the client
+         * 2. client may send large chunked data, but only a smaller part is available at one time.
+         */
+        to_be_processed = available;
+      }
+    }
+    left_unprocessed = to_be_processed;
+#if FIXME_OLD_STYLE
+    if (MHD_NO ==
+        daemon->rc (daemon->rc_cls,
+                    request,
+                    request->url,
+                    request->method,
+                    request->version,
+                    buffer_head,
+                    &left_unprocessed,
+                    &request->client_context))
+    {
+      /* serious internal error, close connection */
+      CONNECTION_CLOSE_ERROR (connection,
+                              MHD_SC_APPLICATION_CALLBACK_FAILURE_CLOSED,
+                              _ (
+                                "Application reported internal error, closing connection.\n"));
+      return;
+    }
 #endif
-      if (left_unprocessed > to_be_processed)
-        mhd_panic (mhd_panic_cls,
-                   __FILE__,
-                   __LINE__
+    if (left_unprocessed > to_be_processed)
+      mhd_panic (mhd_panic_cls,
+                 __FILE__,
+                 __LINE__
 #ifdef HAVE_MESSAGES
-                   , _("libmicrohttpd API violation")
+                 , _ ("libmicrohttpd API violation")
 #else
-                   , NULL
+                 , NULL
 #endif
-                   );
-      if (0 != left_unprocessed)
-        {
-          instant_retry = false; /* client did not process everything */
+                 );
+    if (0 != left_unprocessed)
+    {
+      instant_retry = false; /* client did not process everything */
 #ifdef HAVE_MESSAGES
-          /* client did not process all upload data, complain if
-             the setup was incorrect, which may prevent us from
-             handling the rest of the request */
-          if ( (MHD_TM_EXTERNAL_EVENT_LOOP == daemon->threading_mode) &&
-               (! connection->suspended) )
-            MHD_DLOG (daemon,
-                      MHD_SC_APPLICATION_HUNG_CONNECTION,
-                      _("WARNING: incomplete upload processing and connection not suspended may result in hung connection.\n"));
+      /* client did not process all upload data, complain if
+         the setup was incorrect, which may prevent us from
+         handling the rest of the request */
+      if ( (MHD_TM_EXTERNAL_EVENT_LOOP == daemon->threading_mode) &&
+           (! connection->suspended) )
+        MHD_DLOG (daemon,
+                  MHD_SC_APPLICATION_HUNG_CONNECTION,
+                  _ (
+                    "WARNING: incomplete upload processing and connection not suspended may result in hung connection.\n"));
 #endif
-        }
-      processed_size = to_be_processed - left_unprocessed;
-      if (request->have_chunked_upload)
-        request->current_chunk_offset += processed_size;
-      /* dh left "processed" bytes in buffer for next time... */
-      buffer_head += processed_size;
-      available -= processed_size;
-      if (MHD_SIZE_UNKNOWN != request->remaining_upload_size)
-        request->remaining_upload_size -= processed_size;
     }
+    processed_size = to_be_processed - left_unprocessed;
+    if (request->have_chunked_upload)
+      request->current_chunk_offset += processed_size;
+    /* dh left "processed" bytes in buffer for next time... */
+    buffer_head += processed_size;
+    available -= processed_size;
+    if (MHD_SIZE_UNKNOWN != request->remaining_upload_size)
+      request->remaining_upload_size -= processed_size;
+  }
   while (instant_retry);
   if (available > 0)
     memmove (request->read_buffer,
@@ -2796,58 +2824,59 @@ cleanup_connection (struct MHD_Connection *connection)
     return; /* Prevent double cleanup. */
   connection->request.in_cleanup = true;
   if (NULL != connection->request.response)
-    {
-      MHD_response_queue_for_destroy (connection->request.response);
-      connection->request.response = NULL;
-    }
+  {
+    MHD_response_queue_for_destroy (connection->request.response);
+    connection->request.response = NULL;
+  }
   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   if (connection->suspended)
-    {
-      DLL_remove (daemon->suspended_connections_head,
-                  daemon->suspended_connections_tail,
-                  connection);
-      connection->suspended = false;
-    }
+  {
+    DLL_remove (daemon->suspended_connections_head,
+                daemon->suspended_connections_tail,
+                connection);
+    connection->suspended = false;
+  }
   else
+  {
+    if (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_mode)
     {
-      if (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_mode)
-        {
-          if (connection->connection_timeout ==
-              daemon->connection_default_timeout)
-            XDLL_remove (daemon->normal_timeout_head,
-                         daemon->normal_timeout_tail,
-                         connection);
-          else
-            XDLL_remove (daemon->manual_timeout_head,
-                         daemon->manual_timeout_tail,
-                         connection);
-        }
-      DLL_remove (daemon->connections_head,
-                  daemon->connections_tail,
-                  connection);
+      if (connection->connection_timeout ==
+          daemon->connection_default_timeout)
+        XDLL_remove (daemon->normal_timeout_head,
+                     daemon->normal_timeout_tail,
+                     connection);
+      else
+        XDLL_remove (daemon->manual_timeout_head,
+                     daemon->manual_timeout_tail,
+                     connection);
     }
+    DLL_remove (daemon->connections_head,
+                daemon->connections_tail,
+                connection);
+  }
   DLL_insert (daemon->cleanup_head,
-              daemon->cleanup_tail,
-              connection);
+              daemon->cleanup_tail,
+              connection);
   connection->resuming = false;
   connection->request.in_idle = false;
   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   if (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode)
+  {
+    /* if we were at the connection limit before and are in
+       thread-per-connection mode, signal the main thread
+       to resume accepting connections */
+    if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
+         (! MHD_itc_activate_ (daemon->itc,
+                               "c")) )
     {
-      /* if we were at the connection limit before and are in
-         thread-per-connection mode, signal the main thread
-         to resume accepting connections */
-      if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
-           (! MHD_itc_activate_ (daemon->itc,
-                                 "c")) )
-        {
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    MHD_SC_ITC_USE_FAILED,
-                    _("Failed to signal end of connection via inter-thread communication channel"));
+      MHD_DLOG (daemon,
+                MHD_SC_ITC_USE_FAILED,
+                _ (
+                  "Failed to signal end of connection via inter-thread communication channel"));
 #endif
-        }
     }
+  }
 }
 
 
@@ -2870,31 +2899,31 @@ connection_epoll_update_ (struct MHD_Connection *connection)
        (0 == (connection->epoll_state & MHD_EPOLL_STATE_SUSPENDED)) &&
        ( ( (MHD_EVENT_LOOP_INFO_WRITE == connection->request.event_loop_info) &&
            (0 == (connection->epoll_state & MHD_EPOLL_STATE_WRITE_READY))) ||
-         ( (MHD_EVENT_LOOP_INFO_READ == connection->request.event_loop_info) &&
-           (0 == (connection->epoll_state & MHD_EPOLL_STATE_READ_READY)) ) ) )
+         ( (MHD_EVENT_LOOP_INFO_READ == connection->request.event_loop_info) &&
+           (0 == (connection->epoll_state & MHD_EPOLL_STATE_READ_READY)) ) ) )
+  {
+    /* add to epoll set */
+    struct epoll_event event;
+
+    event.events = EPOLLIN | EPOLLOUT | EPOLLPRI | EPOLLET;
+    event.data.ptr = connection;
+    if (0 != epoll_ctl (daemon->epoll_fd,
+                        EPOLL_CTL_ADD,
+                        connection->socket_fd,
+                        &event))
     {
-      /* add to epoll set */
-      struct epoll_event event;
-
-      event.events = EPOLLIN | EPOLLOUT | EPOLLPRI | EPOLLET;
-      event.data.ptr = connection;
-      if (0 != epoll_ctl (daemon->epoll_fd,
-                          EPOLL_CTL_ADD,
-                          connection->socket_fd,
-                          &event))
-        {
 #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
-          connection->request.state = MHD_REQUEST_CLOSED;
-          cleanup_connection (connection);
-          return false;
-        }
-      connection->epoll_state |= MHD_EPOLL_STATE_IN_EPOLL_SET;
+      connection->request.state = MHD_REQUEST_CLOSED;
+      cleanup_connection (connection);
+      return false;
     }
+    connection->epoll_state |= MHD_EPOLL_STATE_IN_EPOLL_SET;
+  }
   return true;
 }
 #endif
@@ -2922,142 +2951,142 @@ connection_update_event_loop_info (struct MHD_Connection *connection)
     struct MHD_TLS_Plugin *tls;
 
     if ( (NULL != (tls = daemon->tls_api)) &&
-         (tls->update_event_loop_info (tls->cls,
-                                       connection->tls_cs,
-                                       &request->event_loop_info)) )
+         (tls->update_event_loop_info (tls->cls,
+                                       connection->tls_cs,
+                                       &request->event_loop_info)) )
       return; /* TLS has decided what to do */
   }
 #endif /* HTTPS_SUPPORT */
   while (1)
-    {
+  {
 #if DEBUG_STATES
-      MHD_DLOG (daemon,
-                MHD_SC_STATE_MACHINE_STATUS_REPORT,
-                _("In function %s handling connection at state: %s\n"),
-                __FUNCTION__,
-                MHD_state_to_string (request->state));
+    MHD_DLOG (daemon,
+              MHD_SC_STATE_MACHINE_STATUS_REPORT,
+              _ ("In function %s handling connection at state: %s\n"),
+              __FUNCTION__,
+              MHD_state_to_string (request->state));
 #endif
-      switch (request->state)
+    switch (request->state)
+    {
+    case MHD_REQUEST_INIT:
+    case MHD_REQUEST_URL_RECEIVED:
+    case MHD_REQUEST_HEADER_PART_RECEIVED:
+      /* while reading headers, we always grow the
+         read buffer if needed, no size-check required */
+      if ( (request->read_buffer_offset == request->read_buffer_size) &&
+           (! try_grow_read_buffer (request)) )
+      {
+        transmit_error_response (request,
+                                 MHD_SC_CLIENT_HEADER_TOO_BIG,
+                                 (NULL != request->url)
+                                 ? MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE
+                                 : MHD_HTTP_URI_TOO_LONG,
+                                 REQUEST_TOO_BIG);
+        continue;
+      }
+      if (! connection->read_closed)
+        request->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
+      else
+        request->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
+      break;
+    case MHD_REQUEST_HEADERS_RECEIVED:
+      mhd_assert (0);
+      break;
+    case MHD_REQUEST_HEADERS_PROCESSED:
+      mhd_assert (0);
+      break;
+    case MHD_REQUEST_CONTINUE_SENDING:
+      request->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
+      break;
+    case MHD_REQUEST_CONTINUE_SENT:
+      if (request->read_buffer_offset == request->read_buffer_size)
+      {
+        if ( (! try_grow_read_buffer (request)) &&
+             (MHD_TM_EXTERNAL_EVENT_LOOP != daemon->threading_mode) )
         {
-        case MHD_REQUEST_INIT:
-        case MHD_REQUEST_URL_RECEIVED:
-        case MHD_REQUEST_HEADER_PART_RECEIVED:
-          /* while reading headers, we always grow the
-             read buffer if needed, no size-check required */
-          if ( (request->read_buffer_offset == request->read_buffer_size) &&
-               (! try_grow_read_buffer (request)) )
-            {
-              transmit_error_response (request,
-                                       MHD_SC_CLIENT_HEADER_TOO_BIG,
-                                       (NULL != request->url)
-                                       ? MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE
-                                       : MHD_HTTP_URI_TOO_LONG,
-                                       REQUEST_TOO_BIG);
-              continue;
-            }
-          if (! connection->read_closed)
-            request->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
-          else
-            request->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
-          break;
-        case MHD_REQUEST_HEADERS_RECEIVED:
-          mhd_assert (0);
-          break;
-        case MHD_REQUEST_HEADERS_PROCESSED:
-          mhd_assert (0);
-          break;
-        case MHD_REQUEST_CONTINUE_SENDING:
-          request->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
-          break;
-        case MHD_REQUEST_CONTINUE_SENT:
-          if (request->read_buffer_offset == request->read_buffer_size)
-            {
-              if ( (! try_grow_read_buffer (request)) &&
-                   (MHD_TM_EXTERNAL_EVENT_LOOP != daemon->threading_mode) )
-                {
-                  /* failed to grow the read buffer, and the client
-                     which is supposed to handle the received data in
-                     a *blocking* fashion (in this mode) did not
-                     handle the data as it was supposed to!
-
-                     => we would either have to do busy-waiting
-                     (on the client, which would likely fail),
-                     or if we do nothing, we would just timeout
-                     on the connection (if a timeout is even set!).
-
-                     Solution: we kill the connection with an error */
-                  transmit_error_response (request,
-                                           MHD_SC_APPLICATION_HUNG_CONNECTION_CLOSED,
-                                           MHD_HTTP_INTERNAL_SERVER_ERROR,
-                                           INTERNAL_ERROR);
-                  continue;
-                }
-            }
-          if ( (request->read_buffer_offset < request->read_buffer_size) &&
-               (! connection->read_closed) )
-            request->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
-          else
-            request->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
-          break;
-        case MHD_REQUEST_BODY_RECEIVED:
-        case MHD_REQUEST_FOOTER_PART_RECEIVED:
-          /* while reading footers, we always grow the
-             read buffer if needed, no size-check required */
-          if (connection->read_closed)
-            {
-              CONNECTION_CLOSE_ERROR (connection,
-                                      MHD_SC_CONNECTION_READ_FAIL_CLOSED,
-                                      NULL);
-              continue;
-            }
-          request->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
-          /* transition to FOOTERS_RECEIVED
-             happens in read handler */
-          break;
-        case MHD_REQUEST_FOOTERS_RECEIVED:
-          request->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
-          break;
-        case MHD_REQUEST_HEADERS_SENDING:
-          /* headers in buffer, keep writing */
-          request->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
-          break;
-        case MHD_REQUEST_HEADERS_SENT:
-          mhd_assert (0);
-          break;
-        case MHD_REQUEST_NORMAL_BODY_READY:
-          request->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
-          break;
-        case MHD_REQUEST_NORMAL_BODY_UNREADY:
-          request->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
-          break;
-        case MHD_REQUEST_CHUNKED_BODY_READY:
-          request->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
-          break;
-        case MHD_REQUEST_CHUNKED_BODY_UNREADY:
-          request->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
-          break;
-        case MHD_REQUEST_BODY_SENT:
-          mhd_assert (0);
-          break;
-        case MHD_REQUEST_FOOTERS_SENDING:
-          request->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
-          break;
-        case MHD_REQUEST_FOOTERS_SENT:
-          mhd_assert (0);
-          break;
-        case MHD_REQUEST_CLOSED:
-          request->event_loop_info = MHD_EVENT_LOOP_INFO_CLEANUP;
-          return;       /* do nothing, not even reading */
-#ifdef UPGRADE_SUPPORT
-        case MHD_REQUEST_UPGRADE:
-          mhd_assert (0);
-          break;
-#endif /* UPGRADE_SUPPORT */
-        default:
-          mhd_assert (0);
+          /* failed to grow the read buffer, and the client
+             which is supposed to handle the received data in
+             a *blocking* fashion (in this mode) did not
+             handle the data as it was supposed to!
+
+             => we would either have to do busy-waiting
+             (on the client, which would likely fail),
+             or if we do nothing, we would just timeout
+             on the connection (if a timeout is even set!).
+
+             Solution: we kill the connection with an error */
+          transmit_error_response (request,
+                                   MHD_SC_APPLICATION_HUNG_CONNECTION_CLOSED,
+                                   MHD_HTTP_INTERNAL_SERVER_ERROR,
+                                   INTERNAL_ERROR);
+          continue;
         }
+      }
+      if ( (request->read_buffer_offset < request->read_buffer_size) &&
+           (! connection->read_closed) )
+        request->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
+      else
+        request->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
+      break;
+    case MHD_REQUEST_BODY_RECEIVED:
+    case MHD_REQUEST_FOOTER_PART_RECEIVED:
+      /* while reading footers, we always grow the
+         read buffer if needed, no size-check required */
+      if (connection->read_closed)
+      {
+        CONNECTION_CLOSE_ERROR (connection,
+                                MHD_SC_CONNECTION_READ_FAIL_CLOSED,
+                                NULL);
+        continue;
+      }
+      request->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
+      /* transition to FOOTERS_RECEIVED
+         happens in read handler */
+      break;
+    case MHD_REQUEST_FOOTERS_RECEIVED:
+      request->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
+      break;
+    case MHD_REQUEST_HEADERS_SENDING:
+      /* headers in buffer, keep writing */
+      request->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
+      break;
+    case MHD_REQUEST_HEADERS_SENT:
+      mhd_assert (0);
+      break;
+    case MHD_REQUEST_NORMAL_BODY_READY:
+      request->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
+      break;
+    case MHD_REQUEST_NORMAL_BODY_UNREADY:
+      request->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
+      break;
+    case MHD_REQUEST_CHUNKED_BODY_READY:
+      request->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
+      break;
+    case MHD_REQUEST_CHUNKED_BODY_UNREADY:
+      request->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
+      break;
+    case MHD_REQUEST_BODY_SENT:
+      mhd_assert (0);
+      break;
+    case MHD_REQUEST_FOOTERS_SENDING:
+      request->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
       break;
+    case MHD_REQUEST_FOOTERS_SENT:
+      mhd_assert (0);
+      break;
+    case MHD_REQUEST_CLOSED:
+      request->event_loop_info = MHD_EVENT_LOOP_INFO_CLEANUP;
+      return;           /* do nothing, not even reading */
+#ifdef UPGRADE_SUPPORT
+    case MHD_REQUEST_UPGRADE:
+      mhd_assert (0);
+      break;
+#endif /* UPGRADE_SUPPORT */
+    default:
+      mhd_assert (0);
     }
+    break;
+  }
 }
 
 
@@ -3082,491 +3111,494 @@ MHD_request_handle_idle_ (struct MHD_Request *request)
 
   request->in_idle = true;
   while (! connection->suspended)
-    {
+  {
 #ifdef HTTPS_SUPPORT
-      struct MHD_TLS_Plugin *tls;
+    struct MHD_TLS_Plugin *tls;
 
-      if ( (NULL != (tls = daemon->tls_api)) &&
-           (! tls->idle_ready (tls->cls,
-                               connection->tls_cs)) )
-        break;
+    if ( (NULL != (tls = daemon->tls_api)) &&
+         (! tls->idle_ready (tls->cls,
+                             connection->tls_cs)) )
+      break;
 #endif /* HTTPS_SUPPORT */
 #if DEBUG_STATES
-      MHD_DLOG (daemon,
-                MHD_SC_STATE_MACHINE_STATUS_REPORT,
-                _("In function %s handling connection at state: %s\n"),
-                __FUNCTION__,
-                MHD_state_to_string (request->state));
+    MHD_DLOG (daemon,
+              MHD_SC_STATE_MACHINE_STATUS_REPORT,
+              _ ("In function %s handling connection at state: %s\n"),
+              __FUNCTION__,
+              MHD_state_to_string (request->state));
 #endif
-      switch (request->state)
+    switch (request->state)
+    {
+    case MHD_REQUEST_INIT:
+      line = get_next_header_line (request,
+                                   &line_len);
+      /* Check for empty string, as we might want
+         to tolerate 'spurious' empty lines; also
+         NULL means we didn't get a full line yet;
+         line is not 0-terminated here. */
+      if ( (NULL == line) ||
+           (0 == line[0]) )
+      {
+        if (MHD_REQUEST_INIT != request->state)
+          continue;
+        if (connection->read_closed)
         {
-        case MHD_REQUEST_INIT:
-          line = get_next_header_line (request,
-                                       &line_len);
-          /* Check for empty string, as we might want
-             to tolerate 'spurious' empty lines; also
-             NULL means we didn't get a full line yet;
-             line is not 0-terminated here. */
-          if ( (NULL == line) ||
-               (0 == line[0]) )
-            {
-              if (MHD_REQUEST_INIT != request->state)
-                continue;
-              if (connection->read_closed)
-                {
-                  CONNECTION_CLOSE_ERROR (connection,
-                                          MHD_SC_CONNECTION_READ_FAIL_CLOSED,
-                                          NULL);
-                  continue;
-                }
-              break;
-            }
-          if (MHD_NO ==
-              parse_initial_message_line (request,
-                                          line,
-                                          line_len))
-            CONNECTION_CLOSE_ERROR (connection,
-                                    MHD_SC_CONNECTION_CLOSED,
-                                    NULL);
-          else
-            request->state = MHD_REQUEST_URL_RECEIVED;
+          CONNECTION_CLOSE_ERROR (connection,
+                                  MHD_SC_CONNECTION_READ_FAIL_CLOSED,
+                                  NULL);
           continue;
-        case MHD_REQUEST_URL_RECEIVED:
-          line = get_next_header_line (request,
-                                       NULL);
-          if (NULL == line)
-            {
-              if (MHD_REQUEST_URL_RECEIVED != request->state)
-                continue;
-              if (connection->read_closed)
-                {
-                  CONNECTION_CLOSE_ERROR (connection,
-                                          MHD_SC_CONNECTION_READ_FAIL_CLOSED,
-                                          NULL);
-                  continue;
-                }
-              break;
-            }
-          if (0 == line[0])
-            {
-              request->state = MHD_REQUEST_HEADERS_RECEIVED;
-              request->header_size = (size_t) (line - request->read_buffer);
-              continue;
-            }
-          if (! process_header_line (request,
-                                     line))
-            {
-              transmit_error_response (request,
-                                       MHD_SC_CONNECTION_PARSE_FAIL_CLOSED,
-                                       MHD_HTTP_BAD_REQUEST,
-                                       REQUEST_MALFORMED);
-              break;
-            }
-          request->state = MHD_REQUEST_HEADER_PART_RECEIVED;
+        }
+        break;
+      }
+      if (MHD_NO ==
+          parse_initial_message_line (request,
+                                      line,
+                                      line_len))
+        CONNECTION_CLOSE_ERROR (connection,
+                                MHD_SC_CONNECTION_CLOSED,
+                                NULL);
+      else
+        request->state = MHD_REQUEST_URL_RECEIVED;
+      continue;
+    case MHD_REQUEST_URL_RECEIVED:
+      line = get_next_header_line (request,
+                                   NULL);
+      if (NULL == line)
+      {
+        if (MHD_REQUEST_URL_RECEIVED != request->state)
           continue;
-        case MHD_REQUEST_HEADER_PART_RECEIVED:
-          line = get_next_header_line (request,
-                                       NULL);
-          if (NULL == line)
-            {
-              if (request->state != MHD_REQUEST_HEADER_PART_RECEIVED)
-                continue;
-              if (connection->read_closed)
-                {
-                  CONNECTION_CLOSE_ERROR (connection,
-                                          MHD_SC_CONNECTION_READ_FAIL_CLOSED,
-                                          NULL);
-                  continue;
-                }
-              break;
-            }
-          if (MHD_NO ==
-              process_broken_line (request,
-                                   line,
-                                   MHD_HEADER_KIND))
-            continue;
-          if (0 == line[0])
-            {
-              request->state = MHD_REQUEST_HEADERS_RECEIVED;
-              request->header_size = (size_t) (line - request->read_buffer);
-              continue;
-            }
+        if (connection->read_closed)
+        {
+          CONNECTION_CLOSE_ERROR (connection,
+                                  MHD_SC_CONNECTION_READ_FAIL_CLOSED,
+                                  NULL);
           continue;
-        case MHD_REQUEST_HEADERS_RECEIVED:
-          parse_request_headers (request);
-          if (MHD_REQUEST_CLOSED == request->state)
-            continue;
-          request->state = MHD_REQUEST_HEADERS_PROCESSED;
-          if (connection->suspended)
-            break;
+        }
+        break;
+      }
+      if (0 == line[0])
+      {
+        request->state = MHD_REQUEST_HEADERS_RECEIVED;
+        request->header_size = (size_t) (line - request->read_buffer);
+        continue;
+      }
+      if (! process_header_line (request,
+                                 line))
+      {
+        transmit_error_response (request,
+                                 MHD_SC_CONNECTION_PARSE_FAIL_CLOSED,
+                                 MHD_HTTP_BAD_REQUEST,
+                                 REQUEST_MALFORMED);
+        break;
+      }
+      request->state = MHD_REQUEST_HEADER_PART_RECEIVED;
+      continue;
+    case MHD_REQUEST_HEADER_PART_RECEIVED:
+      line = get_next_header_line (request,
+                                   NULL);
+      if (NULL == line)
+      {
+        if (request->state != MHD_REQUEST_HEADER_PART_RECEIVED)
           continue;
-        case MHD_REQUEST_HEADERS_PROCESSED:
-          call_request_handler (request); /* first call */
-          if (MHD_REQUEST_CLOSED == request->state)
-            continue;
-          if (need_100_continue (request))
-            {
-              request->state = MHD_REQUEST_CONTINUE_SENDING;
-              if (socket_flush_possible (connection))
-                socket_start_extra_buffering (connection);
-              else
-                socket_start_no_buffering (connection);
-              break;
-            }
-          if ( (NULL != request->response) &&
-               ( (MHD_METHOD_POST == request->method) ||
-                 (MHD_METHOD_PUT == request->method) ) )
-            {
-              /* we refused (no upload allowed!) */
-              request->remaining_upload_size = 0;
-              /* force close, in case client still tries to upload... */
-              connection->read_closed = true;
-            }
-          request->state = (0 == request->remaining_upload_size)
-            ? MHD_REQUEST_FOOTERS_RECEIVED
-            : MHD_REQUEST_CONTINUE_SENT;
-          if (connection->suspended)
-            break;
+        if (connection->read_closed)
+        {
+          CONNECTION_CLOSE_ERROR (connection,
+                                  MHD_SC_CONNECTION_READ_FAIL_CLOSED,
+                                  NULL);
           continue;
-        case MHD_REQUEST_CONTINUE_SENDING:
-          if (request->continue_message_write_offset ==
-              MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE))
-            {
-              request->state = MHD_REQUEST_CONTINUE_SENT;
-              if (! socket_flush_possible (connection))
-                socket_start_no_buffering_flush (connection);
-              else
-                socket_start_normal_buffering (connection);
-              continue;
-            }
-          break;
-        case MHD_REQUEST_CONTINUE_SENT:
-          if (0 != request->read_buffer_offset)
-            {
-              process_request_body (request);     /* loop call */
-              if (MHD_REQUEST_CLOSED == request->state)
-                continue;
-            }
-          if ( (0 == request->remaining_upload_size) ||
-               ( (MHD_SIZE_UNKNOWN == request->remaining_upload_size) &&
-                 (0 == request->read_buffer_offset) &&
-                 (connection->read_closed) ) )
-            {
-              if ( (request->have_chunked_upload) &&
-                   (! connection->read_closed) )
-                request->state = MHD_REQUEST_BODY_RECEIVED;
-              else
-                request->state = MHD_REQUEST_FOOTERS_RECEIVED;
-              if (connection->suspended)
-                break;
-              continue;
-            }
+        }
+        break;
+      }
+      if (MHD_NO ==
+          process_broken_line (request,
+                               line,
+                               MHD_HEADER_KIND))
+        continue;
+      if (0 == line[0])
+      {
+        request->state = MHD_REQUEST_HEADERS_RECEIVED;
+        request->header_size = (size_t) (line - request->read_buffer);
+        continue;
+      }
+      continue;
+    case MHD_REQUEST_HEADERS_RECEIVED:
+      parse_request_headers (request);
+      if (MHD_REQUEST_CLOSED == request->state)
+        continue;
+      request->state = MHD_REQUEST_HEADERS_PROCESSED;
+      if (connection->suspended)
+        break;
+      continue;
+    case MHD_REQUEST_HEADERS_PROCESSED:
+      call_request_handler (request);     /* first call */
+      if (MHD_REQUEST_CLOSED == request->state)
+        continue;
+      if (need_100_continue (request))
+      {
+        request->state = MHD_REQUEST_CONTINUE_SENDING;
+        if (socket_flush_possible (connection))
+          socket_start_extra_buffering (connection);
+        else
+          socket_start_no_buffering (connection);
+        break;
+      }
+      if ( (NULL != request->response) &&
+           ( (MHD_METHOD_POST == request->method) ||
+             (MHD_METHOD_PUT == request->method) ) )
+      {
+        /* we refused (no upload allowed!) */
+        request->remaining_upload_size = 0;
+        /* force close, in case client still tries to upload... */
+        connection->read_closed = true;
+      }
+      request->state = (0 == request->remaining_upload_size)
+                       ? MHD_REQUEST_FOOTERS_RECEIVED
+                       : MHD_REQUEST_CONTINUE_SENT;
+      if (connection->suspended)
+        break;
+      continue;
+    case MHD_REQUEST_CONTINUE_SENDING:
+      if (request->continue_message_write_offset ==
+          MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE))
+      {
+        request->state = MHD_REQUEST_CONTINUE_SENT;
+        if (! socket_flush_possible (connection))
+          socket_start_no_buffering_flush (connection);
+        else
+          socket_start_normal_buffering (connection);
+        continue;
+      }
+      break;
+    case MHD_REQUEST_CONTINUE_SENT:
+      if (0 != request->read_buffer_offset)
+      {
+        process_request_body (request);           /* loop call */
+        if (MHD_REQUEST_CLOSED == request->state)
+          continue;
+      }
+      if ( (0 == request->remaining_upload_size) ||
+           ( (MHD_SIZE_UNKNOWN == request->remaining_upload_size) &&
+             (0 == request->read_buffer_offset) &&
+             (connection->read_closed) ) )
+      {
+        if ( (request->have_chunked_upload) &&
+             (! connection->read_closed) )
+          request->state = MHD_REQUEST_BODY_RECEIVED;
+        else
+          request->state = MHD_REQUEST_FOOTERS_RECEIVED;
+        if (connection->suspended)
           break;
-        case MHD_REQUEST_BODY_RECEIVED:
-          line = get_next_header_line (request,
-                                       NULL);
-          if (NULL == line)
-            {
-              if (request->state != MHD_REQUEST_BODY_RECEIVED)
-                continue;
-              if (connection->read_closed)
-                {
-                  CONNECTION_CLOSE_ERROR (connection,
-                                          MHD_SC_CONNECTION_CLOSED,
-                                          NULL);
-                  continue;
-                }
-              break;
-            }
-          if (0 == line[0])
-            {
-              request->state = MHD_REQUEST_FOOTERS_RECEIVED;
-              if (connection->suspended)
-                break;
-              continue;
-            }
-          if (MHD_NO == process_header_line (request,
-                                             line))
-            {
-              transmit_error_response (request,
-                                       MHD_SC_CONNECTION_PARSE_FAIL_CLOSED,
-                                       MHD_HTTP_BAD_REQUEST,
-                                       REQUEST_MALFORMED);
-              break;
-            }
-          request->state = MHD_REQUEST_FOOTER_PART_RECEIVED;
+        continue;
+      }
+      break;
+    case MHD_REQUEST_BODY_RECEIVED:
+      line = get_next_header_line (request,
+                                   NULL);
+      if (NULL == line)
+      {
+        if (request->state != MHD_REQUEST_BODY_RECEIVED)
           continue;
-        case MHD_REQUEST_FOOTER_PART_RECEIVED:
-          line = get_next_header_line (request,
-                                       NULL);
-          if (NULL == line)
-            {
-              if (request->state != MHD_REQUEST_FOOTER_PART_RECEIVED)
-                continue;
-              if (connection->read_closed)
-                {
-                  CONNECTION_CLOSE_ERROR (connection,
-                                          MHD_SC_CONNECTION_CLOSED,
-                                          NULL);
-                  continue;
-                }
-              break;
-            }
-          if (MHD_NO ==
-              process_broken_line (request,
-                                   line,
-                                   MHD_FOOTER_KIND))
-            continue;
-          if (0 == line[0])
-            {
-              request->state = MHD_REQUEST_FOOTERS_RECEIVED;
-              if (connection->suspended)
-                break;
-              continue;
-            }
+        if (connection->read_closed)
+        {
+          CONNECTION_CLOSE_ERROR (connection,
+                                  MHD_SC_CONNECTION_CLOSED,
+                                  NULL);
           continue;
-        case MHD_REQUEST_FOOTERS_RECEIVED:
-          call_request_handler (request); /* "final" call */
-          if (request->state == MHD_REQUEST_CLOSED)
-            continue;
-          if (NULL == request->response)
-            break;              /* try again next time */
-          if (! build_header_response (request))
-            {
-              /* oops - close! */
-              CONNECTION_CLOSE_ERROR (connection,
-                                      MHD_SC_FAILED_RESPONSE_HEADER_GENERATION,
-                                      _("Closing connection (failed to create response header)\n"));
-              continue;
-            }
-          request->state = MHD_REQUEST_HEADERS_SENDING;
-          if (MHD_NO != socket_flush_possible (connection))
-            socket_start_extra_buffering (connection);
-          else
-            socket_start_no_buffering (connection);
-
+        }
+        break;
+      }
+      if (0 == line[0])
+      {
+        request->state = MHD_REQUEST_FOOTERS_RECEIVED;
+        if (connection->suspended)
           break;
-        case MHD_REQUEST_HEADERS_SENDING:
-          /* no default action */
+        continue;
+      }
+      if (MHD_NO == process_header_line (request,
+                                         line))
+      {
+        transmit_error_response (request,
+                                 MHD_SC_CONNECTION_PARSE_FAIL_CLOSED,
+                                 MHD_HTTP_BAD_REQUEST,
+                                 REQUEST_MALFORMED);
+        break;
+      }
+      request->state = MHD_REQUEST_FOOTER_PART_RECEIVED;
+      continue;
+    case MHD_REQUEST_FOOTER_PART_RECEIVED:
+      line = get_next_header_line (request,
+                                   NULL);
+      if (NULL == line)
+      {
+        if (request->state != MHD_REQUEST_FOOTER_PART_RECEIVED)
+          continue;
+        if (connection->read_closed)
+        {
+          CONNECTION_CLOSE_ERROR (connection,
+                                  MHD_SC_CONNECTION_CLOSED,
+                                  NULL);
+          continue;
+        }
+        break;
+      }
+      if (MHD_NO ==
+          process_broken_line (request,
+                               line,
+                               MHD_FOOTER_KIND))
+        continue;
+      if (0 == line[0])
+      {
+        request->state = MHD_REQUEST_FOOTERS_RECEIVED;
+        if (connection->suspended)
           break;
-        case MHD_REQUEST_HEADERS_SENT:
-          /* Some clients may take some actions right after header receive */
-          if (MHD_NO != socket_flush_possible (connection))
-            socket_start_no_buffering_flush (connection);
+        continue;
+      }
+      continue;
+    case MHD_REQUEST_FOOTERS_RECEIVED:
+      call_request_handler (request);     /* "final" call */
+      if (request->state == MHD_REQUEST_CLOSED)
+        continue;
+      if (NULL == request->response)
+        break;                  /* try again next time */
+      if (! build_header_response (request))
+      {
+        /* oops - close! */
+        CONNECTION_CLOSE_ERROR (connection,
+                                MHD_SC_FAILED_RESPONSE_HEADER_GENERATION,
+                                _ (
+                                  "Closing connection (failed to create response header)\n"));
+        continue;
+      }
+      request->state = MHD_REQUEST_HEADERS_SENDING;
+      if (MHD_NO != socket_flush_possible (connection))
+        socket_start_extra_buffering (connection);
+      else
+        socket_start_no_buffering (connection);
+
+      break;
+    case MHD_REQUEST_HEADERS_SENDING:
+      /* no default action */
+      break;
+    case MHD_REQUEST_HEADERS_SENT:
+      /* Some clients may take some actions right after header receive */
+      if (MHD_NO != socket_flush_possible (connection))
+        socket_start_no_buffering_flush (connection);
 
 #ifdef UPGRADE_SUPPORT
-          if (NULL != request->response->upgrade_handler)
-            {
-              socket_start_normal_buffering (connection);
-              request->state = MHD_REQUEST_UPGRADE;
+      if (NULL != request->response->upgrade_handler)
+      {
+        socket_start_normal_buffering (connection);
+        request->state = MHD_REQUEST_UPGRADE;
 #if FIXME_LEGACY_STYLE
-              /* This request is "upgraded".  Pass socket to application. */
-              if (! MHD_response_execute_upgrade_ (request->response,
-                                                   request))
-                {
-                  /* upgrade failed, fail hard */
-                  CONNECTION_CLOSE_ERROR (connection,
-                                          MHD_SC_CONNECTION_CLOSED,
-                                          NULL);
-                  continue;
-                }
+        /* This request is "upgraded".  Pass socket to application. */
+        if (! MHD_response_execute_upgrade_ (request->response,
+                                             request))
+        {
+          /* upgrade failed, fail hard */
+          CONNECTION_CLOSE_ERROR (connection,
+                                  MHD_SC_CONNECTION_CLOSED,
+                                  NULL);
+          continue;
+        }
 #endif
-              /* Response is not required anymore for this request. */
-              {
-                struct MHD_Response * const resp = request->response;
-
-                request->response = NULL;
-                MHD_response_queue_for_destroy (resp);
-              }
-              continue;
-            }
+        /* Response is not required anymore for this request. */
+        {
+          struct MHD_Response *const resp = request->response;
+
+          request->response = NULL;
+          MHD_response_queue_for_destroy (resp);
+        }
+        continue;
+      }
 #endif /* UPGRADE_SUPPORT */
-          if (MHD_NO != socket_flush_possible (connection))
-            socket_start_extra_buffering (connection);
-          else
-            socket_start_normal_buffering (connection);
-
-          if (request->have_chunked_upload)
-            request->state = MHD_REQUEST_CHUNKED_BODY_UNREADY;
-          else
-            request->state = MHD_REQUEST_NORMAL_BODY_UNREADY;
-          continue;
-        case MHD_REQUEST_NORMAL_BODY_READY:
-          /* nothing to do here */
-          break;
-        case MHD_REQUEST_NORMAL_BODY_UNREADY:
-          if (NULL != request->response->crc)
-            MHD_mutex_lock_chk_ (&request->response->mutex);
-          if (0 == request->response->total_size)
-            {
-              if (NULL != request->response->crc)
-                MHD_mutex_unlock_chk_ (&request->response->mutex);
-              request->state = MHD_REQUEST_BODY_SENT;
-              continue;
-            }
-          if (try_ready_normal_body (request))
-            {
-              if (NULL != request->response->crc)
-                MHD_mutex_unlock_chk_ (&request->response->mutex);
-              request->state = MHD_REQUEST_NORMAL_BODY_READY;
-              /* Buffering for flushable socket was already enabled*/
-              if (MHD_NO == socket_flush_possible (connection))
-                socket_start_no_buffering (connection);
-              break;
-            }
-          /* mutex was already unlocked by "try_ready_normal_body */
-          /* not ready, no socket action */
-          break;
-        case MHD_REQUEST_CHUNKED_BODY_READY:
-          /* nothing to do here */
-          break;
-        case MHD_REQUEST_CHUNKED_BODY_UNREADY:
-          if (NULL != request->response->crc)
-            MHD_mutex_lock_chk_ (&request->response->mutex);
-          if ( (0 == request->response->total_size) ||
-               (request->response_write_position ==
-                request->response->total_size) )
-            {
-              if (NULL != request->response->crc)
-                MHD_mutex_unlock_chk_ (&request->response->mutex);
-              request->state = MHD_REQUEST_BODY_SENT;
-              continue;
-            }
-          if (try_ready_chunked_body (request))
-            {
-              if (NULL != request->response->crc)
-                MHD_mutex_unlock_chk_ (&request->response->mutex);
-              request->state = MHD_REQUEST_CHUNKED_BODY_READY;
-              /* Buffering for flushable socket was already enabled */
-              if (MHD_NO == socket_flush_possible (connection))
-                socket_start_no_buffering (connection);
-              continue;
-            }
-          /* mutex was already unlocked by try_ready_chunked_body */
-          break;
-        case MHD_REQUEST_BODY_SENT:
-          if (! build_header_response (request))
-            {
-              /* oops - close! */
-              CONNECTION_CLOSE_ERROR (connection,
-                                      MHD_SC_FAILED_RESPONSE_HEADER_GENERATION,
-                                      _("Closing connection (failed to create response header)\n"));
-              continue;
-            }
-          if ( (! request->have_chunked_upload) ||
-               (request->write_buffer_send_offset ==
-                request->write_buffer_append_offset) )
-            request->state = MHD_REQUEST_FOOTERS_SENT;
-          else
-            request->state = MHD_REQUEST_FOOTERS_SENDING;
-          continue;
-        case MHD_REQUEST_FOOTERS_SENDING:
-          /* no default action */
-          break;
-        case MHD_REQUEST_FOOTERS_SENT:
-          {
-            struct MHD_Response *response = request->response;
-
-            if (MHD_HTTP_PROCESSING == response->status_code)
-              {
-                /* After this type of response, we allow sending another! */
-                request->state = MHD_REQUEST_HEADERS_PROCESSED;
-                MHD_response_queue_for_destroy (response);
-                request->response = NULL;
-                /* FIXME: maybe partially reset memory pool? */
-                continue;
-              }
-            if (socket_flush_possible (connection))
-              socket_start_no_buffering_flush (connection);
-            else
-              socket_start_normal_buffering (connection);
-
-            if (NULL != response->termination_cb)
-              {
-                response->termination_cb (response->termination_cb_cls,
-                                          MHD_REQUEST_TERMINATED_COMPLETED_OK,
-                                          request->client_context);
-              }
-            MHD_response_queue_for_destroy (response);
-            request->response = NULL;
-          }
-          if ( (MHD_CONN_USE_KEEPALIVE != request->keepalive) ||
-               (connection->read_closed) )
-            {
-              /* have to close for some reason */
-              MHD_connection_close_ (connection,
-                                     MHD_REQUEST_TERMINATED_COMPLETED_OK);
-              MHD_pool_destroy (connection->pool);
-              connection->pool = NULL;
-              request->read_buffer = NULL;
-              request->read_buffer_size = 0;
-              request->read_buffer_offset = 0;
-            }
-          else
-            {
-              /* can try to keep-alive */
-              if (socket_flush_possible (connection))
-                socket_start_normal_buffering (connection);
-              request->version_s = NULL;
-              request->state = MHD_REQUEST_INIT;
-              request->last = NULL;
-              request->colon = NULL;
-              request->header_size = 0;
-              request->keepalive = MHD_CONN_KEEPALIVE_UNKOWN;
-              /* Reset the read buffer to the starting size,
-                 preserving the bytes we have already read. */
-              request->read_buffer
-                = MHD_pool_reset (connection->pool,
-                                  request->read_buffer,
-                                  request->read_buffer_offset,
-                                  daemon->connection_memory_limit_b / 2);
-              request->read_buffer_size
-                = daemon->connection_memory_limit_b / 2;
-            }
-          // FIXME: this is too much, NULLs out some of the things
-          // initialized above...
-          memset (request,
-                  0,
-                  sizeof (struct MHD_Request));
-          request->daemon = daemon;
-          request->connection = connection;
+      if (MHD_NO != socket_flush_possible (connection))
+        socket_start_extra_buffering (connection);
+      else
+        socket_start_normal_buffering (connection);
+
+      if (request->have_chunked_upload)
+        request->state = MHD_REQUEST_CHUNKED_BODY_UNREADY;
+      else
+        request->state = MHD_REQUEST_NORMAL_BODY_UNREADY;
+      continue;
+    case MHD_REQUEST_NORMAL_BODY_READY:
+      /* nothing to do here */
+      break;
+    case MHD_REQUEST_NORMAL_BODY_UNREADY:
+      if (NULL != request->response->crc)
+        MHD_mutex_lock_chk_ (&request->response->mutex);
+      if (0 == request->response->total_size)
+      {
+        if (NULL != request->response->crc)
+          MHD_mutex_unlock_chk_ (&request->response->mutex);
+        request->state = MHD_REQUEST_BODY_SENT;
+        continue;
+      }
+      if (try_ready_normal_body (request))
+      {
+        if (NULL != request->response->crc)
+          MHD_mutex_unlock_chk_ (&request->response->mutex);
+        request->state = MHD_REQUEST_NORMAL_BODY_READY;
+        /* Buffering for flushable socket was already enabled*/
+        if (MHD_NO == socket_flush_possible (connection))
+          socket_start_no_buffering (connection);
+        break;
+      }
+      /* mutex was already unlocked by "try_ready_normal_body */
+      /* not ready, no socket action */
+      break;
+    case MHD_REQUEST_CHUNKED_BODY_READY:
+      /* nothing to do here */
+      break;
+    case MHD_REQUEST_CHUNKED_BODY_UNREADY:
+      if (NULL != request->response->crc)
+        MHD_mutex_lock_chk_ (&request->response->mutex);
+      if ( (0 == request->response->total_size) ||
+           (request->response_write_position ==
+            request->response->total_size) )
+      {
+        if (NULL != request->response->crc)
+          MHD_mutex_unlock_chk_ (&request->response->mutex);
+        request->state = MHD_REQUEST_BODY_SENT;
+        continue;
+      }
+      if (try_ready_chunked_body (request))
+      {
+        if (NULL != request->response->crc)
+          MHD_mutex_unlock_chk_ (&request->response->mutex);
+        request->state = MHD_REQUEST_CHUNKED_BODY_READY;
+        /* Buffering for flushable socket was already enabled */
+        if (MHD_NO == socket_flush_possible (connection))
+          socket_start_no_buffering (connection);
+        continue;
+      }
+      /* mutex was already unlocked by try_ready_chunked_body */
+      break;
+    case MHD_REQUEST_BODY_SENT:
+      if (! build_header_response (request))
+      {
+        /* oops - close! */
+        CONNECTION_CLOSE_ERROR (connection,
+                                MHD_SC_FAILED_RESPONSE_HEADER_GENERATION,
+                                _ (
+                                  "Closing connection (failed to create response header)\n"));
+        continue;
+      }
+      if ( (! request->have_chunked_upload) ||
+           (request->write_buffer_send_offset ==
+            request->write_buffer_append_offset) )
+        request->state = MHD_REQUEST_FOOTERS_SENT;
+      else
+        request->state = MHD_REQUEST_FOOTERS_SENDING;
+      continue;
+    case MHD_REQUEST_FOOTERS_SENDING:
+      /* no default action */
+      break;
+    case MHD_REQUEST_FOOTERS_SENT:
+      {
+        struct MHD_Response *response = request->response;
+
+        if (MHD_HTTP_PROCESSING == response->status_code)
+        {
+          /* After this type of response, we allow sending another! */
+          request->state = MHD_REQUEST_HEADERS_PROCESSED;
+          MHD_response_queue_for_destroy (response);
+          request->response = NULL;
+          /* FIXME: maybe partially reset memory pool? */
           continue;
-        case MHD_REQUEST_CLOSED:
-          cleanup_connection (connection);
-          request->in_idle = false;
-          return false;
+        }
+        if (socket_flush_possible (connection))
+          socket_start_no_buffering_flush (connection);
+        else
+          socket_start_normal_buffering (connection);
+
+        if (NULL != response->termination_cb)
+        {
+          response->termination_cb (response->termination_cb_cls,
+                                    MHD_REQUEST_TERMINATED_COMPLETED_OK,
+                                    request->client_context);
+        }
+        MHD_response_queue_for_destroy (response);
+        request->response = NULL;
+      }
+      if ( (MHD_CONN_USE_KEEPALIVE != request->keepalive) ||
+           (connection->read_closed) )
+      {
+        /* have to close for some reason */
+        MHD_connection_close_ (connection,
+                               MHD_REQUEST_TERMINATED_COMPLETED_OK);
+        MHD_pool_destroy (connection->pool);
+        connection->pool = NULL;
+        request->read_buffer = NULL;
+        request->read_buffer_size = 0;
+        request->read_buffer_offset = 0;
+      }
+      else
+      {
+        /* can try to keep-alive */
+        if (socket_flush_possible (connection))
+          socket_start_normal_buffering (connection);
+        request->version_s = NULL;
+        request->state = MHD_REQUEST_INIT;
+        request->last = NULL;
+        request->colon = NULL;
+        request->header_size = 0;
+        request->keepalive = MHD_CONN_KEEPALIVE_UNKOWN;
+        /* Reset the read buffer to the starting size,
+           preserving the bytes we have already read. */
+        request->read_buffer
+          = MHD_pool_reset (connection->pool,
+                            request->read_buffer,
+                            request->read_buffer_offset,
+                            daemon->connection_memory_limit_b / 2);
+        request->read_buffer_size
+          = daemon->connection_memory_limit_b / 2;
+      }
+      // FIXME: this is too much, NULLs out some of the things
+      // initialized above...
+      memset (request,
+              0,
+              sizeof (struct MHD_Request));
+      request->daemon = daemon;
+      request->connection = connection;
+      continue;
+    case MHD_REQUEST_CLOSED:
+      cleanup_connection (connection);
+      request->in_idle = false;
+      return false;
 #ifdef UPGRADE_SUPPORT
-        case MHD_REQUEST_UPGRADE:
-          request->in_idle = false;
-          return true; /* keep open */
+    case MHD_REQUEST_UPGRADE:
+      request->in_idle = false;
+      return true;     /* keep open */
 #endif /* UPGRADE_SUPPORT */
-       default:
-          mhd_assert (0);
-          break;
-        }
+    default:
+      mhd_assert (0);
       break;
     }
+    break;
+  }
   if (! connection->suspended)
+  {
+    time_t timeout;
+    timeout = connection->connection_timeout;
+    if ( (0 != timeout) &&
+         (timeout < (MHD_monotonic_sec_counter ()
+                     - connection->last_activity)) )
     {
-      time_t timeout;
-      timeout = connection->connection_timeout;
-      if ( (0 != timeout) &&
-           (timeout < (MHD_monotonic_sec_counter() - connection->last_activity)) )
-        {
-          MHD_connection_close_ (connection,
-                                 MHD_REQUEST_TERMINATED_TIMEOUT_REACHED);
-          request->in_idle = false;
-          return true;
-        }
+      MHD_connection_close_ (connection,
+                             MHD_REQUEST_TERMINATED_TIMEOUT_REACHED);
+      request->in_idle = false;
+      return true;
     }
+  }
   connection_update_event_loop_info (connection);
   ret = true;
 #ifdef EPOLL_SUPPORT
   if ( (! connection->suspended) &&
        (MHD_ELS_EPOLL == daemon->event_loop_syscall) )
-    {
-      ret = connection_epoll_update_ (connection);
-    }
+  {
+    ret = connection_epoll_update_ (connection);
+  }
 #endif /* EPOLL_SUPPORT */
   request->in_idle = false;
   return ret;
@@ -3589,9 +3621,9 @@ MHD_request_handle_idle_ (struct MHD_Request *request)
 // FIXME: rename connection->request?
 int
 MHD_connection_call_handlers_ (struct MHD_Connection *con,
-                               bool read_ready,
-                               bool write_ready,
-                               bool force_close)
+                               bool read_ready,
+                               bool write_ready,
+                               bool force_close)
 {
   struct MHD_Daemon *daemon = con->daemon;
   int ret;
@@ -3604,38 +3636,38 @@ MHD_connection_call_handlers_ (struct MHD_Connection *con,
     read_ready = true;
 #endif /* HTTPS_SUPPORT */
   if (! force_close)
+  {
+    if ( (MHD_EVENT_LOOP_INFO_READ ==
+          con->request.event_loop_info) &&
+         read_ready)
     {
-      if ( (MHD_EVENT_LOOP_INFO_READ ==
-            con->request.event_loop_info) &&
-           read_ready)
-        {
-          MHD_request_handle_read_ (&con->request);
-          ret = MHD_request_handle_idle_ (&con->request);
-          states_info_processed = true;
-        }
-      /* No need to check value of 'ret' here as closed connection
-       * cannot be in MHD_EVENT_LOOP_INFO_WRITE state. */
-      if ( (MHD_EVENT_LOOP_INFO_WRITE ==
-            con->request.event_loop_info) &&
-           write_ready)
-        {
-          MHD_request_handle_write_ (&con->request);
-          ret = MHD_request_handle_idle_ (&con->request);
-          states_info_processed = true;
-        }
+      MHD_request_handle_read_ (&con->request);
+      ret = MHD_request_handle_idle_ (&con->request);
+      states_info_processed = true;
     }
-  else
+    /* No need to check value of 'ret' here as closed connection
+     * cannot be in MHD_EVENT_LOOP_INFO_WRITE state. */
+    if ( (MHD_EVENT_LOOP_INFO_WRITE ==
+          con->request.event_loop_info) &&
+         write_ready)
     {
-      MHD_connection_close_ (con,
-                             MHD_REQUEST_TERMINATED_WITH_ERROR);
-      return MHD_request_handle_idle_ (&con->request);
+      MHD_request_handle_write_ (&con->request);
+      ret = MHD_request_handle_idle_ (&con->request);
+      states_info_processed = true;
     }
+  }
+  else
+  {
+    MHD_connection_close_ (con,
+                           MHD_REQUEST_TERMINATED_WITH_ERROR);
+    return MHD_request_handle_idle_ (&con->request);
+  }
 
   if (! states_info_processed)
-    { /* Connection is not read or write ready, but external conditions
+  {   /* Connection is not read or write ready, but external conditions
        * may be changed and need to be processed. */
-      ret = MHD_request_handle_idle_ (&con->request);
-    }
+    ret = MHD_request_handle_idle_ (&con->request);
+  }
   /* Fast track for fast connections. */
   /* If full request was read by single read_handler() invocation
      and headers were completely prepared by single MHD_request_handle_idle_()
@@ -3647,24 +3679,24 @@ MHD_connection_call_handlers_ (struct MHD_Connection *con,
   /* No need to check 'ret' as connection is always in
    * MHD_CONNECTION_CLOSED state if 'ret' is equal 'MHD_NO'. */
   else if (on_fasttrack &&
-           con->sk_nonblck)
+           con->sk_nonblck)
+  {
+    if (MHD_REQUEST_HEADERS_SENDING == con->request.state)
     {
-      if (MHD_REQUEST_HEADERS_SENDING == con->request.state)
-        {
-          MHD_request_handle_write_ (&con->request);
-          /* Always call 'MHD_request_handle_idle_()' after each read/write. */
-          ret = MHD_request_handle_idle_ (&con->request);
-        }
-      /* If all headers were sent by single write_handler() and
-       * response body is prepared by single MHD_request_handle_idle_()
-       * call - continue. */
-      if ((MHD_REQUEST_NORMAL_BODY_READY == con->request.state) ||
-          (MHD_REQUEST_CHUNKED_BODY_READY == con->request.state))
-        {
-          MHD_request_handle_write_ (&con->request);
-          ret = MHD_request_handle_idle_ (&con->request);
-        }
+      MHD_request_handle_write_ (&con->request);
+      /* Always call 'MHD_request_handle_idle_()' after each read/write. */
+      ret = MHD_request_handle_idle_ (&con->request);
+    }
+    /* If all headers were sent by single write_handler() and
+     * response body is prepared by single MHD_request_handle_idle_()
+     * call - continue. */
+    if ((MHD_REQUEST_NORMAL_BODY_READY == con->request.state) ||
+        (MHD_REQUEST_CHUNKED_BODY_READY == con->request.state))
+    {
+      MHD_request_handle_write_ (&con->request);
+      ret = MHD_request_handle_idle_ (&con->request);
     }
+  }
 
   /* All connection's data and states are processed for this turn.
    * If connection already has more data to be processed - use
@@ -3676,17 +3708,17 @@ MHD_connection_call_handlers_ (struct MHD_Connection *con,
    * without space in read buffer will be market as 'info block'. */
   if ( (! daemon->data_already_pending) &&
        (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_mode) )
-    {
-      if (MHD_EVENT_LOOP_INFO_BLOCK ==
-          con->request.event_loop_info)
-        daemon->data_already_pending = true;
+  {
+    if (MHD_EVENT_LOOP_INFO_BLOCK ==
+        con->request.event_loop_info)
+      daemon->data_already_pending = true;
 #ifdef HTTPS_SUPPORT
-      else if ( (con->tls_read_ready) &&
-                (MHD_EVENT_LOOP_INFO_READ ==
-                 con->request.event_loop_info) )
-        daemon->data_already_pending = true;
+    else if ( (con->tls_read_ready) &&
+              (MHD_EVENT_LOOP_INFO_READ ==
+               con->request.event_loop_info) )
+      daemon->data_already_pending = true;
 #endif /* HTTPS_SUPPORT */
-    }
+  }
   return ret;
 }
 
diff --git a/src/lib/connection_call_handlers.h b/src/lib/connection_call_handlers.h
index 980e8064..6297bb9e 100644
--- a/src/lib/connection_call_handlers.h
+++ b/src/lib/connection_call_handlers.h
@@ -40,10 +40,10 @@
  */
 int
 MHD_connection_call_handlers_ (struct MHD_Connection *con,
-                               bool read_ready,
-                               bool write_ready,
-                               bool force_close)
-  MHD_NONNULL (1);
+                               bool read_ready,
+                               bool write_ready,
+                               bool force_close)
+MHD_NONNULL (1);
 
 
 /**
@@ -58,7 +58,7 @@ MHD_connection_call_handlers_ (struct MHD_Connection *con,
  */
 bool
 MHD_request_handle_idle_ (struct MHD_Request *request)
-  MHD_NONNULL (1);
+MHD_NONNULL (1);
+
 
-  
 #endif
diff --git a/src/lib/connection_cleanup.c b/src/lib/connection_cleanup.c
index 8883213b..4f2cfb0f 100644
--- a/src/lib/connection_cleanup.c
+++ b/src/lib/connection_cleanup.c
@@ -49,7 +49,7 @@ connection_cleanup_upgraded (struct MHD_Connection *connection)
 
     if (NULL != (tls = connection->daemon->tls_api))
       (void) tls->shutdown_connection (tls->cls,
-                                       connection->tls_cs);
+                                       connection->tls_cs);
   }
   if (MHD_INVALID_SOCKET != urh->mhd.socket)
     MHD_socket_close_chk_ (urh->mhd.socket);
@@ -65,7 +65,7 @@ connection_cleanup_upgraded (struct MHD_Connection *connection)
 /**
  * Free resources associated with all closed connections.  (destroy
  * responses, free buffers, etc.).  All closed connections are kept in
- * the "cleanup" doubly-linked list. 
+ * the "cleanup" doubly-linked list.
  *
  * @remark To be called only from thread that process daemon's
  * select()/poll()/etc.
@@ -79,79 +79,79 @@ MHD_connection_cleanup_ (struct MHD_Daemon *daemon)
 
   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   while (NULL != (pos = daemon->cleanup_tail))
-    {
-      DLL_remove (daemon->cleanup_head,
-                  daemon->cleanup_tail,
-                  pos);
-      MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
+  {
+    DLL_remove (daemon->cleanup_head,
+                daemon->cleanup_tail,
+                pos);
+    MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
 
-      if ( (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode) &&
-           (! pos->thread_joined) &&
-           (! MHD_join_thread_ (pos->pid.handle)) )
-        MHD_PANIC (_("Failed to join a thread\n"));
+    if ( (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode) &&
+         (! pos->thread_joined) &&
+         (! MHD_join_thread_ (pos->pid.handle)) )
+      MHD_PANIC (_ ("Failed to join a thread\n"));
 #ifdef UPGRADE_SUPPORT
-      connection_cleanup_upgraded (pos);
+    connection_cleanup_upgraded (pos);
 #endif /* UPGRADE_SUPPORT */
-      MHD_pool_destroy (pos->pool);
+    MHD_pool_destroy (pos->pool);
 #ifdef HTTPS_SUPPORT
-      {
-        struct MHD_TLS_Plugin *tls;
-        
-        if (NULL != (tls = daemon->tls_api))
-          tls->teardown_connection (tls->cls,
-                                    pos->tls_cs);
-      }
+    {
+      struct MHD_TLS_Plugin *tls;
+
+      if (NULL != (tls = daemon->tls_api))
+        tls->teardown_connection (tls->cls,
+                                  pos->tls_cs);
+    }
 #endif /* HTTPS_SUPPORT */
 
-      /* clean up the connection */
-      if (NULL != daemon->notify_connection_cb)
-        daemon->notify_connection_cb (daemon->notify_connection_cb_cls,
-                                      pos,
-                                      MHD_CONNECTION_NOTIFY_CLOSED);
-      MHD_ip_limit_del (daemon,
-                        (const struct sockaddr *) &pos->addr,
-                        pos->addr_len);
+    /* clean up the connection */
+    if (NULL != daemon->notify_connection_cb)
+      daemon->notify_connection_cb (daemon->notify_connection_cb_cls,
+                                    pos,
+                                    MHD_CONNECTION_NOTIFY_CLOSED);
+    MHD_ip_limit_del (daemon,
+                      (const struct sockaddr *) &pos->addr,
+                      pos->addr_len);
 #ifdef EPOLL_SUPPORT
-      if (MHD_ELS_EPOLL == daemon->event_loop_syscall)
-        {
-          if (0 != (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL))
-            {
-              EDLL_remove (daemon->eready_head,
-                           daemon->eready_tail,
-                           pos);
-              pos->epoll_state &= ~MHD_EPOLL_STATE_IN_EREADY_EDLL;
-            }
-          if ( (-1 != daemon->epoll_fd) &&
-               (0 != (pos->epoll_state & MHD_EPOLL_STATE_IN_EPOLL_SET)) )
-            {
-              /* epoll documentation suggests that closing a FD
-                 automatically removes it from the epoll set; however,
-                 this is not true as if we fail to do manually remove it,
-                 we are still seeing an event for this fd in epoll,
-                 causing grief (use-after-free...) --- at least on my
-                 system. */
-              if (0 != epoll_ctl (daemon->epoll_fd,
-                                  EPOLL_CTL_DEL,
-                                  pos->socket_fd,
-                                  NULL))
-                MHD_PANIC (_("Failed to remove FD from epoll set\n"));
-              pos->epoll_state &= ~MHD_EPOLL_STATE_IN_EPOLL_SET;
-            }
-        }
+    if (MHD_ELS_EPOLL == daemon->event_loop_syscall)
+    {
+      if (0 != (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL))
+      {
+        EDLL_remove (daemon->eready_head,
+                     daemon->eready_tail,
+                     pos);
+        pos->epoll_state &= ~MHD_EPOLL_STATE_IN_EREADY_EDLL;
+      }
+      if ( (-1 != daemon->epoll_fd) &&
+           (0 != (pos->epoll_state & MHD_EPOLL_STATE_IN_EPOLL_SET)) )
+      {
+        /* epoll documentation suggests that closing a FD
+           automatically removes it from the epoll set; however,
+           this is not true as if we fail to do manually remove it,
+           we are still seeing an event for this fd in epoll,
+           causing grief (use-after-free...) --- at least on my
+           system. */
+        if (0 != epoll_ctl (daemon->epoll_fd,
+                            EPOLL_CTL_DEL,
+                            pos->socket_fd,
+                            NULL))
+          MHD_PANIC (_ ("Failed to remove FD from epoll set\n"));
+        pos->epoll_state &= ~MHD_EPOLL_STATE_IN_EPOLL_SET;
+      }
+    }
 #endif
-      if (NULL != pos->request.response)
-        {
-          MHD_response_queue_for_destroy (pos->request.response);
-          pos->request.response = NULL;
-        }
-      if (MHD_INVALID_SOCKET != pos->socket_fd)
-        MHD_socket_close_chk_ (pos->socket_fd);
-      free (pos);
-
-      MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
-      daemon->connections--;
-      daemon->at_limit = false;
+    if (NULL != pos->request.response)
+    {
+      MHD_response_queue_for_destroy (pos->request.response);
+      pos->request.response = NULL;
     }
+    if (MHD_INVALID_SOCKET != pos->socket_fd)
+      MHD_socket_close_chk_ (pos->socket_fd);
+    free (pos);
+
+    MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
+    daemon->connections--;
+    daemon->at_limit = false;
+  }
   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
 }
 
diff --git a/src/lib/connection_cleanup.h b/src/lib/connection_cleanup.h
index 26fbebaf..c6beeeee 100644
--- a/src/lib/connection_cleanup.h
+++ b/src/lib/connection_cleanup.h
@@ -18,7 +18,7 @@
 */
 /**
  * @file lib/connection_cleanup.h
- * @brief functions to cleanup completed connection 
+ * @brief functions to cleanup completed connection
  * @author Christian Grothoff
  */
 #ifndef CONNECTION_CLEANUP_H
@@ -28,7 +28,7 @@
 /**
  * Free resources associated with all closed connections.  (destroy
  * responses, free buffers, etc.).  All closed connections are kept in
- * the "cleanup" doubly-linked list. 
+ * the "cleanup" doubly-linked list.
  *
  * @remark To be called only from thread that process daemon's
  * select()/poll()/etc.
@@ -37,6 +37,6 @@
  */
 void
 MHD_connection_cleanup_ (struct MHD_Daemon *daemon)
-  MHD_NONNULL (1);
+MHD_NONNULL (1);
 
 #endif
diff --git a/src/lib/connection_close.c b/src/lib/connection_close.c
index 945997db..3c872b0b 100644
--- a/src/lib/connection_close.c
+++ b/src/lib/connection_close.c
@@ -40,33 +40,33 @@ MHD_connection_mark_closed_ (struct MHD_Connection *connection)
   connection->request.state = MHD_REQUEST_CLOSED;
   connection->request.event_loop_info = MHD_EVENT_LOOP_INFO_CLEANUP;
   if (! daemon->enable_turbo)
-    {
+  {
 #ifdef HTTPS_SUPPORT
-      struct MHD_TLS_Plugin *tls;
+    struct MHD_TLS_Plugin *tls;
 
-      /* For TLS connection use shutdown of TLS layer
-       * and do not shutdown TCP socket. This give more
-       * chances to send TLS closure data to remote side.
-       * Closure of TLS layer will be interpreted by
-       * remote side as end of transmission. */
-      if (NULL != (tls = daemon->tls_api))
-        {
-          if (MHD_YES !=
-              tls->shutdown_connection (tls->cls,
-                                        connection->tls_cs))
-            {
-              (void) shutdown (connection->socket_fd,
-                               SHUT_WR);
-              /* FIXME: log errors */
-            }
-        }
-      else /* Combined with next 'shutdown()'. */
+    /* For TLS connection use shutdown of TLS layer
+     * and do not shutdown TCP socket. This give more
+     * chances to send TLS closure data to remote side.
+     * Closure of TLS layer will be interpreted by
+     * remote side as end of transmission. */
+    if (NULL != (tls = daemon->tls_api))
+    {
+      if (MHD_YES !=
+          tls->shutdown_connection (tls->cls,
+                                    connection->tls_cs))
+      {
+        (void) shutdown (connection->socket_fd,
+                         SHUT_WR);
+        /* FIXME: log errors */
+      }
+    }
+    else   /* Combined with next 'shutdown()'. */
 #endif /* HTTPS_SUPPORT */
-        {
-          (void) shutdown (connection->socket_fd,
-                           SHUT_WR); /* FIXME: log errors */
-        }
+    {
+      (void) shutdown (connection->socket_fd,
+                       SHUT_WR); /* FIXME: log errors */
     }
+  }
 }
 
 
@@ -90,14 +90,14 @@ MHD_connection_close_ (struct MHD_Connection *connection,
   (void) rtc; // FIXME
   MHD_connection_mark_closed_ (connection);
   if (NULL != resp)
-    {
-      connection->request.response = NULL;
-      MHD_response_queue_for_destroy (resp);
-    }
+  {
+    connection->request.response = NULL;
+    MHD_response_queue_for_destroy (resp);
+  }
   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);
 }
 
 /* end of connection_close.c */
diff --git a/src/lib/connection_close.h b/src/lib/connection_close.h
index 41f141d2..c8e159ee 100644
--- a/src/lib/connection_close.h
+++ b/src/lib/connection_close.h
@@ -35,7 +35,7 @@
  */
 void
 MHD_connection_mark_closed_ (struct MHD_Connection *connection)
-  MHD_NONNULL (1);
+MHD_NONNULL (1);
 
 
 /**
@@ -51,6 +51,6 @@ MHD_connection_mark_closed_ (struct MHD_Connection *connection)
 void
 MHD_connection_close_ (struct MHD_Connection *connection,
                        enum MHD_RequestTerminationCode rtc)
-  MHD_NONNULL (1);
+MHD_NONNULL (1);
 
 #endif
diff --git a/src/lib/connection_finish_forward.c b/src/lib/connection_finish_forward.c
index 335a03bf..1ea9aa31 100644
--- a/src/lib/connection_finish_forward.c
+++ b/src/lib/connection_finish_forward.c
@@ -55,34 +55,34 @@ MHD_connection_finish_forward_ (struct MHD_Connection *connection)
                         EPOLL_CTL_DEL,
                         connection->socket_fd,
                         NULL)) )
-    {
-      MHD_PANIC (_("Failed to remove FD from epoll set\n"));
-    }
+  {
+    MHD_PANIC (_ ("Failed to remove FD from epoll set\n"));
+  }
   if (urh->in_eready_list)
-    {
-      EDLL_remove (daemon->eready_urh_head,
-                   daemon->eready_urh_tail,
-                   urh);
-      urh->in_eready_list = false;
-    }
+  {
+    EDLL_remove (daemon->eready_urh_head,
+                 daemon->eready_urh_tail,
+                 urh);
+    urh->in_eready_list = false;
+  }
 #endif /* EPOLL_SUPPORT */
   if (MHD_INVALID_SOCKET != urh->mhd.socket)
-    {
+  {
 #if EPOLL_SUPPORT
-      if ( (MHD_ELS_EPOLL == daemon->event_loop_syscall) &&
-           (0 != epoll_ctl (daemon->epoll_upgrade_fd,
-                            EPOLL_CTL_DEL,
-                            urh->mhd.socket,
-                            NULL)) )
-        {
-          MHD_PANIC (_("Failed to remove FD from epoll set\n"));
-        }
-#endif /* EPOLL_SUPPORT */
-      /* Reflect remote disconnect to application by breaking
-       * socketpair connection. */
-      shutdown (urh->mhd.socket,
-                SHUT_RDWR);
+    if ( (MHD_ELS_EPOLL == daemon->event_loop_syscall) &&
+         (0 != epoll_ctl (daemon->epoll_upgrade_fd,
+                          EPOLL_CTL_DEL,
+                          urh->mhd.socket,
+                          NULL)) )
+    {
+      MHD_PANIC (_ ("Failed to remove FD from epoll set\n"));
     }
+#endif /* EPOLL_SUPPORT */
+    /* Reflect remote disconnect to application by breaking
+     * socketpair connection. */
+    shutdown (urh->mhd.socket,
+              SHUT_RDWR);
+  }
   /* Socketpair sockets will remain open as they will be
    * used with MHD_UPGRADE_ACTION_CLOSE. They will be
    * closed by MHD_cleanup_upgraded_connection_() during
diff --git a/src/lib/connection_finish_forward.h b/src/lib/connection_finish_forward.h
index c6c04f42..ebb77d12 100644
--- a/src/lib/connection_finish_forward.h
+++ b/src/lib/connection_finish_forward.h
@@ -39,6 +39,6 @@
  */
 void
 MHD_connection_finish_forward_ (struct MHD_Connection *connection)
-  MHD_NONNULL (1);
+MHD_NONNULL (1);
 
 #endif
diff --git a/src/lib/connection_info.c b/src/lib/connection_info.c
index 88055fa4..d83b34c5 100644
--- a/src/lib/connection_info.c
+++ b/src/lib/connection_info.c
@@ -42,13 +42,13 @@
  */
 enum MHD_Bool
 MHD_connection_get_information_sz (struct MHD_Connection *connection,
-                                   enum MHD_ConnectionInformationType info_type,
-                                   union MHD_ConnectionInformation *return_value,
-                                   size_t return_value_size)
+                                   enum MHD_ConnectionInformationType info_type,
+                                   union MHD_ConnectionInformation *return_value,
+                                   size_t return_value_size)
 {
 #define CHECK_SIZE(type) if (sizeof(type) < return_value_size) \
     return MHD_NO
-  
+
   switch (info_type)
   {
 #ifdef HTTPS_SUPPORT
@@ -63,7 +63,7 @@ MHD_connection_get_information_sz (struct MHD_Connection *connection,
     CHECK_SIZE (int);
     if (NULL == connection->tls_cs)
       return MHD_NO;
-    //return_value->protocol
+    // return_value->protocol
     //  = gnutls_protocol_get_version (connection->tls_session);
     return MHD_NO; // FIXME: to be implemented
   case MHD_CONNECTION_INFORMATION_GNUTLS_SESSION:
@@ -103,7 +103,7 @@ MHD_connection_get_information_sz (struct MHD_Connection *connection,
   default:
     return MHD_NO;
   }
-  
+
 #undef CHECK_SIZE
 }
 
diff --git a/src/lib/connection_options.c b/src/lib/connection_options.c
index 00652161..ce31b315 100644
--- a/src/lib/connection_options.c
+++ b/src/lib/connection_options.c
@@ -35,44 +35,44 @@
  */
 void
 MHD_connection_set_timeout (struct MHD_Connection *connection,
-                            unsigned int timeout_s)
+                            unsigned int timeout_s)
 {
   struct MHD_Daemon *daemon = connection->daemon;
-  
-  connection->last_activity = MHD_monotonic_sec_counter();
+
+  connection->last_activity = MHD_monotonic_sec_counter ();
   if (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode)
-    {
-      /* Simple case, no need to lock to update DLLs */
-      connection->connection_timeout = (time_t) timeout_s;
-      return;
-    }
+  {
+    /* Simple case, no need to lock to update DLLs */
+    connection->connection_timeout = (time_t) timeout_s;
+    return;
+  }
 
   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   if (! connection->suspended)
-    {
-      if (connection->connection_timeout ==
-          daemon->connection_default_timeout)
-        XDLL_remove (daemon->normal_timeout_head,
-                     daemon->normal_timeout_tail,
-                     connection);
-      else
-        XDLL_remove (daemon->manual_timeout_head,
-                     daemon->manual_timeout_tail,
-                     connection);
-    }  
+  {
+    if (connection->connection_timeout ==
+        daemon->connection_default_timeout)
+      XDLL_remove (daemon->normal_timeout_head,
+                   daemon->normal_timeout_tail,
+                   connection);
+    else
+      XDLL_remove (daemon->manual_timeout_head,
+                   daemon->manual_timeout_tail,
+                   connection);
+  }
   connection->connection_timeout = (time_t) timeout_s;
   if (! connection->suspended)
-    {
-      if (connection->connection_timeout ==
-          daemon->connection_default_timeout)
-        XDLL_insert (daemon->normal_timeout_head,
-                     daemon->normal_timeout_tail,
-                     connection);
-      else
-        XDLL_insert (daemon->manual_timeout_head,
-                     daemon->manual_timeout_tail,
-                     connection);
-    }
+  {
+    if (connection->connection_timeout ==
+        daemon->connection_default_timeout)
+      XDLL_insert (daemon->normal_timeout_head,
+                   daemon->normal_timeout_tail,
+                   connection);
+    else
+      XDLL_insert (daemon->manual_timeout_head,
+                   daemon->manual_timeout_tail,
+                   connection);
+  }
   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
 }
 
@@ -95,7 +95,7 @@ MHD_update_last_activity_ (struct MHD_Connection *connection)
   if (connection->suspended)
     return; /* no activity on suspended connections */
 
-  connection->last_activity = MHD_monotonic_sec_counter();
+  connection->last_activity = MHD_monotonic_sec_counter ();
   if (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode)
     return; /* each connection has personal timeout */
 
@@ -106,11 +106,11 @@ MHD_update_last_activity_ (struct MHD_Connection *connection)
   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   /* move connection to head of timeout list (by remove + add operation) */
   XDLL_remove (daemon->normal_timeout_head,
-               daemon->normal_timeout_tail,
-               connection);
+               daemon->normal_timeout_tail,
+               connection);
   XDLL_insert (daemon->normal_timeout_head,
-               daemon->normal_timeout_tail,
-               connection);
+               daemon->normal_timeout_tail,
+               connection);
   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
 }
 
diff --git a/src/lib/connection_update_last_activity.c b/src/lib/connection_update_last_activity.c
index 7253dc83..741da681 100644
--- a/src/lib/connection_update_last_activity.c
+++ b/src/lib/connection_update_last_activity.c
@@ -43,7 +43,7 @@ MHD_connection_update_last_activity_ (struct MHD_Connection *connection)
   if (connection->suspended)
     return; /* no activity on suspended connections */
 
-  connection->last_activity = MHD_monotonic_sec_counter();
+  connection->last_activity = MHD_monotonic_sec_counter ();
   if (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode)
     return; /* each connection has personal timeout */
 
@@ -53,13 +53,12 @@ MHD_connection_update_last_activity_ (struct MHD_Connection *connection)
   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   /* move connection to head of timeout list (by remove + add operation) */
   XDLL_remove (daemon->normal_timeout_head,
-               daemon->normal_timeout_tail,
-               connection);
+               daemon->normal_timeout_tail,
+               connection);
   XDLL_insert (daemon->normal_timeout_head,
-               daemon->normal_timeout_tail,
-               connection);
+               daemon->normal_timeout_tail,
+               connection);
   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
 }
 
 /* end of connection_update_last_activity.c */
-
diff --git a/src/lib/connection_update_last_activity.h b/src/lib/connection_update_last_activity.h
index 8383b6be..ee9f9975 100644
--- a/src/lib/connection_update_last_activity.h
+++ b/src/lib/connection_update_last_activity.h
@@ -35,6 +35,6 @@
  */
 void
 MHD_connection_update_last_activity_ (struct MHD_Connection *connection)
-  MHD_NONNULL (1);
+MHD_NONNULL (1);
 
 #endif
diff --git a/src/lib/daemon_close_all_connections.c b/src/lib/daemon_close_all_connections.c
index d4b825da..1a777494 100644
--- a/src/lib/daemon_close_all_connections.c
+++ b/src/lib/daemon_close_all_connections.c
@@ -45,10 +45,10 @@ close_connection (struct MHD_Connection *pos)
   struct MHD_Daemon *daemon = pos->daemon;
 
   if (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode)
-    {
-      MHD_connection_mark_closed_ (pos);
-      return; /* must let thread to do the rest */
-    }
+  {
+    MHD_connection_mark_closed_ (pos);
+    return;   /* must let thread to do the rest */
+  }
   MHD_connection_close_ (pos,
                          MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN);
 
@@ -59,18 +59,18 @@ close_connection (struct MHD_Connection *pos)
   if (pos->connection_timeout ==
       pos->daemon->connection_default_timeout)
     XDLL_remove (daemon->normal_timeout_head,
-                 daemon->normal_timeout_tail,
-                 pos);
+                 daemon->normal_timeout_tail,
+                 pos);
   else
     XDLL_remove (daemon->manual_timeout_head,
-                 daemon->manual_timeout_tail,
-                 pos);
+                 daemon->manual_timeout_tail,
+                 pos);
   DLL_remove (daemon->connections_head,
-              daemon->connections_tail,
-              pos);
+              daemon->connections_tail,
+              pos);
   DLL_insert (daemon->cleanup_head,
-              daemon->cleanup_tail,
-              pos);
+              daemon->cleanup_tail,
+              pos);
 
   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
 }
@@ -89,7 +89,8 @@ void
 MHD_daemon_close_all_connections_ (struct MHD_Daemon *daemon)
 {
   struct MHD_Connection *pos;
-  const bool used_thr_p_c = (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode);
+  const bool used_thr_p_c = (MHD_TM_THREAD_PER_CONNECTION ==
+                             daemon->threading_mode);
 #ifdef UPGRADE_SUPPORT
   const bool upg_allowed = (! daemon->disallow_upgrade);
 #endif /* UPGRADE_SUPPORT */
@@ -103,16 +104,16 @@ MHD_daemon_close_all_connections_ (struct MHD_Daemon *daemon)
   /* give upgraded HTTPS connections a chance to finish */
   /* 'daemon->urh_head' is not used in thread-per-connection mode. */
   for (urh = daemon->urh_tail; NULL != urh; urh = urhn)
-    {
-      urhn = urh->prev;
-      /* call generic forwarding function for passing data
-         with chance to detect that application is done. */
-      MHD_upgrade_response_handle_process_ (urh);
-      MHD_connection_finish_forward_ (urh->connection);
-      urh->clean_ready = true;
-      /* Resuming will move connection to cleanup list. */
-      MHD_request_resume (&urh->connection->request);
-    }
+  {
+    urhn = urh->prev;
+    /* call generic forwarding function for passing data
+       with chance to detect that application is done. */
+    MHD_upgrade_response_handle_process_ (urh);
+    MHD_connection_finish_forward_ (urh->connection);
+    urh->clean_ready = true;
+    /* Resuming will move connection to cleanup list. */
+    MHD_request_resume (&urh->connection->request);
+  }
 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
 
   /* Give suspended connections a chance to resume to avoid
@@ -120,89 +121,93 @@ MHD_daemon_close_all_connections_ (struct MHD_Daemon *daemon)
      connections left in case of a tight race with a recently
      resumed connection. */
   if (! daemon->disallow_suspend_resume)
-    {
-      daemon->resuming = true; /* Force check for pending resume. */
-      MHD_resume_suspended_connections_ (daemon);
-    }
+  {
+    daemon->resuming = true;   /* Force check for pending resume. */
+    MHD_resume_suspended_connections_ (daemon);
+  }
   /* first, make sure all threads are aware of shutdown; need to
      traverse DLLs in peace... */
   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
 #ifdef UPGRADE_SUPPORT
   if (upg_allowed)
-    {
-      struct MHD_Connection * susp;
+  {
+    struct MHD_Connection *susp;
 
-      susp = daemon->suspended_connections_tail;
-      while (NULL != susp)
-        {
-          if (NULL == susp->request.urh) /* "Upgraded" connection? */
-            MHD_PANIC (_("MHD_stop_daemon() called while we have suspended connections.\n"));
+    susp = daemon->suspended_connections_tail;
+    while (NULL != susp)
+    {
+      if (NULL == susp->request.urh)     /* "Upgraded" connection? */
+        MHD_PANIC (_ (
+                     "MHD_stop_daemon() called while we have suspended connections.\n"));
 #ifdef HTTPS_SUPPORT
-          else if (used_tls &&
-                   used_thr_p_c &&
-                   (! susp->request.urh->clean_ready) )
-            shutdown (susp->request.urh->app.socket,
-                      SHUT_RDWR); /* Wake thread by shutdown of app socket. */
+      else if (used_tls &&
+               used_thr_p_c &&
+               (! susp->request.urh->clean_ready) )
+        shutdown (susp->request.urh->app.socket,
+                  SHUT_RDWR);     /* Wake thread by shutdown of app socket. */
 #endif /* HTTPS_SUPPORT */
-          else
-            {
+      else
+      {
 #ifdef HAVE_MESSAGES
-              if (! susp->request.urh->was_closed)
-                MHD_DLOG (daemon,
-                          MHD_SC_SHUTDOWN_WITH_OPEN_UPGRADED_CONNECTION,
-                          _("Initiated daemon shutdown while \"upgraded\" connection was not closed.\n"));
+        if (! susp->request.urh->was_closed)
+          MHD_DLOG (daemon,
+                    MHD_SC_SHUTDOWN_WITH_OPEN_UPGRADED_CONNECTION,
+                    _ (
+                      "Initiated daemon shutdown while \"upgraded\" connection was not closed.\n"));
 #endif
-              susp->request.urh->was_closed = true;
-              /* If thread-per-connection is used, connection's thread
-               * may still processing "upgrade" (exiting). */
-              if (! used_thr_p_c)
-                MHD_connection_finish_forward_ (susp);
-              /* Do not use MHD_resume_connection() as mutex is
-               * already locked. */
-              susp->resuming = true;
-              daemon->resuming = true;
-            }
-          susp = susp->prev;
-        }
+        susp->request.urh->was_closed = true;
+        /* If thread-per-connection is used, connection's thread
+         * may still processing "upgrade" (exiting). */
+        if (! used_thr_p_c)
+          MHD_connection_finish_forward_ (susp);
+        /* Do not use MHD_resume_connection() as mutex is
+         * already locked. */
+        susp->resuming = true;
+        daemon->resuming = true;
+      }
+      susp = susp->prev;
     }
+  }
   else /* This 'else' is combined with next 'if' */
 #endif /* UPGRADE_SUPPORT */
   if (NULL != daemon->suspended_connections_head)
-    MHD_PANIC (_("MHD_stop_daemon() called while we have suspended connections.\n"));
+    MHD_PANIC (_ (
+                 "MHD_stop_daemon() called while we have suspended connections.\n"));
   for (pos = daemon->connections_tail; NULL != pos; pos = pos->prev)
-    {
-      shutdown (pos->socket_fd,
-                SHUT_RDWR);
+  {
+    shutdown (pos->socket_fd,
+              SHUT_RDWR);
 #if MHD_WINSOCK_SOCKETS
-      if ( (used_thr_p_c) &&
-           (MHD_ITC_IS_VALID_(daemon->itc)) &&
-           (! MHD_itc_activate_ (daemon->itc,
-                                 "e")) )
-        MHD_PANIC (_("Failed to signal shutdown via inter-thread communication channel"));
+    if ( (used_thr_p_c) &&
+         (MHD_ITC_IS_VALID_ (daemon->itc)) &&
+         (! MHD_itc_activate_ (daemon->itc,
+                               "e")) )
+      MHD_PANIC (_ (
+                   "Failed to signal shutdown via inter-thread communication channel"));
 #endif
-    }
+  }
 
   /* now, collect per-connection threads */
   if (used_thr_p_c)
+  {
+    pos = daemon->connections_tail;
+    while (NULL != pos)
     {
-      pos = daemon->connections_tail;
-      while (NULL != pos)
+      if (! pos->thread_joined)
       {
-        if (! pos->thread_joined)
-          {
-            MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
-            if (! MHD_join_thread_ (pos->pid.handle))
-              MHD_PANIC (_("Failed to join a thread\n"));
-            MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
-            pos->thread_joined = true;
-            /* The thread may have concurrently modified the DLL,
-               need to restart from the beginning */
-            pos = daemon->connections_tail;
-            continue;
-          }
-        pos = pos->prev;
+        MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
+        if (! MHD_join_thread_ (pos->pid.handle))
+          MHD_PANIC (_ ("Failed to join a thread\n"));
+        MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
+        pos->thread_joined = true;
+        /* The thread may have concurrently modified the DLL,
+           need to restart from the beginning */
+        pos = daemon->connections_tail;
+        continue;
       }
+      pos = pos->prev;
     }
+  }
   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
 
 #ifdef UPGRADE_SUPPORT
@@ -211,10 +216,10 @@ MHD_daemon_close_all_connections_ (struct MHD_Daemon *daemon)
   /* "Upgraded" connections that were not closed explicitly by
    * application should be moved to cleanup list too. */
   if (upg_allowed)
-    {
-      daemon->resuming = true; /* Force check for pending resume. */
-      MHD_resume_suspended_connections_ (daemon);
-    }
+  {
+    daemon->resuming = true;   /* Force check for pending resume. */
+    MHD_resume_suspended_connections_ (daemon);
+  }
 #endif /* UPGRADE_SUPPORT */
 
   /* now that we're alone, move everyone to cleanup */
@@ -222,7 +227,7 @@ MHD_daemon_close_all_connections_ (struct MHD_Daemon *daemon)
   {
     if ( (used_thr_p_c) &&
          (! pos->thread_joined) )
-      MHD_PANIC (_("Failed to join a thread\n"));
+      MHD_PANIC (_ ("Failed to join a thread\n"));
     close_connection (pos);
   }
   MHD_connection_cleanup_ (daemon);
diff --git a/src/lib/daemon_close_all_connections.h b/src/lib/daemon_close_all_connections.h
index 340b0d47..2716f9ba 100644
--- a/src/lib/daemon_close_all_connections.h
+++ b/src/lib/daemon_close_all_connections.h
@@ -37,6 +37,6 @@
  */
 void
 MHD_daemon_close_all_connections_ (struct MHD_Daemon *daemon)
-  MHD_NONNULL (1);
+MHD_NONNULL (1);
 
 #endif
diff --git a/src/lib/daemon_create.c b/src/lib/daemon_create.c
index a2173d88..cd3d0ec4 100644
--- a/src/lib/daemon_create.c
+++ b/src/lib/daemon_create.c
@@ -38,16 +38,16 @@
  */
 static void
 file_logger (void *cls,
-             enum MHD_StatusCode sc,
-             const char *fm,
-             va_list ap)
+             enum MHD_StatusCode sc,
+             const char *fm,
+             va_list ap)
 {
   FILE *f = cls;
 
   (void) sc;
   (void) vfprintf (f,
-                   fm,
-                   ap);
+                   fm,
+                   ap);
 }
 
 
@@ -84,16 +84,16 @@ unescape_wrapper (void *cls,
  */
 struct MHD_Daemon *
 MHD_daemon_create (MHD_RequestCallback cb,
-                   void *cb_cls)
+                   void *cb_cls)
 {
   struct MHD_Daemon *daemon;
 
-  MHD_check_global_init_();
+  MHD_check_global_init_ ();
   if (NULL == (daemon = malloc (sizeof (struct MHD_Daemon))))
     return NULL;
   memset (daemon,
-          0,
-          sizeof (struct MHD_Daemon));
+          0,
+          sizeof (struct MHD_Daemon));
 #ifdef EPOLL_SUPPORT
   daemon->epoll_itc_marker = "itc_marker";
 #endif
@@ -107,29 +107,29 @@ MHD_daemon_create (MHD_RequestCallback cb,
 #if ENABLE_DAUTH
   daemon->digest_nc_length = DIGEST_NC_LENGTH_DEFAULT;
 #endif
-  daemon->listen_backlog = LISTEN_BACKLOG_DEFAULT;  
+  daemon->listen_backlog = LISTEN_BACKLOG_DEFAULT;
   daemon->fo_queue_length = FO_QUEUE_LENGTH_DEFAULT;
   daemon->listen_socket = MHD_INVALID_SOCKET;
 
   if (! MHD_mutex_init_ (&daemon->cleanup_connection_mutex))
-    {
-      free (daemon);
-      return NULL;
-    }  
+  {
+    free (daemon);
+    return NULL;
+  }
   if (! MHD_mutex_init_ (&daemon->per_ip_connection_mutex))
-    {
-      (void) MHD_mutex_destroy_ (&daemon->cleanup_connection_mutex);
-      free (daemon);
-      return NULL;
-    }
+  {
+    (void) MHD_mutex_destroy_ (&daemon->cleanup_connection_mutex);
+    free (daemon);
+    return NULL;
+  }
 #ifdef DAUTH_SUPPORT
   if (! MHD_mutex_init_ (&daemon->nnc_lock))
-    {
-      (void) MHD_mutex_destroy_ (&daemon->cleanup_connection_mutex);
-      (void) MHD_mutex_destroy_ (&daemon->per_ip_connection_mutex);
-      free (daemon);
-      return NULL;
-    }
+  {
+    (void) MHD_mutex_destroy_ (&daemon->cleanup_connection_mutex);
+    (void) MHD_mutex_destroy_ (&daemon->per_ip_connection_mutex);
+    free (daemon);
+    return NULL;
+  }
 #endif
   return daemon;
 }
diff --git a/src/lib/daemon_destroy.c b/src/lib/daemon_destroy.c
index b4f34d16..a76c2d6b 100644
--- a/src/lib/daemon_destroy.c
+++ b/src/lib/daemon_destroy.c
@@ -46,35 +46,36 @@ stop_workers (struct MHD_Daemon *daemon)
     fd = daemon->listen_socket;
   /* Let workers shutdown in parallel. */
   for (i = 0; i < daemon->worker_pool_size; i++)
+  {
+    daemon->worker_pool[i].shutdown = true;
+    if (MHD_ITC_IS_VALID_ (daemon->worker_pool[i].itc))
     {
-      daemon->worker_pool[i].shutdown = true;
-      if (MHD_ITC_IS_VALID_(daemon->worker_pool[i].itc))
-        {
-          if (! MHD_itc_activate_ (daemon->worker_pool[i].itc,
-                                   "e"))
-            MHD_PANIC (_("Failed to signal shutdown via inter-thread communication channel."));
-        }
-      else
-        {
-          /* Better hope shutdown() works... */
-          mhd_assert (MHD_INVALID_SOCKET != fd);
-        }
+      if (! MHD_itc_activate_ (daemon->worker_pool[i].itc,
+                               "e"))
+        MHD_PANIC (_ (
+                     "Failed to signal shutdown via inter-thread communication channel."));
     }
-#ifdef HAVE_LISTEN_SHUTDOWN
-  if (MHD_INVALID_SOCKET != fd)
+    else
     {
-      (void) shutdown (fd,
-                       SHUT_RDWR);
+      /* Better hope shutdown() works... */
+      mhd_assert (MHD_INVALID_SOCKET != fd);
     }
+  }
+#ifdef HAVE_LISTEN_SHUTDOWN
+  if (MHD_INVALID_SOCKET != fd)
+  {
+    (void) shutdown (fd,
+                     SHUT_RDWR);
+  }
 #endif /* HAVE_LISTEN_SHUTDOWN */
   for (i = 0; i < daemon->worker_pool_size; ++i)
-    {
-      MHD_daemon_destroy (&daemon->worker_pool[i]);
-    }
+  {
+    MHD_daemon_destroy (&daemon->worker_pool[i]);
+  }
   free (daemon->worker_pool);
   daemon->worker_pool = NULL;
   /* FIXME: does this still hold? */
-  mhd_assert (MHD_ITC_IS_INVALID_(daemon->itc));
+  mhd_assert (MHD_ITC_IS_INVALID_ (daemon->itc));
 #ifdef EPOLL_SUPPORT
   mhd_assert (-1 == daemon->epoll_fd);
 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
@@ -104,65 +105,66 @@ MHD_daemon_destroy (struct MHD_Daemon *daemon)
   /* FIXME: convert from here to microhttpd2-style API! */
 
   if (NULL != daemon->worker_pool)
-    { /* Master daemon with worker pool. */
-      stop_workers (daemon);
-    }
+  {   /* Master daemon with worker pool. */
+    stop_workers (daemon);
+  }
   else
+  {
+    mhd_assert (0 == daemon->worker_pool_size);
+    /* Worker daemon or single-thread daemon. */
+    if (MHD_TM_EXTERNAL_EVENT_LOOP != daemon->threading_mode)
     {
-      mhd_assert (0 == daemon->worker_pool_size);
-      /* Worker daemon or single-thread daemon. */
-      if (MHD_TM_EXTERNAL_EVENT_LOOP != daemon->threading_mode)
-        {
-          /* Worker daemon or single daemon with internal thread(s). */
-          /* Separate thread(s) is used for polling sockets. */
-          if (MHD_ITC_IS_VALID_(daemon->itc))
-            {
-              if (! MHD_itc_activate_ (daemon->itc,
-                                       "e"))
-                MHD_PANIC (_("Failed to signal shutdown via inter-thread communication channel"));
-            }
-          else
-            {
-#ifdef HAVE_LISTEN_SHUTDOWN
-              if (MHD_INVALID_SOCKET != fd)
-                {
-                  if (NULL == daemon->master)
-                    (void) shutdown (fd,
-                                     SHUT_RDWR);
-                }
-              else
-#endif /* HAVE_LISTEN_SHUTDOWN */
-                mhd_assert (false); /* Should never happen */
-            }
-
-          if (! MHD_join_thread_ (daemon->pid.handle))
-            {
-              MHD_PANIC (_("Failed to join a thread\n"));
-            }
-          /* close_all_connections() was called in daemon thread. */
-        }
+      /* Worker daemon or single daemon with internal thread(s). */
+      /* Separate thread(s) is used for polling sockets. */
+      if (MHD_ITC_IS_VALID_ (daemon->itc))
+      {
+        if (! MHD_itc_activate_ (daemon->itc,
+                                 "e"))
+          MHD_PANIC (_ (
+                       "Failed to signal shutdown via inter-thread communication channel"));
+      }
       else
+      {
+#ifdef HAVE_LISTEN_SHUTDOWN
+        if (MHD_INVALID_SOCKET != fd)
         {
-          /* No internal threads are used for polling sockets
-             (external event loop) */
-          MHD_daemon_close_all_connections_ (daemon);
+          if (NULL == daemon->master)
+            (void) shutdown (fd,
+                             SHUT_RDWR);
         }
-      if (MHD_ITC_IS_VALID_ (daemon->itc))
-        MHD_itc_destroy_chk_ (daemon->itc);
+        else
+#endif /* HAVE_LISTEN_SHUTDOWN */
+        mhd_assert (false); /* Should never happen */
+      }
+
+      if (! MHD_join_thread_ (daemon->pid.handle))
+      {
+        MHD_PANIC (_ ("Failed to join a thread\n"));
+      }
+      /* close_all_connections() was called in daemon thread. */
+    }
+    else
+    {
+      /* No internal threads are used for polling sockets
+   (external event loop) */
+      MHD_daemon_close_all_connections_ (daemon);
+    }
+    if (MHD_ITC_IS_VALID_ (daemon->itc))
+      MHD_itc_destroy_chk_ (daemon->itc);
 
 #ifdef EPOLL_SUPPORT
-      if ( (MHD_ELS_EPOLL == daemon->event_loop_syscall) &&
-           (-1 != daemon->epoll_fd) )
-        MHD_socket_close_chk_ (daemon->epoll_fd);
+    if ( (MHD_ELS_EPOLL == daemon->event_loop_syscall) &&
+         (-1 != daemon->epoll_fd) )
+      MHD_socket_close_chk_ (daemon->epoll_fd);
 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
-      if ( (MHD_ELS_EPOLL == daemon->event_loop_syscall) &&
-           (-1 != daemon->epoll_upgrade_fd) )
-        MHD_socket_close_chk_ (daemon->epoll_upgrade_fd);
+    if ( (MHD_ELS_EPOLL == daemon->event_loop_syscall) &&
+         (-1 != daemon->epoll_upgrade_fd) )
+      MHD_socket_close_chk_ (daemon->epoll_upgrade_fd);
 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
 #endif /* EPOLL_SUPPORT */
 
-      MHD_mutex_destroy_chk_ (&daemon->cleanup_connection_mutex);
-    }
+    MHD_mutex_destroy_chk_ (&daemon->cleanup_connection_mutex);
+  }
 
   if (NULL != daemon->master)
     return;
@@ -175,18 +177,18 @@ MHD_daemon_destroy (struct MHD_Daemon *daemon)
   /* TLS clean up */
 #ifdef HTTPS_SUPPORT
   if (NULL != daemon->tls_api)
-    {
+  {
 #if FIXME_TLS_API
-      if (daemon->have_dhparams)
-        {
-          gnutls_dh_params_deinit (daemon->https_mem_dhparams);
-          daemon->have_dhparams = false;
-        }
-      gnutls_priority_deinit (daemon->priority_cache);
-      if (daemon->x509_cred)
-        gnutls_certificate_free_credentials (daemon->x509_cred);
-#endif
+    if (daemon->have_dhparams)
+    {
+      gnutls_dh_params_deinit (daemon->https_mem_dhparams);
+      daemon->have_dhparams = false;
     }
+    gnutls_priority_deinit (daemon->priority_cache);
+    if (daemon->x509_cred)
+      gnutls_certificate_free_credentials (daemon->x509_cred);
+#endif
+  }
 #endif /* HTTPS_SUPPORT */
 
 #ifdef DAUTH_SUPPORT
diff --git a/src/lib/daemon_epoll.c b/src/lib/daemon_epoll.c
index 4bed148f..b25ba9a7 100644
--- a/src/lib/daemon_epoll.c
+++ b/src/lib/daemon_epoll.c
@@ -53,9 +53,9 @@
  *         'false' otherwise
  */
 static bool
-is_urh_ready (struct MHD_UpgradeResponseHandle * const urh)
+is_urh_ready (struct MHD_UpgradeResponseHandle *const urh)
 {
-  const struct MHD_Connection * const connection = urh->connection;
+  const struct MHD_Connection *const connection = urh->connection;
 
   if ( (0 == urh->in_buffer_size) &&
        (0 == urh->out_buffer_size) &&
@@ -80,7 +80,7 @@ is_urh_ready (struct MHD_UpgradeResponseHandle * const urh)
     return true;
 
   if ( (0 != (MHD_EPOLL_STATE_WRITE_READY & urh->mhd.celi)) &&
-         (urh->in_buffer_used > 0) )
+       (urh->in_buffer_used > 0) )
     return true;
 
   return false;
@@ -103,99 +103,99 @@ run_epoll_for_upgrade (struct MHD_Daemon *daemon)
 {
   struct epoll_event events[MAX_EVENTS];
   int num_events;
-  struct MHD_UpgradeResponseHandle * pos;
-  struct MHD_UpgradeResponseHandle * prev;
+  struct MHD_UpgradeResponseHandle *pos;
+  struct MHD_UpgradeResponseHandle *prev;
 
   num_events = MAX_EVENTS;
   while (MAX_EVENTS == num_events)
+  {
+    unsigned int i;
+
+    /* update event masks */
+    num_events = epoll_wait (daemon->epoll_upgrade_fd,
+                             events,
+                             MAX_EVENTS,
+                             0);
+    if (-1 == num_events)
     {
-      unsigned int i;
-      
-      /* update event masks */
-      num_events = epoll_wait (daemon->epoll_upgrade_fd,
-                               events,
-                               MAX_EVENTS,
-                               0);
-      if (-1 == num_events)
-        {
-          const int err = MHD_socket_get_error_ ();
-          if (MHD_SCKT_ERR_IS_EINTR_ (err))
-            return MHD_SC_OK;
+      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_EPOLL_WAIT_ERROR,
-                    _("Call to epoll_wait failed: %s\n"),
-                    MHD_socket_strerr_ (err));
+      MHD_DLOG (daemon,
+                MHD_SC_UNEXPECTED_EPOLL_WAIT_ERROR,
+                _ ("Call to epoll_wait failed: %s\n"),
+                MHD_socket_strerr_ (err));
 #endif
-          return MHD_SC_UNEXPECTED_EPOLL_WAIT_ERROR;
-        }
-      for (i = 0; i < (unsigned int) num_events; i++)
-        {
-          struct UpgradeEpollHandle * const ueh = events[i].data.ptr;
-          struct MHD_UpgradeResponseHandle * const urh = ueh->urh;
-          bool new_err_state = false;
-
-          if (urh->clean_ready)
-            continue;
-
-          /* Update ueh state based on what is ready according to epoll() */
-          if (0 != (events[i].events & EPOLLIN))
-            ueh->celi |= MHD_EPOLL_STATE_READ_READY;
-          if (0 != (events[i].events & EPOLLOUT))
-            ueh->celi |= MHD_EPOLL_STATE_WRITE_READY;
-          if (0 != (events[i].events & EPOLLHUP))
-            ueh->celi |= MHD_EPOLL_STATE_READ_READY | MHD_EPOLL_STATE_WRITE_READY;
-
-          if ( (0 == (ueh->celi & MHD_EPOLL_STATE_ERROR)) &&
-               (0 != (events[i].events & (EPOLLERR | EPOLLPRI))) )
-            {
-              /* Process new error state only one time
-               * and avoid continuously marking this connection
-               * as 'ready'. */
-              ueh->celi |= MHD_EPOLL_STATE_ERROR;
-              new_err_state = true;
-            }
-
-          if (! urh->in_eready_list)
-            {
-              if (new_err_state ||
-                  is_urh_ready(urh))
-                {
-                  EDLL_insert (daemon->eready_urh_head,
-                               daemon->eready_urh_tail,
-                               urh);
-                  urh->in_eready_list = true;
-                }
-            }
+      return MHD_SC_UNEXPECTED_EPOLL_WAIT_ERROR;
+    }
+    for (i = 0; i < (unsigned int) num_events; i++)
+    {
+      struct UpgradeEpollHandle *const ueh = events[i].data.ptr;
+      struct MHD_UpgradeResponseHandle *const urh = ueh->urh;
+      bool new_err_state = false;
+
+      if (urh->clean_ready)
+        continue;
+
+      /* Update ueh state based on what is ready according to epoll() */
+      if (0 != (events[i].events & EPOLLIN))
+        ueh->celi |= MHD_EPOLL_STATE_READ_READY;
+      if (0 != (events[i].events & EPOLLOUT))
+        ueh->celi |= MHD_EPOLL_STATE_WRITE_READY;
+      if (0 != (events[i].events & EPOLLHUP))
+        ueh->celi |= MHD_EPOLL_STATE_READ_READY | MHD_EPOLL_STATE_WRITE_READY;
+
+      if ( (0 == (ueh->celi & MHD_EPOLL_STATE_ERROR)) &&
+           (0 != (events[i].events & (EPOLLERR | EPOLLPRI))) )
+      {
+        /* Process new error state only one time
+         * and avoid continuously marking this connection
+         * as 'ready'. */
+        ueh->celi |= MHD_EPOLL_STATE_ERROR;
+        new_err_state = true;
+      }
+
+      if (! urh->in_eready_list)
+      {
+        if (new_err_state ||
+            is_urh_ready (urh))
+        {
+          EDLL_insert (daemon->eready_urh_head,
+                       daemon->eready_urh_tail,
+                       urh);
+          urh->in_eready_list = true;
         }
+      }
     }
+  }
   prev = daemon->eready_urh_tail;
   while (NULL != (pos = prev))
+  {
+    prev = pos->prevE;
+    MHD_upgrade_response_handle_process_ (pos);
+    if (! is_urh_ready (pos))
     {
-      prev = pos->prevE;
-      MHD_upgrade_response_handle_process_ (pos);
-      if (! is_urh_ready(pos))
-        {
-          EDLL_remove (daemon->eready_urh_head,
-                       daemon->eready_urh_tail,
-                       pos);
-          pos->in_eready_list = false;
-        }
-      /* Finished forwarding? */
-      if ( (0 == pos->in_buffer_size) &&
-           (0 == pos->out_buffer_size) &&
-           (0 == pos->in_buffer_used) &&
-           (0 == pos->out_buffer_used) )
-        {
-          MHD_connection_finish_forward_ (pos->connection);
-          pos->clean_ready = true;
-          /* If 'pos->was_closed' already was set to true, connection
-           * will be moved immediately to cleanup list. Otherwise
-           * connection will stay in suspended list until 'pos' will
-           * be marked with 'was_closed' by application. */
-          MHD_request_resume (&pos->connection->request);
-        }
+      EDLL_remove (daemon->eready_urh_head,
+                   daemon->eready_urh_tail,
+                   pos);
+      pos->in_eready_list = false;
+    }
+    /* Finished forwarding? */
+    if ( (0 == pos->in_buffer_size) &&
+         (0 == pos->out_buffer_size) &&
+         (0 == pos->in_buffer_used) &&
+         (0 == pos->out_buffer_used) )
+    {
+      MHD_connection_finish_forward_ (pos->connection);
+      pos->clean_ready = true;
+      /* If 'pos->was_closed' already was set to true, connection
+       * will be moved immediately to cleanup list. Otherwise
+       * connection will stay in suspended list until 'pos' will
+       * be marked with 'was_closed' by application. */
+      MHD_request_resume (&pos->connection->request);
     }
+  }
 
   return MHD_SC_OK;
 }
@@ -212,10 +212,10 @@ run_epoll_for_upgrade (struct MHD_Daemon *daemon)
  */
 enum MHD_StatusCode
 MHD_daemon_epoll_ (struct MHD_Daemon *daemon,
-                   bool may_block)
+                   bool may_block)
 {
 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
-  static const char * const upgrade_marker = "upgrade_ptr";
+  static const char *const upgrade_marker = "upgrade_ptr";
 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   struct MHD_Connection *pos;
   struct MHD_Connection *prev;
@@ -239,24 +239,24 @@ MHD_daemon_epoll_ (struct MHD_Daemon *daemon,
        (daemon->connections < daemon->global_connection_limit) &&
        (! daemon->listen_socket_in_epoll) &&
        (! daemon->at_limit) )
+  {
+    event.events = EPOLLIN;
+    event.data.ptr = daemon;
+    if (0 != epoll_ctl (daemon->epoll_fd,
+                        EPOLL_CTL_ADD,
+                        ls,
+                        &event))
     {
-      event.events = EPOLLIN;
-      event.data.ptr = daemon;
-      if (0 != epoll_ctl (daemon->epoll_fd,
-                          EPOLL_CTL_ADD,
-                          ls,
-                          &event))
-        {
 #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
-          return MHD_SC_EPOLL_CTL_ADD_FAILED;
-        }
-      daemon->listen_socket_in_epoll = true;
+      return MHD_SC_EPOLL_CTL_ADD_FAILED;
     }
+    daemon->listen_socket_in_epoll = true;
+  }
   if ( (daemon->was_quiesced) &&
        (daemon->listen_socket_in_epoll) )
   {
@@ -271,58 +271,58 @@ MHD_daemon_epoll_ (struct MHD_Daemon *daemon,
 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   if ( (! daemon->upgrade_fd_in_epoll) &&
        (-1 != daemon->epoll_upgrade_fd) )
+  {
+    event.events = EPOLLIN | EPOLLOUT;
+    event.data.ptr = (void *) upgrade_marker;
+    if (0 != epoll_ctl (daemon->epoll_fd,
+                        EPOLL_CTL_ADD,
+                        daemon->epoll_upgrade_fd,
+                        &event))
     {
-      event.events = EPOLLIN | EPOLLOUT;
-      event.data.ptr = (void *) upgrade_marker;
-      if (0 != epoll_ctl (daemon->epoll_fd,
-                          EPOLL_CTL_ADD,
-                          daemon->epoll_upgrade_fd,
-                          &event))
-        {
 #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
-          return MHD_SC_EPOLL_CTL_ADD_FAILED;
-        }
-      daemon->upgrade_fd_in_epoll = true;
+      return MHD_SC_EPOLL_CTL_ADD_FAILED;
     }
+    daemon->upgrade_fd_in_epoll = true;
+  }
 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   if ( (daemon->listen_socket_in_epoll) &&
        ( (daemon->connections == daemon->global_connection_limit) ||
          (daemon->at_limit) ||
          (daemon->was_quiesced) ) )
-    {
-      /* we're at the connection limit, disable listen socket
-         for event loop for now */
-      if (0 != epoll_ctl (daemon->epoll_fd,
-                          EPOLL_CTL_DEL,
-                          ls,
-                          NULL))
-        MHD_PANIC (_("Failed to remove listen FD from epoll set\n"));
-      daemon->listen_socket_in_epoll = false;
-    }
+  {
+    /* we're at the connection limit, disable listen socket
+ for event loop for now */
+    if (0 != epoll_ctl (daemon->epoll_fd,
+                        EPOLL_CTL_DEL,
+                        ls,
+                        NULL))
+      MHD_PANIC (_ ("Failed to remove listen FD from epoll set\n"));
+    daemon->listen_socket_in_epoll = false;
+  }
 
   if ( (! daemon->disallow_suspend_resume) &&
        (MHD_resume_suspended_connections_ (daemon)) )
     may_block = false;
 
   if (may_block)
+  {
+    if (MHD_SC_OK ==   /* FIXME: distinguish between NO_TIMEOUT and errors */
+        MHD_daemon_get_timeout (daemon,
+                                &timeout_ll))
     {
-      if (MHD_SC_OK == /* FIXME: distinguish between NO_TIMEOUT and errors */
-          MHD_daemon_get_timeout (daemon,
-                                  &timeout_ll))
-        {
-          if (timeout_ll >= (MHD_UNSIGNED_LONG_LONG) INT_MAX)
-            timeout_ms = INT_MAX;
-          else
-            timeout_ms = (int) timeout_ll;
-        }
+      if (timeout_ll >= (MHD_UNSIGNED_LONG_LONG) INT_MAX)
+        timeout_ms = INT_MAX;
       else
-        timeout_ms = -1;
+        timeout_ms = (int) timeout_ll;
     }
+    else
+      timeout_ms = -1;
+  }
   else
     timeout_ms = 0;
 
@@ -337,113 +337,114 @@ MHD_daemon_epoll_ (struct MHD_Daemon *daemon,
      than unfair behavior... */
   num_events = MAX_EVENTS;
   while (MAX_EVENTS == num_events)
+  {
+    /* update event masks */
+    num_events = epoll_wait (daemon->epoll_fd,
+                             events,
+                             MAX_EVENTS,
+                             timeout_ms);
+    if (-1 == num_events)
     {
-      /* update event masks */
-      num_events = epoll_wait (daemon->epoll_fd,
-                               events,
-                               MAX_EVENTS,
-                               timeout_ms);
-      if (-1 == num_events)
-        {
-          const int err = MHD_socket_get_error_ ();
-          if (MHD_SCKT_ERR_IS_EINTR_ (err))
-            return MHD_SC_OK;
+      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_EPOLL_WAIT_ERROR,
-                    _("Call to epoll_wait failed: %s\n"),
-                    MHD_socket_strerr_ (err));
+      MHD_DLOG (daemon,
+                MHD_SC_UNEXPECTED_EPOLL_WAIT_ERROR,
+                _ ("Call to epoll_wait failed: %s\n"),
+                MHD_socket_strerr_ (err));
 #endif
-          return MHD_SC_UNEXPECTED_EPOLL_WAIT_ERROR;
-        }
-      for (i=0;i<(unsigned int) num_events;i++)
-        {
-          /* First, check for the values of `ptr` that would indicate
-             that this event is not about a normal connection. */
-          if (NULL == events[i].data.ptr)
-            continue; /* shutdown signal! */
+      return MHD_SC_UNEXPECTED_EPOLL_WAIT_ERROR;
+    }
+    for (i = 0; i<(unsigned int) num_events; i++)
+    {
+      /* First, check for the values of `ptr` that would indicate
+         that this event is not about a normal connection. */
+      if (NULL == events[i].data.ptr)
+        continue; /* shutdown signal! */
 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
-          if (upgrade_marker == events[i].data.ptr)
-            {
-              /* activity on an upgraded connection, we process
-                 those in a separate epoll() */
-              run_upgraded = true;
-              continue;
-            }
+      if (upgrade_marker == events[i].data.ptr)
+      {
+        /* activity on an upgraded connection, we process
+           those in a separate epoll() */
+        run_upgraded = true;
+        continue;
+      }
 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
-          if (daemon->epoll_itc_marker == events[i].data.ptr)
-            {
-              /* It's OK to clear ITC here as all external
-                 conditions will be processed later. */
-              MHD_itc_clear_ (daemon->itc);
-              continue;
-            }
-          if (daemon == events[i].data.ptr)
-            {
-              /* Check for error conditions on listen socket. */
-              /* FIXME: Initiate MHD_quiesce_daemon() to prevent busy waiting? */
-              if (0 == (events[i].events & (EPOLLERR | EPOLLHUP)))
-                {
-                  unsigned int series_length = 0;
-                  /* Run 'accept' until it fails or daemon at limit of connections.
-                   * Do not accept more then 10 connections at once. The rest will
-                   * be accepted on next turn (level trigger is used for listen
-                   * socket). */
-                  while ( (MHD_SC_OK ==
-                           MHD_accept_connection_ (daemon)) &&
-                          (series_length < 10) &&
-                          (daemon->connections < daemon->global_connection_limit) &&
-                          (! daemon->at_limit) )
-                    series_length++;
-                }
-              continue;
-            }
-          /* this is an event relating to a 'normal' connection,
-             remember the event and if appropriate mark the
-             connection as 'eready'. */
-          pos = events[i].data.ptr;
-          /* normal processing: update read/write data */
-          if (0 != (events[i].events & (EPOLLPRI | EPOLLERR | EPOLLHUP)))
-            {
-              pos->epoll_state |= MHD_EPOLL_STATE_ERROR;
-              if (0 == (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL))
-                {
-                  EDLL_insert (daemon->eready_head,
-                               daemon->eready_tail,
-                               pos);
-                  pos->epoll_state |= MHD_EPOLL_STATE_IN_EREADY_EDLL;
-                }
-            }
-          else
-            {
-              if (0 != (events[i].events & EPOLLIN))
-                {
-                  pos->epoll_state |= MHD_EPOLL_STATE_READ_READY;
-                  if ( ( (MHD_EVENT_LOOP_INFO_READ == pos->request.event_loop_info) ||
-                         (pos->request.read_buffer_size > pos->request.read_buffer_offset) ) &&
-                       (0 == (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL) ) )
-                    {
-                      EDLL_insert (daemon->eready_head,
-                                   daemon->eready_tail,
-                                   pos);
-                      pos->epoll_state |= MHD_EPOLL_STATE_IN_EREADY_EDLL;
-                    }
-                }
-              if (0 != (events[i].events & EPOLLOUT))
-                {
-                  pos->epoll_state |= MHD_EPOLL_STATE_WRITE_READY;
-                  if ( (MHD_EVENT_LOOP_INFO_WRITE == pos->request.event_loop_info) &&
-                       (0 == (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL) ) )
-                    {
-                      EDLL_insert (daemon->eready_head,
-                                   daemon->eready_tail,
-                                   pos);
-                      pos->epoll_state |= MHD_EPOLL_STATE_IN_EREADY_EDLL;
-                    }
-                }
-            }
+      if (daemon->epoll_itc_marker == events[i].data.ptr)
+      {
+        /* It's OK to clear ITC here as all external
+           conditions will be processed later. */
+        MHD_itc_clear_ (daemon->itc);
+        continue;
+      }
+      if (daemon == events[i].data.ptr)
+      {
+        /* Check for error conditions on listen socket. */
+        /* FIXME: Initiate MHD_quiesce_daemon() to prevent busy waiting? */
+        if (0 == (events[i].events & (EPOLLERR | EPOLLHUP)))
+        {
+          unsigned int series_length = 0;
+          /* Run 'accept' until it fails or daemon at limit of connections.
+           * Do not accept more then 10 connections at once. The rest will
+           * be accepted on next turn (level trigger is used for listen
+           * socket). */
+          while ( (MHD_SC_OK ==
+                   MHD_accept_connection_ (daemon)) &&
+                  (series_length < 10) &&
+                  (daemon->connections < daemon->global_connection_limit) &&
+                  (! daemon->at_limit) )
+            series_length++;
+        }
+        continue;
+      }
+      /* this is an event relating to a 'normal' connection,
+         remember the event and if appropriate mark the
+         connection as 'eready'. */
+      pos = events[i].data.ptr;
+      /* normal processing: update read/write data */
+      if (0 != (events[i].events & (EPOLLPRI | EPOLLERR | EPOLLHUP)))
+      {
+        pos->epoll_state |= MHD_EPOLL_STATE_ERROR;
+        if (0 == (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL))
+        {
+          EDLL_insert (daemon->eready_head,
+                       daemon->eready_tail,
+                       pos);
+          pos->epoll_state |= MHD_EPOLL_STATE_IN_EREADY_EDLL;
+        }
+      }
+      else
+      {
+        if (0 != (events[i].events & EPOLLIN))
+        {
+          pos->epoll_state |= MHD_EPOLL_STATE_READ_READY;
+          if ( ( (MHD_EVENT_LOOP_INFO_READ == pos->request.event_loop_info) ||
+                 (pos->request.read_buffer_size >
+                  pos->request.read_buffer_offset) ) &&
+               (0 == (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL) ) )
+          {
+            EDLL_insert (daemon->eready_head,
+                         daemon->eready_tail,
+                         pos);
+            pos->epoll_state |= MHD_EPOLL_STATE_IN_EREADY_EDLL;
+          }
+        }
+        if (0 != (events[i].events & EPOLLOUT))
+        {
+          pos->epoll_state |= MHD_EPOLL_STATE_WRITE_READY;
+          if ( (MHD_EVENT_LOOP_INFO_WRITE == pos->request.event_loop_info) &&
+               (0 == (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL) ) )
+          {
+            EDLL_insert (daemon->eready_head,
+                         daemon->eready_tail,
+                         pos);
+            pos->epoll_state |= MHD_EPOLL_STATE_IN_EREADY_EDLL;
+          }
         }
+      }
     }
+  }
 
 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   if (run_upgraded)
@@ -453,28 +454,32 @@ MHD_daemon_epoll_ (struct MHD_Daemon *daemon,
   /* process events for connections */
   prev = daemon->eready_tail;
   while (NULL != (pos = prev))
+  {
+    prev = pos->prevE;
+    MHD_connection_call_handlers_ (pos,
+                                   0 != (pos->epoll_state
+                                         & MHD_EPOLL_STATE_READ_READY),
+                                   0 != (pos->epoll_state
+                                         & MHD_EPOLL_STATE_WRITE_READY),
+                                   0 != (pos->epoll_state
+                                         & MHD_EPOLL_STATE_ERROR));
+    if (MHD_EPOLL_STATE_IN_EREADY_EDLL ==
+        (pos->epoll_state & (MHD_EPOLL_STATE_SUSPENDED
+                             | MHD_EPOLL_STATE_IN_EREADY_EDLL)))
     {
-      prev = pos->prevE;
-      MHD_connection_call_handlers_ (pos,
-                                     0 != (pos->epoll_state & MHD_EPOLL_STATE_READ_READY),
-                                     0 != (pos->epoll_state & MHD_EPOLL_STATE_WRITE_READY),
-                                     0 != (pos->epoll_state & MHD_EPOLL_STATE_ERROR));
-      if (MHD_EPOLL_STATE_IN_EREADY_EDLL ==
-            (pos->epoll_state & (MHD_EPOLL_STATE_SUSPENDED | MHD_EPOLL_STATE_IN_EREADY_EDLL)))
-        {
-          if ( (MHD_EVENT_LOOP_INFO_READ == pos->request.event_loop_info &&
-                0 == (pos->epoll_state & MHD_EPOLL_STATE_READ_READY) ) ||
-               (MHD_EVENT_LOOP_INFO_WRITE == pos->request.event_loop_info &&
-                0 == (pos->epoll_state & MHD_EPOLL_STATE_WRITE_READY) ) ||
-               MHD_EVENT_LOOP_INFO_CLEANUP == pos->request.event_loop_info)
-            {
-              EDLL_remove (daemon->eready_head,
-                           daemon->eready_tail,
-                           pos);
-              pos->epoll_state &= ~MHD_EPOLL_STATE_IN_EREADY_EDLL;
-            }
-        }
+      if ( ((MHD_EVENT_LOOP_INFO_READ == pos->request.event_loop_info) &&
+            (0 == (pos->epoll_state & MHD_EPOLL_STATE_READ_READY)) ) ||
+           ((MHD_EVENT_LOOP_INFO_WRITE == pos->request.event_loop_info) &&
+            (0 == (pos->epoll_state & MHD_EPOLL_STATE_WRITE_READY)) ) ||
+           (MHD_EVENT_LOOP_INFO_CLEANUP == pos->request.event_loop_info) )
+      {
+        EDLL_remove (daemon->eready_head,
+                     daemon->eready_tail,
+                     pos);
+        pos->epoll_state &= ~MHD_EPOLL_STATE_IN_EREADY_EDLL;
+      }
     }
+  }
 
   /* Finally, handle timed-out connections; we need to do this here
      as the epoll mechanism won't call the 'MHD_request_handle_idle_()' on everything,
@@ -486,22 +491,22 @@ MHD_daemon_epoll_ (struct MHD_Daemon *daemon,
      do not bother to sort that (presumably very short) list. */
   prev = daemon->manual_timeout_tail;
   while (NULL != (pos = prev))
-    {
-      prev = pos->prevX;
-      MHD_request_handle_idle_ (&pos->request);
-    }
+  {
+    prev = pos->prevX;
+    MHD_request_handle_idle_ (&pos->request);
+  }
   /* Connections with the default timeout are sorted by prepending
      them to the head of the list whenever we touch the connection;
      thus it suffices to iterate from the tail until the first
      connection is NOT timed out */
   prev = daemon->normal_timeout_tail;
   while (NULL != (pos = prev))
-    {
-      prev = pos->prevX;
-      MHD_request_handle_idle_ (&pos->request);
-      if (MHD_REQUEST_CLOSED != pos->request.state)
-        break; /* sorted by timeout, no need to visit the rest! */
-    }
+  {
+    prev = pos->prevX;
+    MHD_request_handle_idle_ (&pos->request);
+    if (MHD_REQUEST_CLOSED != pos->request.state)
+      break; /* sorted by timeout, no need to visit the rest! */
+  }
   return MHD_SC_OK;
 }
 #endif
diff --git a/src/lib/daemon_epoll.h b/src/lib/daemon_epoll.h
index 50452d8d..37d0e423 100644
--- a/src/lib/daemon_epoll.h
+++ b/src/lib/daemon_epoll.h
@@ -38,8 +38,8 @@
  */
 enum MHD_StatusCode
 MHD_daemon_epoll_ (struct MHD_Daemon *daemon,
-                   bool may_block)
-  MHD_NONNULL (1);
+                   bool may_block)
+MHD_NONNULL (1);
 
 #endif
 
diff --git a/src/lib/daemon_get_timeout.c b/src/lib/daemon_get_timeout.c
index fcf3ecbc..604c52e2 100644
--- a/src/lib/daemon_get_timeout.c
+++ b/src/lib/daemon_get_timeout.c
@@ -46,7 +46,7 @@
  */
 enum MHD_StatusCode
 MHD_daemon_get_timeout (struct MHD_Daemon *daemon,
-                        MHD_UNSIGNED_LONG_LONG *timeout)
+                        MHD_UNSIGNED_LONG_LONG *timeout)
 {
   time_t earliest_deadline;
   time_t now;
@@ -54,71 +54,71 @@ MHD_daemon_get_timeout (struct MHD_Daemon *daemon,
   bool have_timeout;
 
   if (MHD_TM_EXTERNAL_EVENT_LOOP != daemon->threading_mode)
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_CONFIGURATION_MISMATCH_FOR_GET_TIMEOUT,
-                _("Illegal call to MHD_get_timeout\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_CONFIGURATION_MISMATCH_FOR_GET_TIMEOUT,
+              _ ("Illegal call to MHD_get_timeout\n"));
 #endif
-      return MHD_SC_CONFIGURATION_MISSMATCH_FOR_GET_TIMEOUT;
-    }
+    return MHD_SC_CONFIGURATION_MISSMATCH_FOR_GET_TIMEOUT;
+  }
 
   if (daemon->data_already_pending)
-    {
-      /* Some data already waiting to be processed. */
-      *timeout = 0;
-      return MHD_SC_OK;
-    }
+  {
+    /* Some data already waiting to be processed. */
+    *timeout = 0;
+    return MHD_SC_OK;
+  }
 
 #ifdef EPOLL_SUPPORT
   if ( (MHD_ELS_EPOLL == daemon->event_loop_syscall) &&
        ((NULL != daemon->eready_head)
 #if defined(UPGRADE_SUPPORT) && defined(HTTPS_SUPPORT)
-         || (NULL != daemon->eready_urh_head)
+        || (NULL != daemon->eready_urh_head)
 #endif /* UPGRADE_SUPPORT && HTTPS_SUPPORT */
-         ) )
-    {
-          /* Some connection(s) already have some data pending. */
-      *timeout = 0;
-      return MHD_SC_OK;
-    }
+       ) )
+  {
+    /* Some connection(s) already have some data pending. */
+    *timeout = 0;
+    return MHD_SC_OK;
+  }
 #endif /* EPOLL_SUPPORT */
 
   have_timeout = false;
   earliest_deadline = 0; /* avoid compiler warnings */
   for (pos = daemon->manual_timeout_tail; NULL != pos; pos = pos->prevX)
+  {
+    if (0 != pos->connection_timeout)
     {
-      if (0 != pos->connection_timeout)
-        {
-          if ( (! have_timeout) ||
-               (earliest_deadline - pos->last_activity > pos->connection_timeout) )
-            earliest_deadline = pos->last_activity + pos->connection_timeout;
-          have_timeout = true;
-        }
+      if ( (! have_timeout) ||
+           (earliest_deadline - pos->last_activity > pos->connection_timeout) )
+        earliest_deadline = pos->last_activity + pos->connection_timeout;
+      have_timeout = true;
     }
+  }
   /* normal timeouts are sorted, so we only need to look at the 'tail' (oldest) */
   pos = daemon->normal_timeout_tail;
   if ( (NULL != pos) &&
        (0 != pos->connection_timeout) )
-    {
-      if ( (! have_timeout) ||
-           (earliest_deadline - pos->connection_timeout > pos->last_activity) )
-        earliest_deadline = pos->last_activity + pos->connection_timeout;
-      have_timeout = true;
-    }
+  {
+    if ( (! have_timeout) ||
+         (earliest_deadline - pos->connection_timeout > pos->last_activity) )
+      earliest_deadline = pos->last_activity + pos->connection_timeout;
+    have_timeout = true;
+  }
 
   if (! have_timeout)
     return MHD_SC_NO_TIMEOUT;
-  now = MHD_monotonic_sec_counter();
+  now = MHD_monotonic_sec_counter ();
   if (earliest_deadline < now)
     *timeout = 0;
   else
-    {
-      const time_t second_left = earliest_deadline - now;
-      if (second_left > ULLONG_MAX / 1000) /* Ignore compiler warning: 'second_left' is always positive. */
-        *timeout = ULLONG_MAX;
-      else
-        *timeout = 1000LL * second_left;
+  {
+    const time_t second_left = earliest_deadline - now;
+    if (second_left > ULLONG_MAX / 1000)   /* Ignore compiler warning: 'second_left' is always positive. */
+      *timeout = ULLONG_MAX;
+    else
+      *timeout = 1000LL * second_left;
   }
   return MHD_SC_OK;
 }
diff --git a/src/lib/daemon_info.c b/src/lib/daemon_info.c
index b0c5ec14..d32f244b 100644
--- a/src/lib/daemon_info.c
+++ b/src/lib/daemon_info.c
@@ -43,62 +43,62 @@
  */
 enum MHD_Bool
 MHD_daemon_get_information_sz (struct MHD_Daemon *daemon,
-                               enum MHD_DaemonInformationType info_type,
-                               union MHD_DaemonInformation *return_value,
-                               size_t return_value_size)
+                               enum MHD_DaemonInformationType info_type,
+                               union MHD_DaemonInformation *return_value,
+                               size_t return_value_size)
 {
-#define CHECK_SIZE(type) if (sizeof(type) < return_value_size)  \
+#define CHECK_SIZE(type) if (sizeof(type) < return_value_size)  \
     return MHD_NO
 
   switch (info_type)
-    {
-    case MHD_DAEMON_INFORMATION_LISTEN_SOCKET:
-      CHECK_SIZE (MHD_socket);
-      return_value->listen_socket
-        = daemon->listen_socket;
-      return MHD_YES;
+  {
+  case MHD_DAEMON_INFORMATION_LISTEN_SOCKET:
+    CHECK_SIZE (MHD_socket);
+    return_value->listen_socket
+      = daemon->listen_socket;
+    return MHD_YES;
 #ifdef EPOLL_SUPPORT
-    case MHD_DAEMON_INFORMATION_EPOLL_FD:
-      CHECK_SIZE (int);
-      // FIXME: maybe return MHD_NO if we are not using EPOLL?
-      return_value->epoll_fd = daemon->epoll_fd;
-      return MHD_YES;
+  case MHD_DAEMON_INFORMATION_EPOLL_FD:
+    CHECK_SIZE (int);
+    // FIXME: maybe return MHD_NO if we are not using EPOLL?
+    return_value->epoll_fd = daemon->epoll_fd;
+    return MHD_YES;
 #endif
-    case MHD_DAEMON_INFORMATION_CURRENT_CONNECTIONS:
-      CHECK_SIZE (unsigned int);
-      if (MHD_TM_EXTERNAL_EVENT_LOOP == daemon->threading_mode)
-        {
-          /* Assumes that MHD_run() in not called in other thread
-             (of the application) at the same time. */
-          MHD_connection_cleanup_ (daemon);
-          return_value->num_connections
-            = daemon->connections;
-        }
-      else if (daemon->worker_pool)
-        {
-          unsigned int i;
-          /* Collect the connection information stored in the workers. */
-          return_value->num_connections = 0;
-          for (i = 0; i < daemon->worker_pool_size; i++)
-            {
-              /* FIXME: next line is thread-safe only if read is atomic. */
-              return_value->num_connections
-                += daemon->worker_pool[i].connections;
-            }
-        }
-      else
-        return_value->num_connections
-          = daemon->connections;
-      return MHD_YES;
-    case MHD_DAEMON_INFORMATION_BIND_PORT:
-      CHECK_SIZE (uint16_t);
-      // FIXME: return MHD_NO if port is not known/UNIX?
-      return_value->port = daemon->listen_port;
-      return MHD_YES;
-    default:
-      return MHD_NO;
+  case MHD_DAEMON_INFORMATION_CURRENT_CONNECTIONS:
+    CHECK_SIZE (unsigned int);
+    if (MHD_TM_EXTERNAL_EVENT_LOOP == daemon->threading_mode)
+    {
+      /* Assumes that MHD_run() in not called in other thread
+   (of the application) at the same time. */
+      MHD_connection_cleanup_ (daemon);
+      return_value->num_connections
+        = daemon->connections;
     }
-  
+    else if (daemon->worker_pool)
+    {
+      unsigned int i;
+      /* Collect the connection information stored in the workers. */
+      return_value->num_connections = 0;
+      for (i = 0; i < daemon->worker_pool_size; i++)
+      {
+        /* FIXME: next line is thread-safe only if read is atomic. */
+        return_value->num_connections
+          += daemon->worker_pool[i].connections;
+      }
+    }
+    else
+      return_value->num_connections
+        = daemon->connections;
+    return MHD_YES;
+  case MHD_DAEMON_INFORMATION_BIND_PORT:
+    CHECK_SIZE (uint16_t);
+    // FIXME: return MHD_NO if port is not known/UNIX?
+    return_value->port = daemon->listen_port;
+    return MHD_YES;
+  default:
+    return MHD_NO;
+  }
+
 #undef CHECK_SIZE
 }
 
diff --git a/src/lib/daemon_ip_limit.c b/src/lib/daemon_ip_limit.c
index 4a131c92..21550265 100644
--- a/src/lib/daemon_ip_limit.c
+++ b/src/lib/daemon_ip_limit.c
@@ -89,7 +89,7 @@ get_master (struct MHD_Daemon *daemon)
 static void
 MHD_ip_count_lock (struct MHD_Daemon *daemon)
 {
-  MHD_mutex_lock_chk_(&daemon->per_ip_connection_mutex);
+  MHD_mutex_lock_chk_ (&daemon->per_ip_connection_mutex);
 }
 
 
@@ -101,7 +101,7 @@ MHD_ip_count_lock (struct MHD_Daemon *daemon)
 static void
 MHD_ip_count_unlock (struct MHD_Daemon *daemon)
 {
-  MHD_mutex_unlock_chk_(&daemon->per_ip_connection_mutex);
+  MHD_mutex_unlock_chk_ (&daemon->per_ip_connection_mutex);
 }
 
 
@@ -135,37 +135,37 @@ MHD_ip_addr_compare (const void *a1,
  */
 static int
 MHD_ip_addr_to_key (const struct sockaddr *addr,
-                    socklen_t addrlen,
-                    struct MHD_IPCount *key)
+                    socklen_t addrlen,
+                    struct MHD_IPCount *key)
 {
-  memset(key,
-         0,
-         sizeof(*key));
+  memset (key,
+          0,
+          sizeof(*key));
 
   /* IPv4 addresses */
   if (sizeof (struct sockaddr_in) == addrlen)
-    {
-      const struct sockaddr_in *addr4 = (const struct sockaddr_in*) addr;
+  {
+    const struct sockaddr_in *addr4 = (const struct sockaddr_in*) addr;
 
-      key->family = AF_INET;
-      memcpy (&key->addr.ipv4,
-              &addr4->sin_addr,
-              sizeof(addr4->sin_addr));
-      return MHD_YES;
-    }
+    key->family = AF_INET;
+    memcpy (&key->addr.ipv4,
+            &addr4->sin_addr,
+            sizeof(addr4->sin_addr));
+    return MHD_YES;
+  }
 
 #if HAVE_INET6
   /* IPv6 addresses */
   if (sizeof (struct sockaddr_in6) == addrlen)
-    {
-      const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6*) addr;
-
-      key->family = AF_INET6;
-      memcpy (&key->addr.ipv6,
-              &addr6->sin6_addr,
-              sizeof(addr6->sin6_addr));
-      return MHD_YES;
-    }
+  {
+    const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6*) addr;
+
+    key->family = AF_INET6;
+    memcpy (&key->addr.ipv6,
+            &addr6->sin6_addr,
+            sizeof(addr6->sin6_addr));
+    return MHD_YES;
+  }
 #endif
 
   /* Some other address */
@@ -186,8 +186,8 @@ MHD_ip_addr_to_key (const struct sockaddr *addr,
  */
 int
 MHD_ip_limit_add (struct MHD_Daemon *daemon,
-                  const struct sockaddr *addr,
-                  socklen_t addrlen)
+                  const struct sockaddr *addr,
+                  socklen_t addrlen)
 {
   struct MHD_IPCount *key;
   void **nodep;
@@ -206,31 +206,31 @@ MHD_ip_limit_add (struct MHD_Daemon *daemon,
   if (MHD_NO == MHD_ip_addr_to_key (addr,
                                     addrlen,
                                     key))
-    {
-      /* Allow unhandled address types through */
-      free (key);
-      return MHD_YES;
-    }
+  {
+    /* Allow unhandled address types through */
+    free (key);
+    return MHD_YES;
+  }
   MHD_ip_count_lock (daemon);
 
   /* Search for the IP address */
   if (NULL == (nodep = tsearch (key,
-                                &daemon->per_ip_connection_count,
-                                &MHD_ip_addr_compare)))
-    {
+                                &daemon->per_ip_connection_count,
+                                &MHD_ip_addr_compare)))
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_IP_COUNTER_FAILURE,
-                _("Failed to add IP connection count node\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_IP_COUNTER_FAILURE,
+              _ ("Failed to add IP connection count node\n"));
 #endif
-      MHD_ip_count_unlock (daemon);
-      free (key);
-      return MHD_NO;
-    }
+    MHD_ip_count_unlock (daemon);
+    free (key);
+    return MHD_NO;
+  }
   node = *nodep;
   /* If we got an existing node back, free the one we created */
   if (node != key)
-    free(key);
+    free (key);
   key = (struct MHD_IPCount *) node;
   /* Test if there is room for another connection; if so,
    * increment count */
@@ -253,8 +253,8 @@ MHD_ip_limit_add (struct MHD_Daemon *daemon,
  */
 void
 MHD_ip_limit_del (struct MHD_Daemon *daemon,
-                  const struct sockaddr *addr,
-                  socklen_t addrlen)
+                  const struct sockaddr *addr,
+                  socklen_t addrlen)
 {
   struct MHD_IPCount search_key;
   struct MHD_IPCount *found_key;
@@ -274,27 +274,27 @@ MHD_ip_limit_del (struct MHD_Daemon *daemon,
 
   /* Search for the IP address */
   if (NULL == (nodep = tfind (&search_key,
-                              &daemon->per_ip_connection_count,
-                              &MHD_ip_addr_compare)))
-    {
-      /* Something's wrong if we couldn't find an IP address
-       * that was previously added */
-      MHD_PANIC (_("Failed to find previously-added IP address\n"));
-    }
+                              &daemon->per_ip_connection_count,
+                              &MHD_ip_addr_compare)))
+  {
+    /* Something's wrong if we couldn't find an IP address
+     * that was previously added */
+    MHD_PANIC (_ ("Failed to find previously-added IP address\n"));
+  }
   found_key = (struct MHD_IPCount *) *nodep;
   /* Validate existing count for IP address */
   if (0 == found_key->count)
-    {
-      MHD_PANIC (_("Previously-added IP address had counter of zero\n"));
-    }
+  {
+    MHD_PANIC (_ ("Previously-added IP address had counter of zero\n"));
+  }
   /* Remove the node entirely if count reduces to 0 */
   if (0 == --found_key->count)
-    {
-      tdelete (found_key,
-               &daemon->per_ip_connection_count,
-               &MHD_ip_addr_compare);
-      free (found_key);
-    }
+  {
+    tdelete (found_key,
+             &daemon->per_ip_connection_count,
+             &MHD_ip_addr_compare);
+    free (found_key);
+  }
 
   MHD_ip_count_unlock (daemon);
 }
diff --git a/src/lib/daemon_ip_limit.h b/src/lib/daemon_ip_limit.h
index 5f22db05..9c587825 100644
--- a/src/lib/daemon_ip_limit.h
+++ b/src/lib/daemon_ip_limit.h
@@ -38,9 +38,9 @@
  */
 int
 MHD_ip_limit_add (struct MHD_Daemon *daemon,
-                  const struct sockaddr *addr,
-                  socklen_t addrlen)
-  MHD_NONNULL (1,2);
+                  const struct sockaddr *addr,
+                  socklen_t addrlen)
+MHD_NONNULL (1,2);
 
 
 /**
@@ -53,8 +53,8 @@ MHD_ip_limit_add (struct MHD_Daemon *daemon,
  */
 void
 MHD_ip_limit_del (struct MHD_Daemon *daemon,
-                  const struct sockaddr *addr,
-                  socklen_t addrlen)
-  MHD_NONNULL (1,2);
+                  const struct sockaddr *addr,
+                  socklen_t addrlen)
+MHD_NONNULL (1,2);
 
 #endif
diff --git a/src/lib/daemon_options.c b/src/lib/daemon_options.c
index 4d7bbdf1..04c9cb2f 100644
--- a/src/lib/daemon_options.c
+++ b/src/lib/daemon_options.c
@@ -38,8 +38,8 @@
  */
 void
 MHD_daemon_set_logger (struct MHD_Daemon *daemon,
-                       MHD_LoggingCallback logger,
-                       void *logger_cls)
+                       MHD_LoggingCallback logger,
+                       void *logger_cls)
 {
   daemon->logger = logger;
   daemon->logger_cls = logger_cls;
@@ -148,8 +148,8 @@ MHD_daemon_disallow_upgrade (struct MHD_Daemon *daemon)
  */
 enum MHD_Bool
 MHD_daemon_tcp_fastopen (struct MHD_Daemon *daemon,
-                         enum MHD_FastOpenMethod fom,
-                         unsigned int queue_length)
+                         enum MHD_FastOpenMethod fom,
+                         unsigned int queue_length)
 {
   daemon->fast_open_method = fom;
   daemon->fo_queue_length = queue_length;
@@ -185,8 +185,8 @@ MHD_daemon_tcp_fastopen (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_bind_port (struct MHD_Daemon *daemon,
-                      enum MHD_AddressFamily af,
-                      uint16_t port)
+                      enum MHD_AddressFamily af,
+                      uint16_t port)
 {
   daemon->listen_af = af;
   daemon->listen_port = port;
@@ -204,12 +204,12 @@ MHD_daemon_bind_port (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_bind_socket_address (struct MHD_Daemon *daemon,
-                                const struct sockaddr *sa,
-                                size_t sa_len)
+                                const struct sockaddr *sa,
+                                size_t sa_len)
 {
   memcpy (&daemon->listen_sa,
-          sa,
-          sa_len);
+          sa,
+          sa_len);
   daemon->listen_sa_len = sa_len;
 }
 
@@ -223,7 +223,7 @@ MHD_daemon_bind_socket_address (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_listen_backlog (struct MHD_Daemon *daemon,
-                           int listen_backlog)
+                           int listen_backlog)
 {
   daemon->listen_backlog = listen_backlog;
 }
@@ -275,7 +275,7 @@ MHD_daemon_enable_shoutcast (struct MHD_Daemon *daemon)
  */
 void
 MHD_daemon_listen_socket (struct MHD_Daemon *daemon,
-                          MHD_socket listen_socket)
+                          MHD_socket listen_socket)
 {
   daemon->listen_socket = listen_socket;
 }
@@ -290,7 +290,7 @@ MHD_daemon_listen_socket (struct MHD_Daemon *daemon,
  */
 enum MHD_Bool
 MHD_daemon_event_loop (struct MHD_Daemon *daemon,
-                       enum MHD_EventLoopSyscall els)
+                       enum MHD_EventLoopSyscall els)
 {
   switch (els)
   {
@@ -326,7 +326,7 @@ MHD_daemon_event_loop (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_protocol_strict_level (struct MHD_Daemon *daemon,
-                                  enum MHD_ProtocolStrictLevel sl)
+                                  enum MHD_ProtocolStrictLevel sl)
 {
   daemon->protocol_strict_level = sl;
 }
@@ -349,8 +349,8 @@ MHD_daemon_protocol_strict_level (struct MHD_Daemon *daemon,
  */
 enum MHD_StatusCode
 MHD_daemon_set_tls_backend (struct MHD_Daemon *daemon,
-                            const char *tls_backend,
-                            const char *ciphers)
+                            const char *tls_backend,
+                            const char *ciphers)
 {
 #if ! (defined(HTTPS_SUPPORT) && defined (HAVE_DLFCN_H))
   return MHD_SC_TLS_DISABLED;
@@ -361,18 +361,18 @@ MHD_daemon_set_tls_backend (struct MHD_Daemon *daemon,
 
   /* todo: .dll on W32? */
   res = MHD_snprintf_ (filename,
-                       sizeof (filename),
-                       "%s/libmicrohttpd_tls_%s.so",
-                       MHD_PLUGIN_INSTALL_PREFIX,
-                       tls_backend);
+                       sizeof (filename),
+                       "%s/libmicrohttpd_tls_%s.so",
+                       MHD_PLUGIN_INSTALL_PREFIX,
+                       tls_backend);
   if (0 >= res)
     return MHD_SC_TLS_BACKEND_UNSUPPORTED; /* string too long? */
   if (NULL ==
       (daemon->tls_backend_lib = dlopen (filename,
-                                         RTLD_NOW | RTLD_LOCAL)))
+                                         RTLD_NOW | RTLD_LOCAL)))
     return MHD_SC_TLS_BACKEND_UNSUPPORTED; /* plugin not found */
   if (NULL == (init = dlsym (daemon->tls_backend_lib,
-                             "MHD_TLS_init_" MHD_TLS_ABI_VERSION_STR)))
+                             "MHD_TLS_init_" MHD_TLS_ABI_VERSION_STR)))
 
   {
     dlclose (daemon->tls_backend_lib);
@@ -405,9 +405,9 @@ MHD_daemon_set_tls_backend (struct MHD_Daemon *daemon,
  */
 enum MHD_StatusCode
 MHD_daemon_tls_key_and_cert_from_memory (struct MHD_Daemon *daemon,
-                                         const char *mem_key,
-                                         const char *mem_cert,
-                                         const char *pass)
+                                         const char *mem_key,
+                                         const char *mem_cert,
+                                         const char *pass)
 {
 #ifndef HTTPS_SUPPORT
   return MHD_SC_TLS_DISABLED;
@@ -417,9 +417,9 @@ MHD_daemon_tls_key_and_cert_from_memory (struct MHD_Daemon *daemon,
   if (NULL == (plugin = daemon->tls_api))
     return MHD_SC_TLS_BACKEND_UNINITIALIZED;
   return plugin->init_kcp (plugin->cls,
-                           mem_key,
-                           mem_cert,
-                           pass);
+                           mem_key,
+                           mem_cert,
+                           pass);
 #endif
 }
 
@@ -435,7 +435,7 @@ MHD_daemon_tls_key_and_cert_from_memory (struct MHD_Daemon *daemon,
  */
 enum MHD_StatusCode
 MHD_daemon_tls_mem_dhparams (struct MHD_Daemon *daemon,
-                             const char *dh)
+                             const char *dh)
 {
 #ifndef HTTPS_SUPPORT
   return MHD_SC_TLS_DISABLED;
@@ -445,7 +445,7 @@ MHD_daemon_tls_mem_dhparams (struct MHD_Daemon *daemon,
   if (NULL == (plugin = daemon->tls_api))
     return MHD_SC_TLS_BACKEND_UNINITIALIZED;
   return plugin->init_dhparams (plugin->cls,
-                                dh);
+                                dh);
 #endif
 }
 
@@ -461,7 +461,7 @@ MHD_daemon_tls_mem_dhparams (struct MHD_Daemon *daemon,
  */
 enum MHD_StatusCode
 MHD_daemon_tls_mem_trust (struct MHD_Daemon *daemon,
-                          const char *mem_trust)
+                          const char *mem_trust)
 {
 #ifndef HTTPS_SUPPORT
   return MHD_SC_TLS_DISABLED;
@@ -471,7 +471,7 @@ MHD_daemon_tls_mem_trust (struct MHD_Daemon *daemon,
   if (NULL == (plugin = daemon->tls_api))
     return MHD_SC_TLS_BACKEND_UNINITIALIZED;
   return plugin->init_mem_trust (plugin->cls,
-                                 mem_trust);
+                                 mem_trust);
 #endif
 }
 
@@ -485,7 +485,7 @@ MHD_daemon_tls_mem_trust (struct MHD_Daemon *daemon,
  */
 enum MHD_StatusCode
 MHD_daemon_gnutls_credentials (struct MHD_Daemon *daemon,
-                               int gnutls_credentials)
+                               int gnutls_credentials)
 {
 #ifndef HTTPS_SUPPORT
   return MHD_SC_TLS_DISABLED;
@@ -518,7 +518,7 @@ MHD_daemon_gnutls_credentials (struct MHD_Daemon *daemon,
  */
 enum MHD_StatusCode
 MHD_daemon_gnutls_key_and_cert_from_callback (struct MHD_Daemon *daemon,
-                                              void *cb)
+                                              void *cb)
 {
 #ifndef HTTPS_SUPPORT
   return MHD_SC_TLS_DISABLED;
@@ -541,7 +541,7 @@ MHD_daemon_gnutls_key_and_cert_from_callback (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_threading_mode (struct MHD_Daemon *daemon,
-                            enum MHD_ThreadingMode tm)
+                           enum MHD_ThreadingMode tm)
 {
   daemon->threading_mode = tm;
 }
@@ -558,8 +558,8 @@ MHD_daemon_threading_mode (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_accept_policy (struct MHD_Daemon *daemon,
-                          MHD_AcceptPolicyCallback apc,
-                          void *apc_cls)
+                          MHD_AcceptPolicyCallback apc,
+                          void *apc_cls)
 {
   daemon->accept_policy_cb = apc;
   daemon->accept_policy_cb_cls = apc_cls;
@@ -577,8 +577,8 @@ MHD_daemon_accept_policy (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_set_early_uri_logger (struct MHD_Daemon *daemon,
-                                 MHD_EarlyUriLogCallback cb,
-                                 void *cb_cls)
+                                 MHD_EarlyUriLogCallback cb,
+                                 void *cb_cls)
 {
   daemon->early_uri_logger_cb = cb;
   daemon->early_uri_logger_cb_cls = cb_cls;
@@ -595,8 +595,8 @@ MHD_daemon_set_early_uri_logger (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_set_notify_connection (struct MHD_Daemon *daemon,
-                                  MHD_NotifyConnectionCallback ncc,
-                                  void *ncc_cls)
+                                  MHD_NotifyConnectionCallback ncc,
+                                  void *ncc_cls)
 {
   daemon->notify_connection_cb = ncc;
   daemon->notify_connection_cb_cls = ncc_cls;
@@ -616,8 +616,8 @@ MHD_daemon_set_notify_connection (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_connection_memory_limit (struct MHD_Daemon *daemon,
-                                    size_t memory_limit_b,
-                                    size_t memory_increment_b)
+                                    size_t memory_limit_b,
+                                    size_t memory_increment_b)
 {
   if (memory_increment_b >= memory_limit_b)
     MHD_PANIC ("sane memory increment must be below memory limit");
@@ -636,7 +636,7 @@ MHD_daemon_connection_memory_limit (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_thread_stack_size (struct MHD_Daemon *daemon,
-                              size_t stack_limit_b)
+                              size_t stack_limit_b)
 {
   daemon->thread_stack_limit_b = stack_limit_b;
 }
@@ -659,8 +659,8 @@ MHD_daemon_thread_stack_size (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_connection_limits (struct MHD_Daemon *daemon,
-                              unsigned int global_connection_limit,
-                              unsigned int ip_connection_limit)
+                              unsigned int global_connection_limit,
+                              unsigned int ip_connection_limit)
 {
   daemon->global_connection_limit = global_connection_limit;
   daemon->ip_connection_limit = ip_connection_limit;
@@ -677,7 +677,7 @@ MHD_daemon_connection_limits (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_connection_default_timeout (struct MHD_Daemon *daemon,
-                                       unsigned int timeout_s)
+                                       unsigned int timeout_s)
 {
   daemon->connection_default_timeout = (time_t) timeout_s;
 }
@@ -696,8 +696,8 @@ MHD_daemon_connection_default_timeout (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_unescape_cb (struct MHD_Daemon *daemon,
-                        MHD_UnescapeCallback unescape_cb,
-                        void *unescape_cb_cls)
+                        MHD_UnescapeCallback unescape_cb,
+                        void *unescape_cb_cls)
 {
   daemon->unescape_cb = unescape_cb;
   daemon->unescape_cb_cls = unescape_cb_cls;
@@ -715,8 +715,8 @@ MHD_daemon_unescape_cb (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_digest_auth_random (struct MHD_Daemon *daemon,
-                               size_t buf_size,
-                               const void *buf)
+                               size_t buf_size,
+                               const void *buf)
 {
 #if ENABLE_DAUTH
   daemon->digest_auth_random_buf = buf;
@@ -739,34 +739,34 @@ MHD_daemon_digest_auth_random (struct MHD_Daemon *daemon,
  */
 enum MHD_StatusCode
 MHD_daemon_digest_auth_nc_length (struct MHD_Daemon *daemon,
-                                  size_t nc_length)
+                                  size_t nc_length)
 {
 #if ENABLE_DAUTH
-  if ( ( (size_t) (nc_length * sizeof (struct MHD_NonceNc))) /
-       sizeof (struct MHD_NonceNc) != nc_length)
-    {
+  if ( ( (size_t) (nc_length * sizeof (struct MHD_NonceNc)))
+       / sizeof (struct MHD_NonceNc) != nc_length)
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                _("Specified value for NC_SIZE too large\n"));
+    MHD_DLOG (daemon,
+              _ ("Specified value for NC_SIZE too large\n"));
 #endif
-      return MHD_SC_DIGEST_AUTH_NC_LENGTH_TOO_BIG;
-    }
+    return MHD_SC_DIGEST_AUTH_NC_LENGTH_TOO_BIG;
+  }
   if (0 < nc_length)
+  {
+    if (NULL != daemon->nnc)
+      free (daemon->nnc);
+    daemon->nnc = malloc (daemon->nonce_nc_size
+                          * sizeof (struct MHD_NonceNc));
+    if (NULL == daemon->nnc)
     {
-      if (NULL != daemon->nnc)
-        free (daemon->nnc);
-      daemon->nnc = malloc (daemon->nonce_nc_size *
-                            sizeof (struct MHD_NonceNc));
-      if (NULL == daemon->nnc)
-        {
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    _("Failed to allocate memory for nonce-nc map: %s\n"),
-                    MHD_strerror_ (errno));
+      MHD_DLOG (daemon,
+                _ ("Failed to allocate memory for nonce-nc map: %s\n"),
+                MHD_strerror_ (errno));
 #endif
-          return MHD_SC_DIGEST_AUTH_NC_ALLOCATION_FAILURE;
-        }
+      return MHD_SC_DIGEST_AUTH_NC_ALLOCATION_FAILURE;
     }
+  }
   daemon->digest_nc_length = nc_length;
   return MHD_SC_OK;
 #else
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
diff --git a/src/lib/daemon_poll.h b/src/lib/daemon_poll.h
index fc5663b0..3c408620 100644
--- a/src/lib/daemon_poll.h
+++ b/src/lib/daemon_poll.h
@@ -37,8 +37,8 @@
  */
 enum MHD_StatusCode
 MHD_daemon_poll_all_ (struct MHD_Daemon *daemon,
-                      bool may_block)
-  MHD_NONNULL(1);
+                      bool may_block)
+MHD_NONNULL (1);
 
 
 /**
@@ -50,8 +50,8 @@ MHD_daemon_poll_all_ (struct MHD_Daemon *daemon,
  */
 enum MHD_StatusCode
 MHD_daemon_poll_listen_socket_ (struct MHD_Daemon *daemon,
-                                bool may_block)
-  MHD_NONNULL (1);
+                                bool may_block)
+MHD_NONNULL (1);
 
 
 /**
@@ -63,8 +63,8 @@ MHD_daemon_poll_listen_socket_ (struct MHD_Daemon *daemon,
  */
 enum MHD_StatusCode
 MHD_daemon_poll_ (struct MHD_Daemon *daemon,
-                  bool may_block)
-  MHD_NONNULL (1);
+                  bool may_block)
+MHD_NONNULL (1);
 #endif
 
 
@@ -78,7 +78,7 @@ MHD_daemon_poll_ (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_upgrade_connection_with_poll_ (struct MHD_Connection *con)
-  MHD_NONNULL(1);
+MHD_NONNULL (1);
 #endif
 #endif
 
diff --git a/src/lib/daemon_quiesce.c b/src/lib/daemon_quiesce.c
index 0d920608..c7275099 100644
--- a/src/lib/daemon_quiesce.c
+++ b/src/lib/daemon_quiesce.c
@@ -54,75 +54,76 @@ MHD_daemon_quiesce (struct MHD_Daemon *daemon)
     return MHD_INVALID_SOCKET;
   if ( (daemon->disable_itc) &&
        (MHD_TM_EXTERNAL_EVENT_LOOP != daemon->threading_mode) )
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_SYSCALL_QUIESCE_REQUIRES_ITC,
-                "Using MHD_quiesce_daemon in this mode requires ITC\n");
+    MHD_DLOG (daemon,
+              MHD_SC_SYSCALL_QUIESCE_REQUIRES_ITC,
+              "Using MHD_quiesce_daemon in this mode requires ITC\n");
 #endif
-      return MHD_INVALID_SOCKET;
-    }
+    return MHD_INVALID_SOCKET;
+  }
 
   if (NULL != daemon->worker_pool)
+  {
+    unsigned int i;
+
+    for (i = 0; i < daemon->worker_pool_size; i++)
     {
-      unsigned int i;
+      struct MHD_Daemon *worker = &daemon->worker_pool[i];
 
-      for (i = 0; i < daemon->worker_pool_size; i++)
-        {
-          struct MHD_Daemon *worker = &daemon->worker_pool[i];
-          
-          worker->was_quiesced = true;
-#ifdef EPOLL_SUPPORT
-          if ( (MHD_ELS_EPOLL == daemon->event_loop_syscall) &&
-               (-1 != worker->epoll_fd) &&
-               (worker->listen_socket_in_epoll) )
-            {
-              if (0 != epoll_ctl (worker->epoll_fd,
-                                  EPOLL_CTL_DEL,
-                                  listen_socket,
-                                  NULL))
-                MHD_PANIC (_("Failed to remove listen FD from epoll set\n"));
-              worker->listen_socket_in_epoll = false;
-            }
-          else
-#endif
-            if (MHD_ITC_IS_VALID_(worker->itc))
-              {
-                if (! MHD_itc_activate_ (worker->itc,
-                                         "q"))
-                  MHD_PANIC (_("Failed to signal quiesce via inter-thread communication channel"));
-              }
-        }
-      daemon->was_quiesced = true;
+      worker->was_quiesced = true;
 #ifdef EPOLL_SUPPORT
       if ( (MHD_ELS_EPOLL == daemon->event_loop_syscall) &&
-           (-1 != daemon->epoll_fd) &&
-           (daemon->listen_socket_in_epoll) )
-        {
-          if (0 != epoll_ctl (daemon->epoll_fd,
-                              EPOLL_CTL_DEL,
-                              listen_socket,
-                              NULL))
-            MHD_PANIC ("Failed to remove listen FD from epoll set\n");
-          daemon->listen_socket_in_epoll = false;
-        }
+           (-1 != worker->epoll_fd) &&
+           (worker->listen_socket_in_epoll) )
+      {
+        if (0 != epoll_ctl (worker->epoll_fd,
+                            EPOLL_CTL_DEL,
+                            listen_socket,
+                            NULL))
+          MHD_PANIC (_ ("Failed to remove listen FD from epoll set\n"));
+        worker->listen_socket_in_epoll = false;
+      }
+      else
 #endif
+      if (MHD_ITC_IS_VALID_ (worker->itc))
+      {
+        if (! MHD_itc_activate_ (worker->itc,
+                                 "q"))
+          MHD_PANIC (_ (
+                       "Failed to signal quiesce via inter-thread communication channel"));
+      }
     }
-  
-  if ( (MHD_ITC_IS_VALID_(daemon->itc)) &&
+    daemon->was_quiesced = true;
+#ifdef EPOLL_SUPPORT
+    if ( (MHD_ELS_EPOLL == daemon->event_loop_syscall) &&
+         (-1 != daemon->epoll_fd) &&
+         (daemon->listen_socket_in_epoll) )
+    {
+      if (0 != epoll_ctl (daemon->epoll_fd,
+                          EPOLL_CTL_DEL,
+                          listen_socket,
+                          NULL))
+        MHD_PANIC ("Failed to remove listen FD from epoll set\n");
+      daemon->listen_socket_in_epoll = false;
+    }
+#endif
+  }
+
+  if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
        (! MHD_itc_activate_ (daemon->itc,
-                             "q")) )
-    MHD_PANIC (_("Failed to signal quiesce via inter-thread communication channel"));
+                             "q")) )
+    MHD_PANIC (_ (
+                 "Failed to signal quiesce via inter-thread communication channel"));
 
   /* FIXME: we might want some bi-directional communication here
-     (in both the thread-pool and single-thread case!) 
+     (in both the thread-pool and single-thread case!)
      to be sure that the threads have stopped using the listen
      socket, otherwise there is still the possibility of a race
      between a thread accept()ing and the caller closing and
      re-binding the socket. */
-  
+
   return listen_socket;
 }
 
 /* end of daemon_quiesce.c */
-
diff --git a/src/lib/daemon_run.c b/src/lib/daemon_run.c
index 129f7efb..cae500da 100644
--- a/src/lib/daemon_run.c
+++ b/src/lib/daemon_run.c
@@ -57,26 +57,26 @@ MHD_daemon_run (struct MHD_Daemon *daemon)
   if (MHD_TM_EXTERNAL_EVENT_LOOP != daemon->threading_mode)
     return MHD_SC_CONFIGURATION_MISMATCH_FOR_RUN_EXTERNAL;
   switch (daemon->event_loop_syscall)
-    {
-    case MHD_ELS_POLL:
-      sc = MHD_daemon_poll_ (daemon,
-                             MHD_NO);
-      MHD_connection_cleanup_ (daemon);
-      return sc;
+  {
+  case MHD_ELS_POLL:
+    sc = MHD_daemon_poll_ (daemon,
+                           MHD_NO);
+    MHD_connection_cleanup_ (daemon);
+    return sc;
 #ifdef EPOLL_SUPPORT
-    case MHD_ELS_EPOLL:
-      sc = MHD_daemon_epoll_ (daemon,
-                              MHD_NO);
-      MHD_connection_cleanup_ (daemon);
-      return sc;
+  case MHD_ELS_EPOLL:
+    sc = MHD_daemon_epoll_ (daemon,
+                            MHD_NO);
+    MHD_connection_cleanup_ (daemon);
+    return sc;
 #endif
-    case MHD_ELS_SELECT:
-      return MHD_daemon_select_ (daemon,
-                                 MHD_NO);
-      /* MHD_select does MHD_connection_cleanup_ already */
-    default:
-      return MHD_SC_CONFIGURATION_UNEXPECTED_ELS;
-    }
+  case MHD_ELS_SELECT:
+    return MHD_daemon_select_ (daemon,
+                               MHD_NO);
+  /* MHD_select does MHD_connection_cleanup_ already */
+  default:
+    return MHD_SC_CONFIGURATION_UNEXPECTED_ELS;
+  }
 }
 
 /* end of daemon_run.c */
diff --git a/src/lib/daemon_select.c b/src/lib/daemon_select.c
index 08281d8c..69913a9a 100644
--- a/src/lib/daemon_select.c
+++ b/src/lib/daemon_select.c
@@ -66,17 +66,17 @@
  */
 enum MHD_StatusCode
 MHD_daemon_get_fdset (struct MHD_Daemon *daemon,
-                      fd_set *read_fd_set,
-                      fd_set *write_fd_set,
-                      fd_set *except_fd_set,
-                      MHD_socket *max_fd)
+                      fd_set *read_fd_set,
+                      fd_set *write_fd_set,
+                      fd_set *except_fd_set,
+                      MHD_socket *max_fd)
 {
   return MHD_daemon_get_fdset2 (daemon,
-                                read_fd_set,
-                                write_fd_set,
-                                except_fd_set,
-                                max_fd,
-                                _MHD_SYS_DEFAULT_FD_SETSIZE);
+                                read_fd_set,
+                                write_fd_set,
+                                except_fd_set,
+                                max_fd,
+                                _MHD_SYS_DEFAULT_FD_SETSIZE);
 }
 
 
@@ -108,55 +108,55 @@ urh_to_fdset (struct MHD_UpgradeResponseHandle *urh,
   /* Do not add to 'es' only if socket is closed
    * or not used anymore. */
   if (MHD_INVALID_SOCKET != conn_sckt)
-    {
-      if ( (urh->in_buffer_used < urh->in_buffer_size) &&
-           (! MHD_add_to_fd_set_ (conn_sckt,
-                                  rs,
-                                  max_fd,
-                                  fd_setsize)) )
-        res = false;
-      if ( (0 != urh->out_buffer_used) &&
-           (! MHD_add_to_fd_set_ (conn_sckt,
-                                  ws,
-                                  max_fd,
-                                  fd_setsize)) )
-        res = false;
-      /* 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)))
-        MHD_add_to_fd_set_ (conn_sckt,
-                            es,
-                            max_fd,
-                            fd_setsize);
-    }
+  {
+    if ( (urh->in_buffer_used < urh->in_buffer_size) &&
+         (! MHD_add_to_fd_set_ (conn_sckt,
+                                rs,
+                                max_fd,
+                                fd_setsize)) )
+      res = false;
+    if ( (0 != urh->out_buffer_used) &&
+         (! MHD_add_to_fd_set_ (conn_sckt,
+                                ws,
+                                max_fd,
+                                fd_setsize)) )
+      res = false;
+    /* 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)))
+      MHD_add_to_fd_set_ (conn_sckt,
+                          es,
+                          max_fd,
+                          fd_setsize);
+  }
   if (MHD_INVALID_SOCKET != mhd_sckt)
-    {
-      if ( (urh->out_buffer_used < urh->out_buffer_size) &&
-           (! MHD_add_to_fd_set_ (mhd_sckt,
-                                  rs,
-                                  max_fd,
-                                  fd_setsize)) )
-        res = false;
-      if ( (0 != urh->in_buffer_used) &&
-           (! MHD_add_to_fd_set_ (mhd_sckt,
-                                  ws,
-                                  max_fd,
-                                  fd_setsize)) )
-        res = false;
-      /* 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)))
-        MHD_add_to_fd_set_ (mhd_sckt,
-                            es,
-                            max_fd,
-                            fd_setsize);
-    }
+  {
+    if ( (urh->out_buffer_used < urh->out_buffer_size) &&
+         (! MHD_add_to_fd_set_ (mhd_sckt,
+                                rs,
+                                max_fd,
+                                fd_setsize)) )
+      res = false;
+    if ( (0 != urh->in_buffer_used) &&
+         (! MHD_add_to_fd_set_ (mhd_sckt,
+                                ws,
+                                max_fd,
+                                fd_setsize)) )
+      res = false;
+    /* 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)))
+      MHD_add_to_fd_set_ (mhd_sckt,
+                          es,
+                          max_fd,
+                          fd_setsize);
+  }
 
   return res;
 }
@@ -207,77 +207,77 @@ internal_get_fdset2 (struct MHD_Daemon *daemon,
    * or INFO_WRITE sockets will not fit 'except_fd_set'. */
   /* Start from oldest connections. Make sense for W32 FDSETs. */
   for (pos = daemon->connections_tail; NULL != pos; pos = posn)
+  {
+    posn = pos->prev;
+
+    switch (pos->request.event_loop_info)
     {
-      posn = pos->prev;
-
-      switch (pos->request.event_loop_info)
-        {
-        case MHD_EVENT_LOOP_INFO_READ:
-          if (! MHD_add_to_fd_set_ (pos->socket_fd,
-                                    read_fd_set,
-                                    max_fd,
-                                    fd_setsize))
-            result = MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
+    case MHD_EVENT_LOOP_INFO_READ:
+      if (! MHD_add_to_fd_set_ (pos->socket_fd,
+                                read_fd_set,
+                                max_fd,
+                                fd_setsize))
+        result = MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
 #ifdef MHD_POSIX_SOCKETS
-          MHD_add_to_fd_set_ (pos->socket_fd,
-                              except_fd_set,
-                              max_fd,
-                              fd_setsize);
+      MHD_add_to_fd_set_ (pos->socket_fd,
+                          except_fd_set,
+                          max_fd,
+                          fd_setsize);
 #endif /* MHD_POSIX_SOCKETS */
-          break;
-        case MHD_EVENT_LOOP_INFO_WRITE:
-          if (! MHD_add_to_fd_set_ (pos->socket_fd,
-                                    write_fd_set,
-                                    max_fd,
-                                    fd_setsize))
-            result = MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
+      break;
+    case MHD_EVENT_LOOP_INFO_WRITE:
+      if (! MHD_add_to_fd_set_ (pos->socket_fd,
+                                write_fd_set,
+                                max_fd,
+                                fd_setsize))
+        result = MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
 #ifdef MHD_POSIX_SOCKETS
-          MHD_add_to_fd_set_ (pos->socket_fd,
-                              except_fd_set,
-                              max_fd,
-                              fd_setsize);
+      MHD_add_to_fd_set_ (pos->socket_fd,
+                          except_fd_set,
+                          max_fd,
+                          fd_setsize);
 #endif /* MHD_POSIX_SOCKETS */
-          break;
-        case MHD_EVENT_LOOP_INFO_BLOCK:
-          if ( (NULL == except_fd_set) ||
-              ! MHD_add_to_fd_set_ (pos->socket_fd,
-                                    except_fd_set,
-                                    max_fd,
-                                    fd_setsize))
-            result = MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
-          break;
-        case MHD_EVENT_LOOP_INFO_CLEANUP:
-          /* this should never happen */
-          break;
-        }
+      break;
+    case MHD_EVENT_LOOP_INFO_BLOCK:
+      if ( (NULL == except_fd_set) ||
+           ! MHD_add_to_fd_set_ (pos->socket_fd,
+                                 except_fd_set,
+                                 max_fd,
+                                 fd_setsize))
+        result = MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
+      break;
+    case MHD_EVENT_LOOP_INFO_CLEANUP:
+      /* this should never happen */
+      break;
     }
+  }
 #ifdef MHD_WINSOCK_SOCKETS
   /* W32 use limited array for fd_set so add INFO_READ/INFO_WRITE sockets
    * only after INFO_BLOCK sockets to ensure that INFO_BLOCK sockets will
    * not be pushed out. */
   for (pos = daemon->connections_tail; NULL != pos; pos = posn)
-    {
-      posn = pos->prev;
-      MHD_add_to_fd_set_ (pos->socket_fd,
-                          except_fd_set,
-                          max_fd,
-                          fd_setsize);
-    }
+  {
+    posn = pos->prev;
+    MHD_add_to_fd_set_ (pos->socket_fd,
+                        except_fd_set,
+                        max_fd,
+                        fd_setsize);
+  }
 #endif /* MHD_WINSOCK_SOCKETS */
 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   {
     struct MHD_UpgradeResponseHandle *urh;
 
     for (urh = daemon->urh_tail; NULL != urh; urh = urh->prev)
-      {
-        if (! urh_to_fdset (urh,
-                            read_fd_set,
-                            write_fd_set,
-                            except_fd_set,
-                            max_fd,
-                            fd_setsize))
-          result = MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
-      }
+    {
+      if (! urh_to_fdset (urh,
+                          read_fd_set,
+                          write_fd_set,
+                          except_fd_set,
+                          max_fd,
+                          fd_setsize))
+        result = MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
+    }
   }
 #endif
   return result;
@@ -313,11 +313,11 @@ internal_get_fdset2 (struct MHD_Daemon *daemon,
  */
 enum MHD_StatusCode
 MHD_daemon_get_fdset2 (struct MHD_Daemon *daemon,
-                       fd_set *read_fd_set,
-                       fd_set *write_fd_set,
-                       fd_set *except_fd_set,
-                       MHD_socket *max_fd,
-                       unsigned int fd_setsize)
+                       fd_set *read_fd_set,
+                       fd_set *write_fd_set,
+                       fd_set *except_fd_set,
+                       MHD_socket *max_fd,
+                       unsigned int fd_setsize)
 {
   if ( (MHD_TM_EXTERNAL_EVENT_LOOP != daemon->threading_mode) ||
        (MHD_ELS_POLL == daemon->event_loop_syscall) )
@@ -325,28 +325,28 @@ MHD_daemon_get_fdset2 (struct MHD_Daemon *daemon,
 
 #ifdef EPOLL_SUPPORT
   if (MHD_ELS_EPOLL == daemon->event_loop_syscall)
-    {
-      if (daemon->shutdown)
-        return MHD_SC_DAEMON_ALREADY_SHUTDOWN;
-
-      /* we're in epoll mode, use the epoll FD as a stand-in for
-         the entire event set */
-
-      return MHD_add_to_fd_set_ (daemon->epoll_fd,
-                                 read_fd_set,
-                                 max_fd,
-                                 fd_setsize)
-        ? MHD_SC_OK
-        : MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
-    }
+  {
+    if (daemon->shutdown)
+      return MHD_SC_DAEMON_ALREADY_SHUTDOWN;
+
+    /* we're in epoll mode, use the epoll FD as a stand-in for
+       the entire event set */
+
+    return MHD_add_to_fd_set_ (daemon->epoll_fd,
+                               read_fd_set,
+                               max_fd,
+                               fd_setsize)
+           ? MHD_SC_OK
+           : MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
+  }
 #endif
 
   return internal_get_fdset2 (daemon,
-                              read_fd_set,
+                              read_fd_set,
                               write_fd_set,
-                              except_fd_set,
+                              except_fd_set,
                               max_fd,
-                              fd_setsize);
+                              fd_setsize);
 }
 
 
@@ -374,23 +374,23 @@ urh_from_fdset (struct MHD_UpgradeResponseHandle *urh,
   urh->mhd.celi &= (~MHD_EPOLL_STATE_READ_READY & ~MHD_EPOLL_STATE_WRITE_READY);
 
   if (MHD_INVALID_SOCKET != conn_sckt)
-    {
-      if (FD_ISSET (conn_sckt, rs))
-        urh->app.celi |= MHD_EPOLL_STATE_READ_READY;
-      if (FD_ISSET (conn_sckt, ws))
-        urh->app.celi |= MHD_EPOLL_STATE_WRITE_READY;
-      if (FD_ISSET (conn_sckt, es))
-        urh->app.celi |= MHD_EPOLL_STATE_ERROR;
-    }
+  {
+    if (FD_ISSET (conn_sckt, rs))
+      urh->app.celi |= MHD_EPOLL_STATE_READ_READY;
+    if (FD_ISSET (conn_sckt, ws))
+      urh->app.celi |= MHD_EPOLL_STATE_WRITE_READY;
+    if (FD_ISSET (conn_sckt, es))
+      urh->app.celi |= MHD_EPOLL_STATE_ERROR;
+  }
   if ((MHD_INVALID_SOCKET != mhd_sckt))
-    {
-      if (FD_ISSET (mhd_sckt, rs))
-        urh->mhd.celi |= MHD_EPOLL_STATE_READ_READY;
-      if (FD_ISSET (mhd_sckt, ws))
-        urh->mhd.celi |= MHD_EPOLL_STATE_WRITE_READY;
-      if (FD_ISSET (mhd_sckt, es))
-        urh->mhd.celi |= MHD_EPOLL_STATE_ERROR;
-    }
+  {
+    if (FD_ISSET (mhd_sckt, rs))
+      urh->mhd.celi |= MHD_EPOLL_STATE_READ_READY;
+    if (FD_ISSET (mhd_sckt, ws))
+      urh->mhd.celi |= MHD_EPOLL_STATE_WRITE_READY;
+    if (FD_ISSET (mhd_sckt, es))
+      urh->mhd.celi |= MHD_EPOLL_STATE_ERROR;
+  }
 }
 #endif
 
@@ -425,7 +425,7 @@ internal_run_from_select (struct MHD_Daemon *daemon,
   /* Clear ITC to avoid spinning select */
   /* Do it before any other processing so new signals
      will trigger select again and will be processed */
-  if ( (MHD_ITC_IS_VALID_(daemon->itc)) &&
+  if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
        (FD_ISSET (MHD_itc_r_fd_ (daemon->itc),
                   read_fd_set)) )
     MHD_itc_clear_ (daemon->itc);
@@ -438,49 +438,49 @@ internal_run_from_select (struct MHD_Daemon *daemon,
     (void) MHD_accept_connection_ (daemon);
 
   if (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_mode)
+  {
+    /* do not have a thread per connection, process all connections now */
+    prev = daemon->connections_tail;
+    while (NULL != (pos = prev))
     {
-      /* do not have a thread per connection, process all connections now */
-      prev = daemon->connections_tail;
-      while (NULL != (pos = prev))
-        {
-          prev = pos->prev;
-          ds = pos->socket_fd;
-          if (MHD_INVALID_SOCKET == ds)
-            continue;
-          MHD_connection_call_handlers_ (pos,
-                                         FD_ISSET (ds,
-                                                   read_fd_set),
-                                         FD_ISSET (ds,
-                                                   write_fd_set),
-                                         FD_ISSET (ds,
-                                                   except_fd_set));
-        }
+      prev = pos->prev;
+      ds = pos->socket_fd;
+      if (MHD_INVALID_SOCKET == ds)
+        continue;
+      MHD_connection_call_handlers_ (pos,
+                                     FD_ISSET (ds,
+                                               read_fd_set),
+                                     FD_ISSET (ds,
+                                               write_fd_set),
+                                     FD_ISSET (ds,
+                                               except_fd_set));
     }
+  }
 
 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   /* handle upgraded HTTPS connections */
   for (urh = daemon->urh_tail; NULL != urh; urh = urhn)
+  {
+    urhn = urh->prev;
+    /* update urh state based on select() output */
+    urh_from_fdset (urh,
+                    read_fd_set,
+                    write_fd_set,
+                    except_fd_set);
+    /* call generic forwarding function for passing data */
+    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) )
     {
-      urhn = urh->prev;
-      /* update urh state based on select() output */
-      urh_from_fdset (urh,
-                      read_fd_set,
-                      write_fd_set,
-                      except_fd_set);
-      /* call generic forwarding function for passing data */
-      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_ (urh->connection);
-          urh->clean_ready = true;
-          /* Resuming will move connection to cleanup list. */
-          MHD_request_resume (&urh->connection->request);
-        }
+      MHD_connection_finish_forward_ (urh->connection);
+      urh->clean_ready = true;
+      /* Resuming will move connection to cleanup list. */
+      MHD_request_resume (&urh->connection->request);
     }
+  }
 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   MHD_connection_cleanup_ (daemon);
   return MHD_SC_OK;
@@ -500,80 +500,80 @@ MHD_daemon_upgrade_connection_with_select_ (struct MHD_Connection *con)
   struct MHD_UpgradeResponseHandle *urh = con->request.urh;
 
   while ( (0 != urh->in_buffer_size) ||
-          (0 != urh->out_buffer_size) ||
-          (0 != urh->in_buffer_used) ||
-          (0 != urh->out_buffer_used) )
+          (0 != urh->out_buffer_size) ||
+          (0 != urh->in_buffer_used) ||
+          (0 != urh->out_buffer_used) )
+  {
+    /* use select */
+    fd_set rs;
+    fd_set ws;
+    fd_set es;
+    MHD_socket max_fd;
+    int num_ready;
+    bool result;
+
+    FD_ZERO (&rs);
+    FD_ZERO (&ws);
+    FD_ZERO (&es);
+    max_fd = MHD_INVALID_SOCKET;
+    result = urh_to_fdset (urh,
+                           &rs,
+                           &ws,
+                           &es,
+                           &max_fd,
+                           FD_SETSIZE);
+    if (! result)
     {
-      /* use select */
-      fd_set rs;
-      fd_set ws;
-      fd_set es;
-      MHD_socket max_fd;
-      int num_ready;
-      bool result;
-
-      FD_ZERO (&rs);
-      FD_ZERO (&ws);
-      FD_ZERO (&es);
-      max_fd = MHD_INVALID_SOCKET;
-      result = urh_to_fdset (urh,
-                             &rs,
-                             &ws,
-                             &es,
-                             &max_fd,
-                             FD_SETSIZE);
-      if (! result)
-        {
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (con->daemon,
-                    MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE,
-                    _("Error preparing select\n"));
+      MHD_DLOG (con->daemon,
+                MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE,
+                _ ("Error preparing select\n"));
 #endif
-          break;
-        }
-      /* FIXME: does this check really needed? */
-      if (MHD_INVALID_SOCKET != max_fd)
-        {
-          struct timeval* tvp;
-          struct timeval tv;
-          if ( (con->tls_read_ready) &&
-               (urh->in_buffer_used < urh->in_buffer_size))
-            { /* No need to wait if incoming data is already pending in TLS buffers. */
-              tv.tv_sec = 0;
-              tv.tv_usec = 0;
-              tvp = &tv;
-            }
-          else
-            tvp = NULL;
-          num_ready = MHD_SYS_select_ (max_fd + 1,
-                                       &rs,
-                                       &ws,
-                                       &es,
-                                       tvp);
-        }
+      break;
+    }
+    /* FIXME: does this check really needed? */
+    if (MHD_INVALID_SOCKET != max_fd)
+    {
+      struct timeval*tvp;
+      struct timeval tv;
+      if ( (con->tls_read_ready) &&
+           (urh->in_buffer_used < urh->in_buffer_size))
+      { /* No need to wait if incoming data is already pending in TLS buffers. */
+        tv.tv_sec = 0;
+        tv.tv_usec = 0;
+        tvp = &tv;
+      }
       else
-        num_ready = 0;
-      if (num_ready < 0)
-        {
-          const int err = MHD_socket_get_error_();
+        tvp = NULL;
+      num_ready = MHD_SYS_select_ (max_fd + 1,
+                                   &rs,
+                                   &ws,
+                                   &es,
+                                   tvp);
+    }
+    else
+      num_ready = 0;
+    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;
-        }
-      urh_from_fdset (urh,
-                      &rs,
-                      &ws,
-                      &es);
-      MHD_upgrade_response_handle_process_ (urh);
+      break;
     }
+    urh_from_fdset (urh,
+                    &rs,
+                    &ws,
+                    &es);
+    MHD_upgrade_response_handle_process_ (urh);
+  }
 }
 #endif
 
@@ -602,37 +602,37 @@ MHD_daemon_upgrade_connection_with_select_ (struct MHD_Connection *con)
  */
 enum MHD_StatusCode
 MHD_daemon_run_from_select (struct MHD_Daemon *daemon,
-                            const fd_set *read_fd_set,
+                            const fd_set *read_fd_set,
 
 
-                            const fd_set *write_fd_set,
-                            const fd_set *except_fd_set)
+                            const fd_set *write_fd_set,
+                            const fd_set *except_fd_set)
 {
   if ( (MHD_TM_EXTERNAL_EVENT_LOOP != daemon->threading_mode) ||
        (MHD_ELS_POLL == daemon->event_loop_syscall) )
     return MHD_SC_CONFIGURATION_MISSMATCH_FOR_RUN_SELECT;
   if (MHD_ELS_EPOLL == daemon->event_loop_syscall)
-    {
+  {
 #ifdef EPOLL_SUPPORT
-      enum MHD_StatusCode sc;
+    enum MHD_StatusCode sc;
 
-      sc = MHD_daemon_epoll_ (daemon,
-                              MHD_NO);
-      MHD_connection_cleanup_ (daemon);
-      return sc;
+    sc = MHD_daemon_epoll_ (daemon,
+                            MHD_NO);
+    MHD_connection_cleanup_ (daemon);
+    return sc;
 #else  /* ! EPOLL_SUPPORT */
-      return MHD_NO;
+    return MHD_NO;
 #endif /* ! EPOLL_SUPPORT */
-    }
+  }
 
   /* Resuming external connections when using an extern mainloop  */
   if (! daemon->disallow_suspend_resume)
     (void) MHD_resume_suspended_connections_ (daemon);
 
   return internal_run_from_select (daemon,
-                                   read_fd_set,
+                                   read_fd_set,
                                    write_fd_set,
-                                   except_fd_set);
+                                   except_fd_set);
 }
 
 
@@ -646,7 +646,7 @@ MHD_daemon_run_from_select (struct MHD_Daemon *daemon,
  */
 enum MHD_StatusCode
 MHD_daemon_select_ (struct MHD_Daemon *daemon,
-                    int may_block)
+                    int may_block)
 {
   int num_ready;
   fd_set rs;
@@ -675,74 +675,75 @@ MHD_daemon_select_ (struct MHD_Daemon *daemon,
     may_block = MHD_NO;
 
   if (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_mode)
-    {
+  {
 
-      /* single-threaded, go over everything */
-      if (MHD_SC_OK !=
-          (sc = internal_get_fdset2 (daemon,
-                                     &rs,
-                                     &ws,
-                                     &es,
-                                     &maxsock,
-                                     FD_SETSIZE)))
-        {
+    /* single-threaded, go over everything */
+    if (MHD_SC_OK !=
+        (sc = internal_get_fdset2 (daemon,
+                                   &rs,
+                                   &ws,
+                                   &es,
+                                   &maxsock,
+                                   FD_SETSIZE)))
+    {
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    sc,
-                    _("Could not obtain daemon fdsets"));
+      MHD_DLOG (daemon,
+                sc,
+                _ ("Could not obtain daemon fdsets"));
 #endif
-        }
     }
+  }
   else
+  {
+    /* accept only, have one thread per connection */
+    if ( (MHD_INVALID_SOCKET != (ls = daemon->listen_socket)) &&
+         (! daemon->was_quiesced) &&
+         (! MHD_add_to_fd_set_ (ls,
+                                &rs,
+                                &maxsock,
+                                FD_SETSIZE)) )
     {
-      /* accept only, have one thread per connection */
-      if ( (MHD_INVALID_SOCKET != (ls = daemon->listen_socket)) &&
-           (! daemon->was_quiesced) &&
-           (! MHD_add_to_fd_set_ (ls,
-                                  &rs,
-                                  &maxsock,
-                                  FD_SETSIZE)) )
-        {
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE,
-                    _("Could not add listen socket to fdset"));
+      MHD_DLOG (daemon,
+                MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE,
+                _ ("Could not add listen socket to fdset"));
 #endif
-          return MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
-        }
+      return MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
     }
-  if ( (MHD_ITC_IS_VALID_(daemon->itc)) &&
+  }
+  if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
        (! MHD_add_to_fd_set_ (MHD_itc_r_fd_ (daemon->itc),
                               &rs,
                               &maxsock,
                               FD_SETSIZE)) )
-    {
+  {
 #if defined(MHD_WINSOCK_SOCKETS)
-      /* fdset limit reached, new connections
-         cannot be handled. Remove listen socket FD
-         from fdset and retry to add ITC FD. */
-      if ( (MHD_INVALID_SOCKET != (ls = daemon->listen_socket)) &&
-           (! daemon->was_quiesced) )
-        {
-          FD_CLR (ls,
-                  &rs);
-          if (! MHD_add_to_fd_set_ (MHD_itc_r_fd_(daemon->itc),
-                                    &rs,
-                                    &maxsock,
-                                    FD_SETSIZE))
-            {
+    /* fdset limit reached, new connections
+       cannot be handled. Remove listen socket FD
+       from fdset and retry to add ITC FD. */
+    if ( (MHD_INVALID_SOCKET != (ls = daemon->listen_socket)) &&
+         (! daemon->was_quiesced) )
+    {
+      FD_CLR (ls,
+              &rs);
+      if (! MHD_add_to_fd_set_ (MHD_itc_r_fd_ (daemon->itc),
+                                &rs,
+                                &maxsock,
+                                FD_SETSIZE))
+      {
 #endif /* MHD_WINSOCK_SOCKETS */
-              sc = MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
+    sc = MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE;
 #ifdef HAVE_MESSAGES
-              MHD_DLOG (daemon,
-                        sc,
-                        _("Could not add control inter-thread communication channel FD to fdset"));
+    MHD_DLOG (daemon,
+              sc,
+              _ (
+                "Could not add control inter-thread communication channel FD to fdset"));
 #endif
 #if defined(MHD_WINSOCK_SOCKETS)
-            }
-        }
+  }
+}
 #endif /* MHD_WINSOCK_SOCKETS */
-    }
+  }
   /* Stop listening if we are at the configured connection limit */
   /* If we're at the connection limit, no point in really
      accepting new connections; however, make sure we do not miss
@@ -750,35 +751,35 @@ MHD_daemon_select_ (struct MHD_Daemon *daemon,
      only do this optimization if we have a signaling ITC in
      place. */
   if ( (MHD_INVALID_SOCKET != (ls = daemon->listen_socket)) &&
-       (MHD_ITC_IS_VALID_(daemon->itc)) &&
+       (MHD_ITC_IS_VALID_ (daemon->itc)) &&
        ( (daemon->connections == daemon->global_connection_limit) ||
          (daemon->at_limit) ) )
-    {
-      FD_CLR (ls,
-              &rs);
-    }
+  {
+    FD_CLR (ls,
+            &rs);
+  }
   tv = NULL;
   if (MHD_SC_OK != sc)
     may_block = MHD_NO;
   if (MHD_NO == may_block)
-    {
-      timeout.tv_usec = 0;
-      timeout.tv_sec = 0;
-      tv = &timeout;
-    }
+  {
+    timeout.tv_usec = 0;
+    timeout.tv_sec = 0;
+    tv = &timeout;
+  }
   else if ( (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_mode) &&
-            (MHD_SC_OK ==
-             MHD_daemon_get_timeout (daemon,
-                                     &ltimeout)) )
-    {
-      /* ltimeout is in ms */
-      timeout.tv_usec = (ltimeout % 1000) * 1000;
-      if (ltimeout / 1000 > TIMEVAL_TV_SEC_MAX)
-        timeout.tv_sec = TIMEVAL_TV_SEC_MAX;
-      else
-        timeout.tv_sec = (_MHD_TIMEVAL_TV_SEC_TYPE)(ltimeout / 1000);
-      tv = &timeout;
-    }
+            (MHD_SC_OK ==
+             MHD_daemon_get_timeout (daemon,
+                                     &ltimeout)) )
+  {
+    /* ltimeout is in ms */
+    timeout.tv_usec = (ltimeout % 1000) * 1000;
+    if (ltimeout / 1000 > TIMEVAL_TV_SEC_MAX)
+      timeout.tv_sec = TIMEVAL_TV_SEC_MAX;
+    else
+      timeout.tv_sec = (_MHD_TIMEVAL_TV_SEC_TYPE) (ltimeout / 1000);
+    tv = &timeout;
+  }
   num_ready = MHD_SYS_select_ (maxsock + 1,
                                &rs,
                                &ws,
@@ -787,24 +788,24 @@ MHD_daemon_select_ (struct MHD_Daemon *daemon,
   if (daemon->shutdown)
     return MHD_SC_DAEMON_ALREADY_SHUTDOWN;
   if (num_ready < 0)
-    {
-      const int err = MHD_socket_get_error_ ();
+  {
+    const int err = MHD_socket_get_error_ ();
 
-      if (MHD_SCKT_ERR_IS_EINTR_(err))
-        return sc;
+    if (MHD_SCKT_ERR_IS_EINTR_ (err))
+      return sc;
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_UNEXPECTED_SELECT_ERROR,
-                _("select failed: %s\n"),
-                MHD_socket_strerr_ (err));
+    MHD_DLOG (daemon,
+              MHD_SC_UNEXPECTED_SELECT_ERROR,
+              _ ("select failed: %s\n"),
+              MHD_socket_strerr_ (err));
 #endif
-      return MHD_SC_UNEXPECTED_SELECT_ERROR;
-    }
+    return MHD_SC_UNEXPECTED_SELECT_ERROR;
+  }
   if (MHD_SC_OK !=
       (sc2 = internal_run_from_select (daemon,
-                                       &rs,
-                                       &ws,
-                                       &es)))
+                                       &rs,
+                                       &ws,
+                                       &es)))
     return sc2;
   return sc;
 }
diff --git a/src/lib/daemon_select.h b/src/lib/daemon_select.h
index d6e9e106..7dac8a80 100644
--- a/src/lib/daemon_select.h
+++ b/src/lib/daemon_select.h
@@ -36,8 +36,8 @@
  */
 enum MHD_StatusCode
 MHD_daemon_select_ (struct MHD_Daemon *daemon,
-                    int may_block)
-  MHD_NONNULL(1);
+                    int may_block)
+MHD_NONNULL (1);
 
 
 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
@@ -49,7 +49,7 @@ MHD_daemon_select_ (struct MHD_Daemon *daemon,
  */
 void
 MHD_daemon_upgrade_connection_with_select_ (struct MHD_Connection *con)
-  MHD_NONNULL(1);
+MHD_NONNULL (1);
 #endif
 
 #endif
diff --git a/src/lib/daemon_start.c b/src/lib/daemon_start.c
index 52124c77..c8c498be 100644
--- a/src/lib/daemon_start.c
+++ b/src/lib/daemon_start.c
@@ -46,63 +46,64 @@ configure_listen_reuse (struct MHD_Daemon *daemon)
   /* Apply the socket options according to
      listening_address_reuse. */
   if (daemon->allow_address_reuse)
-    {
-      /* User requested to allow reusing listening address:port. */
+  {
+    /* User requested to allow reusing listening address:port. */
 #ifndef MHD_WINSOCK_SOCKETS
-      /* Use SO_REUSEADDR on non-W32 platforms, and do not fail if
-       * it doesn't work. */
-      if (0 > setsockopt (daemon->listen_socket,
-                          SOL_SOCKET,
-                          SO_REUSEADDR,
-                          (void *) &on,
-                          sizeof (on)))
-        {
+    /* Use SO_REUSEADDR on non-W32 platforms, and do not fail if
+     * it doesn't work. */
+    if (0 > setsockopt (daemon->listen_socket,
+                        SOL_SOCKET,
+                        SO_REUSEADDR,
+                        (void *) &on,
+                        sizeof (on)))
+    {
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    MHD_SC_LISTEN_ADDRESS_REUSE_ENABLE_FAILED,
-                    _("setsockopt failed: %s\n"),
-                    MHD_socket_last_strerr_ ());
+      MHD_DLOG (daemon,
+                MHD_SC_LISTEN_ADDRESS_REUSE_ENABLE_FAILED,
+                _ ("setsockopt failed: %s\n"),
+                MHD_socket_last_strerr_ ());
 #endif
-          return MHD_SC_LISTEN_ADDRESS_REUSE_ENABLE_FAILED;
-        }
-      return MHD_SC_OK;
+      return MHD_SC_LISTEN_ADDRESS_REUSE_ENABLE_FAILED;
+    }
+    return MHD_SC_OK;
 #endif /* ! MHD_WINSOCK_SOCKETS */
-      /* Use SO_REUSEADDR on Windows and SO_REUSEPORT on most platforms.
-       * Fail if SO_REUSEPORT is not defined or setsockopt fails.
-       */
-      /* SO_REUSEADDR on W32 has the same semantics
-         as SO_REUSEPORT on BSD/Linux */
+       /* Use SO_REUSEADDR on Windows and SO_REUSEPORT on most platforms.
+        * Fail if SO_REUSEPORT is not defined or setsockopt fails.
+        */
+       /* SO_REUSEADDR on W32 has the same semantics
+    as SO_REUSEPORT on BSD/Linux */
 #if defined(MHD_WINSOCK_SOCKETS) || defined(SO_REUSEPORT)
-      if (0 > setsockopt (daemon->listen_socket,
-                          SOL_SOCKET,
+    if (0 > setsockopt (daemon->listen_socket,
+                        SOL_SOCKET,
 #ifndef MHD_WINSOCK_SOCKETS
-                          SO_REUSEPORT,
+                        SO_REUSEPORT,
 #else  /* MHD_WINSOCK_SOCKETS */
-                          SO_REUSEADDR,
+                        SO_REUSEADDR,
 #endif /* MHD_WINSOCK_SOCKETS */
-                          (void *) &on,
-                          sizeof (on)))
-        {
+                        (void *) &on,
+                        sizeof (on)))
+    {
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    MHD_SC_LISTEN_ADDRESS_REUSE_ENABLE_FAILED,
-                    _("setsockopt failed: %s\n"),
-                    MHD_socket_last_strerr_ ());
+      MHD_DLOG (daemon,
+                MHD_SC_LISTEN_ADDRESS_REUSE_ENABLE_FAILED,
+                _ ("setsockopt failed: %s\n"),
+                MHD_socket_last_strerr_ ());
 #endif
-          return MHD_SC_LISTEN_ADDRESS_REUSE_ENABLE_FAILED;
-        }
-      return MHD_SC_OK;
+      return MHD_SC_LISTEN_ADDRESS_REUSE_ENABLE_FAILED;
+    }
+    return MHD_SC_OK;
 #else  /* !MHD_WINSOCK_SOCKETS && !SO_REUSEPORT */
-      /* we're supposed to allow address:port re-use, but
-         on this platform we cannot; fail hard */
+       /* we're supposed to allow address:port re-use, but
+    on this platform we cannot; fail hard */
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_LISTEN_ADDRESS_REUSE_ENABLE_NOT_SUPPORTED,
-                _("Cannot allow listening address reuse: SO_REUSEPORT not defined\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_LISTEN_ADDRESS_REUSE_ENABLE_NOT_SUPPORTED,
+              _ (
+                "Cannot allow listening address reuse: SO_REUSEPORT not defined\n"));
 #endif
-      return MHD_SC_LISTEN_ADDRESS_REUSE_ENABLE_NOT_SUPPORTED;
+    return MHD_SC_LISTEN_ADDRESS_REUSE_ENABLE_NOT_SUPPORTED;
 #endif /* !MHD_WINSOCK_SOCKETS && !SO_REUSEPORT */
-    }
+  }
 
   /* if (! daemon->allow_address_reuse) */
   /* User requested to disallow reusing listening address:port.
@@ -111,32 +112,33 @@ configure_listen_reuse (struct MHD_Daemon *daemon)
    * Fail if MHD was compiled for W32 without SO_EXCLUSIVEADDRUSE
    * or setsockopt fails.
    */
-#if (defined(MHD_WINSOCK_SOCKETS) && defined(SO_EXCLUSIVEADDRUSE)) ||   \
+#if (defined(MHD_WINSOCK_SOCKETS) && defined(SO_EXCLUSIVEADDRUSE)) || \
   (defined(__sun) && defined(SO_EXCLBIND))
   if (0 > setsockopt (daemon->listen_socket,
-                      SOL_SOCKET,
+                      SOL_SOCKET,
 #ifdef SO_EXCLUSIVEADDRUSE
-                      SO_EXCLUSIVEADDRUSE,
+                      SO_EXCLUSIVEADDRUSE,
 #else  /* SO_EXCLBIND */
-                      SO_EXCLBIND,
+                      SO_EXCLBIND,
 #endif /* SO_EXCLBIND */
-                      (void *) &on,
-                      sizeof (on)))
-    {
+                      (void *) &on,
+                      sizeof (on)))
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_LISTEN_ADDRESS_REUSE_DISABLE_FAILED,
-                _("setsockopt failed: %s\n"),
-                MHD_socket_last_strerr_ ());
+    MHD_DLOG (daemon,
+              MHD_SC_LISTEN_ADDRESS_REUSE_DISABLE_FAILED,
+              _ ("setsockopt failed: %s\n"),
+              MHD_socket_last_strerr_ ());
 #endif
-      return MHD_SC_LISTEN_ADDRESS_REUSE_DISABLE_FAILED;
-    }
+    return MHD_SC_LISTEN_ADDRESS_REUSE_DISABLE_FAILED;
+  }
   return MHD_SC_OK;
 #elif defined(MHD_WINSOCK_SOCKETS) /* SO_EXCLUSIVEADDRUSE not defined on W32? */
 #ifdef HAVE_MESSAGES
   MHD_DLOG (daemon,
-            MHD_SC_LISTEN_ADDRESS_REUSE_DISABLE_NOT_SUPPORTED,
-            _("Cannot disallow listening address reuse: SO_EXCLUSIVEADDRUSE not defined\n"));
+            MHD_SC_LISTEN_ADDRESS_REUSE_DISABLE_NOT_SUPPORTED,
+            _ (
+              "Cannot disallow listening address reuse: SO_EXCLUSIVEADDRUSE not defined\n"));
 #endif
   return MHD_SC_LISTEN_ADDRESS_REUSE_DISABLE_NOT_SUPPORTED;
 #endif /* MHD_WINSOCK_SOCKETS */
@@ -166,86 +168,86 @@ open_listen_socket (struct MHD_Daemon *daemon)
   pf = -1;
   /* Determine address family */
   switch (daemon->listen_af)
+  {
+  case MHD_AF_NONE:
+    if (0 == daemon->listen_sa_len)
     {
-    case MHD_AF_NONE:
-      if (0 == daemon->listen_sa_len)
-        {
-          /* no listening desired, that's OK */
-          return MHD_SC_OK;
-        }
-      /* we have a listen address, get AF from there! */
-      switch (daemon->listen_sa.ss_family)
-        {
-        case AF_INET:
-          pf = PF_INET;
-          use_v6 = false;
-          break;
+      /* no listening desired, that's OK */
+      return MHD_SC_OK;
+    }
+    /* we have a listen address, get AF from there! */
+    switch (daemon->listen_sa.ss_family)
+    {
+    case AF_INET:
+      pf = PF_INET;
+      use_v6 = false;
+      break;
 #ifdef AF_INET6
-        case AF_INET6:
-          pf = PF_INET6;
-          use_v6 = true;
-          break;
-#endif
-#ifdef AF_UNIX
-        case AF_UNIX:
-          pf = PF_UNIX;
-          use_v6 = false;
-          break;
-#endif
-        default:
-          return MHD_SC_AF_NOT_SUPPORTED_BY_BUILD;
-        } /* switch on ss_family */
-      break; /* MHD_AF_NONE */
-    case MHD_AF_AUTO:
-#if HAVE_INET6
+    case AF_INET6:
       pf = PF_INET6;
       use_v6 = true;
-#else
-      pf = PF_INET;
-      use_v6 = false;
-#endif
       break;
-    case MHD_AF_INET4:
+#endif
+#ifdef AF_UNIX
+    case AF_UNIX:
+      pf = PF_UNIX;
       use_v6 = false;
-      pf = PF_INET;
       break;
-    case MHD_AF_INET6:
-    case MHD_AF_DUAL:
+#endif
+    default:
+      return MHD_SC_AF_NOT_SUPPORTED_BY_BUILD;
+    } /* switch on ss_family */
+    break;   /* MHD_AF_NONE */
+  case MHD_AF_AUTO:
 #if HAVE_INET6
-      pf = PF_INET6;
-      use_v6 = true;
-      break;
+    pf = PF_INET6;
+    use_v6 = true;
+#else
+    pf = PF_INET;
+    use_v6 = false;
+#endif
+    break;
+  case MHD_AF_INET4:
+    use_v6 = false;
+    pf = PF_INET;
+    break;
+  case MHD_AF_INET6:
+  case MHD_AF_DUAL:
+#if HAVE_INET6
+    pf = PF_INET6;
+    use_v6 = true;
+    break;
 #else
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_IPV6_NOT_SUPPORTED_BY_BUILD,
-                _("IPv6 not supported by this build\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_IPV6_NOT_SUPPORTED_BY_BUILD,
+              _ ("IPv6 not supported by this build\n"));
 #endif
-      return MHD_SC_IPV6_NOT_SUPPORTED_BY_BUILD;
+    return MHD_SC_IPV6_NOT_SUPPORTED_BY_BUILD;
 #endif
-    }
+  }
   mhd_assert (-1 != pf);
   /* try to open listen socket */
- try_open_listen_socket:
-  daemon->listen_socket = MHD_socket_create_listen_(pf);
+try_open_listen_socket:
+  daemon->listen_socket = MHD_socket_create_listen_ (pf);
   if ( (MHD_INVALID_SOCKET == daemon->listen_socket) &&
        (MHD_AF_AUTO == daemon->listen_af) &&
        (use_v6) )
-    {
-      use_v6 = false;
-      pf = PF_INET;
-      goto try_open_listen_socket;
-    }
+  {
+    use_v6 = false;
+    pf = PF_INET;
+    goto try_open_listen_socket;
+  }
   if (MHD_INVALID_SOCKET == daemon->listen_socket)
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_FAILED_TO_OPEN_LISTEN_SOCKET,
-                _("Failed to create socket for listening: %s\n"),
-                MHD_socket_last_strerr_ ());
+    MHD_DLOG (daemon,
+              MHD_SC_FAILED_TO_OPEN_LISTEN_SOCKET,
+              _ ("Failed to create socket for listening: %s\n"),
+              MHD_socket_last_strerr_ ());
 #endif
-      return MHD_SC_FAILED_TO_OPEN_LISTEN_SOCKET;
-    }
+    return MHD_SC_FAILED_TO_OPEN_LISTEN_SOCKET;
+  }
 
   if (MHD_SC_OK !=
       (sc = configure_listen_reuse (daemon)))
@@ -253,156 +255,157 @@ open_listen_socket (struct MHD_Daemon *daemon)
 
   /* configure for dual stack (or not) */
   if (use_v6)
-    {
+  {
 #if defined IPPROTO_IPV6 && defined IPV6_V6ONLY
-      /* Note: "IPV6_V6ONLY" is declared by Windows Vista ff., see "IPPROTO_IPV6 Socket Options"
-         (http://msdn.microsoft.com/en-us/library/ms738574%28v=VS.85%29.aspx);
-         and may also be missing on older POSIX systems; good luck if you have any of those,
-         your IPv6 socket may then also bind against IPv4 anyway... */
-      const MHD_SCKT_OPT_BOOL_ v6_only =
-        (MHD_AF_INET6 == daemon->listen_af);
-      if (0 > setsockopt (daemon->listen_socket,
-                          IPPROTO_IPV6,
-                          IPV6_V6ONLY,
-                          (const void *) &v6_only,
-                          sizeof (v6_only)))
-        {
+    /* Note: "IPV6_V6ONLY" is declared by Windows Vista ff., see "IPPROTO_IPV6 Socket Options"
+ (http://msdn.microsoft.com/en-us/library/ms738574%28v=VS.85%29.aspx);
+ and may also be missing on older POSIX systems; good luck if you have any of those,
+ your IPv6 socket may then also bind against IPv4 anyway... */
+    const MHD_SCKT_OPT_BOOL_ v6_only =
+      (MHD_AF_INET6 == daemon->listen_af);
+    if (0 > setsockopt (daemon->listen_socket,
+                        IPPROTO_IPV6,
+                        IPV6_V6ONLY,
+                        (const void *) &v6_only,
+                        sizeof (v6_only)))
+    {
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    MHD_SC_LISTEN_DUAL_STACK_CONFIGURATION_FAILED,
-                    _("setsockopt failed: %s\n"),
-                    MHD_socket_last_strerr_ ());
+      MHD_DLOG (daemon,
+                MHD_SC_LISTEN_DUAL_STACK_CONFIGURATION_FAILED,
+                _ ("setsockopt failed: %s\n"),
+                MHD_socket_last_strerr_ ());
 #endif
-        }
+    }
 #else
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    MHD_SC_LISTEN_DUAL_STACK_CONFIGURATION_NOT_SUPPORTED,
-                    _("Cannot explicitly setup dual stack behavior on this platform\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_LISTEN_DUAL_STACK_CONFIGURATION_NOT_SUPPORTED,
+              _ (
+                "Cannot explicitly setup dual stack behavior on this platform\n"));
 #endif
 #endif
-    }
+  }
 
   /* Determine address to bind to */
   if (0 != daemon->listen_sa_len)
-    {
-      /* Bind address explicitly given */
-      sa = (const struct sockaddr *) &daemon->listen_sa;
-      addrlen = daemon->listen_sa_len;
-    }
+  {
+    /* Bind address explicitly given */
+    sa = (const struct sockaddr *) &daemon->listen_sa;
+    addrlen = daemon->listen_sa_len;
+  }
   else
-    {
-      /* Compute bind address based on port and AF */
+  {
+    /* Compute bind address based on port and AF */
 #if HAVE_INET6
-      if (use_v6)
-        {
+    if (use_v6)
+    {
 #ifdef IN6ADDR_ANY_INIT
-          static const struct in6_addr static_in6any = IN6ADDR_ANY_INIT;
+      static const struct in6_addr static_in6any = IN6ADDR_ANY_INIT;
 #endif
-          struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &ss;
+      struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &ss;
 
-          addrlen = sizeof (struct sockaddr_in6);
-          memset (sin6,
-                  0,
-                  sizeof (struct sockaddr_in6));
-          sin6->sin6_family = AF_INET6;
-          sin6->sin6_port = htons (daemon->listen_port);
+      addrlen = sizeof (struct sockaddr_in6);
+      memset (sin6,
+              0,
+              sizeof (struct sockaddr_in6));
+      sin6->sin6_family = AF_INET6;
+      sin6->sin6_port = htons (daemon->listen_port);
 #ifdef IN6ADDR_ANY_INIT
-          sin6->sin6_addr = static_in6any;
+      sin6->sin6_addr = static_in6any;
 #endif
 #if HAVE_STRUCT_SOCKADDR_IN6_SIN6_LEN
-          sin6->sin6_len = sizeof (struct sockaddr_in6);
+      sin6->sin6_len = sizeof (struct sockaddr_in6);
 #endif
-        }
-      else
+    }
+    else
 #endif
-        {
-          struct sockaddr_in *sin4 = (struct sockaddr_in *) &ss;
-
-          addrlen = sizeof (struct sockaddr_in);
-          memset (sin4,
-                  0,
-                  sizeof (struct sockaddr_in));
-          sin4->sin_family = AF_INET;
-          sin4->sin_port = htons (daemon->listen_port);
-          if (0 != INADDR_ANY)
-            sin4->sin_addr.s_addr = htonl (INADDR_ANY);
+    {
+      struct sockaddr_in *sin4 = (struct sockaddr_in *) &ss;
+
+      addrlen = sizeof (struct sockaddr_in);
+      memset (sin4,
+              0,
+              sizeof (struct sockaddr_in));
+      sin4->sin_family = AF_INET;
+      sin4->sin_port = htons (daemon->listen_port);
+      if (0 != INADDR_ANY)
+        sin4->sin_addr.s_addr = htonl (INADDR_ANY);
 #if HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
-          sin4->sin_len = sizeof (struct sockaddr_in);
+      sin4->sin_len = sizeof (struct sockaddr_in);
 #endif
-        }
-      sa = (const struct sockaddr *) &ss;
     }
+    sa = (const struct sockaddr *) &ss;
+  }
 
   /* actually do the bind() */
   if (-1 == bind (daemon->listen_socket,
-                  sa,
-                  addrlen))
-    {
+                  sa,
+                  addrlen))
+  {
 #ifdef HAVE_MESSAGES
-      unsigned int port = 0;
-
-      switch (sa->sa_family)
-        {
-        case AF_INET:
-          if (addrlen == sizeof (struct sockaddr_in))
-            port = ntohs (((const struct sockaddr_in *) sa)->sin_port);
-          else
-            port = UINT16_MAX + 1; /* indicate size error */
-          break;
-        case AF_INET6:
-          if (addrlen == sizeof (struct sockaddr_in6))
-            port = ntohs (((const struct sockaddr_in6 *) sa)->sin6_port);
-          else
-            port = UINT16_MAX + 1; /* indicate size error */
-          break;
-        default:
-          port = UINT_MAX; /* AF_UNIX? */
-          break;
-        }
-      MHD_DLOG (daemon,
-                MHD_SC_LISTEN_SOCKET_BIND_FAILED,
-                _("Failed to bind to port %u: %s\n"),
-                port,
-                MHD_socket_last_strerr_ ());
-#endif
-      return MHD_SC_LISTEN_SOCKET_BIND_FAILED;
+    unsigned int port = 0;
+
+    switch (sa->sa_family)
+    {
+    case AF_INET:
+      if (addrlen == sizeof (struct sockaddr_in))
+        port = ntohs (((const struct sockaddr_in *) sa)->sin_port);
+      else
+        port = UINT16_MAX + 1; /* indicate size error */
+      break;
+    case AF_INET6:
+      if (addrlen == sizeof (struct sockaddr_in6))
+        port = ntohs (((const struct sockaddr_in6 *) sa)->sin6_port);
+      else
+        port = UINT16_MAX + 1; /* indicate size error */
+      break;
+    default:
+      port = UINT_MAX; /* AF_UNIX? */
+      break;
     }
+    MHD_DLOG (daemon,
+              MHD_SC_LISTEN_SOCKET_BIND_FAILED,
+              _ ("Failed to bind to port %u: %s\n"),
+              port,
+              MHD_socket_last_strerr_ ());
+#endif
+    return MHD_SC_LISTEN_SOCKET_BIND_FAILED;
+  }
 
   /* setup TCP_FASTOPEN */
 #ifdef TCP_FASTOPEN
   if (MHD_FOM_DISABLE != daemon->fast_open_method)
+  {
+    if (0 != setsockopt (daemon->listen_socket,
+                         IPPROTO_TCP,
+                         TCP_FASTOPEN,
+                         &daemon->fo_queue_length,
+                         sizeof (daemon->fo_queue_length)))
     {
-      if (0 != setsockopt (daemon->listen_socket,
-                           IPPROTO_TCP,
-                           TCP_FASTOPEN,
-                           &daemon->fo_queue_length,
-                           sizeof (daemon->fo_queue_length)))
-        {
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    MHD_SC_FAST_OPEN_FAILURE,
-                    _("setsockopt failed: %s\n"),
-                    MHD_socket_last_strerr_ ());
-#endif
-          if (MHD_FOM_REQUIRE == daemon->fast_open_method)
-            return MHD_SC_FAST_OPEN_FAILURE;
-        }
-      }
+      MHD_DLOG (daemon,
+                MHD_SC_FAST_OPEN_FAILURE,
+                _ ("setsockopt failed: %s\n"),
+                MHD_socket_last_strerr_ ());
+#endif
+      if (MHD_FOM_REQUIRE == daemon->fast_open_method)
+        return MHD_SC_FAST_OPEN_FAILURE;
+    }
+  }
 #endif
 
   /* setup listening */
   if (0 > listen (daemon->listen_socket,
                   daemon->listen_backlog))
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_LISTEN_FAILURE,
-                _("Failed to listen for connections: %s\n"),
-                MHD_socket_last_strerr_ ());
+    MHD_DLOG (daemon,
+              MHD_SC_LISTEN_FAILURE,
+              _ ("Failed to listen for connections: %s\n"),
+              MHD_socket_last_strerr_ ());
 #endif
-      return MHD_SC_LISTEN_FAILURE;
-    }
+    return MHD_SC_LISTEN_FAILURE;
+  }
   return MHD_SC_OK;
 }
 
@@ -426,65 +429,66 @@ get_listen_port_number (struct MHD_Daemon *daemon)
     return; /* nothing to be done */
 
   memset (&servaddr,
-          0,
-          sizeof (struct sockaddr_storage));
+          0,
+          sizeof (struct sockaddr_storage));
   addrlen = sizeof (servaddr);
   if (0 != getsockname (daemon->listen_socket,
-                        (struct sockaddr *) &servaddr,
-                        &addrlen))
-    {
+                        (struct sockaddr *) &servaddr,
+                        &addrlen))
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_LISTEN_PORT_INTROSPECTION_FAILURE,
-                _("Failed to get listen port number: %s\n"),
-                MHD_socket_last_strerr_ ());
+    MHD_DLOG (daemon,
+              MHD_SC_LISTEN_PORT_INTROSPECTION_FAILURE,
+              _ ("Failed to get listen port number: %s\n"),
+              MHD_socket_last_strerr_ ());
 #endif /* HAVE_MESSAGES */
-      return;
-    }
+    return;
+  }
 #ifdef MHD_POSIX_SOCKETS
   if (sizeof (servaddr) < addrlen)
-    {
-      /* should be impossible with `struct sockaddr_storage` */
+  {
+    /* should be impossible with `struct sockaddr_storage` */
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_LISTEN_PORT_INTROSPECTION_FAILURE,
-                _("Failed to get listen port number (`struct sockaddr_storage` too small!?)\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_LISTEN_PORT_INTROSPECTION_FAILURE,
+              _ (
+                "Failed to get listen port number (`struct sockaddr_storage` too small!?)\n"));
 #endif /* HAVE_MESSAGES */
-      return;
-    }
+    return;
+  }
 #endif /* MHD_POSIX_SOCKETS */
   switch (servaddr.ss_family)
+  {
+  case AF_INET:
     {
-    case AF_INET:
-      {
-        struct sockaddr_in *s4 = (struct sockaddr_in *) &servaddr;
+      struct sockaddr_in *s4 = (struct sockaddr_in *) &servaddr;
 
-        daemon->listen_port = ntohs (s4->sin_port);
-        break;
-      }
+      daemon->listen_port = ntohs (s4->sin_port);
+      break;
+    }
 #ifdef HAVE_INET6
-    case AF_INET6:
-      {
-        struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) &servaddr;
+  case AF_INET6:
+    {
+      struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) &servaddr;
 
-        daemon->listen_port = ntohs(s6->sin6_port);
-        break;
-      }
+      daemon->listen_port = ntohs (s6->sin6_port);
+      break;
+    }
 #endif /* HAVE_INET6 */
 #ifdef AF_UNIX
-    case AF_UNIX:
-      daemon->listen_port = 0; /* special value for UNIX domain sockets */
-      break;
+  case AF_UNIX:
+    daemon->listen_port = 0;   /* special value for UNIX domain sockets */
+    break;
 #endif
-    default:
+  default:
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_LISTEN_PORT_INTROSPECTION_UNKNOWN_AF,
-                _("Unknown address family!\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_LISTEN_PORT_INTROSPECTION_UNKNOWN_AF,
+              _ ("Unknown address family!\n"));
 #endif
-      daemon->listen_port = 0; /* ugh */
-      break;
-    }
+    daemon->listen_port = 0;   /* ugh */
+    break;
+  }
 }
 
 
@@ -501,7 +505,7 @@ setup_epoll_fd (struct MHD_Daemon *daemon)
   int fd;
 
 #ifndef HAVE_MESSAGES
-  (void)daemon; /* Mute compiler warning. */
+  (void) daemon; /* Mute compiler warning. */
 #endif /* ! HAVE_MESSAGES */
 
 #ifdef USE_EPOLL_CREATE1
@@ -510,24 +514,24 @@ setup_epoll_fd (struct MHD_Daemon *daemon)
   fd = epoll_create (MAX_EVENTS);
 #endif /* ! USE_EPOLL_CREATE1 */
   if (MHD_INVALID_SOCKET == fd)
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_EPOLL_CTL_CREATE_FAILED,
-                _("Call to epoll_create1 failed: %s\n"),
-                MHD_socket_last_strerr_ ());
-#endif
-      return MHD_INVALID_SOCKET;
-    }
-#if !defined(USE_EPOLL_CREATE1)
+    MHD_DLOG (daemon,
+              MHD_SC_EPOLL_CTL_CREATE_FAILED,
+              _ ("Call to epoll_create1 failed: %s\n"),
+              MHD_socket_last_strerr_ ());
+#endif
+    return MHD_INVALID_SOCKET;
+  }
+#if ! defined(USE_EPOLL_CREATE1)
   if (! MHD_socket_noninheritable_ (fd))
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_EPOLL_CTL_CONFIGURE_NOINHERIT_FAILED,
-                _("Failed to set noninheritable mode on epoll FD.\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_EPOLL_CTL_CONFIGURE_NOINHERIT_FAILED,
+              _ ("Failed to set noninheritable mode on epoll FD.\n"));
 #endif
-    }
+  }
 #endif /* ! USE_EPOLL_CREATE1 */
   return fd;
 }
@@ -554,11 +558,11 @@ setup_epoll_to_listen (struct MHD_Daemon *daemon)
     return MHD_SC_EPOLL_CTL_CREATE_FAILED;
 #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
   if (! daemon->disallow_upgrade)
-    {
-       daemon->epoll_upgrade_fd = setup_epoll_fd (daemon);
-       if (MHD_INVALID_SOCKET == daemon->epoll_upgrade_fd)
-         return MHD_SC_EPOLL_CTL_CREATE_FAILED;
-    }
+  {
+    daemon->epoll_upgrade_fd = setup_epoll_fd (daemon);
+    if (MHD_INVALID_SOCKET == daemon->epoll_upgrade_fd)
+      return MHD_SC_EPOLL_CTL_CREATE_FAILED;
+  }
 #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
   if ( (MHD_INVALID_SOCKET == (ls = daemon->listen_socket)) ||
        (daemon->was_quiesced) )
@@ -566,37 +570,37 @@ setup_epoll_to_listen (struct MHD_Daemon *daemon)
   event.events = EPOLLIN;
   event.data.ptr = daemon;
   if (0 != epoll_ctl (daemon->epoll_fd,
-                      EPOLL_CTL_ADD,
-                      ls,
-                      &event))
-    {
+                      EPOLL_CTL_ADD,
+                      ls,
+                      &event))
+  {
 #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
-      return MHD_SC_EPOLL_CTL_ADD_FAILED;
-    }
+    return MHD_SC_EPOLL_CTL_ADD_FAILED;
+  }
   daemon->listen_socket_in_epoll = true;
-  if (MHD_ITC_IS_VALID_(daemon->itc))
+  if (MHD_ITC_IS_VALID_ (daemon->itc))
+  {
+    event.events = EPOLLIN;
+    event.data.ptr = (void *) daemon->epoll_itc_marker;
+    if (0 != epoll_ctl (daemon->epoll_fd,
+                        EPOLL_CTL_ADD,
+                        MHD_itc_r_fd_ (daemon->itc),
+                        &event))
     {
-      event.events = EPOLLIN;
-      event.data.ptr = (void *) daemon->epoll_itc_marker;
-      if (0 != epoll_ctl (daemon->epoll_fd,
-                          EPOLL_CTL_ADD,
-                          MHD_itc_r_fd_ (daemon->itc),
-                          &event))
-        {
 #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
-          return MHD_SC_EPOLL_CTL_ADD_FAILED;
-        }
+      return MHD_SC_EPOLL_CTL_ADD_FAILED;
     }
+  }
   return MHD_SC_OK;
 }
 #endif
@@ -616,35 +620,35 @@ MHD_polling_thread (void *cls)
 
   MHD_thread_init_ (&daemon->pid);
   while (! daemon->shutdown)
+  {
+    switch (daemon->event_loop_syscall)
     {
-      switch (daemon->event_loop_syscall)
-      {
-      case MHD_ELS_AUTO:
-        MHD_PANIC ("MHD_ELS_AUTO should have been mapped to preferred style");
-        break;
-      case MHD_ELS_SELECT:
-        MHD_daemon_select_ (daemon,
-                            MHD_YES);
-        break;
-      case MHD_ELS_POLL:
+    case MHD_ELS_AUTO:
+      MHD_PANIC ("MHD_ELS_AUTO should have been mapped to preferred style");
+      break;
+    case MHD_ELS_SELECT:
+      MHD_daemon_select_ (daemon,
+                          MHD_YES);
+      break;
+    case MHD_ELS_POLL:
 #if HAVE_POLL
-        MHD_daemon_poll_ (daemon,
-                          MHD_YES);
+      MHD_daemon_poll_ (daemon,
+                        MHD_YES);
 #else
-        MHD_PANIC ("MHD_ELS_POLL not supported, should have failed earlier");
+      MHD_PANIC ("MHD_ELS_POLL not supported, should have failed earlier");
 #endif
-        break;
-      case MHD_ELS_EPOLL:
+      break;
+    case MHD_ELS_EPOLL:
 #ifdef EPOLL_SUPPORT
-        MHD_daemon_epoll_ (daemon,
-                           MHD_YES);
+      MHD_daemon_epoll_ (daemon,
+                         MHD_YES);
 #else
-        MHD_PANIC ("MHD_ELS_EPOLL not supported, should have failed earlier");
+      MHD_PANIC ("MHD_ELS_EPOLL not supported, should have failed earlier");
 #endif
-        break;
-      }
-      MHD_connection_cleanup_ (daemon);
+      break;
     }
+    MHD_connection_cleanup_ (daemon);
+  }
   /* Resume any pending for resume connections, join
    * all connection's threads (if any) and finally cleanup
    * everything. */
@@ -652,7 +656,7 @@ MHD_polling_thread (void *cls)
     MHD_resume_suspended_connections_ (daemon);
   MHD_daemon_close_all_connections_ (daemon);
 
-  return (MHD_THRD_RTRN_TYPE_)0;
+  return (MHD_THRD_RTRN_TYPE_) 0;
 }
 
 
@@ -669,114 +673,116 @@ setup_thread_pool (struct MHD_Daemon *daemon)
    * due to integer division). Also keep track of how many
    * connections are leftover after an equal split. */
   unsigned int conns_per_thread = daemon->global_connection_limit
-    / daemon->threading_mode;
+                                  / daemon->threading_mode;
   unsigned int leftover_conns = daemon->global_connection_limit
-    % daemon->threading_mode;
+                                % daemon->threading_mode;
   int i;
   enum MHD_StatusCode sc;
 
   /* Allocate memory for pooled objects */
   daemon->worker_pool = MHD_calloc_ (daemon->threading_mode,
-                                     sizeof (struct MHD_Daemon));
+                                     sizeof (struct MHD_Daemon));
   if (NULL == daemon->worker_pool)
     return MHD_SC_THREAD_POOL_MALLOC_FAILURE;
 
   /* Start the workers in the pool */
   for (i = 0; i < daemon->threading_mode; i++)
+  {
+    /* Create copy of the Daemon object for each worker */
+    struct MHD_Daemon *d = &daemon->worker_pool[i];
+
+    memcpy (d,
+            daemon,
+            sizeof (struct MHD_Daemon));
+    /* Adjust pooling params for worker daemons; note that memcpy()
+ has already copied MHD_USE_INTERNAL_POLLING_THREAD thread mode into
+ the worker threads. */
+    d->master = daemon;
+    d->worker_pool_size = 0;
+    d->worker_pool = NULL;
+    /* Divide available connections evenly amongst the threads.
+     * Thread indexes in [0, leftover_conns) each get one of the
+     * leftover connections. */
+    d->global_connection_limit = conns_per_thread;
+    if (((unsigned int) i) < leftover_conns)
+      ++d->global_connection_limit;
+
+    if (! daemon->disable_itc)
     {
-      /* Create copy of the Daemon object for each worker */
-      struct MHD_Daemon *d = &daemon->worker_pool[i];
-
-      memcpy (d,
-              daemon,
-              sizeof (struct MHD_Daemon));
-      /* Adjust pooling params for worker daemons; note that memcpy()
-         has already copied MHD_USE_INTERNAL_POLLING_THREAD thread mode into
-         the worker threads. */
-      d->master = daemon;
-      d->worker_pool_size = 0;
-      d->worker_pool = NULL;
-      /* Divide available connections evenly amongst the threads.
-       * Thread indexes in [0, leftover_conns) each get one of the
-       * leftover connections. */
-      d->global_connection_limit = conns_per_thread;
-      if (((unsigned int) i) < leftover_conns)
-        ++d->global_connection_limit;
-
-      if (! daemon->disable_itc)
-        {
-          if (! MHD_itc_init_ (d->itc))
-            {
+      if (! MHD_itc_init_ (d->itc))
+      {
 #ifdef HAVE_MESSAGES
-              MHD_DLOG (daemon,
-                        MHD_SC_ITC_INITIALIZATION_FAILED,
-                        _("Failed to create worker inter-thread communication channel: %s\n"),
-                        MHD_itc_last_strerror_() );
-#endif
-              sc = MHD_SC_ITC_INITIALIZATION_FAILED;
-              goto thread_failed;
-            }
-          if ( (MHD_ELS_SELECT == daemon->event_loop_syscall) &&
-               (! MHD_SCKT_FD_FITS_FDSET_(MHD_itc_r_fd_ (d->itc),
-                                          NULL)) )
-            {
+        MHD_DLOG (daemon,
+                  MHD_SC_ITC_INITIALIZATION_FAILED,
+                  _ (
+                    "Failed to create worker inter-thread communication channel: %s\n"),
+                  MHD_itc_last_strerror_ () );
+#endif
+        sc = MHD_SC_ITC_INITIALIZATION_FAILED;
+        goto thread_failed;
+      }
+      if ( (MHD_ELS_SELECT == daemon->event_loop_syscall) &&
+           (! MHD_SCKT_FD_FITS_FDSET_ (MHD_itc_r_fd_ (d->itc),
+                                       NULL)) )
+      {
 #ifdef HAVE_MESSAGES
-              MHD_DLOG (daemon,
-                        MHD_SC_ITC_DESCRIPTOR_TOO_LARGE,
-                        _("File descriptor for inter-thread communication channel exceeds maximum value\n"));
-#endif
-              MHD_itc_destroy_chk_ (d->itc);
-              sc = MHD_SC_ITC_DESCRIPTOR_TOO_LARGE;
-              goto thread_failed;
-            }
-        }
-      else
-        {
-          MHD_itc_set_invalid_ (d->itc);
-        }
+        MHD_DLOG (daemon,
+                  MHD_SC_ITC_DESCRIPTOR_TOO_LARGE,
+                  _ (
+                    "File descriptor for inter-thread communication channel exceeds maximum value\n"));
+#endif
+        MHD_itc_destroy_chk_ (d->itc);
+        sc = MHD_SC_ITC_DESCRIPTOR_TOO_LARGE;
+        goto thread_failed;
+      }
+    }
+    else
+    {
+      MHD_itc_set_invalid_ (d->itc);
+    }
 
 #ifdef EPOLL_SUPPORT
-      if ( (MHD_ELS_EPOLL == daemon->event_loop_syscall) &&
-           (MHD_SC_OK != (sc = setup_epoll_to_listen (d))) )
-        goto thread_failed;
+    if ( (MHD_ELS_EPOLL == daemon->event_loop_syscall) &&
+         (MHD_SC_OK != (sc = setup_epoll_to_listen (d))) )
+      goto thread_failed;
 #endif
 
-      /* Must init cleanup connection mutex for each worker */
-      if (! MHD_mutex_init_ (&d->cleanup_connection_mutex))
-        {
+    /* Must init cleanup connection mutex for each worker */
+    if (! MHD_mutex_init_ (&d->cleanup_connection_mutex))
+    {
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    MHD_SC_THREAD_POOL_CREATE_MUTEX_FAILURE,
-                    _("MHD failed to initialize cleanup connection mutex\n"));
-#endif
-          if (! daemon->disable_itc)
-            MHD_itc_destroy_chk_ (d->itc);
-          sc = MHD_SC_THREAD_POOL_CREATE_MUTEX_FAILURE;
-          goto thread_failed;
-        }
-
-      /* Spawn the worker thread */
-      if (! MHD_create_named_thread_ (&d->pid,
-                                      "MHD-worker",
-                                      daemon->thread_stack_limit_b,
-                                      &MHD_polling_thread,
-                                      d))
-        {
+      MHD_DLOG (daemon,
+                MHD_SC_THREAD_POOL_CREATE_MUTEX_FAILURE,
+                _ ("MHD failed to initialize cleanup connection mutex\n"));
+#endif
+      if (! daemon->disable_itc)
+        MHD_itc_destroy_chk_ (d->itc);
+      sc = MHD_SC_THREAD_POOL_CREATE_MUTEX_FAILURE;
+      goto thread_failed;
+    }
+
+    /* Spawn the worker thread */
+    if (! MHD_create_named_thread_ (&d->pid,
+                                    "MHD-worker",
+                                    daemon->thread_stack_limit_b,
+                                    &MHD_polling_thread,
+                                    d))
+    {
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    MHD_SC_THREAD_POOL_LAUNCH_FAILURE,
-                    _("Failed to create pool thread: %s\n"),
-                    MHD_strerror_ (errno));
-#endif
-          /* Free memory for this worker; cleanup below handles
-           * all previously-created workers. */
-          if (! daemon->disable_itc)
-            MHD_itc_destroy_chk_ (d->itc);
-          MHD_mutex_destroy_chk_ (&d->cleanup_connection_mutex);
-          sc = MHD_SC_THREAD_POOL_LAUNCH_FAILURE;
-          goto thread_failed;
-        }
-    } /* end for() */
+      MHD_DLOG (daemon,
+                MHD_SC_THREAD_POOL_LAUNCH_FAILURE,
+                _ ("Failed to create pool thread: %s\n"),
+                MHD_strerror_ (errno));
+#endif
+      /* Free memory for this worker; cleanup below handles
+       * all previously-created workers. */
+      if (! daemon->disable_itc)
+        MHD_itc_destroy_chk_ (d->itc);
+      MHD_mutex_destroy_chk_ (&d->cleanup_connection_mutex);
+      sc = MHD_SC_THREAD_POOL_LAUNCH_FAILURE;
+      goto thread_failed;
+    }
+  }   /* end for() */
   return MHD_SC_OK;
 
 thread_failed:
@@ -785,14 +791,14 @@ thread_failed:
      assumes a 0-sized thread pool means we had been in the default
      MHD_USE_INTERNAL_POLLING_THREAD mode. */
   if (0 == i)
+  {
+    if (NULL != daemon->worker_pool)
     {
-      if (NULL != daemon->worker_pool)
-        {
-          free (daemon->worker_pool);
-          daemon->worker_pool = NULL;
-        }
-      return MHD_SC_THREAD_LAUNCH_FAILURE;
+      free (daemon->worker_pool);
+      daemon->worker_pool = NULL;
     }
+    return MHD_SC_THREAD_LAUNCH_FAILURE;
+  }
   /* Shutdown worker threads we've already created. Pretend
      as though we had fully initialized our daemon, but
      with a smaller number of threads than had been
@@ -817,63 +823,65 @@ MHD_daemon_start (struct MHD_Daemon *daemon)
   enum MHD_StatusCode sc;
 
   if (MHD_ELS_AUTO == daemon->event_loop_syscall)
-    {
+  {
 #if EPOLL_SUPPORT
-      /* We do not support thread-per-connection in combination
-         with epoll, so use poll in this case, otherwise prefer
-         epoll. */
-      if (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode)
-        daemon->event_loop_syscall = MHD_ELS_POLL;
-      else
-        daemon->event_loop_syscall = MHD_ELS_EPOLL;
-#elif HAVE_POLL
+    /* We do not support thread-per-connection in combination
+ with epoll, so use poll in this case, otherwise prefer
+ epoll. */
+    if (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode)
       daemon->event_loop_syscall = MHD_ELS_POLL;
+    else
+      daemon->event_loop_syscall = MHD_ELS_EPOLL;
+#elif HAVE_POLL
+    daemon->event_loop_syscall = MHD_ELS_POLL;
 #else
-      daemon->event_loop_syscall = MHD_ELS_SELECT;
+    daemon->event_loop_syscall = MHD_ELS_SELECT;
 #endif
-    }
+  }
 
 #ifdef EPOLL_SUPPORT
   if ( (MHD_ELS_EPOLL == daemon->event_loop_syscall) &&
        (0 == daemon->worker_pool_size) &&
        (MHD_INVALID_SOCKET != daemon->listen_socket) &&
        (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode) )
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_SYSCALL_THREAD_COMBINATION_INVALID,
-                _("Combining MHD_USE_THREAD_PER_CONNECTION and MHD_USE_EPOLL is not supported.\n"));
+    MHD_DLOG (daemon,
+              MHD_SC_SYSCALL_THREAD_COMBINATION_INVALID,
+              _ (
+                "Combining MHD_USE_THREAD_PER_CONNECTION and MHD_USE_EPOLL is not supported.\n"));
 #endif
-      return MHD_SC_SYSCALL_THREAD_COMBINATION_INVALID;
-    }
+    return MHD_SC_SYSCALL_THREAD_COMBINATION_INVALID;
+  }
 #endif
 
   /* Setup ITC */
   if ( (! daemon->disable_itc) &&
        (0 == daemon->worker_pool_size) )
+  {
+    if (! MHD_itc_init_ (daemon->itc))
     {
-      if (! MHD_itc_init_ (daemon->itc))
-        {
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    MHD_SC_ITC_INITIALIZATION_FAILED,
-                    _("Failed to create inter-thread communication channel: %s\n"),
-                    MHD_itc_last_strerror_ ());
+      MHD_DLOG (daemon,
+                MHD_SC_ITC_INITIALIZATION_FAILED,
+                _ ("Failed to create inter-thread communication channel: %s\n"),
+                MHD_itc_last_strerror_ ());
 #endif
-          return MHD_SC_ITC_INITIALIZATION_FAILED;
-        }
-      if ( (MHD_ELS_SELECT == daemon->event_loop_syscall) &&
-           (! MHD_SCKT_FD_FITS_FDSET_(MHD_itc_r_fd_ (daemon->itc),
-                                      NULL)) )
-        {
+      return MHD_SC_ITC_INITIALIZATION_FAILED;
+    }
+    if ( (MHD_ELS_SELECT == daemon->event_loop_syscall) &&
+         (! MHD_SCKT_FD_FITS_FDSET_ (MHD_itc_r_fd_ (daemon->itc),
+                                     NULL)) )
+    {
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    MHD_SC_ITC_DESCRIPTOR_TOO_LARGE,
-                    _("File descriptor for inter-thread communication channel exceeds maximum value\n"));
+      MHD_DLOG (daemon,
+                MHD_SC_ITC_DESCRIPTOR_TOO_LARGE,
+                _ (
+                  "File descriptor for inter-thread communication channel exceeds maximum value\n"));
 #endif
-          return MHD_SC_ITC_DESCRIPTOR_TOO_LARGE;
-        }
+      return MHD_SC_ITC_DESCRIPTOR_TOO_LARGE;
     }
+  }
 
   if (MHD_SC_OK != (sc = open_listen_socket (daemon)))
     return sc;
@@ -881,39 +889,39 @@ MHD_daemon_start (struct MHD_Daemon *daemon)
   /* Check listen socket is in range (if we are limited) */
   if ( (MHD_INVALID_SOCKET != daemon->listen_socket) &&
        (MHD_ELS_SELECT == daemon->event_loop_syscall) &&
-       (! MHD_SCKT_FD_FITS_FDSET_(daemon->listen_socket,
-                                  NULL)) )
-    {
+       (! MHD_SCKT_FD_FITS_FDSET_ (daemon->listen_socket,
+                                   NULL)) )
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_LISTEN_SOCKET_TOO_LARGE,
-                _("Socket descriptor larger than FD_SETSIZE: %d > %d\n"),
-                daemon->listen_socket,
-                FD_SETSIZE);
+    MHD_DLOG (daemon,
+              MHD_SC_LISTEN_SOCKET_TOO_LARGE,
+              _ ("Socket descriptor larger than FD_SETSIZE: %d > %d\n"),
+              daemon->listen_socket,
+              FD_SETSIZE);
 #endif
-      return MHD_SC_LISTEN_SOCKET_TOO_LARGE;
-    }
+    return MHD_SC_LISTEN_SOCKET_TOO_LARGE;
+  }
 
   /* set listen socket to non-blocking */
   if ( (MHD_INVALID_SOCKET != daemon->listen_socket) &&
        (! MHD_socket_nonblocking_ (daemon->listen_socket)) )
-    {
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_LISTEN_SOCKET_NONBLOCKING_FAILURE,
-                _("Failed to set nonblocking mode on listening socket: %s\n"),
-                MHD_socket_last_strerr_());
-#endif
-      if ( (MHD_ELS_EPOLL == daemon->event_loop_syscall) ||
-           (daemon->worker_pool_size > 0) )
-        {
-          /* Accept must be non-blocking. Multiple children may wake
-           * up to handle a new connection, but only one will win the
-           * race.  The others must immediately return. As this is
-           * not possible, we must fail hard here. */
-          return MHD_SC_LISTEN_SOCKET_NONBLOCKING_FAILURE;
-        }
+    MHD_DLOG (daemon,
+              MHD_SC_LISTEN_SOCKET_NONBLOCKING_FAILURE,
+              _ ("Failed to set nonblocking mode on listening socket: %s\n"),
+              MHD_socket_last_strerr_ ());
+#endif
+    if ( (MHD_ELS_EPOLL == daemon->event_loop_syscall) ||
+         (daemon->worker_pool_size > 0) )
+    {
+      /* Accept must be non-blocking. Multiple children may wake
+       * up to handle a new connection, but only one will win the
+       * race.  The others must immediately return. As this is
+       * not possible, we must fail hard here. */
+      return MHD_SC_LISTEN_SOCKET_NONBLOCKING_FAILURE;
     }
+  }
 
 #ifdef EPOLL_SUPPORT
   /* Setup epoll */
@@ -928,30 +936,31 @@ MHD_daemon_start (struct MHD_Daemon *daemon)
      external event loop and do have a listen socket) */
   /* FIXME: why no worker thread if we have no listen socket? */
   if ( ( (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode) ||
-         (1 == daemon->threading_mode) ) &&
+         (1 == daemon->threading_mode) ) &&
        (MHD_INVALID_SOCKET != daemon->listen_socket) &&
        (! MHD_create_named_thread_ (&daemon->pid,
-                                    (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode)
-                                    ? "MHD-listen"
-                                    : "MHD-single",
-                                    daemon->thread_stack_limit_b,
-                                    &MHD_polling_thread,
-                                    daemon) ) )
-    {
+                                    (MHD_TM_THREAD_PER_CONNECTION ==
+                                     daemon->threading_mode)
+                                    ? "MHD-listen"
+                                    : "MHD-single",
+                                    daemon->thread_stack_limit_b,
+                                    &MHD_polling_thread,
+                                    daemon) ) )
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_THREAD_MAIN_LAUNCH_FAILURE,
-                _("Failed to create listen thread: %s\n"),
-                MHD_strerror_ (errno));
+    MHD_DLOG (daemon,
+              MHD_SC_THREAD_MAIN_LAUNCH_FAILURE,
+              _ ("Failed to create listen thread: %s\n"),
+              MHD_strerror_ (errno));
 #endif
-      return MHD_SC_THREAD_MAIN_LAUNCH_FAILURE;
-    }
+    return MHD_SC_THREAD_MAIN_LAUNCH_FAILURE;
+  }
 
   /* Setup worker threads */
   /* FIXME: why no thread pool if we have no listen socket? */
   if ( (1 < daemon->threading_mode) &&
-        (MHD_INVALID_SOCKET != daemon->listen_socket) &&
-        (MHD_SC_OK != (sc = setup_thread_pool (daemon))) )
+       (MHD_INVALID_SOCKET != daemon->listen_socket) &&
+       (MHD_SC_OK != (sc = setup_thread_pool (daemon))) )
     return sc;
 
   /* make sure we know our listen port (if any) */
diff --git a/src/lib/init.c b/src/lib/init.c
index b23bdadf..5dcb02c4 100644
--- a/src/lib/init.c
+++ b/src/lib/init.c
@@ -36,7 +36,7 @@ volatile unsigned int global_init_count = 0;
 /**
  * Global initialisation mutex
  */
-MHD_MUTEX_STATIC_DEFN_INIT_(global_init_mutex_);
+MHD_MUTEX_STATIC_DEFN_INIT_ (global_init_mutex_);
 #endif /* MHD_MUTEX_STATIC_DEFN_INIT_ */
 
 #endif
@@ -59,21 +59,21 @@ static int mhd_winsock_inited_ = 0;
  */
 static void
 mhd_panic_std (void *cls,
-               const char *file,
-               unsigned int line,
-               const char *reason)
+               const char *file,
+               unsigned int line,
+               const char *reason)
 {
-  (void)cls; /* Mute compiler warning. */
+  (void) cls; /* Mute compiler warning. */
 #ifdef HAVE_MESSAGES
   fprintf (stderr,
-           _("Fatal error in GNU libmicrohttpd %s:%u: %s\n"),
-           file,
+           _ ("Fatal error in GNU libmicrohttpd %s:%u: %s\n"),
+           file,
            line,
            reason);
 #else  /* ! HAVE_MESSAGES */
-  (void)file;   /* Mute compiler warning. */
-  (void)line;   /* Mute compiler warning. */
-  (void)reason; /* Mute compiler warning. */
+  (void) file;   /* Mute compiler warning. */
+  (void) line;   /* Mute compiler warning. */
+  (void) reason; /* Mute compiler warning. */
 #endif
   abort ();
 }
@@ -93,13 +93,13 @@ MHD_init (void)
     mhd_panic = &mhd_panic_std;
 
 #if defined(_WIN32) && ! defined(__CYGWIN__)
-  if (0 != WSAStartup (MAKEWORD(2, 2),
-                       &wsd))
-    MHD_PANIC (_("Failed to initialize winsock\n"));
+  if (0 != WSAStartup (MAKEWORD (2, 2),
+                       &wsd))
+    MHD_PANIC (_ ("Failed to initialize winsock\n"));
   mhd_winsock_inited_ = 1;
-  if ( (2 != LOBYTE(wsd.wVersion)) &&
-       (2 != HIBYTE(wsd.wVersion)) )
-    MHD_PANIC (_("Winsock version 2.2 is not available\n"));
+  if ( (2 != LOBYTE (wsd.wVersion)) &&
+       (2 != HIBYTE (wsd.wVersion)) )
+    MHD_PANIC (_ ("Winsock version 2.2 is not available\n"));
 #endif
   MHD_monotonic_sec_counter_init ();
 #ifdef HAVE_FREEBSD_SENDFILE
@@ -116,14 +116,14 @@ MHD_fini (void)
 {
 #if defined(_WIN32) && ! defined(__CYGWIN__)
   if (mhd_winsock_inited_)
-    WSACleanup();
+    WSACleanup ();
 #endif
   MHD_monotonic_sec_counter_finish ();
 }
 
 #ifdef _AUTOINIT_FUNCS_ARE_SUPPORTED
 
-_SET_INIT_AND_DEINIT_FUNCS(MHD_init, MHD_fini);
+_SET_INIT_AND_DEINIT_FUNCS (MHD_init, MHD_fini);
 
 #else
 
@@ -135,12 +135,12 @@ void
 MHD_check_global_init_ (void)
 {
 #ifdef MHD_MUTEX_STATIC_DEFN_INIT_
-  MHD_mutex_lock_chk_(&global_init_mutex_);
+  MHD_mutex_lock_chk_ (&global_init_mutex_);
 #endif /* MHD_MUTEX_STATIC_DEFN_INIT_ */
   if (0 == global_init_count++)
     MHD_init ();
 #ifdef MHD_MUTEX_STATIC_DEFN_INIT_
-  MHD_mutex_unlock_chk_(&global_init_mutex_);
+  MHD_mutex_unlock_chk_ (&global_init_mutex_);
 #endif /* MHD_MUTEX_STATIC_DEFN_INIT_ */
 }
 #endif
diff --git a/src/lib/init.h b/src/lib/init.h
index fae96159..2d9a9389 100644
--- a/src/lib/init.h
+++ b/src/lib/init.h
@@ -31,7 +31,7 @@
  * Do nothing - global initialisation is
  * performed by library constructor.
  */
-#define MHD_check_global_init_() (void)0
+#define MHD_check_global_init_() (void) 0
 #else  /* ! _AUTOINIT_FUNCS_ARE_SUPPORTED */
 /**
  * Check whether global initialisation was performed
diff --git a/src/lib/internal.c b/src/lib/internal.c
index 75eae8a4..04d83624 100644
--- a/src/lib/internal.c
+++ b/src/lib/internal.c
@@ -35,50 +35,50 @@ const char *
 MHD_state_to_string (enum MHD_CONNECTION_STATE state)
 {
   switch (state)
-    {
-    case MHD_CONNECTION_INIT:
-      return "connection init";
-    case MHD_CONNECTION_URL_RECEIVED:
-      return "connection url received";
-    case MHD_CONNECTION_HEADER_PART_RECEIVED:
-      return "header partially received";
-    case MHD_CONNECTION_HEADERS_RECEIVED:
-      return "headers received";
-    case MHD_CONNECTION_HEADERS_PROCESSED:
-      return "headers processed";
-    case MHD_CONNECTION_CONTINUE_SENDING:
-      return "continue sending";
-    case MHD_CONNECTION_CONTINUE_SENT:
-      return "continue sent";
-    case MHD_CONNECTION_BODY_RECEIVED:
-      return "body received";
-    case MHD_CONNECTION_FOOTER_PART_RECEIVED:
-      return "footer partially received";
-    case MHD_CONNECTION_FOOTERS_RECEIVED:
-      return "footers received";
-    case MHD_CONNECTION_HEADERS_SENDING:
-      return "headers sending";
-    case MHD_CONNECTION_HEADERS_SENT:
-      return "headers sent";
-    case MHD_CONNECTION_NORMAL_BODY_READY:
-      return "normal body ready";
-    case MHD_CONNECTION_NORMAL_BODY_UNREADY:
-      return "normal body unready";
-    case MHD_CONNECTION_CHUNKED_BODY_READY:
-      return "chunked body ready";
-    case MHD_CONNECTION_CHUNKED_BODY_UNREADY:
-      return "chunked body unready";
-    case MHD_CONNECTION_BODY_SENT:
-      return "body sent";
-    case MHD_CONNECTION_FOOTERS_SENDING:
-      return "footers sending";
-    case MHD_CONNECTION_FOOTERS_SENT:
-      return "footers sent";
-    case MHD_CONNECTION_CLOSED:
-      return "closed";
-    default:
-      return "unrecognized connection state";
-    }
+  {
+  case MHD_CONNECTION_INIT:
+    return "connection init";
+  case MHD_CONNECTION_URL_RECEIVED:
+    return "connection url received";
+  case MHD_CONNECTION_HEADER_PART_RECEIVED:
+    return "header partially received";
+  case MHD_CONNECTION_HEADERS_RECEIVED:
+    return "headers received";
+  case MHD_CONNECTION_HEADERS_PROCESSED:
+    return "headers processed";
+  case MHD_CONNECTION_CONTINUE_SENDING:
+    return "continue sending";
+  case MHD_CONNECTION_CONTINUE_SENT:
+    return "continue sent";
+  case MHD_CONNECTION_BODY_RECEIVED:
+    return "body received";
+  case MHD_CONNECTION_FOOTER_PART_RECEIVED:
+    return "footer partially received";
+  case MHD_CONNECTION_FOOTERS_RECEIVED:
+    return "footers received";
+  case MHD_CONNECTION_HEADERS_SENDING:
+    return "headers sending";
+  case MHD_CONNECTION_HEADERS_SENT:
+    return "headers sent";
+  case MHD_CONNECTION_NORMAL_BODY_READY:
+    return "normal body ready";
+  case MHD_CONNECTION_NORMAL_BODY_UNREADY:
+    return "normal body unready";
+  case MHD_CONNECTION_CHUNKED_BODY_READY:
+    return "chunked body ready";
+  case MHD_CONNECTION_CHUNKED_BODY_UNREADY:
+    return "chunked body unready";
+  case MHD_CONNECTION_BODY_SENT:
+    return "body sent";
+  case MHD_CONNECTION_FOOTERS_SENDING:
+    return "footers sending";
+  case MHD_CONNECTION_FOOTERS_SENT:
+    return "footers sent";
+  case MHD_CONNECTION_CLOSED:
+    return "closed";
+  default:
+    return "unrecognized connection state";
+  }
 }
 #endif
 #endif
@@ -91,7 +91,7 @@ MHD_state_to_string (enum MHD_CONNECTION_STATE state)
  */
 void
 MHD_DLOG (const struct MHD_Daemon *daemon,
-          enum MHD_StatusCode sc,
+          enum MHD_StatusCode sc,
           const char *format,
           ...)
 {
@@ -100,11 +100,11 @@ MHD_DLOG (const struct MHD_Daemon *daemon,
   if (NULL == daemon->logger)
     return;
   va_start (va,
-            format);
+            format);
   daemon->logger (daemon->logger_cls,
-                  sc,
-                  format,
-                  va);
+                  sc,
+                  format,
+                  va);
   va_end (va);
 }
 #endif
@@ -120,7 +120,7 @@ MHD_unescape_plus (char *arg)
 {
   char *p;
 
-  for (p=strchr (arg, '+'); NULL != p; p = strchr (p + 1, '+'))
+  for (p = strchr (arg, '+'); NULL != p; p = strchr (p + 1, '+'))
     *p = ' ';
 }
 
@@ -141,28 +141,28 @@ MHD_http_unescape (char *val)
   char *wpos = val;
 
   while ('\0' != *rpos)
+  {
+    uint32_t num;
+    switch (*rpos)
     {
-      uint32_t num;
-      switch (*rpos)
-        {
-        case '%':
-          if (2 == MHD_strx_to_uint32_n_ (rpos + 1,
-                                          2,
-                                          &num))
-            {
-              *wpos = (char)((unsigned char) num);
-              wpos++;
-              rpos += 3;
-              break;
-            }
-          /* TODO: add bad sequence handling */
-          /* intentional fall through! */
-        default:
-          *wpos = *rpos;
-          wpos++;
-          rpos++;
-        }
+    case '%':
+      if (2 == MHD_strx_to_uint32_n_ (rpos + 1,
+                                      2,
+                                      &num))
+      {
+        *wpos = (char) ((unsigned char) num);
+        wpos++;
+        rpos += 3;
+        break;
+      }
+    /* TODO: add bad sequence handling */
+    /* intentional fall through! */
+    default:
+      *wpos = *rpos;
+      wpos++;
+      rpos++;
     }
+  }
   *wpos = '\0'; /* add 0-terminator */
   return wpos - val; /* = strlen(val) */
 }
@@ -184,10 +184,10 @@ MHD_http_unescape (char *val)
  */
 bool
 MHD_parse_arguments_ (struct MHD_Request *request,
-                      enum MHD_ValueKind kind,
-                      char *args,
-                      MHD_ArgumentIterator_ cb,
-                      unsigned int *num_headers)
+                      enum MHD_ValueKind kind,
+                      char *args,
+                      MHD_ArgumentIterator_ cb,
+                      unsigned int *num_headers)
 {
   struct MHD_Daemon *daemon = request->daemon;
   char *equals;
@@ -195,88 +195,88 @@ MHD_parse_arguments_ (struct MHD_Request *request,
 
   *num_headers = 0;
   while ( (NULL != args) &&
-          ('\0' != args[0]) )
+          ('\0' != args[0]) )
+  {
+    equals = strchr (args, '=');
+    amper = strchr (args, '&');
+    if (NULL == amper)
     {
-      equals = strchr (args, '=');
-      amper = strchr (args, '&');
-      if (NULL == amper)
-        {
-          /* last argument */
-          if (NULL == equals)
-            {
-              /* last argument, without '=' */
-              MHD_unescape_plus (args);
-              daemon->unescape_cb (daemon->unescape_cb_cls,
-                                   request,
-                                   args);
-              if (! cb (request,
-                        args,
-                        NULL,
-                        kind))
-                return false;
-              (*num_headers)++;
-              break;
-            }
-          /* got 'foo=bar' */
-          equals[0] = '\0';
-          equals++;
-          MHD_unescape_plus (args);
-          daemon->unescape_cb (daemon->unescape_cb_cls,
-                               request,
-                               args);
-          MHD_unescape_plus (equals);
-          daemon->unescape_cb (daemon->unescape_cb_cls,
-                               request,
-                               equals);
-          if (! cb (request,
-                    args,
-                    equals,
-                    kind))
-            return false;
-          (*num_headers)++;
-          break;
-        }
-      /* amper is non-NULL here */
-      amper[0] = '\0';
-      amper++;
-      if ( (NULL == equals) ||
-           (equals >= amper) )
-        {
-          /* got 'foo&bar' or 'foo&bar=val', add key 'foo' with NULL for value */
-          MHD_unescape_plus (args);
-          daemon->unescape_cb (daemon->unescape_cb_cls,
-                               request,
-                               args);
-          if (! cb (request,
-                    args,
-                    NULL,
-                    kind))
-            return false;
-          /* continue with 'bar' */
-          (*num_headers)++;
-          args = amper;
-          continue;
-        }
-      /* equals and amper are non-NULL here, and equals < amper,
-         so we got regular 'foo=value&bar...'-kind of argument */
+      /* last argument */
+      if (NULL == equals)
+      {
+        /* last argument, without '=' */
+        MHD_unescape_plus (args);
+        daemon->unescape_cb (daemon->unescape_cb_cls,
+                             request,
+                             args);
+        if (! cb (request,
+                  args,
+                  NULL,
+                  kind))
+          return false;
+        (*num_headers)++;
+        break;
+      }
+      /* got 'foo=bar' */
       equals[0] = '\0';
       equals++;
       MHD_unescape_plus (args);
       daemon->unescape_cb (daemon->unescape_cb_cls,
-                           request,
-                           args);
+                           request,
+                           args);
       MHD_unescape_plus (equals);
       daemon->unescape_cb (daemon->unescape_cb_cls,
-                           request,
-                           equals);
+                           request,
+                           equals);
+      if (! cb (request,
+                args,
+                equals,
+                kind))
+        return false;
+      (*num_headers)++;
+      break;
+    }
+    /* amper is non-NULL here */
+    amper[0] = '\0';
+    amper++;
+    if ( (NULL == equals) ||
+         (equals >= amper) )
+    {
+      /* got 'foo&bar' or 'foo&bar=val', add key 'foo' with NULL for value */
+      MHD_unescape_plus (args);
+      daemon->unescape_cb (daemon->unescape_cb_cls,
+                           request,
+                           args);
       if (! cb (request,
-                args,
-                         equals,
-                kind))
+                args,
+                NULL,
+                kind))
         return false;
+      /* continue with 'bar' */
       (*num_headers)++;
       args = amper;
+      continue;
     }
+    /* equals and amper are non-NULL here, and equals < amper,
+ so we got regular 'foo=value&bar...'-kind of argument */
+    equals[0] = '\0';
+    equals++;
+    MHD_unescape_plus (args);
+    daemon->unescape_cb (daemon->unescape_cb_cls,
+                         request,
+                         args);
+    MHD_unescape_plus (equals);
+    daemon->unescape_cb (daemon->unescape_cb_cls,
+                         request,
+                         equals);
+    if (! cb (request,
+              args,
+              equals,
+              kind))
+      return false;
+    (*num_headers)++;
+    args = amper;
+  }
   return true;
 }
 
diff --git a/src/lib/internal.h b/src/lib/internal.h
index bd3bd1c6..b5ec3039 100644
--- a/src/lib/internal.h
+++ b/src/lib/internal.h
@@ -58,14 +58,16 @@
  *
  * @param msg error message (const char *)
  */
-#define MHD_PANIC(msg) do { mhd_panic (mhd_panic_cls, __FILE__, __LINE__, msg); BUILTIN_NOT_REACHED; } while (0)
+#define MHD_PANIC(msg) do { mhd_panic (mhd_panic_cls, __FILE__, __LINE__, msg); \
+                            BUILTIN_NOT_REACHED; } while (0)
 #else
 /**
  * Trigger 'panic' action based on fatal errors.
  *
  * @param msg error message (const char *)
  */
-#define MHD_PANIC(msg) do { mhd_panic (mhd_panic_cls, __FILE__, __LINE__, NULL); BUILTIN_NOT_REACHED; } while (0)
+#define MHD_PANIC(msg) do { mhd_panic (mhd_panic_cls, __FILE__, __LINE__, NULL); \
+                            BUILTIN_NOT_REACHED; } while (0)
 #endif
 
 #include "mhd_threads.h"
@@ -82,8 +84,8 @@
  */
 void
 MHD_DLOG (const struct MHD_Daemon *daemon,
-          enum MHD_StatusCode sc,
-          const char *format,
+          enum MHD_StatusCode sc,
+          const char *format,
           ...);
 #endif
 
@@ -93,9 +95,9 @@ MHD_DLOG (const struct MHD_Daemon *daemon,
  * @param fd the FD to close
  */
 #define MHD_fd_close_chk_(fd) do {                      \
-    if ( (0 != close ((fd)) && (EBADF == errno)) )      \
-      MHD_PANIC(_("Failed to close FD.\n"));            \
-  } while(0)
+    if ( (0 != close ((fd)) && (EBADF == errno)) )  \
+      MHD_PANIC (_ ("Failed to close FD.\n"));            \
+} while (0)
 
 /**
  * Should we perform additional sanity checks at runtime (on our internal
@@ -128,10 +130,11 @@ extern MHD_PanicCallback mhd_panic;
 extern void *mhd_panic_cls;
 
 /* If we have Clang or gcc >= 4.5, use __buildin_unreachable() */
-#if defined(__clang__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
-#define BUILTIN_NOT_REACHED __builtin_unreachable()
+#if defined(__clang__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= \
+                                             5)
+#define BUILTIN_NOT_REACHED __builtin_unreachable ()
 #elif defined(_MSC_FULL_VER)
-#define BUILTIN_NOT_REACHED __assume(0)
+#define BUILTIN_NOT_REACHED __assume (0)
 #else
 #define BUILTIN_NOT_REACHED
 #endif
@@ -140,7 +143,7 @@ extern void *mhd_panic_cls;
 /**
  * Determine length of static string / macro strings at compile time.
  */
-#define MHD_STATICSTR_LEN_(macro) (sizeof(macro)/sizeof(char) - 1)
+#define MHD_STATICSTR_LEN_(macro) (sizeof(macro) / sizeof(char) - 1)
 #endif /* ! MHD_STATICSTR_LEN_ */
 
 
@@ -1534,8 +1537,8 @@ struct MHD_Daemon
  * @return #MHD_SC_OK on success, otherwise an error code
  */
 typedef enum MHD_StatusCode
-(*ActionCallback) (void *cls,
-                   struct MHD_Request *request);
+(*ActionCallback)(void *cls,
+                  struct MHD_Request *request);
 
 
 /**
@@ -1703,9 +1706,9 @@ struct MHD_Response
  */
 typedef bool
 (*MHD_ArgumentIterator_)(struct MHD_Request *request,
-                         const char *key,
-                         const char *value,
-                         enum MHD_ValueKind kind);
+                         const char *key,
+                         const char *value,
+                         enum MHD_ValueKind kind);
 
 
 /**
@@ -1724,10 +1727,10 @@ typedef bool
  */
 bool
 MHD_parse_arguments_ (struct MHD_Request *request,
-                      enum MHD_ValueKind kind,
-                      char *args,
-                      MHD_ArgumentIterator_ cb,
-                      unsigned int *num_headers);
+                      enum MHD_ValueKind kind,
+                      char *args,
+                      MHD_ArgumentIterator_ cb,
+                      unsigned int *num_headers);
 
 
 
@@ -1740,15 +1743,15 @@ MHD_parse_arguments_ (struct MHD_Request *request,
  * @param element element to insert
  */
 #define DLL_insert(head,tail,element) do { \
-  mhd_assert (NULL == (element)->next); \
-  mhd_assert (NULL == (element)->prev); \
-  (element)->next = (head); \
-  (element)->prev = NULL; \
-  if ((tail) == NULL) \
-    (tail) = element; \
-  else \
-    (head)->prev = element; \
-  (head) = (element); } while (0)
+    mhd_assert (NULL == (element)->next); \
+    mhd_assert (NULL == (element)->prev); \
+    (element)->next = (head); \
+    (element)->prev = NULL; \
+    if ((tail) == NULL) \
+      (tail) = element; \
+    else \
+      (head)->prev = element; \
+    (head) = (element); } while (0)
 
 
 /**
@@ -1760,18 +1763,18 @@ MHD_parse_arguments_ (struct MHD_Request *request,
  * @param element element to remove
  */
 #define DLL_remove(head,tail,element) do { \
-  mhd_assert ( (NULL != (element)->next) || ((element) == (tail)));  \
-  mhd_assert ( (NULL != (element)->prev) || ((element) == (head)));  \
-  if ((element)->prev == NULL) \
-    (head) = (element)->next;  \
-  else \
-    (element)->prev->next = (element)->next; \
-  if ((element)->next == NULL) \
-    (tail) = (element)->prev;  \
-  else \
-    (element)->next->prev = (element)->prev; \
-  (element)->next = NULL; \
-  (element)->prev = NULL; } while (0)
+    mhd_assert ( (NULL != (element)->next) || ((element) == (tail)));  \
+    mhd_assert ( (NULL != (element)->prev) || ((element) == (head)));  \
+    if ((element)->prev == NULL) \
+      (head) = (element)->next;  \
+    else \
+      (element)->prev->next = (element)->next; \
+    if ((element)->next == NULL) \
+      (tail) = (element)->prev;  \
+    else \
+      (element)->next->prev = (element)->prev; \
+    (element)->next = NULL; \
+    (element)->prev = NULL; } while (0)
 
 
 
@@ -1784,15 +1787,15 @@ MHD_parse_arguments_ (struct MHD_Request *request,
  * @param element element to insert
  */
 #define XDLL_insert(head,tail,element) do { \
-  mhd_assert (NULL == (element)->nextX); \
-  mhd_assert (NULL == (element)->prevX); \
-  (element)->nextX = (head); \
-  (element)->prevX = NULL; \
-  if (NULL == (tail)) \
-    (tail) = element; \
-  else \
-    (head)->prevX = element; \
-  (head) = (element); } while (0)
+    mhd_assert (NULL == (element)->nextX); \
+    mhd_assert (NULL == (element)->prevX); \
+    (element)->nextX = (head); \
+    (element)->prevX = NULL; \
+    if (NULL == (tail)) \
+      (tail) = element; \
+    else \
+      (head)->prevX = element; \
+    (head) = (element); } while (0)
 
 
 /**
@@ -1804,18 +1807,18 @@ MHD_parse_arguments_ (struct MHD_Request *request,
  * @param element element to remove
  */
 #define XDLL_remove(head,tail,element) do { \
-  mhd_assert ( (NULL != (element)->nextX) || ((element) == (tail)));  \
-  mhd_assert ( (NULL != (element)->prevX) || ((element) == (head)));  \
-  if (NULL == (element)->prevX) \
-    (head) = (element)->nextX;  \
-  else \
-    (element)->prevX->nextX = (element)->nextX; \
-  if (NULL == (element)->nextX) \
-    (tail) = (element)->prevX;  \
-  else \
-    (element)->nextX->prevX = (element)->prevX; \
-  (element)->nextX = NULL; \
-  (element)->prevX = NULL; } while (0)
+    mhd_assert ( (NULL != (element)->nextX) || ((element) == (tail)));  \
+    mhd_assert ( (NULL != (element)->prevX) || ((element) == (head)));  \
+    if (NULL == (element)->prevX) \
+      (head) = (element)->nextX;  \
+    else \
+      (element)->prevX->nextX = (element)->nextX; \
+    if (NULL == (element)->nextX) \
+      (tail) = (element)->prevX;  \
+    else \
+      (element)->nextX->prevX = (element)->prevX; \
+    (element)->nextX = NULL; \
+    (element)->prevX = NULL; } while (0)
 
 
 /**
@@ -1827,13 +1830,13 @@ MHD_parse_arguments_ (struct MHD_Request *request,
  * @param element element to insert
  */
 #define EDLL_insert(head,tail,element) do { \
-  (element)->nextE = (head); \
-  (element)->prevE = NULL; \
-  if ((tail) == NULL) \
-    (tail) = element; \
-  else \
-    (head)->prevE = element; \
-  (head) = (element); } while (0)
+    (element)->nextE = (head); \
+    (element)->prevE = NULL; \
+    if ((tail) == NULL) \
+      (tail) = element; \
+    else \
+      (head)->prevE = element; \
+    (head) = (element); } while (0)
 
 
 /**
@@ -1845,16 +1848,16 @@ MHD_parse_arguments_ (struct MHD_Request *request,
  * @param element element to remove
  */
 #define EDLL_remove(head,tail,element) do { \
-  if ((element)->prevE == NULL) \
-    (head) = (element)->nextE;  \
-  else \
-    (element)->prevE->nextE = (element)->nextE; \
-  if ((element)->nextE == NULL) \
-    (tail) = (element)->prevE;  \
-  else \
-    (element)->nextE->prevE = (element)->prevE; \
-  (element)->nextE = NULL; \
-  (element)->prevE = NULL; } while (0)
+    if ((element)->prevE == NULL) \
+      (head) = (element)->nextE;  \
+    else \
+      (element)->prevE->nextE = (element)->nextE; \
+    if ((element)->nextE == NULL) \
+      (tail) = (element)->prevE;  \
+    else \
+      (element)->nextE->prevE = (element)->prevE; \
+    (element)->nextE = NULL; \
+    (element)->prevE = NULL; } while (0)
 
 
 
diff --git a/src/lib/md5.c b/src/lib/md5.c
index a7eb35fe..3d0f7493 100644
--- a/src/lib/md5.c
+++ b/src/lib/md5.c
@@ -20,21 +20,21 @@
 #include "md5.h"
 #include "mhd_byteorder.h"
 
-#define PUT_64BIT_LE(cp, value) do {                                    \
-        (cp)[7] = (uint8_t)((value) >> 56);                             \
-        (cp)[6] = (uint8_t)((value) >> 48);                             \
-        (cp)[5] = (uint8_t)((value) >> 40);                             \
-        (cp)[4] = (uint8_t)((value) >> 32);                             \
-        (cp)[3] = (uint8_t)((value) >> 24);                             \
-        (cp)[2] = (uint8_t)((value) >> 16);                             \
-        (cp)[1] = (uint8_t)((value) >> 8);                              \
-        (cp)[0] = (uint8_t)((value)); } while (0)
-
-#define PUT_32BIT_LE(cp, value) do {                                    \
-        (cp)[3] = (uint8_t)((value) >> 24);                             \
-        (cp)[2] = (uint8_t)((value) >> 16);                             \
-        (cp)[1] = (uint8_t)((value) >> 8);                              \
-        (cp)[0] = (uint8_t)((value)); } while (0)
+#define PUT_64BIT_LE(cp, value) do {          \
+    (cp)[7] = (uint8_t) ((value) >> 56);       \
+    (cp)[6] = (uint8_t) ((value) >> 48);       \
+    (cp)[5] = (uint8_t) ((value) >> 40);       \
+    (cp)[4] = (uint8_t) ((value) >> 32);       \
+    (cp)[3] = (uint8_t) ((value) >> 24);       \
+    (cp)[2] = (uint8_t) ((value) >> 16);       \
+    (cp)[1] = (uint8_t) ((value) >> 8);        \
+    (cp)[0] = (uint8_t) ((value)); } while (0)
+
+#define PUT_32BIT_LE(cp, value) do {          \
+    (cp)[3] = (uint8_t) ((value) >> 24);       \
+    (cp)[2] = (uint8_t) ((value) >> 16);       \
+    (cp)[1] = (uint8_t) ((value) >> 8);        \
+    (cp)[0] = (uint8_t) ((value)); } while (0)
 
 static uint8_t PADDING[MD5_BLOCK_SIZE] = {
   0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -47,9 +47,9 @@ static uint8_t PADDING[MD5_BLOCK_SIZE] = {
  * initialization constants.
  */
 void
-MHD_MD5Init(struct MD5Context *ctx)
+MHD_MD5Init (struct MD5Context *ctx)
 {
-  if (!ctx)
+  if (! ctx)
     return;
 
   ctx->count = 0;
@@ -64,26 +64,26 @@ MHD_MD5Init(struct MD5Context *ctx)
  * of bytes.
  */
 void
-MHD_MD5Update(struct MD5Context *ctx, const unsigned char *input, size_t len)
+MHD_MD5Update (struct MD5Context *ctx, const unsigned char *input, size_t len)
 {
   size_t have, need;
 
-  if (!ctx || !input)
+  if (! ctx || ! input)
     return;
 
   /* Check how many bytes we already have and how many more we need. */
-  have = (size_t)((ctx->count >> 3) & (MD5_BLOCK_SIZE - 1));
+  have = (size_t) ((ctx->count >> 3) & (MD5_BLOCK_SIZE - 1));
   need = MD5_BLOCK_SIZE - have;
 
   /* Update bitcount */
-  ctx->count += (uint64_t)len << 3;
+  ctx->count += (uint64_t) len << 3;
 
   if (len >= need)
   {
     if (have != 0)
     {
-      memcpy(ctx->buffer + have, input, need);
-      MD5Transform(ctx->state, ctx->buffer);
+      memcpy (ctx->buffer + have, input, need);
+      MD5Transform (ctx->state, ctx->buffer);
       input += need;
       len -= need;
       have = 0;
@@ -92,7 +92,7 @@ MHD_MD5Update(struct MD5Context *ctx, const unsigned char *input, size_t len)
     /* Process data in MD5_BLOCK_SIZE-byte chunks. */
     while (len >= MD5_BLOCK_SIZE)
     {
-      MD5Transform(ctx->state, input);
+      MD5Transform (ctx->state, input);
       input += MD5_BLOCK_SIZE;
       len -= MD5_BLOCK_SIZE;
     }
@@ -100,7 +100,7 @@ MHD_MD5Update(struct MD5Context *ctx, const unsigned char *input, size_t len)
 
   /* Handle any remaining bytes of data. */
   if (len != 0)
-    memcpy(ctx->buffer + have, input, len);
+    memcpy (ctx->buffer + have, input, len);
 }
 
 /*
@@ -108,42 +108,42 @@ MHD_MD5Update(struct MD5Context *ctx, const unsigned char *input, size_t len)
  * 1 0* (64-bit count of bits processed, MSB-first)
  */
 void
-MD5Pad(struct MD5Context *ctx)
+MD5Pad (struct MD5Context *ctx)
 {
   uint8_t count[8];
   size_t padlen;
 
-  if (!ctx)
+  if (! ctx)
     return;
 
   /* Convert count to 8 bytes in little endian order. */
-  PUT_64BIT_LE(count, ctx->count);
+  PUT_64BIT_LE (count, ctx->count);
 
   /* Pad out to 56 mod 64. */
-  padlen = MD5_BLOCK_SIZE -
-    ((ctx->count >> 3) & (MD5_BLOCK_SIZE - 1));
+  padlen = MD5_BLOCK_SIZE
+           - ((ctx->count >> 3) & (MD5_BLOCK_SIZE - 1));
   if (padlen < 1 + 8)
     padlen += MD5_BLOCK_SIZE;
-  MHD_MD5Update(ctx, PADDING, padlen - 8);              /* padlen - 8 <= 64 */
-  MHD_MD5Update(ctx, count, 8);
+  MHD_MD5Update (ctx, PADDING, padlen - 8);    /* padlen - 8 <= 64 */
+  MHD_MD5Update (ctx, count, 8);
 }
 
 /*
  * Final wrapup--call MD5Pad, fill in digest and zero out ctx.
  */
 void
-MHD_MD5Final(unsigned char digest[MD5_DIGEST_SIZE], struct MD5Context *ctx)
+MHD_MD5Final (unsigned char digest[MD5_DIGEST_SIZE], struct MD5Context *ctx)
 {
   int i;
 
-  if (!ctx || !digest)
+  if (! ctx || ! digest)
     return;
 
-  MD5Pad(ctx);
+  MD5Pad (ctx);
   for (i = 0; i < 4; i++)
-    PUT_32BIT_LE(digest + i * 4, ctx->state[i]);
+    PUT_32BIT_LE (digest + i * 4, ctx->state[i]);
 
-  memset(ctx, 0, sizeof(*ctx));
+  memset (ctx, 0, sizeof(*ctx));
 }
 
 
@@ -151,13 +151,13 @@ MHD_MD5Final(unsigned char digest[MD5_DIGEST_SIZE], struct MD5Context *ctx)
 
 /* #define F1(x, y, z) (x & y | ~x & z) */
 #define F1(x, y, z) (z ^ (x & (y ^ z)))
-#define F2(x, y, z) F1(z, x, y)
+#define F2(x, y, z) F1 (z, x, y)
 #define F3(x, y, z) (x ^ y ^ z)
 #define F4(x, y, z) (y ^ (x | ~z))
 
 /* This is the central step in the MD5 algorithm. */
 #define MD5STEP(f, w, x, y, z, data, s) \
-        ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+  (w += f (x, y, z) + data,  w = w << s | w >> (32 - s),  w += x)
 
 /*
  * The core of the MD5 algorithm, this alters an existing MD5 hash to
@@ -165,20 +165,20 @@ MHD_MD5Final(unsigned char digest[MD5_DIGEST_SIZE], struct MD5Context *ctx)
  * the data and converts bytes into longwords for this routine.
  */
 void
-MD5Transform(uint32_t state[4], const uint8_t block[MD5_BLOCK_SIZE])
+MD5Transform (uint32_t state[4], const uint8_t block[MD5_BLOCK_SIZE])
 {
   uint32_t a, b, c, d, in[MD5_BLOCK_SIZE / 4];
 
 #if _MHD_BYTE_ORDER == _MHD_LITTLE_ENDIAN
-  memcpy(in, block, sizeof(in));
+  memcpy (in, block, sizeof(in));
 #else
   for (a = 0; a < MD5_BLOCK_SIZE / 4; a++)
   {
-    in[a] = (uint32_t)(
-      (uint32_t)(block[a * 4 + 0]) |
-      (uint32_t)(block[a * 4 + 1]) << 8 |
-      (uint32_t)(block[a * 4 + 2]) << 16 |
-      (uint32_t)(block[a * 4 + 3]) << 24);
+    in[a] = (uint32_t) (
+      (uint32_t) (block[a * 4 + 0])
+      | (uint32_t) (block[a * 4 + 1]) << 8
+        | (uint32_t) (block[a * 4 + 2]) << 16
+        | (uint32_t) (block[a * 4 + 3]) << 24);
   }
 #endif
 
@@ -187,73 +187,73 @@ MD5Transform(uint32_t state[4], const uint8_t block[MD5_BLOCK_SIZE])
   c = state[2];
   d = state[3];
 
-  MD5STEP(F1, a, b, c, d, in[0]  + 0xd76aa478, 7);
-  MD5STEP(F1, d, a, b, c, in[1]  + 0xe8c7b756, 12);
-  MD5STEP(F1, c, d, a, b, in[2]  + 0x242070db, 17);
-  MD5STEP(F1, b, c, d, a, in[3]  + 0xc1bdceee, 22);
-  MD5STEP(F1, a, b, c, d, in[4]  + 0xf57c0faf, 7);
-  MD5STEP(F1, d, a, b, c, in[5]  + 0x4787c62a, 12);
-  MD5STEP(F1, c, d, a, b, in[6]  + 0xa8304613, 17);
-  MD5STEP(F1, b, c, d, a, in[7]  + 0xfd469501, 22);
-  MD5STEP(F1, a, b, c, d, in[8]  + 0x698098d8, 7);
-  MD5STEP(F1, d, a, b, c, in[9]  + 0x8b44f7af, 12);
-  MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
-  MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
-  MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
-  MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
-  MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
-  MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
-
-  MD5STEP(F2, a, b, c, d, in[1]  + 0xf61e2562, 5);
-  MD5STEP(F2, d, a, b, c, in[6]  + 0xc040b340, 9);
-  MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
-  MD5STEP(F2, b, c, d, a, in[0]  + 0xe9b6c7aa, 20);
-  MD5STEP(F2, a, b, c, d, in[5]  + 0xd62f105d, 5);
-  MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
-  MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
-  MD5STEP(F2, b, c, d, a, in[4]  + 0xe7d3fbc8, 20);
-  MD5STEP(F2, a, b, c, d, in[9]  + 0x21e1cde6, 5);
-  MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
-  MD5STEP(F2, c, d, a, b, in[3]  + 0xf4d50d87, 14);
-  MD5STEP(F2, b, c, d, a, in[8]  + 0x455a14ed, 20);
-  MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
-  MD5STEP(F2, d, a, b, c, in[2]  + 0xfcefa3f8, 9);
-  MD5STEP(F2, c, d, a, b, in[7]  + 0x676f02d9, 14);
-  MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
-
-  MD5STEP(F3, a, b, c, d, in[5]  + 0xfffa3942, 4);
-  MD5STEP(F3, d, a, b, c, in[8]  + 0x8771f681, 11);
-  MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
-  MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
-  MD5STEP(F3, a, b, c, d, in[1]  + 0xa4beea44, 4);
-  MD5STEP(F3, d, a, b, c, in[4]  + 0x4bdecfa9, 11);
-  MD5STEP(F3, c, d, a, b, in[7]  + 0xf6bb4b60, 16);
-  MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
-  MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
-  MD5STEP(F3, d, a, b, c, in[0]  + 0xeaa127fa, 11);
-  MD5STEP(F3, c, d, a, b, in[3]  + 0xd4ef3085, 16);
-  MD5STEP(F3, b, c, d, a, in[6]  + 0x04881d05, 23);
-  MD5STEP(F3, a, b, c, d, in[9]  + 0xd9d4d039, 4);
-  MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
-  MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
-  MD5STEP(F3, b, c, d, a, in[2]  + 0xc4ac5665, 23);
-
-  MD5STEP(F4, a, b, c, d, in[0]  + 0xf4292244, 6);
-  MD5STEP(F4, d, a, b, c, in[7]  + 0x432aff97, 10);
-  MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
-  MD5STEP(F4, b, c, d, a, in[5]  + 0xfc93a039, 21);
-  MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
-  MD5STEP(F4, d, a, b, c, in[3]  + 0x8f0ccc92, 10);
-  MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
-  MD5STEP(F4, b, c, d, a, in[1]  + 0x85845dd1, 21);
-  MD5STEP(F4, a, b, c, d, in[8]  + 0x6fa87e4f, 6);
-  MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
-  MD5STEP(F4, c, d, a, b, in[6]  + 0xa3014314, 15);
-  MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
-  MD5STEP(F4, a, b, c, d, in[4]  + 0xf7537e82, 6);
-  MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
-  MD5STEP(F4, c, d, a, b, in[2]  + 0x2ad7d2bb, 15);
-  MD5STEP(F4, b, c, d, a, in[9]  + 0xeb86d391, 21);
+  MD5STEP (F1, a, b, c, d, in[0]  + 0xd76aa478, 7);
+  MD5STEP (F1, d, a, b, c, in[1]  + 0xe8c7b756, 12);
+  MD5STEP (F1, c, d, a, b, in[2]  + 0x242070db, 17);
+  MD5STEP (F1, b, c, d, a, in[3]  + 0xc1bdceee, 22);
+  MD5STEP (F1, a, b, c, d, in[4]  + 0xf57c0faf, 7);
+  MD5STEP (F1, d, a, b, c, in[5]  + 0x4787c62a, 12);
+  MD5STEP (F1, c, d, a, b, in[6]  + 0xa8304613, 17);
+  MD5STEP (F1, b, c, d, a, in[7]  + 0xfd469501, 22);
+  MD5STEP (F1, a, b, c, d, in[8]  + 0x698098d8, 7);
+  MD5STEP (F1, d, a, b, c, in[9]  + 0x8b44f7af, 12);
+  MD5STEP (F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
+  MD5STEP (F1, b, c, d, a, in[11] + 0x895cd7be, 22);
+  MD5STEP (F1, a, b, c, d, in[12] + 0x6b901122, 7);
+  MD5STEP (F1, d, a, b, c, in[13] + 0xfd987193, 12);
+  MD5STEP (F1, c, d, a, b, in[14] + 0xa679438e, 17);
+  MD5STEP (F1, b, c, d, a, in[15] + 0x49b40821, 22);
+
+  MD5STEP (F2, a, b, c, d, in[1]  + 0xf61e2562, 5);
+  MD5STEP (F2, d, a, b, c, in[6]  + 0xc040b340, 9);
+  MD5STEP (F2, c, d, a, b, in[11] + 0x265e5a51, 14);
+  MD5STEP (F2, b, c, d, a, in[0]  + 0xe9b6c7aa, 20);
+  MD5STEP (F2, a, b, c, d, in[5]  + 0xd62f105d, 5);
+  MD5STEP (F2, d, a, b, c, in[10] + 0x02441453, 9);
+  MD5STEP (F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
+  MD5STEP (F2, b, c, d, a, in[4]  + 0xe7d3fbc8, 20);
+  MD5STEP (F2, a, b, c, d, in[9]  + 0x21e1cde6, 5);
+  MD5STEP (F2, d, a, b, c, in[14] + 0xc33707d6, 9);
+  MD5STEP (F2, c, d, a, b, in[3]  + 0xf4d50d87, 14);
+  MD5STEP (F2, b, c, d, a, in[8]  + 0x455a14ed, 20);
+  MD5STEP (F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
+  MD5STEP (F2, d, a, b, c, in[2]  + 0xfcefa3f8, 9);
+  MD5STEP (F2, c, d, a, b, in[7]  + 0x676f02d9, 14);
+  MD5STEP (F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
+
+  MD5STEP (F3, a, b, c, d, in[5]  + 0xfffa3942, 4);
+  MD5STEP (F3, d, a, b, c, in[8]  + 0x8771f681, 11);
+  MD5STEP (F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
+  MD5STEP (F3, b, c, d, a, in[14] + 0xfde5380c, 23);
+  MD5STEP (F3, a, b, c, d, in[1]  + 0xa4beea44, 4);
+  MD5STEP (F3, d, a, b, c, in[4]  + 0x4bdecfa9, 11);
+  MD5STEP (F3, c, d, a, b, in[7]  + 0xf6bb4b60, 16);
+  MD5STEP (F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
+  MD5STEP (F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
+  MD5STEP (F3, d, a, b, c, in[0]  + 0xeaa127fa, 11);
+  MD5STEP (F3, c, d, a, b, in[3]  + 0xd4ef3085, 16);
+  MD5STEP (F3, b, c, d, a, in[6]  + 0x04881d05, 23);
+  MD5STEP (F3, a, b, c, d, in[9]  + 0xd9d4d039, 4);
+  MD5STEP (F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
+  MD5STEP (F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
+  MD5STEP (F3, b, c, d, a, in[2]  + 0xc4ac5665, 23);
+
+  MD5STEP (F4, a, b, c, d, in[0]  + 0xf4292244, 6);
+  MD5STEP (F4, d, a, b, c, in[7]  + 0x432aff97, 10);
+  MD5STEP (F4, c, d, a, b, in[14] + 0xab9423a7, 15);
+  MD5STEP (F4, b, c, d, a, in[5]  + 0xfc93a039, 21);
+  MD5STEP (F4, a, b, c, d, in[12] + 0x655b59c3, 6);
+  MD5STEP (F4, d, a, b, c, in[3]  + 0x8f0ccc92, 10);
+  MD5STEP (F4, c, d, a, b, in[10] + 0xffeff47d, 15);
+  MD5STEP (F4, b, c, d, a, in[1]  + 0x85845dd1, 21);
+  MD5STEP (F4, a, b, c, d, in[8]  + 0x6fa87e4f, 6);
+  MD5STEP (F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
+  MD5STEP (F4, c, d, a, b, in[6]  + 0xa3014314, 15);
+  MD5STEP (F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
+  MD5STEP (F4, a, b, c, d, in[4]  + 0xf7537e82, 6);
+  MD5STEP (F4, d, a, b, c, in[11] + 0xbd3af235, 10);
+  MD5STEP (F4, c, d, a, b, in[2]  + 0x2ad7d2bb, 15);
+  MD5STEP (F4, b, c, d, a, in[9]  + 0xeb86d391, 21);
 
   state[0] += a;
   state[1] += b;
diff --git a/src/lib/md5.h b/src/lib/md5.h
index 7a6f84e6..8e95b29b 100644
--- a/src/lib/md5.h
+++ b/src/lib/md5.h
@@ -20,45 +20,47 @@
 
 #include "platform.h"
 
-#define MD5_BLOCK_SIZE              64
-#define MD5_DIGEST_SIZE             16
-#define MD5_DIGEST_STRING_LENGTH    (MD5_DIGEST_SIZE * 2 + 1)
+#define MD5_BLOCK_SIZE              64
+#define MD5_DIGEST_SIZE             16
+#define MD5_DIGEST_STRING_LENGTH    (MD5_DIGEST_SIZE * 2 + 1)
 
 struct MD5Context
 {
-  uint32_t state[4];                    /* state */
-  uint64_t count;                       /* number of bits, mod 2^64 */
-  uint8_t buffer[MD5_BLOCK_SIZE];       /* input buffer */
+  uint32_t state[4];      /* state */
+  uint64_t count;     /* number of bits, mod 2^64 */
+  uint8_t buffer[MD5_BLOCK_SIZE]; /* input buffer */
 };
 
 /*
  * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
  * initialization constants.
  */
-void MHD_MD5Init(struct MD5Context *ctx);
+void MHD_MD5Init (struct MD5Context *ctx);
 
 /*
  * Update context to reflect the concatenation of another buffer full
  * of bytes.
  */
-void MHD_MD5Update(struct MD5Context *ctx, const unsigned char *input, size_t len);
+void MHD_MD5Update (struct MD5Context *ctx, const unsigned char *input, size_t
+                    len);
 
 /*
  * Pad pad to 64-byte boundary with the bit pattern
  * 1 0* (64-bit count of bits processed, MSB-first)
  */
-void MD5Pad(struct MD5Context *ctx);
+void MD5Pad (struct MD5Context *ctx);
 
 /*
  * Final wrapup--call MD5Pad, fill in digest and zero out ctx.
  */
-void MHD_MD5Final(unsigned char digest[MD5_DIGEST_SIZE], struct MD5Context *ctx);
+void MHD_MD5Final (unsigned char digest[MD5_DIGEST_SIZE], struct
+                   MD5Context *ctx);
 
 /*
  * The core of the MD5 algorithm, this alters an existing MD5 hash to
  * reflect the addition of 16 longwords of new data.  MHD_MD5Update blocks
  * the data and converts bytes into longwords for this routine.
  */
-void MD5Transform(uint32_t state[4], const uint8_t block[MD5_BLOCK_SIZE]);
+void MD5Transform (uint32_t state[4], const uint8_t block[MD5_BLOCK_SIZE]);
 
 #endif /* !MHD_MD5_H */
diff --git a/src/lib/memorypool.c b/src/lib/memorypool.c
index 8ef1e2d1..9f7472e1 100644
--- a/src/lib/memorypool.c
+++ b/src/lib/memorypool.c
@@ -25,11 +25,11 @@
 #include "memorypool.h"
 
 /* define MAP_ANONYMOUS for Mac OS X */
-#if defined(MAP_ANON) && !defined(MAP_ANONYMOUS)
+#if defined(MAP_ANON) && ! defined(MAP_ANONYMOUS)
 #define MAP_ANONYMOUS MAP_ANON
 #endif
 #ifndef MAP_FAILED
-#define MAP_FAILED ((void*)-1)
+#define MAP_FAILED ((void*) -1)
 #endif
 
 /**
@@ -40,7 +40,7 @@
 /**
  * Round up 'n' to a multiple of ALIGN_SIZE.
  */
-#define ROUND_TO_ALIGN(n) ((n+(ALIGN_SIZE-1)) & (~(ALIGN_SIZE-1)))
+#define ROUND_TO_ALIGN(n) ((n + (ALIGN_SIZE - 1)) & (~(ALIGN_SIZE - 1)))
 
 
 /**
@@ -110,11 +110,11 @@ MHD_pool_create (size_t max)
   if (max <= 32 * 1024)
     pool->memory = MAP_FAILED;
   else
-#if defined(MAP_ANONYMOUS) && !defined(_WIN32)
+#if defined(MAP_ANONYMOUS) && ! defined(_WIN32)
     pool->memory = mmap (NULL,
                          max,
                          PROT_READ | PROT_WRITE,
-                         MAP_PRIVATE | MAP_ANONYMOUS,
+                         MAP_PRIVATE | MAP_ANONYMOUS,
                          -1,
                          0);
 #elif defined(_WIN32)
@@ -128,19 +128,19 @@ MHD_pool_create (size_t max)
 #endif
   if ( (MAP_FAILED == pool->memory) ||
        (NULL == pool->memory))
+  {
+    pool->memory = malloc (max);
+    if (NULL == pool->memory)
     {
-      pool->memory = malloc (max);
-      if (NULL == pool->memory)
-        {
-          free (pool);
-          return NULL;
-        }
-      pool->is_mmap = false;
+      free (pool);
+      return NULL;
     }
+    pool->is_mmap = false;
+  }
   else
-    {
-      pool->is_mmap = true;
-    }
+  {
+    pool->is_mmap = true;
+  }
   pool->pos = 0;
   pool->end = max;
   pool->size = max;
@@ -161,7 +161,7 @@ MHD_pool_destroy (struct MemoryPool *pool)
   if (! pool->is_mmap)
     free (pool->memory);
   else
-#if defined(MAP_ANONYMOUS) && !defined(_WIN32)
+#if defined(MAP_ANONYMOUS) && ! defined(_WIN32)
     munmap (pool->memory,
             pool->size);
 #elif defined(_WIN32)
@@ -201,7 +201,7 @@ MHD_pool_get_free (struct MemoryPool *pool)
  */
 void *
 MHD_pool_allocate (struct MemoryPool *pool,
-                   size_t size,
+                   size_t size,
                    int from_end)
 {
   void *ret;
@@ -214,15 +214,15 @@ MHD_pool_allocate (struct MemoryPool *pool,
        (pool->pos + asize < pool->pos))
     return NULL;
   if (from_end == MHD_YES)
-    {
-      ret = &pool->memory[pool->end - asize];
-      pool->end -= asize;
-    }
+  {
+    ret = &pool->memory[pool->end - asize];
+    pool->end -= asize;
+  }
   else
-    {
-      ret = &pool->memory[pool->pos];
-      pool->pos += asize;
-    }
+  {
+    ret = &pool->memory[pool->pos];
+    pool->pos += asize;
+  }
   return ret;
 }
 
@@ -247,8 +247,8 @@ MHD_pool_allocate (struct MemoryPool *pool,
 void *
 MHD_pool_reallocate (struct MemoryPool *pool,
                      void *old,
-                     size_t old_size,
-                     size_t new_size)
+                     size_t old_size,
+                     size_t new_size)
 {
   void *ret;
   size_t asize;
@@ -263,35 +263,35 @@ MHD_pool_reallocate (struct MemoryPool *pool,
 
   if ( (pool->pos >= old_size) &&
        (&pool->memory[pool->pos - old_size] == old) )
+  {
+    /* was the previous allocation - optimize! */
+    if (pool->pos + asize - old_size <= pool->end)
     {
-      /* was the previous allocation - optimize! */
-      if (pool->pos + asize - old_size <= pool->end)
-        {
-          /* fits */
-          pool->pos += asize - old_size;
-          if (asize < old_size)      /* shrinking - zero again! */
-            memset (&pool->memory[pool->pos],
-                    0,
-                    old_size - asize);
-          return old;
-        }
-      /* does not fit */
-      return NULL;
+      /* fits */
+      pool->pos += asize - old_size;
+      if (asize < old_size)          /* shrinking - zero again! */
+        memset (&pool->memory[pool->pos],
+                0,
+                old_size - asize);
+      return old;
     }
+    /* does not fit */
+    return NULL;
+  }
   if (asize <= old_size)
     return old;                 /* cannot shrink, no need to move */
   if ((pool->pos + asize >= pool->pos) &&
       (pool->pos + asize <= pool->end))
-    {
-      /* fits */
-      ret = &pool->memory[pool->pos];
-      if (0 != old_size)
-        memmove (ret,
-                 old,
-                 old_size);
-      pool->pos += asize;
-      return ret;
-    }
+  {
+    /* fits */
+    ret = &pool->memory[pool->pos];
+    if (0 != old_size)
+      memmove (ret,
+               old,
+               old_size);
+    pool->pos += asize;
+    return ret;
+  }
   /* does not fit */
   return NULL;
 }
@@ -312,19 +312,19 @@ MHD_pool_reallocate (struct MemoryPool *pool,
  */
 void *
 MHD_pool_reset (struct MemoryPool *pool,
-                void *keep,
-                size_t copy_bytes,
+                void *keep,
+                size_t copy_bytes,
                 size_t new_size)
 {
   if ( (NULL != keep) &&
        (keep != pool->memory) )
-    {
-      if (0 != copy_bytes)
-        memmove (pool->memory,
-                 keep,
-                 copy_bytes);
-      keep = pool->memory;
-    }
+  {
+    if (0 != copy_bytes)
+      memmove (pool->memory,
+               keep,
+               copy_bytes);
+    keep = pool->memory;
+  }
   pool->end = pool->size;
   /* technically not needed, but safer to zero out */
   if (pool->size > copy_bytes)
diff --git a/src/lib/memorypool.h b/src/lib/memorypool.h
index 36136af8..774b05ba 100644
--- a/src/lib/memorypool.h
+++ b/src/lib/memorypool.h
@@ -70,7 +70,7 @@ MHD_pool_destroy (struct MemoryPool *pool);
  */
 void *
 MHD_pool_allocate (struct MemoryPool *pool,
-                   size_t size,
+                   size_t size,
                    int from_end);
 
 
@@ -93,9 +93,9 @@ MHD_pool_allocate (struct MemoryPool *pool,
  */
 void *
 MHD_pool_reallocate (struct MemoryPool *pool,
-                     void *old,
-                     size_t old_size,
-                     size_t new_size);
+                     void *old,
+                     size_t old_size,
+                     size_t new_size);
 
 
 /**
@@ -123,8 +123,8 @@ MHD_pool_get_free (struct MemoryPool *pool);
  */
 void *
 MHD_pool_reset (struct MemoryPool *pool,
-                void *keep,
-                size_t copy_bytes,
+                void *keep,
+                size_t copy_bytes,
                 size_t new_size);
 
 #endif
diff --git a/src/lib/mhd_assert.h b/src/lib/mhd_assert.h
index c720ce5c..e99632d0 100644
--- a/src/lib/mhd_assert.h
+++ b/src/lib/mhd_assert.h
@@ -28,21 +28,21 @@
 
 #include "mhd_options.h"
 #ifdef NDEBUG
-#  define mhd_assert(ignore) ((void)0)
+#  define mhd_assert(ignore) ((void) 0)
 #else  /* _DEBUG */
 #  ifdef HAVE_ASSERT
 #    include <assert.h>
-#    define mhd_assert(CHK) assert(CHK)
+#    define mhd_assert(CHK) assert (CHK)
 #  else  /* ! HAVE_ASSERT */
 #    include <stdio.h>
 #    include <stdlib.h>
 #    define mhd_assert(CHK) \
-       do { \
-           if (!(CHK)) { \
-             fprintf(stderr, "%s:%u Assertion failed: %s\nProgram aborted.\n", \
-                     __FILE__, (unsigned)__LINE__, #CHK); \
-             fflush(stderr); abort(); } \
-          } while(0)
+  do { \
+    if (! (CHK)) { \
+      fprintf (stderr, "%s:%u Assertion failed: %s\nProgram aborted.\n", \
+               __FILE__, (unsigned) __LINE__, #CHK); \
+      fflush (stderr); abort (); } \
+  } while (0)
 #  endif /* ! HAVE_ASSERT */
 #endif /* _DEBUG */
 
diff --git a/src/lib/mhd_byteorder.h b/src/lib/mhd_byteorder.h
index 66689804..230ae803 100644
--- a/src/lib/mhd_byteorder.h
+++ b/src/lib/mhd_byteorder.h
@@ -71,7 +71,8 @@
 #if defined(__BYTE_ORDER__)
 #if defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 #define _MHD_BYTE_ORDER _MHD_BIG_ENDIAN
-#elif defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#elif defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == \
+  __ORDER_LITTLE_ENDIAN__
 #define _MHD_BYTE_ORDER _MHD_LITTLE_ENDIAN
 #elif defined(__ORDER_PDP_ENDIAN__) && __BYTE_ORDER__ == __ORDER_PDP_ENDIAN__
 #define _MHD_BYTE_ORDER _MHD_PDP_ENDIAN
@@ -106,36 +107,40 @@
 /* Byte order specification didn't detected in system headers */
 /* Try some guessing */
 
-#if   (defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)) || \
-      (defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN))
+#if   (defined(__BIG_ENDIAN__) && ! defined(__LITTLE_ENDIAN__)) || \
+  (defined(_BIG_ENDIAN) && ! defined(_LITTLE_ENDIAN))
 /* Seems that we are on big endian platform */
 #define _MHD_BYTE_ORDER _MHD_BIG_ENDIAN
-#elif (defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)) || \
-      (defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN))
+#elif (defined(__LITTLE_ENDIAN__) && ! defined(__BIG_ENDIAN__)) || \
+  (defined(_LITTLE_ENDIAN) && ! defined(_BIG_ENDIAN))
 /* Seems that we are on little endian platform */
 #define _MHD_BYTE_ORDER _MHD_LITTLE_ENDIAN
-#elif defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || \
-      defined(_M_X64) || defined(_M_AMD64) || defined(i386) || defined(__i386) || \
-      defined(__i386__) || defined(__i486__) || defined(__i586__) || defined(__i686__) || \
-      defined(_M_IX86) || defined(_X86_) || defined (__THW_INTEL__)
+#elif defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || \
+  defined(__x86_64) || \
+  defined(_M_X64) || defined(_M_AMD64) || defined(i386) || defined(__i386) || \
+  defined(__i386__) || defined(__i486__) || defined(__i586__) || \
+  defined(__i686__) || \
+  defined(_M_IX86) || defined(_X86_) || defined (__THW_INTEL__)
 /* x86 family is little endian */
 #define _MHD_BYTE_ORDER _MHD_LITTLE_ENDIAN
 #elif defined(__ARMEB__) || defined(__THUMBEB__) ||  defined(__AARCH64EB__) || \
-      defined(_MIPSEB) || defined(__MIPSEB) || defined(__MIPSEB__)
+  defined(_MIPSEB) || defined(__MIPSEB) || defined(__MIPSEB__)
 /* Looks like we are on ARM/MIPS in big endian mode */
 #define _MHD_BYTE_ORDER _MHD_BIG_ENDIAN
 #elif defined(__ARMEL__) || defined(__THUMBEL__) || defined(__AARCH64EL__) || \
-      defined(_MIPSEL) || defined(__MIPSEL) || defined(__MIPSEL__)
+  defined(_MIPSEL) || defined(__MIPSEL) || defined(__MIPSEL__)
 /* Looks like we are on ARM/MIPS in little endian mode */
 #define _MHD_BYTE_ORDER _MHD_LITTLE_ENDIAN
-#elif defined(__m68k__) || defined(M68000) || defined(__hppa__) || defined(__hppa) || \
-      defined(__HPPA__) || defined(__370__) || defined(__THW_370__) || \
-      defined(__s390__) || defined(__s390x__) || defined(__SYSC_ZARCH__)
+#elif defined(__m68k__) || defined(M68000) || defined(__hppa__) || \
+  defined(__hppa) || \
+  defined(__HPPA__) || defined(__370__) || defined(__THW_370__) || \
+  defined(__s390__) || defined(__s390x__) || defined(__SYSC_ZARCH__)
 /* Looks like we are on big endian platform */
 #define _MHD_BYTE_ORDER _MHD_BIG_ENDIAN
-#elif defined(__ia64__) || defined(_IA64) || defined(__IA64__) || defined(__ia64) || \
-      defined(_M_IA64) || defined(__itanium__) || defined(__bfin__) || \
-      defined(__BFIN__) || defined(bfin) || defined(BFIN)
+#elif defined(__ia64__) || defined(_IA64) || defined(__IA64__) || \
+  defined(__ia64) || \
+  defined(_M_IA64) || defined(__itanium__) || defined(__bfin__) || \
+  defined(__BFIN__) || defined(bfin) || defined(BFIN)
 /* Looks like we are on little endian platform */
 #define _MHD_BYTE_ORDER _MHD_LITTLE_ENDIAN
 #elif defined(_WIN32)
@@ -151,9 +156,11 @@
 #ifdef _MHD_BYTE_ORDER
 /* Some safety checks */
 #if defined(WORDS_BIGENDIAN) && _MHD_BYTE_ORDER != _MHD_BIG_ENDIAN
-#error Configure detected big endian byte order but headers specify different byte order
-#elif !defined(WORDS_BIGENDIAN) && _MHD_BYTE_ORDER == _MHD_BIG_ENDIAN
-#error Configure did not detect big endian byte order but headers specify big endian byte order
+#error \
+  Configure detected big endian byte order but headers specify different byte order
+#elif ! defined(WORDS_BIGENDIAN) && _MHD_BYTE_ORDER == _MHD_BIG_ENDIAN
+#error \
+  Configure did not detect big endian byte order but headers specify big endian byte order
 #endif /* !WORDS_BIGENDIAN && _MHD_BYTE_ORDER == _MHD_BIG_ENDIAN */
 #endif /* _MHD_BYTE_ORDER */
 
diff --git a/src/lib/mhd_compat.c b/src/lib/mhd_compat.c
index 3abdc367..6f6c6f9c 100644
--- a/src/lib/mhd_compat.c
+++ b/src/lib/mhd_compat.c
@@ -25,7 +25,7 @@
  */
 
 #include "mhd_compat.h"
-#if defined(_WIN32) && !defined(__CYGWIN__)
+#if defined(_WIN32) && ! defined(__CYGWIN__)
 #include <stdint.h>
 #include <time.h>
 #ifndef HAVE_SNPRINTF
@@ -38,7 +38,7 @@
 #include <string.h> /* for memset() */
 #endif /* ! HAVE_CALLOC */
 
-#if defined(_WIN32) && !defined(__CYGWIN__)
+#if defined(_WIN32) && ! defined(__CYGWIN__)
 
 #ifndef HAVE_SNPRINTF
 /* Emulate snprintf function on W32 */
@@ -61,16 +61,16 @@ W32_snprintf (char *__restrict s,
                       format,
                       args);
     va_end (args);
-    if ((int)n == ret)
+    if ((int) n == ret)
       s[n - 1] = 0;
     if (ret >= 0)
       return ret;
   }
-  va_start(args,
-           format);
+  va_start (args,
+            format);
   ret = _vscprintf (format,
                     args);
-  va_end(args);
+  va_end (args);
   if ( (0 <= ret) &&
        (0 != n) &&
        (NULL == s) )
@@ -85,30 +85,30 @@ W32_snprintf (char *__restrict s,
 #ifndef HAVE_CALLOC
 
 #ifdef __has_builtin
-#  if __has_builtin(__builtin_mul_overflow)
+#  if __has_builtin (__builtin_mul_overflow)
 #    define MHD_HAVE_NUL_OVERFLOW 1
 #  endif
-#elif __GNUC__+0 >= 5
+#elif __GNUC__ + 0 >= 5
 #  define MHD_HAVE_NUL_OVERFLOW 1
 #endif /* __GNUC__ >= 5 */
 
 
-void *MHD_calloc_(size_t nelem, size_t elsize)
+void *MHD_calloc_ (size_t nelem, size_t elsize)
 {
   size_t alloc_size;
   void *ptr;
 #ifdef MHD_HAVE_NUL_OVERFLOW
-  if (__builtin_mul_overflow(nelem, elsize, &alloc_size) || 0 == alloc_size)
+  if (__builtin_mul_overflow (nelem, elsize, &alloc_size) ||(0 == alloc_size))
     return NULL;
 #else  /* ! MHD_HAVE_NUL_OVERFLOW */
   alloc_size = nelem * elsize;
-  if (0 == alloc_size || elsize != alloc_size / nelem)
+  if ((0 == alloc_size)||(elsize != alloc_size / nelem))
     return NULL;
 #endif /* ! MHD_HAVE_NUL_OVERFLOW */
   ptr = malloc (alloc_size);
   if (NULL == ptr)
     return NULL;
-  memset(ptr, 0, alloc_size);
+  memset (ptr, 0, alloc_size);
   return ptr;
 }
 #endif /* ! HAVE_CALLOC */
diff --git a/src/lib/mhd_compat.h b/src/lib/mhd_compat.h
index b4e2c66c..6b38a03e 100644
--- a/src/lib/mhd_compat.h
+++ b/src/lib/mhd_compat.h
@@ -40,8 +40,8 @@
 #include <string.h>
 #endif /* HAVE_STRING_H */
 
- /* MHD_strerror_ is strerror */
-#define MHD_strerror_(errnum) strerror((errnum))
+/* MHD_strerror_ is strerror */
+#define MHD_strerror_(errnum) strerror ((errnum))
 
 /* Platform-independent snprintf name */
 #if defined(HAVE_SNPRINTF)
@@ -49,10 +49,12 @@
 #else  /* ! HAVE_SNPRINTF */
 #if defined(_WIN32) && ! defined(__CYGWIN__)
 /* Emulate snprintf function on W32 */
-int W32_snprintf(char *__restrict s, size_t n, const char *__restrict format, ...);
+int W32_snprintf (char *__restrict s, size_t n, const char *__restrict format,
+                  ...);
 #define MHD_snprintf_ W32_snprintf
 #else  /* ! _WIN32 || __CYGWIN__ */
-#error Your platform does not support snprintf() and MHD does not know how to emulate it on your platform.
+#error \
+  Your platform does not support snprintf() and MHD does not know how to emulate it on your platform.
 #endif /* ! _WIN32 || __CYGWIN__ */
 #endif /* ! HAVE_SNPRINTF */
 
@@ -61,14 +63,14 @@ int W32_snprintf(char *__restrict s, size_t n, const char *__restrict format, ..
  * Generate pseudo random number at least 30-bit wide.
  * @return pseudo random number at least 30-bit wide.
  */
-#define MHD_random_() random()
+#define MHD_random_() random ()
 #else  /* HAVE_RANDOM */
 #ifdef HAVE_RAND
 /**
  * Generate pseudo random number at least 30-bit wide.
  * @return pseudo random number at least 30-bit wide.
  */
-#define MHD_random_() ( (((long)rand()) << 15) + (long)rand() )
+#define MHD_random_() ( (((long) rand ()) << 15) + (long) rand () )
 #endif /* HAVE_RAND */
 #endif /* HAVE_RANDOM */
 
@@ -76,12 +78,12 @@ int W32_snprintf(char *__restrict s, size_t n, const char *__restrict format, ..
 /**
  * MHD_calloc_ is platform-independent calloc()
  */
-#define MHD_calloc_(n,s) calloc((n),(s))
+#define MHD_calloc_(n,s) calloc ((n),(s))
 #else  /* ! HAVE_CALLOC */
 /**
  * MHD_calloc_ is platform-independent calloc()
  */
-void *MHD_calloc_(size_t nelem, size_t elsize);
+void *MHD_calloc_ (size_t nelem, size_t elsize);
 #endif /* ! HAVE_CALLOC */
 
 #endif /* MHD_COMPAT_H */
diff --git a/src/lib/mhd_itc.c b/src/lib/mhd_itc.c
index 8aeee576..6c81ef62 100644
--- a/src/lib/mhd_itc.c
+++ b/src/lib/mhd_itc.c
@@ -34,7 +34,7 @@
 
 
 #if defined(_MHD_ITC_PIPE)
-#if !defined(_WIN32) || defined(__CYGWIN__)
+#if ! defined(_WIN32) || defined(__CYGWIN__)
 
 #ifndef HAVE_PIPE2_FUNC
 /**
@@ -48,7 +48,7 @@ MHD_itc_nonblocking_ (struct MHD_itc_ itc)
 {
   unsigned int i;
 
-  for (i=0;i<2;i++)
+  for (i = 0; i<2; i++)
   {
     int flags;
 
@@ -63,7 +63,7 @@ MHD_itc_nonblocking_ (struct MHD_itc_ itc)
                       flags | O_NONBLOCK)) )
       return 0;
   }
-  return !0;
+  return ! 0;
 }
 #endif /* ! HAVE_PIPE2_FUNC */
 #endif /* !_WIN32 || __CYGWIN__ */
diff --git a/src/lib/mhd_itc.h b/src/lib/mhd_itc.h
index 01331f13..8e303ef9 100644
--- a/src/lib/mhd_itc.h
+++ b/src/lib/mhd_itc.h
@@ -41,8 +41,9 @@
 #  include <stdlib.h>
 /* Simple implementation of MHD_PANIC, to be used outside lib */
 #  define MHD_PANIC(msg) do { fprintf (stderr,           \
-     "Abnormal termination at %d line in file %s: %s\n", \
-     (int)__LINE__, __FILE__, msg); abort();} while(0)
+                                       "Abnormal termination at %d line in file %s: %s\n", \
+                                       (int) __LINE__, __FILE__, msg); abort (); \
+} while (0)
 #endif /* ! MHD_PANIC */
 
 #if defined(_MHD_ITC_EVENTFD)
@@ -63,12 +64,13 @@
  * @param itc the itc to initialise
  * @return non-zero if succeeded, zero otherwise
  */
-#define MHD_itc_init_(itc) (-1 != ((itc).fd = eventfd (0, EFD_CLOEXEC | EFD_NONBLOCK)))
+#define MHD_itc_init_(itc) (-1 != ((itc).fd = eventfd (0, EFD_CLOEXEC \
+                                                       | EFD_NONBLOCK)))
 
 /**
  * Get description string of last errno for itc operations.
  */
-#define MHD_itc_last_strerror_() strerror(errno)
+#define MHD_itc_last_strerror_() strerror (errno)
 
 /**
  * Internal static const helper for MHD_itc_activate_()
@@ -82,7 +84,8 @@ static const uint64_t _MHD_itc_wr_data = 1;
  * @return non-zero if succeeded, zero otherwise
  */
 #define MHD_itc_activate_(itc, str) \
-  ((write((itc).fd, (const void*)&_MHD_itc_wr_data, 8) > 0) || (EAGAIN == errno))
+  ((write ((itc).fd, (const void*) &_MHD_itc_wr_data, 8) > 0) || (EAGAIN == \
+                                                                  errno))
 
 /**
  * Return read FD of @a itc which can be used for poll(), select() etc.
@@ -104,8 +107,8 @@ static const uint64_t _MHD_itc_wr_data = 1;
  */
 #define MHD_itc_clear_(itc)                  \
   do { uint64_t __b; int __r;                \
-       __r = read((itc).fd, &__b, sizeof(__b)); \
-       (void)__r; } while(0)
+       __r = read ((itc).fd, &__b, sizeof(__b)); \
+       (void) __r; } while (0)
 
 /**
  * Destroy previously initialised ITC.  Note that close()
@@ -155,20 +158,20 @@ static const uint64_t _MHD_itc_wr_data = 1;
  * @return non-zero if succeeded, zero otherwise
  */
 #ifdef HAVE_PIPE2_FUNC
-#  define MHD_itc_init_(itc) (!pipe2((itc).fd, O_CLOEXEC | O_NONBLOCK))
+#  define MHD_itc_init_(itc) (! pipe2 ((itc).fd, O_CLOEXEC | O_NONBLOCK))
 #else  /* ! HAVE_PIPE2_FUNC */
 #  define MHD_itc_init_(itc)              \
-     ( (!pipe((itc).fd)) ?                \
-         (MHD_itc_nonblocking_((itc)) ?   \
-           (!0) :                         \
-           (MHD_itc_destroy_((itc)), 0) ) \
-         : (0) )
+  ( (! pipe ((itc).fd)) ?                \
+    (MHD_itc_nonblocking_ ((itc)) ?   \
+     (! 0) :                         \
+     (MHD_itc_destroy_ ((itc)), 0) ) \
+    : (0) )
 #endif /* ! HAVE_PIPE2_FUNC */
 
 /**
  * Get description string of last errno for itc operations.
  */
-#define MHD_itc_last_strerror_() strerror(errno)
+#define MHD_itc_last_strerror_() strerror (errno)
 
 /**
  * Activate signal on @a itc
@@ -177,7 +180,7 @@ static const uint64_t _MHD_itc_wr_data = 1;
  * @return non-zero if succeeded, zero otherwise
  */
 #define MHD_itc_activate_(itc, str) \
-  ((write((itc).fd[1], (const void*)(str), 1) > 0) || (EAGAIN == errno))
+  ((write ((itc).fd[1], (const void*) (str), 1) > 0) || (EAGAIN == errno))
 
 
 /**
@@ -200,8 +203,8 @@ static const uint64_t _MHD_itc_wr_data = 1;
  */
 #define MHD_itc_clear_(itc) do                      \
   { long __b;                                       \
-    while(0 < read((itc).fd[0], &__b, sizeof(__b))) \
-    {} } while(0)
+    while (0 < read ((itc).fd[0], &__b, sizeof(__b))) \
+    {} } while (0)
 
 /**
  * Destroy previously initialised ITC
@@ -210,8 +213,8 @@ static const uint64_t _MHD_itc_wr_data = 1;
  */
 #define MHD_itc_destroy_(itc)      \
   ( (0 == close ((itc).fd[0])) ?   \
-      (0 == close ((itc).fd[1])) : \
-      ((close ((itc).fd[1])), 0) )
+    (0 == close ((itc).fd[1])) : \
+    ((close ((itc).fd[1])), 0) )
 
 /**
  * Check whether ITC has valid value.
@@ -231,14 +234,14 @@ static const uint64_t _MHD_itc_wr_data = 1;
 #define MHD_itc_set_invalid_(itc) ((itc).fd[0] = (itc).fd[1] = -1)
 
 #ifndef HAVE_PIPE2_FUNC
-  /**
-   * Change itc FD options to be non-blocking.
-   *
-   * @param fd the FD to manipulate
-   * @return non-zero if succeeded, zero otherwise
-   */
-  int
-  MHD_itc_nonblocking_ (struct MHD_itc_ itc);
+/**
+ * Change itc FD options to be non-blocking.
+ *
+ * @param fd the FD to manipulate
+ * @return non-zero if succeeded, zero otherwise
+ */
+int
+MHD_itc_nonblocking_ (struct MHD_itc_ itc);
 #endif /* ! HAVE_PIPE2_FUNC */
 
 
@@ -255,20 +258,20 @@ static const uint64_t _MHD_itc_wr_data = 1;
  * @return non-zero if succeeded, zero otherwise
  */
 #ifdef MHD_socket_pair_nblk_
-#  define MHD_itc_init_(itc) MHD_socket_pair_nblk_((itc).sk)
+#  define MHD_itc_init_(itc) MHD_socket_pair_nblk_ ((itc).sk)
 #else  /* ! MHD_socket_pair_nblk_ */
 #  define MHD_itc_init_(itc)            \
-     (MHD_socket_pair_((itc).sk) ?      \
-       (MHD_itc_nonblocking_((itc)) ?   \
-         (!0) :                         \
-         (MHD_itc_destroy_((itc)), 0) ) \
-       : (0))
+  (MHD_socket_pair_ ((itc).sk) ?      \
+   (MHD_itc_nonblocking_ ((itc)) ?   \
+    (! 0) :                         \
+    (MHD_itc_destroy_ ((itc)), 0) ) \
+   : (0))
 #endif /* ! MHD_socket_pair_nblk_ */
 
 /**
  * Get description string of last error for itc operations.
  */
-#define MHD_itc_last_strerror_() MHD_socket_last_strerr_()
+#define MHD_itc_last_strerror_() MHD_socket_last_strerr_ ()
 
 /**
  * Activate signal on @a itc
@@ -277,8 +280,8 @@ static const uint64_t _MHD_itc_wr_data = 1;
  * @return non-zero if succeeded, zero otherwise
  */
 #define MHD_itc_activate_(itc, str)          \
-  ((MHD_send_((itc).sk[1], (str), 1) > 0) || \
-   (MHD_SCKT_ERR_IS_EAGAIN_(MHD_socket_get_error_())))
+  ((MHD_send_ ((itc).sk[1], (str), 1) > 0) || \
+   (MHD_SCKT_ERR_IS_EAGAIN_ (MHD_socket_get_error_ ())))
 
 /**
  * Return read FD of @a itc which can be used for poll(), select() etc.
@@ -300,10 +303,10 @@ static const uint64_t _MHD_itc_wr_data = 1;
  */
 #define MHD_itc_clear_(itc) do      \
   { long __b;                       \
-    while(0 < recv((itc).sk[0],     \
-                   (char*)&__b,     \
-                   sizeof(__b), 0)) \
-    {} } while(0)
+    while (0 < recv ((itc).sk[0],     \
+                     (char*) &__b,     \
+                     sizeof(__b), 0)) \
+    {} } while (0)
 
 /**
  * Destroy previously initialised ITC
@@ -311,9 +314,9 @@ static const uint64_t _MHD_itc_wr_data = 1;
  * @return non-zero if succeeded, zero otherwise
  */
 #define MHD_itc_destroy_(itc)          \
-  ( MHD_socket_close_((itc).sk[0]) ?   \
-      MHD_socket_close_((itc).sk[1]) : \
-      ((void)MHD_socket_close_((itc).sk[1]), 0) )
+  (MHD_socket_close_ ((itc).sk[0]) ?   \
+   MHD_socket_close_ ((itc).sk[1]) : \
+   ((void) MHD_socket_close_ ((itc).sk[1]), 0) )
 
 
 /**
@@ -331,10 +334,12 @@ static const uint64_t _MHD_itc_wr_data = 1;
  * Set @a itc to invalid value.
  * @param itc the itc to set
  */
-#define MHD_itc_set_invalid_(itc) ((itc).sk[0] = (itc).sk[1] = MHD_INVALID_SOCKET)
+#define MHD_itc_set_invalid_(itc) ((itc).sk[0] = (itc).sk[1] = \
+                                     MHD_INVALID_SOCKET)
 
 #ifndef MHD_socket_pair_nblk_
-#  define MHD_itc_nonblocking_(pip) (MHD_socket_nonblocking_((pip).sk[0]) && MHD_socket_nonblocking_((pip).sk[1]))
+#  define MHD_itc_nonblocking_(pip) (MHD_socket_nonblocking_ ((pip).sk[0]) && \
+                                     MHD_socket_nonblocking_ ((pip).sk[1]))
 #endif /* ! MHD_socket_pair_nblk_ */
 
 #endif /* _MHD_ITC_SOCKETPAIR */
@@ -345,9 +350,9 @@ static const uint64_t _MHD_itc_wr_data = 1;
  * @param itc the itc to destroy
  */
 #define MHD_itc_destroy_chk_(itc) do {          \
-    if (!MHD_itc_destroy_(itc))                 \
-      MHD_PANIC(_("Failed to destroy ITC.\n")); \
-  } while(0)
+    if (! MHD_itc_destroy_ (itc))                 \
+      MHD_PANIC (_ ("Failed to destroy ITC.\n")); \
+} while (0)
 
 /**
  * Check whether ITC has invalid value.
@@ -358,6 +363,6 @@ static const uint64_t _MHD_itc_wr_data = 1;
  * @return boolean true if @a itc has invalid value,
  *         boolean false otherwise.
  */
-#define MHD_ITC_IS_INVALID_(itc)  (! MHD_ITC_IS_VALID_(itc))
+#define MHD_ITC_IS_INVALID_(itc)  (! MHD_ITC_IS_VALID_ (itc))
 
 #endif /* MHD_ITC_H */
diff --git a/src/lib/mhd_itc_types.h b/src/lib/mhd_itc_types.h
index 04966d36..36d4218b 100644
--- a/src/lib/mhd_itc_types.h
+++ b/src/lib/mhd_itc_types.h
@@ -32,7 +32,7 @@
 #include "mhd_options.h"
 
 /* Force socketpair on native W32 */
-#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(_MHD_ITC_SOCKETPAIR)
+#if defined(_WIN32) && ! defined(__CYGWIN__) && ! defined(_MHD_ITC_SOCKETPAIR)
 #error _MHD_ITC_SOCKETPAIR is not defined on naitive W32 platform
 #endif /* _WIN32 && !__CYGWIN__ && !_MHD_ITC_SOCKETPAIR */
 
diff --git a/src/lib/mhd_limits.h b/src/lib/mhd_limits.h
index 41d33a8f..87b41447 100644
--- a/src/lib/mhd_limits.h
+++ b/src/lib/mhd_limits.h
@@ -32,17 +32,17 @@
 #include <limits.h>
 #endif /* HAVE_LIMITS_H */
 
-#define MHD_UNSIGNED_TYPE_MAX_(type) ((type)-1)
+#define MHD_UNSIGNED_TYPE_MAX_(type) ((type) - 1)
 /* Assume 8 bits per byte, no padding bits. */
 #define MHD_SIGNED_TYPE_MAX_(type) \
-        ( (type)((( ((type)1) << (sizeof(type)*8 - 2)) - 1)*2 + 1) )
-#define MHD_TYPE_IS_SIGNED_(type) (((type)0)>((type)-1))
+  ( (type) ((( ((type) 1) << (sizeof(type) * 8 - 2)) - 1) * 2 + 1) )
+#define MHD_TYPE_IS_SIGNED_(type) (((type) 0)>((type) - 1))
 
 #ifndef UINT_MAX
 #ifdef __UINT_MAX__
 #define UINT_MAX __UINT_MAX__
 #else  /* ! __UINT_MAX__ */
-#define UINT_MAX MHD_UNSIGNED_TYPE_MAX_(unsigned int)
+#define UINT_MAX MHD_UNSIGNED_TYPE_MAX_ (unsigned int)
 #endif /* ! __UINT_MAX__ */
 #endif /* !UINT_MAX */
 
@@ -50,19 +50,19 @@
 #ifdef __LONG_MAX__
 #define LONG_MAX __LONG_MAX__
 #else  /* ! __LONG_MAX__ */
-#define LONG_MAX MHD_SIGNED_TYPE_MAX(long)
+#define LONG_MAX MHD_SIGNED_TYPE_MAX (long)
 #endif /* ! __LONG_MAX__ */
 #endif /* !OFF_T_MAX */
 
 #ifndef ULLONG_MAX
-#define ULLONG_MAX MHD_UNSIGNED_TYPE_MAX_(MHD_UNSIGNED_LONG_LONG)
+#define ULLONG_MAX MHD_UNSIGNED_TYPE_MAX_ (MHD_UNSIGNED_LONG_LONG)
 #endif /* !ULLONG_MAX */
 
 #ifndef INT32_MAX
 #ifdef __INT32_MAX__
 #define INT32_MAX __INT32_MAX__
 #else  /* ! __INT32_MAX__ */
-#define INT32_MAX ((int32_t)0x7FFFFFFF)
+#define INT32_MAX ((int32_t) 0x7FFFFFFF)
 #endif /* ! __INT32_MAX__ */
 #endif /* !INT32_MAX */
 
@@ -70,7 +70,7 @@
 #ifdef __UINT32_MAX__
 #define UINT32_MAX __UINT32_MAX__
 #else  /* ! __UINT32_MAX__ */
-#define UINT32_MAX ((int32_t)0xFFFFFFFF)
+#define UINT32_MAX ((int32_t) 0xFFFFFFFF)
 #endif /* ! __UINT32_MAX__ */
 #endif /* !UINT32_MAX */
 
@@ -78,7 +78,7 @@
 #ifdef __UINT64_MAX__
 #define UINT64_MAX __UINT64_MAX__
 #else  /* ! __UINT64_MAX__ */
-#define UINT64_MAX ((uint64_t)0xFFFFFFFFFFFFFFFF)
+#define UINT64_MAX ((uint64_t) 0xFFFFFFFFFFFFFFFF)
 #endif /* ! __UINT64_MAX__ */
 #endif /* !UINT64_MAX */
 
@@ -86,7 +86,7 @@
 #ifdef __INT64_MAX__
 #define INT64_MAX __INT64_MAX__
 #else  /* ! __INT64_MAX__ */
-#define INT64_MAX ((int64_t)0x7FFFFFFFFFFFFFFF)
+#define INT64_MAX ((int64_t) 0x7FFFFFFFFFFFFFFF)
 #endif /* ! __UINT64_MAX__ */
 #endif /* !INT64_MAX */
 
@@ -96,8 +96,8 @@
 #elif defined(UINTPTR_MAX)
 #define SIZE_MAX UINTPTR_MAX
 #else  /* ! __SIZE_MAX__ */
-#define SIZE_MAX MHD_UNSIGNED_TYPE_MAX_(size_t)
-#endif /* ! __SIZE_MAX__ */ 
+#define SIZE_MAX MHD_UNSIGNED_TYPE_MAX_ (size_t)
+#endif /* ! __SIZE_MAX__ */
 #endif /* !SIZE_MAX */
 
 #ifndef SSIZE_MAX
@@ -108,7 +108,7 @@
 #elif defined(INTPTR_MAX)
 #define SSIZE_MAX INTPTR_MAX
 #else
-#define SSIZE_MAN MHD_SIGNED_TYPE_MAX_(ssize_t)
+#define SSIZE_MAN MHD_SIGNED_TYPE_MAX_ (ssize_t)
 #endif
 #endif /* ! SSIZE_MAX */
 
@@ -120,19 +120,19 @@
 #elif defined(__APPLE__) && defined(__MACH__)
 #define OFF_T_MAX INT64_MAX
 #else
-#define OFF_T_MAX MHD_SIGNED_TYPE_MAX_(off_t)
+#define OFF_T_MAX MHD_SIGNED_TYPE_MAX_ (off_t)
 #endif
 #endif /* !OFF_T_MAX */
 
-#if defined(_LARGEFILE64_SOURCE) && !defined(OFF64_T_MAX)
-#define OFF64_T_MAX MHD_SIGNED_TYPE_MAX_(uint64_t)
+#if defined(_LARGEFILE64_SOURCE) && ! defined(OFF64_T_MAX)
+#define OFF64_T_MAX MHD_SIGNED_TYPE_MAX_ (uint64_t)
 #endif /* _LARGEFILE64_SOURCE && !OFF64_T_MAX */
 
 #ifndef TIME_T_MAX
 #define TIME_T_MAX ((time_t)              \
-       ( MHD_TYPE_IS_SIGNED_(time_t) ?    \
-           MHD_SIGNED_TYPE_MAX_(time_t) : \
-           MHD_UNSIGNED_TYPE_MAX_(time_t)))
+                    (MHD_TYPE_IS_SIGNED_ (time_t) ?    \
+                     MHD_SIGNED_TYPE_MAX_ (time_t) : \
+                     MHD_UNSIGNED_TYPE_MAX_ (time_t)))
 #endif /* !TIME_T_MAX */
 
 #ifndef TIMEVAL_TV_SEC_MAX
diff --git a/src/lib/mhd_locks.h b/src/lib/mhd_locks.h
index 21db56c4..8c9b0844 100644
--- a/src/lib/mhd_locks.h
+++ b/src/lib/mhd_locks.h
@@ -59,14 +59,15 @@
 #  include <stdlib.h>
 /* Simple implementation of MHD_PANIC, to be used outside lib */
 #  define MHD_PANIC(msg) do { fprintf (stderr,           \
-     "Abnormal termination at %d line in file %s: %s\n", \
-     (int)__LINE__, __FILE__, msg); abort();} while(0)
+                                       "Abnormal termination at %d line in file %s: %s\n", \
+                                       (int) __LINE__, __FILE__, msg); abort (); \
+} while (0)
 #endif /* ! MHD_PANIC */
 
 #if defined(MHD_PTHREAD_MUTEX_)
-  typedef pthread_mutex_t MHD_mutex_;
+typedef pthread_mutex_t MHD_mutex_;
 #elif defined(MHD_W32_MUTEX_)
-  typedef CRITICAL_SECTION MHD_mutex_;
+typedef CRITICAL_SECTION MHD_mutex_;
 #endif
 
 #if defined(MHD_PTHREAD_MUTEX_)
@@ -75,14 +76,15 @@
  * @param pmutex pointer to the mutex
  * @return nonzero on success, zero otherwise
  */
-#define MHD_mutex_init_(pmutex) (!(pthread_mutex_init((pmutex), NULL)))
+#define MHD_mutex_init_(pmutex) (! (pthread_mutex_init ((pmutex), NULL)))
 #elif defined(MHD_W32_MUTEX_)
 /**
  * Initialise new mutex.
  * @param pmutex pointer to mutex
  * @return nonzero on success, zero otherwise
  */
-#define MHD_mutex_init_(pmutex) (InitializeCriticalSectionAndSpinCount((pmutex),16))
+#define MHD_mutex_init_(pmutex) (InitializeCriticalSectionAndSpinCount ( \
+                                   (pmutex),16))
 #endif
 
 #if defined(MHD_PTHREAD_MUTEX_)
@@ -90,7 +92,8 @@
 /**
  *  Define static mutex and statically initialise it.
  */
-#    define MHD_MUTEX_STATIC_DEFN_INIT_(m) static MHD_mutex_ m = PTHREAD_MUTEX_INITIALIZER
+#    define MHD_MUTEX_STATIC_DEFN_INIT_(m) static MHD_mutex_ m = \
+  PTHREAD_MUTEX_INITIALIZER
 #  endif /* PTHREAD_MUTEX_INITIALIZER */
 #endif
 
@@ -100,14 +103,14 @@
  * @param pmutex pointer to mutex
  * @return nonzero on success, zero otherwise
  */
-#define MHD_mutex_destroy_(pmutex) (!(pthread_mutex_destroy((pmutex))))
+#define MHD_mutex_destroy_(pmutex) (! (pthread_mutex_destroy ((pmutex))))
 #elif defined(MHD_W32_MUTEX_)
 /**
  * Destroy previously initialised mutex.
  * @param pmutex pointer to mutex
  * @return Always nonzero
  */
-#define MHD_mutex_destroy_(pmutex) (DeleteCriticalSection((pmutex)), !0)
+#define MHD_mutex_destroy_(pmutex) (DeleteCriticalSection ((pmutex)), ! 0)
 #endif
 
 /**
@@ -116,9 +119,9 @@
  * @param pmutex pointer to mutex
  */
 #define MHD_mutex_destroy_chk_(pmutex) do {       \
-    if (!MHD_mutex_destroy_(pmutex))              \
-      MHD_PANIC(_("Failed to destroy mutex.\n")); \
-  } while(0)
+    if (! MHD_mutex_destroy_ (pmutex))              \
+      MHD_PANIC (_ ("Failed to destroy mutex.\n")); \
+} while (0)
 
 
 #if defined(MHD_PTHREAD_MUTEX_)
@@ -129,7 +132,7 @@
  * @param pmutex pointer to mutex
  * @return nonzero on success, zero otherwise
  */
-#define MHD_mutex_lock_(pmutex) (!(pthread_mutex_lock((pmutex))))
+#define MHD_mutex_lock_(pmutex) (! (pthread_mutex_lock ((pmutex))))
 #elif defined(MHD_W32_MUTEX_)
 /**
  * Acquire lock on previously initialised mutex.
@@ -138,7 +141,7 @@
  * @param pmutex pointer to mutex
  * @return Always nonzero
  */
-#define MHD_mutex_lock_(pmutex) (EnterCriticalSection((pmutex)), !0)
+#define MHD_mutex_lock_(pmutex) (EnterCriticalSection ((pmutex)), ! 0)
 #endif
 
 /**
@@ -149,9 +152,9 @@
  * @param pmutex pointer to mutex
  */
 #define MHD_mutex_lock_chk_(pmutex) do {       \
-    if (!MHD_mutex_lock_(pmutex))              \
-      MHD_PANIC(_("Failed to lock mutex.\n")); \
-  } while(0)
+    if (! MHD_mutex_lock_ (pmutex))              \
+      MHD_PANIC (_ ("Failed to lock mutex.\n")); \
+} while (0)
 
 #if defined(MHD_PTHREAD_MUTEX_)
 /**
@@ -159,14 +162,14 @@
  * @param pmutex pointer to mutex
  * @return nonzero on success, zero otherwise
  */
-#define MHD_mutex_unlock_(pmutex) (!(pthread_mutex_unlock((pmutex))))
+#define MHD_mutex_unlock_(pmutex) (! (pthread_mutex_unlock ((pmutex))))
 #elif defined(MHD_W32_MUTEX_)
 /**
  * Unlock previously initialised and locked mutex.
  * @param pmutex pointer to mutex
  * @return Always nonzero
  */
-#define MHD_mutex_unlock_(pmutex) (LeaveCriticalSection((pmutex)), !0)
+#define MHD_mutex_unlock_(pmutex) (LeaveCriticalSection ((pmutex)), ! 0)
 #endif
 
 /**
@@ -175,9 +178,9 @@
  * @param pmutex pointer to mutex
  */
 #define MHD_mutex_unlock_chk_(pmutex) do {       \
-    if (!MHD_mutex_unlock_(pmutex))              \
-      MHD_PANIC(_("Failed to unlock mutex.\n")); \
-  } while(0)
+    if (! MHD_mutex_unlock_ (pmutex))              \
+      MHD_PANIC (_ ("Failed to unlock mutex.\n")); \
+} while (0)
 
 
 #endif /* ! MHD_LOCKS_H */
diff --git a/src/lib/mhd_mono_clock.c b/src/lib/mhd_mono_clock.c
index 97dbfb9f..eee911fb 100644
--- a/src/lib/mhd_mono_clock.c
+++ b/src/lib/mhd_mono_clock.c
@@ -76,7 +76,8 @@ static clockid_t mono_clock_id = _MHD_UNWANTED_CLOCK;
 #endif /* HAVE_CLOCK_GETTIME */
 
 /* sync clocks; reduce chance of value wrap */
-#if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_CLOCK_GET_TIME) || defined(HAVE_GETHRTIME)
+#if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_CLOCK_GET_TIME) || \
+  defined(HAVE_GETHRTIME)
 static time_t mono_clock_start;
 #endif /* HAVE_CLOCK_GETTIME || HAVE_CLOCK_GET_TIME || HAVE_GETHRTIME */
 static time_t sys_clock_start;
@@ -124,9 +125,9 @@ enum _MHD_mono_clock_source
    */
   _MHD_CLOCK_GETTICKCOUNT64,
 
-   /**
-    * QueryPerformanceCounter() / QueryPerformanceFrequency()
-    */
+  /**
+   * QueryPerformanceCounter() / QueryPerformanceFrequency()
+   */
   _MHD_CLOCK_PERFCOUNTER
 };
 
@@ -153,8 +154,8 @@ MHD_monotonic_sec_counter_init (void)
   /* just a little syntactic trick to get the
      various following ifdef's to work out nicely */
   if (0)
-    {
-    }
+  {
+  }
   else
 #ifdef HAVE_CLOCK_GETTIME
 #ifdef CLOCK_MONOTONIC_COARSE
@@ -163,11 +164,11 @@ MHD_monotonic_sec_counter_init (void)
   /* but preferred since it's fast */
   if (0 == clock_gettime (CLOCK_MONOTONIC_COARSE,
                           &ts))
-    {
-      mono_clock_id = CLOCK_MONOTONIC_COARSE;
-      mono_clock_start = ts.tv_sec;
-      mono_clock_source = _MHD_CLOCK_GETTIME;
-    }
+  {
+    mono_clock_id = CLOCK_MONOTONIC_COARSE;
+    mono_clock_start = ts.tv_sec;
+    mono_clock_source = _MHD_CLOCK_GETTIME;
+  }
   else
 #endif /* CLOCK_MONOTONIC_COARSE */
 #ifdef CLOCK_MONOTONIC_FAST
@@ -175,11 +176,11 @@ MHD_monotonic_sec_counter_init (void)
   /* Can be affected by frequency adjustment, but preferred since it's fast */
   if (0 == clock_gettime (CLOCK_MONOTONIC_FAST,
                           &ts))
-    {
-      mono_clock_id = CLOCK_MONOTONIC_FAST;
-      mono_clock_start = ts.tv_sec;
-      mono_clock_source = _MHD_CLOCK_GETTIME;
-    }
+  {
+    mono_clock_id = CLOCK_MONOTONIC_FAST;
+    mono_clock_start = ts.tv_sec;
+    mono_clock_source = _MHD_CLOCK_GETTIME;
+  }
   else
 #endif /* CLOCK_MONOTONIC_COARSE */
 #ifdef CLOCK_MONOTONIC_RAW
@@ -187,11 +188,11 @@ MHD_monotonic_sec_counter_init (void)
   /* Not affected by frequency adjustment, but don't count time in suspend */
   if (0 == clock_gettime (CLOCK_MONOTONIC_RAW,
                           &ts))
-    {
-      mono_clock_id = CLOCK_MONOTONIC_RAW;
-      mono_clock_start = ts.tv_sec;
-      mono_clock_source = _MHD_CLOCK_GETTIME;
-    }
+  {
+    mono_clock_id = CLOCK_MONOTONIC_RAW;
+    mono_clock_start = ts.tv_sec;
+    mono_clock_source = _MHD_CLOCK_GETTIME;
+  }
   else
 #endif /* CLOCK_MONOTONIC_RAW */
 #ifdef CLOCK_BOOTTIME
@@ -200,11 +201,11 @@ MHD_monotonic_sec_counter_init (void)
   /* but can be slower value-getting than other clocks */
   if (0 == clock_gettime (CLOCK_BOOTTIME,
                           &ts))
-    {
-      mono_clock_id = CLOCK_BOOTTIME;
-      mono_clock_start = ts.tv_sec;
-      mono_clock_source = _MHD_CLOCK_GETTIME;
-    }
+  {
+    mono_clock_id = CLOCK_BOOTTIME;
+    mono_clock_start = ts.tv_sec;
+    mono_clock_source = _MHD_CLOCK_GETTIME;
+  }
   else
 #endif /* CLOCK_BOOTTIME */
 #ifdef CLOCK_MONOTONIC
@@ -213,11 +214,11 @@ MHD_monotonic_sec_counter_init (void)
   /* On Linux it's not truly monotonic as it doesn't count time in suspend */
   if (0 == clock_gettime (CLOCK_MONOTONIC,
                           &ts))
-    {
-      mono_clock_id = CLOCK_MONOTONIC;
-      mono_clock_start = ts.tv_sec;
-      mono_clock_source = _MHD_CLOCK_GETTIME;
-    }
+  {
+    mono_clock_id = CLOCK_MONOTONIC;
+    mono_clock_start = ts.tv_sec;
+    mono_clock_source = _MHD_CLOCK_GETTIME;
+  }
   else
 #endif /* CLOCK_BOOTTIME */
 #endif /* HAVE_CLOCK_GETTIME */
@@ -225,15 +226,15 @@ MHD_monotonic_sec_counter_init (void)
   /* Darwin-specific monotonic clock */
   /* Should be monotonic as clock_set_time function always unconditionally */
   /* failed on latest kernels */
-  if ( (KERN_SUCCESS == host_get_clock_service (mach_host_self(),
+  if ( (KERN_SUCCESS == host_get_clock_service (mach_host_self (),
                                                 SYSTEM_CLOCK,
                                                 &mono_clock_service)) &&
        (KERN_SUCCESS == clock_get_time (mono_clock_service,
                                         &cur_time)) )
-    {
-      mono_clock_start = cur_time.tv_sec;
-      mono_clock_source = _MHD_CLOCK_GET_TIME;
-    }
+  {
+    mono_clock_start = cur_time.tv_sec;
+    mono_clock_source = _MHD_CLOCK_GET_TIME;
+  }
   else
 #endif /* HAVE_CLOCK_GET_TIME */
 #ifdef _WIN32
@@ -241,25 +242,25 @@ MHD_monotonic_sec_counter_init (void)
   /* W32 Vista or later specific monotonic clock */
   /* Available since Vista, ~15ms accuracy */
   if (1)
-    {
-      tick_start = GetTickCount64 ();
-      mono_clock_source = _MHD_CLOCK_GETTICKCOUNT64;
-    }
+  {
+    tick_start = GetTickCount64 ();
+    mono_clock_source = _MHD_CLOCK_GETTICKCOUNT64;
+  }
   else
 #else  /* _WIN32_WINNT < 0x0600 */
   /* W32 specific monotonic clock */
   /* Available on Windows 2000 and later */
   if (1)
-    {
-      LARGE_INTEGER freq;
-      LARGE_INTEGER perf_counter;
-
-      QueryPerformanceFrequency (&freq); /* never fail on XP and later */
-      QueryPerformanceCounter (&perf_counter); /* never fail on XP and later */
-      perf_freq = freq.QuadPart;
-      perf_start = perf_counter.QuadPart;
-      mono_clock_source = _MHD_CLOCK_PERFCOUNTER;
-    }
+  {
+    LARGE_INTEGER freq;
+    LARGE_INTEGER perf_counter;
+
+    QueryPerformanceFrequency (&freq);   /* never fail on XP and later */
+    QueryPerformanceCounter (&perf_counter);   /* never fail on XP and later */
+    perf_freq = freq.QuadPart;
+    perf_start = perf_counter.QuadPart;
+    mono_clock_source = _MHD_CLOCK_PERFCOUNTER;
+  }
   else
 #endif /* _WIN32_WINNT < 0x0600 */
 #endif /* _WIN32 */
@@ -269,11 +270,11 @@ MHD_monotonic_sec_counter_init (void)
   /* Not preferred due to be potentially resource-hungry */
   if (0 == clock_gettime (CLOCK_HIGHRES,
                           &ts))
-    {
-      mono_clock_id = CLOCK_HIGHRES;
-      mono_clock_start = ts.tv_sec;
-      mono_clock_source = _MHD_CLOCK_GETTIME;
-    }
+  {
+    mono_clock_id = CLOCK_HIGHRES;
+    mono_clock_start = ts.tv_sec;
+    mono_clock_source = _MHD_CLOCK_GETTIME;
+  }
   else
 #endif /* CLOCK_HIGHRES */
 #endif /* HAVE_CLOCK_GETTIME */
@@ -281,26 +282,26 @@ MHD_monotonic_sec_counter_init (void)
   /* HP-UX and Solaris monotonic clock */
   /* Not preferred due to be potentially resource-hungry */
   if (1)
-    {
-      hrtime_start = gethrtime ();
-      mono_clock_source = _MHD_CLOCK_GETHRTIME;
-    }
+  {
+    hrtime_start = gethrtime ();
+    mono_clock_source = _MHD_CLOCK_GETHRTIME;
+  }
   else
 #endif /* HAVE_GETHRTIME */
-    {
-      /* no suitable clock source was found */
-      mono_clock_source = _MHD_CLOCK_NO_SOURCE;
-    }
+  {
+    /* no suitable clock source was found */
+    mono_clock_source = _MHD_CLOCK_NO_SOURCE;
+  }
 
 #ifdef HAVE_CLOCK_GET_TIME
   if ( (_MHD_CLOCK_GET_TIME != mono_clock_source) &&
        (_MHD_INVALID_CLOCK_SERV != mono_clock_service) )
-    {
-      /* clock service was initialised but clock_get_time failed */
-      mach_port_deallocate (mach_task_self(),
-                            mono_clock_service);
-      mono_clock_service = _MHD_INVALID_CLOCK_SERV;
-    }
+  {
+    /* clock service was initialised but clock_get_time failed */
+    mach_port_deallocate (mach_task_self (),
+                          mono_clock_service);
+    mono_clock_service = _MHD_INVALID_CLOCK_SERV;
+  }
 #else
   (void) mono_clock_source; /* avoid compiler warning */
 #endif /* HAVE_CLOCK_GET_TIME */
@@ -317,11 +318,11 @@ MHD_monotonic_sec_counter_finish (void)
 {
 #ifdef HAVE_CLOCK_GET_TIME
   if (_MHD_INVALID_CLOCK_SERV != mono_clock_service)
-    {
-      mach_port_deallocate (mach_task_self(),
-                            mono_clock_service);
-      mono_clock_service = _MHD_INVALID_CLOCK_SERV;
-    }
+  {
+    mach_port_deallocate (mach_task_self (),
+                          mono_clock_service);
+    mono_clock_service = _MHD_INVALID_CLOCK_SERV;
+  }
 #endif /* HAVE_CLOCK_GET_TIME */
 }
 
@@ -340,37 +341,38 @@ MHD_monotonic_sec_counter (void)
   struct timespec ts;
 
   if ( (_MHD_UNWANTED_CLOCK != mono_clock_id) &&
-       (0 == clock_gettime (mono_clock_id ,
+       (0 == clock_gettime (mono_clock_id,
                             &ts)) )
     return ts.tv_sec - mono_clock_start;
 #endif /* HAVE_CLOCK_GETTIME */
 #ifdef HAVE_CLOCK_GET_TIME
   if (_MHD_INVALID_CLOCK_SERV != mono_clock_service)
-    {
-      mach_timespec_t cur_time;
+  {
+    mach_timespec_t cur_time;
 
-      if (KERN_SUCCESS == clock_get_time(mono_clock_service,
-                                         &cur_time))
-        return cur_time.tv_sec - mono_clock_start;
-    }
+    if (KERN_SUCCESS == clock_get_time (mono_clock_service,
+                                        &cur_time))
+      return cur_time.tv_sec - mono_clock_start;
+  }
 #endif /* HAVE_CLOCK_GET_TIME */
 #if defined(_WIN32)
 #if _WIN32_WINNT >= 0x0600
   if (1)
-    return (time_t)(((uint64_t)(GetTickCount64() - tick_start)) / 1000);
+    return (time_t) (((uint64_t) (GetTickCount64 () - tick_start)) / 1000);
 #else  /* _WIN32_WINNT < 0x0600 */
   if (0 != perf_freq)
-    {
-      LARGE_INTEGER perf_counter;
+  {
+    LARGE_INTEGER perf_counter;
 
-      QueryPerformanceCounter (&perf_counter); /* never fail on XP and later */
-      return (time_t)(((uint64_t)(perf_counter.QuadPart - perf_start)) / perf_freq);
-    }
+    QueryPerformanceCounter (&perf_counter);   /* never fail on XP and later */
+    return (time_t) (((uint64_t) (perf_counter.QuadPart - perf_start))
+                     / perf_freq);
+  }
 #endif /* _WIN32_WINNT < 0x0600 */
 #endif /* _WIN32 */
 #ifdef HAVE_GETHRTIME
   if (1)
-    return (time_t)(((uint64_t) (gethrtime () - hrtime_start)) / 1000000000);
+    return (time_t) (((uint64_t) (gethrtime () - hrtime_start)) / 1000000000);
 #endif /* HAVE_GETHRTIME */
 
   return time (NULL) - sys_clock_start;
diff --git a/src/lib/mhd_mono_clock.h b/src/lib/mhd_mono_clock.h
index f4722af2..92485e00 100644
--- a/src/lib/mhd_mono_clock.h
+++ b/src/lib/mhd_mono_clock.h
@@ -37,14 +37,14 @@
  * Initialise monotonic seconds counter.
  */
 void
-MHD_monotonic_sec_counter_init(void);
+MHD_monotonic_sec_counter_init (void);
 
 
 /**
  * Deinitialise monotonic seconds counter by freeing any allocated resources
  */
 void
-MHD_monotonic_sec_counter_finish(void);
+MHD_monotonic_sec_counter_finish (void);
 
 
 /**
@@ -55,6 +55,6 @@ MHD_monotonic_sec_counter_finish(void);
  * @return number of seconds from some fixed moment
  */
 time_t
-MHD_monotonic_sec_counter(void);
+MHD_monotonic_sec_counter (void);
 
 #endif /* MHD_MONO_CLOCK_H */
diff --git a/src/lib/mhd_sockets.c b/src/lib/mhd_sockets.c
index 356d288f..248b9a68 100644
--- a/src/lib/mhd_sockets.c
+++ b/src/lib/mhd_sockets.c
@@ -37,10 +37,10 @@
  * @param err the WinSock error code.
  * @return pointer to string description of specified WinSock error.
  */
-const char* MHD_W32_strerror_winsock_(int err)
+const char*MHD_W32_strerror_winsock_ (int err)
 {
   switch (err)
-    {
+  {
   case 0:
     return "No error";
   case WSA_INVALID_HANDLE:
@@ -233,7 +233,7 @@ const char* MHD_W32_strerror_winsock_(int err)
     return "Invalid QoS shaping rate object";
   case WSA_QOS_RESERVED_PETYPE:
     return "Reserved policy QoS element type";
-    }
+  }
   return "Unknown winsock error";
 }
 
@@ -246,113 +246,114 @@ const char* MHD_W32_strerror_winsock_(int err)
  * @return non-zero if succeeded, zero otherwise
  */
 int
-MHD_W32_socket_pair_(SOCKET sockets_pair[2], int non_blk)
+MHD_W32_socket_pair_ (SOCKET sockets_pair[2], int non_blk)
 {
   int i;
 
   if (! sockets_pair)
-    {
-      WSASetLastError (WSAEFAULT);
-      return 0;
-    }
+  {
+    WSASetLastError (WSAEFAULT);
+    return 0;
+  }
 
 #define PAIRMAXTRYIES 800
   for (i = 0; i < PAIRMAXTRYIES; i++)
+  {
+    struct sockaddr_in listen_addr;
+    SOCKET listen_s;
+    static const int c_addinlen = sizeof(struct sockaddr_in);   /* help compiler to optimize */
+    int addr_len = c_addinlen;
+    unsigned long on_val = 1;
+    unsigned long off_val = 0;
+
+    listen_s = socket (AF_INET,
+                       SOCK_STREAM,
+                       IPPROTO_TCP);
+    if (INVALID_SOCKET == listen_s)
+      break;   /* can't create even single socket */
+
+    listen_addr.sin_family = AF_INET;
+    listen_addr.sin_port = 0;   /* same as htons(0) */
+    listen_addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+    if ( ((0 == bind (listen_s,
+                      (struct sockaddr*) &listen_addr,
+                      c_addinlen)) &&
+          (0 == listen (listen_s,
+                        1) ) &&
+          (0 == getsockname (listen_s,
+                             (struct sockaddr*) &listen_addr,
+                             &addr_len))) )
     {
-      struct sockaddr_in listen_addr;
-      SOCKET listen_s;
-      static const int c_addinlen = sizeof(struct sockaddr_in); /* help compiler to optimize */
-      int addr_len = c_addinlen;
-      unsigned long on_val = 1;
-      unsigned long off_val = 0;
-
-      listen_s = socket (AF_INET,
-                         SOCK_STREAM,
-                         IPPROTO_TCP);
-      if (INVALID_SOCKET == listen_s)
-        break; /* can't create even single socket */
-
-      listen_addr.sin_family = AF_INET;
-      listen_addr.sin_port = 0; /* same as htons(0) */
-      listen_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-      if ( (0 == bind (listen_s,
-                       (struct sockaddr*) &listen_addr,
-                       c_addinlen) &&
-            (0 == listen (listen_s,
-                          1) ) &&
-            (0 == getsockname (listen_s,
-                               (struct sockaddr*) &listen_addr,
-                               &addr_len))) )
-        {
-          SOCKET client_s = socket(AF_INET,
-                                   SOCK_STREAM,
-                                   IPPROTO_TCP);
-          struct sockaddr_in accepted_from_addr;
-          struct sockaddr_in client_addr;
-          SOCKET server_s;
-
-          if (INVALID_SOCKET == client_s)
-            {
-              /* try again */
-              closesocket (listen_s);
-              continue;
-            }
-
-          if ( (0 != ioctlsocket (client_s,
-                                  FIONBIO,
-                                  &on_val)) ||
-               ( (0 != connect (client_s,
-                                (struct sockaddr*) &listen_addr,
-                                c_addinlen)) &&
-                 (WSAGetLastError() != WSAEWOULDBLOCK)) )
-            {
-              /* try again */
-              closesocket (listen_s);
-              closesocket (client_s);
-              continue;
-            }
-
-          addr_len = c_addinlen;
-          server_s = accept (listen_s,
-                             (struct sockaddr*) &accepted_from_addr,
-                             &addr_len);
-          if (INVALID_SOCKET == server_s)
-            {
-              /* try again */
-              closesocket (listen_s);
-              closesocket (client_s);
-              continue;
-            }
-
-          addr_len = c_addinlen;
-          if ( (0 == getsockname (client_s,
-                                  (struct sockaddr*) &client_addr,
-                                  &addr_len)) &&
-               (accepted_from_addr.sin_family == client_addr.sin_family) &&
-               (accepted_from_addr.sin_port == client_addr.sin_port) &&
-               (accepted_from_addr.sin_addr.s_addr == client_addr.sin_addr.s_addr) &&
-               ( (0 != non_blk) ?
-                    (0 == ioctlsocket(server_s,
-                                      FIONBIO,
-                                      &on_val)) :
-                    (0 == ioctlsocket(client_s,
-                                      FIONBIO,
-                                      &off_val)) ) )
-            {
-              closesocket (listen_s);
-              sockets_pair[0] = server_s;
-              sockets_pair[1] = client_s;
-              return !0;
-            }
-          closesocket (server_s);
-          closesocket (client_s);
-        }
-      closesocket(listen_s);
+      SOCKET client_s = socket (AF_INET,
+                                SOCK_STREAM,
+                                IPPROTO_TCP);
+      struct sockaddr_in accepted_from_addr;
+      struct sockaddr_in client_addr;
+      SOCKET server_s;
+
+      if (INVALID_SOCKET == client_s)
+      {
+        /* try again */
+        closesocket (listen_s);
+        continue;
+      }
+
+      if ( (0 != ioctlsocket (client_s,
+                              FIONBIO,
+                              &on_val)) ||
+           ( (0 != connect (client_s,
+                            (struct sockaddr*) &listen_addr,
+                            c_addinlen)) &&
+             (WSAGetLastError () != WSAEWOULDBLOCK)) )
+      {
+        /* try again */
+        closesocket (listen_s);
+        closesocket (client_s);
+        continue;
+      }
+
+      addr_len = c_addinlen;
+      server_s = accept (listen_s,
+                         (struct sockaddr*) &accepted_from_addr,
+                         &addr_len);
+      if (INVALID_SOCKET == server_s)
+      {
+        /* try again */
+        closesocket (listen_s);
+        closesocket (client_s);
+        continue;
+      }
+
+      addr_len = c_addinlen;
+      if ( (0 == getsockname (client_s,
+                              (struct sockaddr*) &client_addr,
+                              &addr_len)) &&
+           (accepted_from_addr.sin_family == client_addr.sin_family) &&
+           (accepted_from_addr.sin_port == client_addr.sin_port) &&
+           (accepted_from_addr.sin_addr.s_addr ==
+            client_addr.sin_addr.s_addr) &&
+           ( (0 != non_blk) ?
+             (0 == ioctlsocket (server_s,
+                                FIONBIO,
+                                &on_val)) :
+             (0 == ioctlsocket (client_s,
+                                FIONBIO,
+                                &off_val)) ) )
+      {
+        closesocket (listen_s);
+        sockets_pair[0] = server_s;
+        sockets_pair[1] = client_s;
+        return ! 0;
+      }
+      closesocket (server_s);
+      closesocket (client_s);
     }
+    closesocket (listen_s);
+  }
 
   sockets_pair[0] = INVALID_SOCKET;
   sockets_pair[1] = INVALID_SOCKET;
-  WSASetLastError(WSAECONNREFUSED);
+  WSASetLastError (WSAECONNREFUSED);
 
   return 0;
 }
@@ -383,9 +384,9 @@ MHD_add_to_fd_set_ (MHD_socket fd,
                                          set,
                                          fd_setsize))
     return 0;
-  MHD_SCKT_ADD_FD_TO_FDSET_SETSIZE_(fd,
-                                    set,
-                                    fd_setsize);
+  MHD_SCKT_ADD_FD_TO_FDSET_SETSIZE_ (fd,
+                                     set,
+                                     fd_setsize);
   if ( (NULL != max_fd) &&
        ( (fd > *max_fd) ||
          (MHD_INVALID_SOCKET == *max_fd) ) )
@@ -424,7 +425,7 @@ MHD_socket_nonblocking_ (MHD_socket sock)
                         &flags))
     return 0;
 #endif /* MHD_WINSOCK_SOCKETS */
-  return !0;
+  return ! 0;
 }
 
 
@@ -452,12 +453,12 @@ MHD_socket_noninheritable_ (MHD_socket sock)
                     flags | FD_CLOEXEC)) )
     return 0;
 #elif defined(MHD_WINSOCK_SOCKETS)
-  if (! SetHandleInformation ((HANDLE)sock,
+  if (! SetHandleInformation ((HANDLE) sock,
                               HANDLE_FLAG_INHERIT,
                               0))
     return 0;
 #endif /* MHD_WINSOCK_SOCKETS */
-  return !0;
+  return ! 0;
 }
 
 
@@ -477,7 +478,7 @@ MHD_socket_create_listen_ (int pf)
   fd = socket (pf,
                SOCK_STREAM | SOCK_CLOEXEC,
                0);
-  cloexec_set = !0;
+  cloexec_set = ! 0;
 #elif defined(MHD_WINSOCK_SOCKETS) && defined (WSA_FLAG_NO_HANDLE_INHERIT)
   fd = WSASocketW (pf,
                    SOCK_STREAM,
@@ -485,27 +486,27 @@ MHD_socket_create_listen_ (int pf)
                    NULL,
                    0,
                    WSA_FLAG_NO_HANDLE_INHERIT);
-  cloexec_set = !0;
+  cloexec_set = ! 0;
 #else  /* !SOCK_CLOEXEC */
   fd = MHD_INVALID_SOCKET;
 #endif /* !SOCK_CLOEXEC */
   if (MHD_INVALID_SOCKET == fd)
-    {
-      fd = socket (pf,
-                   SOCK_STREAM,
-                   0);
-      cloexec_set = 0;
-    }
+  {
+    fd = socket (pf,
+                 SOCK_STREAM,
+                 0);
+    cloexec_set = 0;
+  }
   if (MHD_INVALID_SOCKET == fd)
     return MHD_INVALID_SOCKET;
 #ifdef MHD_socket_nosignal_
-  if(! MHD_socket_nosignal_(fd))
-    {
-      const int err = MHD_socket_get_error_ ();
-      (void) MHD_socket_close_ (fd);
-      MHD_socket_fset_error_ (err);
-      return MHD_INVALID_SOCKET;
-    }
+  if (! MHD_socket_nosignal_ (fd))
+  {
+    const int err = MHD_socket_get_error_ ();
+    (void) MHD_socket_close_ (fd);
+    MHD_socket_fset_error_ (err);
+    return MHD_INVALID_SOCKET;
+  }
 #endif /* MHD_socket_nosignal_ */
   if (! cloexec_set)
     (void) MHD_socket_noninheritable_ (fd);
diff --git a/src/lib/mhd_sockets.h b/src/lib/mhd_sockets.h
index 9be34144..ebe40275 100644
--- a/src/lib/mhd_sockets.h
+++ b/src/lib/mhd_sockets.h
@@ -36,8 +36,8 @@
 
 #include <errno.h>
 
-#if !defined(MHD_POSIX_SOCKETS) && !defined(MHD_WINSOCK_SOCKETS)
-#  if !defined(_WIN32) || defined(__CYGWIN__)
+#if ! defined(MHD_POSIX_SOCKETS) && ! defined(MHD_WINSOCK_SOCKETS)
+#  if ! defined(_WIN32) || defined(__CYGWIN__)
 #    define MHD_POSIX_SOCKETS 1
 #  else  /* defined(_WIN32) && !defined(__CYGWIN__) */
 #    define MHD_WINSOCK_SOCKETS 1
@@ -92,7 +92,7 @@
 #    include <sys/epoll.h>
 #  endif
 #  ifdef HAVE_NETINET_TCP_H
-     /* for TCP_FASTOPEN and TCP_CORK */
+/* for TCP_FASTOPEN and TCP_CORK */
 #    include <netinet/tcp.h>
 #  endif
 #  ifdef HAVE_STRING_H
@@ -111,10 +111,10 @@
 #endif
 
 #include <stddef.h>
-#if defined(_MSC_FULL_VER) && !defined (_SSIZE_T_DEFINED)
+#if defined(_MSC_FULL_VER) && ! defined (_SSIZE_T_DEFINED)
 #  include <stdint.h>
 #  define _SSIZE_T_DEFINED
-   typedef intptr_t ssize_t;
+typedef intptr_t ssize_t;
 #endif /* !_SSIZE_T_DEFINED */
 
 #include "mhd_limits.h"
@@ -123,7 +123,7 @@
 #  define _MHD_SYS_DEFAULT_FD_SETSIZE FD_SETSIZE
 #else  /* ! _MHD_FD_SETSIZE_IS_DEFAULT */
 #  include "sysfdsetsize.h"
-#  define _MHD_SYS_DEFAULT_FD_SETSIZE get_system_fdsetsize_value()
+#  define _MHD_SYS_DEFAULT_FD_SETSIZE get_system_fdsetsize_value ()
 #endif /* ! _MHD_FD_SETSIZE_IS_DEFAULT */
 
 #ifndef MHD_PANIC
@@ -131,8 +131,9 @@
 #  include <stdlib.h>
 /* Simple implementation of MHD_PANIC, to be used outside lib */
 #  define MHD_PANIC(msg) do { fprintf (stderr,           \
-     "Abnormal termination at %d line in file %s: %s\n", \
-     (int)__LINE__, __FILE__, msg); abort();} while(0)
+                                       "Abnormal termination at %d line in file %s: %s\n", \
+                                       (int) __LINE__, __FILE__, msg); abort (); \
+} while (0)
 #endif /* ! MHD_PANIC */
 
 #ifndef MHD_SOCKET_DEFINED
@@ -140,10 +141,10 @@
  * MHD_socket is type for socket FDs
  */
 #  if defined(MHD_POSIX_SOCKETS)
-     typedef int MHD_socket;
+typedef int MHD_socket;
 #    define MHD_INVALID_SOCKET (-1)
 #  elif defined(MHD_WINSOCK_SOCKETS)
-     typedef SOCKET MHD_socket;
+typedef SOCKET MHD_socket;
 #    define MHD_INVALID_SOCKET (INVALID_SOCKET)
 #  endif /* MHD_WINSOCK_SOCKETS */
 
@@ -168,17 +169,18 @@
 #  define MAYBE_MSG_NOSIGNAL 0
 #endif /* ! MSG_NOSIGNAL */
 
-#if !defined(SHUT_WR) && defined(SD_SEND)
+#if ! defined(SHUT_WR) && defined(SD_SEND)
 #  define SHUT_WR SD_SEND
 #endif
-#if !defined(SHUT_RD) && defined(SD_RECEIVE)
+#if ! defined(SHUT_RD) && defined(SD_RECEIVE)
 #  define SHUT_RD SD_RECEIVE
 #endif
-#if !defined(SHUT_RDWR) && defined(SD_BOTH)
+#if ! defined(SHUT_RDWR) && defined(SD_BOTH)
 #  define SHUT_RDWR SD_BOTH
 #endif
 
-#if HAVE_ACCEPT4+0 != 0 && (defined(HAVE_SOCK_NONBLOCK) || defined(SOCK_CLOEXEC))
+#if HAVE_ACCEPT4 + 0 != 0 && (defined(HAVE_SOCK_NONBLOCK) || \
+  defined(SOCK_CLOEXEC))
 #  define USE_ACCEPT4 1
 #endif
 
@@ -198,25 +200,25 @@
  * MHD_SCKT_OPT_BOOL_ is type for bool parameters for setsockopt()/getsockopt()
  */
 #ifdef MHD_POSIX_SOCKETS
-  typedef int MHD_SCKT_OPT_BOOL_;
+typedef int MHD_SCKT_OPT_BOOL_;
 #else /* MHD_WINSOCK_SOCKETS */
-  typedef BOOL MHD_SCKT_OPT_BOOL_;
+typedef BOOL MHD_SCKT_OPT_BOOL_;
 #endif /* MHD_WINSOCK_SOCKETS */
 
 /**
  * MHD_SCKT_SEND_SIZE_ is type used to specify size for send and recv
  * functions
  */
-#if !defined(MHD_WINSOCK_SOCKETS)
-  typedef size_t MHD_SCKT_SEND_SIZE_;
+#if ! defined(MHD_WINSOCK_SOCKETS)
+typedef size_t MHD_SCKT_SEND_SIZE_;
 #else
-  typedef int MHD_SCKT_SEND_SIZE_;
+typedef int MHD_SCKT_SEND_SIZE_;
 #endif
 
 /**
  * MHD_SCKT_SEND_MAX_SIZE_ is maximum send()/recv() size value.
  */
-#if !defined(MHD_WINSOCK_SOCKETS)
+#if ! defined(MHD_WINSOCK_SOCKETS)
 #  define MHD_SCKT_SEND_MAX_SIZE_ SSIZE_MAX
 #else
 #  define MHD_SCKT_SEND_MAX_SIZE_ INT_MAX
@@ -232,10 +234,10 @@
  *         counted as success, only EBADF counts as an error!),
  *         boolean false otherwise.
  */
-#if !defined(MHD_WINSOCK_SOCKETS)
-#  define MHD_socket_close_(fd) ((0 == close((fd))) || (EBADF != errno))
+#if ! defined(MHD_WINSOCK_SOCKETS)
+#  define MHD_socket_close_(fd) ((0 == close ((fd))) || (EBADF != errno))
 #else
-#  define MHD_socket_close_(fd) (0 == closesocket((fd)))
+#  define MHD_socket_close_(fd) (0 == closesocket ((fd)))
 #endif
 
 /**
@@ -244,9 +246,9 @@
  * @param fd socket to close
  */
 #define MHD_socket_close_chk_(fd) do {        \
-    if (!MHD_socket_close_(fd))               \
-      MHD_PANIC(_("Close socket failed.\n")); \
-  } while(0)
+    if (! MHD_socket_close_ (fd))               \
+      MHD_PANIC (_ ("Close socket failed.\n")); \
+} while (0)
 
 
 /**
@@ -257,7 +259,8 @@
  * @return ssize_t type value
  */
 #define MHD_send_(s,b,l) \
-  ((ssize_t)send((s),(const void*)(b),((MHD_SCKT_SEND_SIZE_)l), MAYBE_MSG_NOSIGNAL))
+  ((ssize_t) send ((s),(const void*) (b),((MHD_SCKT_SEND_SIZE_) l), \
+                   MAYBE_MSG_NOSIGNAL))
 
 
 /**
@@ -268,7 +271,7 @@
  * @return ssize_t type value
  */
 #define MHD_recv_(s,b,l) \
-  ((ssize_t)recv((s),(void*)(b),((MHD_SCKT_SEND_SIZE_)l), 0))
+  ((ssize_t) recv ((s),(void*) (b),((MHD_SCKT_SEND_SIZE_) l), 0))
 
 
 /**
@@ -281,11 +284,18 @@
  *         boolean false otherwise.
  */
 #if defined(MHD_POSIX_SOCKETS)
-#  define MHD_SCKT_FD_FITS_FDSET_SETSIZE_(fd,pset,setsize) ((fd) < ((MHD_socket)setsize))
+#  define MHD_SCKT_FD_FITS_FDSET_SETSIZE_(fd,pset,setsize) ((fd) < \
+                                                            ((MHD_socket) \
+                                                             setsize))
 #elif defined(MHD_WINSOCK_SOCKETS)
-#  define MHD_SCKT_FD_FITS_FDSET_SETSIZE_(fd,pset,setsize) ( ((void*)(pset)==(void*)0) || \
-                                                             (((fd_set*)(pset))->fd_count < ((unsigned)setsize)) || \
-                                                             (FD_ISSET((fd),(pset))) )
+#  define MHD_SCKT_FD_FITS_FDSET_SETSIZE_(fd,pset,setsize) ( ((void*) (pset)== \
+                                                              (void*) 0) || \
+                                                             (((fd_set*) (pset)) \
+                                                              ->fd_count < \
+                                                              ((unsigned) \
+                                                               setsize)) || \
+                                                             (FD_ISSET ((fd), \
+                                                                        (pset))) )
 #endif
 
 /**
@@ -296,7 +306,9 @@
  * @return boolean true if FD can be added to fd_set,
  *         boolean false otherwise.
  */
-#define MHD_SCKT_FD_FITS_FDSET_(fd,pset) MHD_SCKT_FD_FITS_FDSET_SETSIZE_((fd),(pset),FD_SETSIZE)
+#define MHD_SCKT_FD_FITS_FDSET_(fd,pset) MHD_SCKT_FD_FITS_FDSET_SETSIZE_ ((fd), \
+                                                                          (pset), \
+                                                                          FD_SETSIZE)
 
 /**
  * Add FD to fd_set with specified FD_SETSIZE.
@@ -307,34 +319,35 @@
  *        system definition of FD_SET() is not used.
  */
 #if defined(MHD_POSIX_SOCKETS)
-#  define MHD_SCKT_ADD_FD_TO_FDSET_SETSIZE_(fd,pset,setsize) FD_SET((fd),(pset))
+#  define MHD_SCKT_ADD_FD_TO_FDSET_SETSIZE_(fd,pset,setsize) FD_SET ((fd), \
+                                                                     (pset))
 #elif defined(MHD_WINSOCK_SOCKETS)
 #  define MHD_SCKT_ADD_FD_TO_FDSET_SETSIZE_(fd,pset,setsize)                     \
-        do {                                                                     \
-           u_int _i_ = 0;                                                        \
-           fd_set* const _s_ = (fd_set*)(pset);                                  \
-           while((_i_ < _s_->fd_count) && ((fd) != _s_->fd_array[_i_])) {++_i_;} \
-           if ((_i_ == _s_->fd_count)) {_s_->fd_array[_s_->fd_count++] = (fd);}  \
-        } while(0)
+  do {                                                                     \
+    u_int _i_ = 0;                                                        \
+    fd_set*const _s_ = (fd_set*) (pset);                                  \
+    while ((_i_ < _s_->fd_count) && ((fd) != _s_->fd_array [_i_])) {++_i_;} \
+    if ((_i_ == _s_->fd_count)) {_s_->fd_array [_s_->fd_count ++] = (fd);}  \
+  } while (0)
 #endif
 
- /* MHD_SYS_select_ is wrapper macro for system select() function */
-#if !defined(MHD_WINSOCK_SOCKETS)
-#  define MHD_SYS_select_(n,r,w,e,t) select((n),(r),(w),(e),(t))
+/* MHD_SYS_select_ is wrapper macro for system select() function */
+#if ! defined(MHD_WINSOCK_SOCKETS)
+#  define MHD_SYS_select_(n,r,w,e,t) select ((n),(r),(w),(e),(t))
 #else
 #  define MHD_SYS_select_(n,r,w,e,t) \
-( ( (((void*)(r) == (void*)0) || ((fd_set*)(r))->fd_count == 0) &&  \
-    (((void*)(w) == (void*)0) || ((fd_set*)(w))->fd_count == 0) &&  \
-    (((void*)(e) == (void*)0) || ((fd_set*)(e))->fd_count == 0) ) ? \
-  ( ((void*)(t) == (void*)0) ? 0 :                                  \
-    (Sleep(((struct timeval*)(t))->tv_sec * 1000 +                  \
-           ((struct timeval*)(t))->tv_usec / 1000), 0) ) :          \
-  (select((int)0,(r),(w),(e),(t))) )
+  ( ( (((void*) (r) == (void*) 0) || ((fd_set*) (r))->fd_count == 0) &&  \
+      (((void*) (w) == (void*) 0) || ((fd_set*) (w))->fd_count == 0) &&  \
+      (((void*) (e) == (void*) 0) || ((fd_set*) (e))->fd_count == 0) ) ? \
+    ( ((void*) (t) == (void*) 0) ? 0 :                                  \
+      (Sleep (((struct timeval*) (t))->tv_sec * 1000                    \
+              + ((struct timeval*) (t))->tv_usec / 1000), 0) ) :          \
+    (select ((int) 0,(r),(w),(e),(t))) )
 #endif
 
 #if defined(HAVE_POLL)
 /* MHD_sys_poll_ is wrapper macro for system poll() function */
-#  if !defined(MHD_WINSOCK_SOCKETS)
+#  if ! defined(MHD_WINSOCK_SOCKETS)
 #    define MHD_sys_poll_ poll
 #  else  /* MHD_WINSOCK_SOCKETS */
 #    define MHD_sys_poll_ WSAPoll
@@ -363,16 +376,19 @@
 #  elif defined(__linux__)
 #    define MHD_POLL_EVENTS_ERR_DISC POLLPRI
 #  else /* ! __linux__ */
-#    define MHD_POLL_EVENTS_ERR_DISC (MHD_POLLPRI_OR_ZERO | MHD_POLLRDBAND_OR_ZERO)
+#    define MHD_POLL_EVENTS_ERR_DISC (MHD_POLLPRI_OR_ZERO \
+                                      | MHD_POLLRDBAND_OR_ZERO)
 #  endif /* ! __linux__ */
 /* MHD_POLL_REVENTS_ERR_DISC is 'revents' mask for errors and disconnect.
  * Note: Out-of-band data is treated as error. */
 #  define MHD_POLL_REVENTS_ERR_DISC \
-     (MHD_POLLPRI_OR_ZERO | MHD_POLLRDBAND_OR_ZERO | MHD_POLLNVAL_OR_ZERO | POLLERR | POLLHUP)
+  (MHD_POLLPRI_OR_ZERO | MHD_POLLRDBAND_OR_ZERO | MHD_POLLNVAL_OR_ZERO \
+   | POLLERR | POLLHUP)
 /* MHD_POLL_REVENTS_ERRROR is 'revents' mask for errors.
  * Note: Out-of-band data is treated as error. */
 #  define MHD_POLL_REVENTS_ERRROR \
-     (MHD_POLLPRI_OR_ZERO | MHD_POLLRDBAND_OR_ZERO | MHD_POLLNVAL_OR_ZERO | POLLERR)
+  (MHD_POLLPRI_OR_ZERO | MHD_POLLRDBAND_OR_ZERO | MHD_POLLNVAL_OR_ZERO \
+   | POLLERR)
 #endif /* HAVE_POLL */
 
 #define MHD_SCKT_MISSING_ERR_CODE_ 31450
@@ -506,30 +522,30 @@
 #if defined(MHD_POSIX_SOCKETS)
 #  define MHD_socket_get_error_() (errno)
 #elif defined(MHD_WINSOCK_SOCKETS)
-#  define MHD_socket_get_error_() WSAGetLastError()
+#  define MHD_socket_get_error_() WSAGetLastError ()
 #endif
 
 #ifdef MHD_WINSOCK_SOCKETS
-  /* POSIX-W32 sockets compatibility functions */
+/* POSIX-W32 sockets compatibility functions */
 
 /**
  * Return pointer to string description of specified WinSock error
  * @param err the WinSock error code.
  * @return pointer to string description of specified WinSock error.
  */
-  const char* MHD_W32_strerror_winsock_(int err);
+const char*MHD_W32_strerror_winsock_ (int err);
 #endif /* MHD_WINSOCK_SOCKETS */
 
 /* MHD_socket_last_strerr_ is description string of specified socket error code */
 #if defined(MHD_POSIX_SOCKETS)
-#  define MHD_socket_strerr_(err) strerror((err))
+#  define MHD_socket_strerr_(err) strerror ((err))
 #elif defined(MHD_WINSOCK_SOCKETS)
-#  define MHD_socket_strerr_(err) MHD_W32_strerror_winsock_((err))
+#  define MHD_socket_strerr_(err) MHD_W32_strerror_winsock_ ((err))
 #endif
 
 /* MHD_socket_last_strerr_ is description string of last errno (non-W32) /
  *                            description string of last socket error (W32) */
-#define MHD_socket_last_strerr_() MHD_socket_strerr_(MHD_socket_get_error_())
+#define MHD_socket_last_strerr_() MHD_socket_strerr_ (MHD_socket_get_error_ ())
 
 /**
  * MHD_socket_fset_error_() set socket system native error code.
@@ -537,7 +553,7 @@
 #if defined(MHD_POSIX_SOCKETS)
 #  define MHD_socket_fset_error_(err) (errno = (err))
 #elif defined(MHD_WINSOCK_SOCKETS)
-#  define MHD_socket_fset_error_(err) (WSASetLastError((err)))
+#  define MHD_socket_fset_error_(err) (WSASetLastError ((err)))
 #endif
 
 /**
@@ -549,7 +565,8 @@
  *         and error was not set.
  */
 #define MHD_socket_try_set_error_(err) ( (MHD_SCKT_MISSING_ERR_CODE_ != (err)) ? \
-                                         (MHD_socket_fset_error_((err)), !0) : 0 )
+                                         (MHD_socket_fset_error_ ((err)), ! 0) : \
+                                         0)
 
 /**
  * MHD_socket_set_error_() set socket system native error code to
@@ -562,7 +579,8 @@
                                          (errno = ENOSYS) : (errno = (err)) )
 #  elif defined(EOPNOTSUPP)
 #    define MHD_socket_set_error_(err) ( (MHD_SCKT_MISSING_ERR_CODE_ == (err)) ? \
-                                         (errno = EOPNOTSUPP) : (errno = (err)) )
+                                         (errno = EOPNOTSUPP) : (errno = \
+                                                                   (err)) )
 #  elif defined (EFAULT)
 #    define MHD_socket_set_error_(err) ( (MHD_SCKT_MISSING_ERR_CODE_ == (err)) ? \
                                          (errno = EFAULT) : (errno = (err)) )
@@ -570,13 +588,14 @@
 #    define MHD_socket_set_error_(err) ( (MHD_SCKT_MISSING_ERR_CODE_ == (err)) ? \
                                          (errno = EINVAL) : (errno = (err)) )
 #  else  /* !EOPNOTSUPP && !EFAULT && !EINVAL */
-#    warning No suitable replacement for missing socket error code is found. Edit this file and add replacement code which is defined on system.
+#    warning \
+  No suitable replacement for missing socket error code is found. Edit this file and add replacement code which is defined on system.
 #    define MHD_socket_set_error_(err) (errno = (err))
 #  endif /* !EOPNOTSUPP && !EFAULT && !EINVAL*/
 #elif defined(MHD_WINSOCK_SOCKETS)
 #  define MHD_socket_set_error_(err) ( (MHD_SCKT_MISSING_ERR_CODE_ == (err)) ? \
-                                       (WSASetLastError((WSAEOPNOTSUPP))) : \
-                                       (WSASetLastError((err))) )
+                                       (WSASetLastError ((WSAEOPNOTSUPP))) : \
+                                       (WSASetLastError ((err))) )
 #endif
 
 /**
@@ -600,7 +619,8 @@
  *         last socket error equals to MHD_SCKT_E*_ @a code;
  *         boolean false otherwise
  */
-#define MHD_SCKT_LAST_ERR_IS_(code) MHD_SCKT_ERR_IS_(MHD_socket_get_error_() ,(code))
+#define MHD_SCKT_LAST_ERR_IS_(code) MHD_SCKT_ERR_IS_ (MHD_socket_get_error_ (), \
+                                                      (code))
 
 /* Specific error code checks */
 
@@ -610,7 +630,7 @@
  * @return boolean true if @a err is equal to sockets' EINTR code;
  *         boolean false otherwise.
  */
-#define MHD_SCKT_ERR_IS_EINTR_(err) MHD_SCKT_ERR_IS_((err),MHD_SCKT_EINTR_)
+#define MHD_SCKT_ERR_IS_EINTR_(err) MHD_SCKT_ERR_IS_ ((err),MHD_SCKT_EINTR_)
 
 /**
  * Check whether given socket error is equal to system's
@@ -619,10 +639,12 @@
  *         boolean false otherwise.
  */
 #if MHD_SCKT_EAGAIN_ == MHD_SCKT_EWOULDBLOCK_
-#  define MHD_SCKT_ERR_IS_EAGAIN_(err) MHD_SCKT_ERR_IS_((err),MHD_SCKT_EAGAIN_)
+#  define MHD_SCKT_ERR_IS_EAGAIN_(err) MHD_SCKT_ERR_IS_ ((err),MHD_SCKT_EAGAIN_)
 #else  /* MHD_SCKT_EAGAIN_ != MHD_SCKT_EWOULDBLOCK_ */
-#  define MHD_SCKT_ERR_IS_EAGAIN_(err) ( MHD_SCKT_ERR_IS_((err),MHD_SCKT_EAGAIN_) || \
-                                         MHD_SCKT_ERR_IS_((err),MHD_SCKT_EWOULDBLOCK_) )
+#  define MHD_SCKT_ERR_IS_EAGAIN_(err) (MHD_SCKT_ERR_IS_ ((err), \
+                                                          MHD_SCKT_EAGAIN_) || \
+                                        MHD_SCKT_ERR_IS_ ((err), \
+                                                          MHD_SCKT_EWOULDBLOCK_) )
 #endif /* MHD_SCKT_EAGAIN_ != MHD_SCKT_EWOULDBLOCK_ */
 
 /**
@@ -630,10 +652,17 @@
  * @return boolean true if @a err is any kind of "low resource" error,
  *         boolean false otherwise.
  */
-#define MHD_SCKT_ERR_IS_LOW_RESOURCES_(err) ( MHD_SCKT_ERR_IS_((err),MHD_SCKT_EMFILE_) || \
-                                              MHD_SCKT_ERR_IS_((err),MHD_SCKT_ENFILE_) || \
-                                              MHD_SCKT_ERR_IS_((err),MHD_SCKT_ENOMEM_) || \
-                                              MHD_SCKT_ERR_IS_((err),MHD_SCKT_ENOBUFS_) )
+#define MHD_SCKT_ERR_IS_LOW_RESOURCES_(err) (MHD_SCKT_ERR_IS_ ((err), \
+                                                               MHD_SCKT_EMFILE_) \
+                                             || \
+                                             MHD_SCKT_ERR_IS_ ((err), \
+                                                               MHD_SCKT_ENFILE_) \
+                                             || \
+                                             MHD_SCKT_ERR_IS_ ((err), \
+                                                               MHD_SCKT_ENOMEM_) \
+                                             || \
+                                             MHD_SCKT_ERR_IS_ ((err), \
+                                                               MHD_SCKT_ENOBUFS_) )
 
 /**
  * Check whether is given socket error is type of "incoming connection
@@ -642,9 +671,11 @@
  *         boolean false otherwise.
  */
 #if defined(MHD_POSIX_SOCKETS)
-#  define MHD_SCKT_ERR_IS_DISCNN_BEFORE_ACCEPT_(err) MHD_SCKT_ERR_IS_((err),MHD_SCKT_ECONNABORTED_)
+#  define MHD_SCKT_ERR_IS_DISCNN_BEFORE_ACCEPT_(err) MHD_SCKT_ERR_IS_ ((err), \
+                                                                       MHD_SCKT_ECONNABORTED_)
 #elif defined(MHD_WINSOCK_SOCKETS)
-#  define MHD_SCKT_ERR_IS_DISCNN_BEFORE_ACCEPT_(err) MHD_SCKT_ERR_IS_((err),MHD_SCKT_ECONNRESET_)
+#  define MHD_SCKT_ERR_IS_DISCNN_BEFORE_ACCEPT_(err) MHD_SCKT_ERR_IS_ ((err), \
+                                                                       MHD_SCKT_ECONNRESET_)
 #endif
 
 /**
@@ -653,8 +684,11 @@
  * @return boolean true is @a err match described socket error code,
  *         boolean false otherwise.
  */
-#define MHD_SCKT_ERR_IS_REMOTE_DISCNN_(err) ( MHD_SCKT_ERR_IS_((err),MHD_SCKT_ECONNRESET_) || \
-                                              MHD_SCKT_ERR_IS_((err),MHD_SCKT_ECONNABORTED_))
+#define MHD_SCKT_ERR_IS_REMOTE_DISCNN_(err) (MHD_SCKT_ERR_IS_ ((err), \
+                                                               MHD_SCKT_ECONNRESET_) \
+                                             || \
+                                             MHD_SCKT_ERR_IS_ ((err), \
+                                                               MHD_SCKT_ECONNABORTED_))
 
 /* Specific error code set */
 
@@ -663,12 +697,16 @@
  * available on platform.
  */
 #if MHD_SCKT_MISSING_ERR_CODE_ != MHD_SCKT_ENOMEM_
-#  define MHD_socket_set_error_to_ENOMEM() MHD_socket_set_error_(MHD_SCKT_ENOMEM_)
+#  define MHD_socket_set_error_to_ENOMEM() MHD_socket_set_error_ ( \
+    MHD_SCKT_ENOMEM_)
 #elif MHD_SCKT_MISSING_ERR_CODE_ != MHD_SCKT_ENOBUFS_
-#  define MHD_socket_set_error_to_ENOMEM() MHD_socket_set_error_(MHD_SCKT_ENOBUFS_)
+#  define MHD_socket_set_error_to_ENOMEM() MHD_socket_set_error_ ( \
+    MHD_SCKT_ENOBUFS_)
 #else
-#  warning No suitable replacement for ENOMEM error codes is found. Edit this file and add replacement code which is defined on system.
-#  define MHD_socket_set_error_to_ENOMEM() MHD_socket_set_error_(MHD_SCKT_ENOMEM_)
+#  warning \
+  No suitable replacement for ENOMEM error codes is found. Edit this file and add replacement code which is defined on system.
+#  define MHD_socket_set_error_to_ENOMEM() MHD_socket_set_error_ ( \
+    MHD_SCKT_ENOMEM_)
 #endif
 
 /* Socket functions */
@@ -680,22 +718,26 @@
 #endif /* AF_UNIX */
 
 #if defined(MHD_POSIX_SOCKETS) && defined(MHD_SCKT_LOCAL)
-#  define MHD_socket_pair_(fdarr) (!socketpair(MHD_SCKT_LOCAL, SOCK_STREAM, 0, (fdarr)))
+#  define MHD_socket_pair_(fdarr) (! socketpair (MHD_SCKT_LOCAL, SOCK_STREAM, 0, \
+                                                 (fdarr)))
 #  if defined(HAVE_SOCK_NONBLOCK)
-#    define MHD_socket_pair_nblk_(fdarr) (!socketpair(MHD_SCKT_LOCAL, SOCK_STREAM | SOCK_NONBLOCK, 0, (fdarr)))
+#    define MHD_socket_pair_nblk_(fdarr) (! socketpair (MHD_SCKT_LOCAL, \
+                                                        SOCK_STREAM \
+                                                        | SOCK_NONBLOCK, 0, \
+                                                        (fdarr)))
 #  endif /* HAVE_SOCK_NONBLOCK*/
 #elif defined(MHD_WINSOCK_SOCKETS)
-   /**
-    * Create pair of mutually connected TCP/IP sockets on loopback address
-    * @param sockets_pair array to receive resulted sockets
-    * @param non_blk if set to non-zero value, sockets created in non-blocking mode
-    *                otherwise sockets will be in blocking mode
-    * @return non-zero if succeeded, zero otherwise
-    */
-   int MHD_W32_socket_pair_(SOCKET sockets_pair[2], int non_blk);
-
-#  define MHD_socket_pair_(fdarr) MHD_W32_socket_pair_((fdarr), 0)
-#  define MHD_socket_pair_nblk_(fdarr) MHD_W32_socket_pair_((fdarr), 1)
+/**
+ * Create pair of mutually connected TCP/IP sockets on loopback address
+ * @param sockets_pair array to receive resulted sockets
+ * @param non_blk if set to non-zero value, sockets created in non-blocking mode
+ *                otherwise sockets will be in blocking mode
+ * @return non-zero if succeeded, zero otherwise
+ */
+int MHD_W32_socket_pair_ (SOCKET sockets_pair[2], int non_blk);
+
+#  define MHD_socket_pair_(fdarr) MHD_W32_socket_pair_ ((fdarr), 0)
+#  define MHD_socket_pair_nblk_(fdarr) MHD_W32_socket_pair_ ((fdarr), 1)
 #endif
 
 /**
@@ -737,7 +779,7 @@ MHD_socket_noninheritable_ (MHD_socket sock);
 
 
 #if defined(SOL_SOCKET) && defined(SO_NOSIGPIPE)
-   static const int _MHD_socket_int_one = 1;
+static const int _MHD_socket_int_one = 1;
 /**
  * Change socket options to no signal on remote disconnect.
  *
@@ -745,7 +787,8 @@ MHD_socket_noninheritable_ (MHD_socket sock);
  * @return non-zero if succeeded, zero otherwise
  */
 #  define MHD_socket_nosignal_(sock) \
-    (!setsockopt((sock),SOL_SOCKET,SO_NOSIGPIPE,&_MHD_socket_int_one,sizeof(_MHD_socket_int_one)))
+  (! setsockopt ((sock),SOL_SOCKET,SO_NOSIGPIPE,&_MHD_socket_int_one, \
+                 sizeof(_MHD_socket_int_one)))
 #endif /* SOL_SOCKET && SO_NOSIGPIPE */
 
 /**
diff --git a/src/lib/mhd_str.c b/src/lib/mhd_str.c
index d0b03ead..6f2d7b98 100644
--- a/src/lib/mhd_str.c
+++ b/src/lib/mhd_str.c
@@ -117,8 +117,8 @@ _MHD_static_inline bool
 isasciixdigit (char c)
 {
   return isasciidigit (c) ||
-    ( (c >= 'A') && (c <= 'F') ) ||
-    ( (c >= 'a') && (c <= 'f') );
+         ( (c >= 'A') && (c <= 'F') ) ||
+         ( (c >= 'a') && (c <= 'f') );
 }
 
 
@@ -181,7 +181,7 @@ _MHD_static_inline int
 todigitvalue (char c)
 {
   if (isasciidigit (c))
-    return (unsigned char)(c - '0');
+    return (unsigned char) (c - '0');
 
   return -1;
 }
@@ -198,11 +198,11 @@ _MHD_static_inline int
 toxdigitvalue (char c)
 {
   if (isasciidigit (c))
-    return (unsigned char)(c - '0');
+    return (unsigned char) (c - '0');
   if ( (c >= 'A') && (c <= 'F') )
-    return (unsigned char)(c - 'A' + 10);
+    return (unsigned char) (c - 'A' + 10);
   if ( (c >= 'a') && (c <= 'f') )
-    return (unsigned char)(c - 'a' + 10);
+    return (unsigned char) (c - 'a' + 10);
 
   return -1;
 }
@@ -216,7 +216,7 @@ toxdigitvalue (char c)
  * @return boolean true if character is lower case letter,
  *         boolean false otherwise
  */
-#define isasciilower(c) (((char)(c)) >= 'a' && ((char)(c)) <= 'z')
+#define isasciilower(c) (((char) (c)) >= 'a' && ((char) (c)) <= 'z')
 
 
 /**
@@ -226,7 +226,7 @@ toxdigitvalue (char c)
  * @return boolean true if character is upper case letter,
  *         boolean false otherwise
  */
-#define isasciiupper(c) (((char)(c)) >= 'A' && ((char)(c)) <= 'Z')
+#define isasciiupper(c) (((char) (c)) >= 'A' && ((char) (c)) <= 'Z')
 
 
 /**
@@ -236,7 +236,7 @@ toxdigitvalue (char c)
  * @return boolean true if character is letter, boolean false
  *         otherwise
  */
-#define isasciialpha(c) (isasciilower(c) || isasciiupper(c))
+#define isasciialpha(c) (isasciilower (c) || isasciiupper (c))
 
 
 /**
@@ -246,7 +246,7 @@ toxdigitvalue (char c)
  * @return boolean true if character is decimal digit, boolean false
  *         otherwise
  */
-#define isasciidigit(c) (((char)(c)) >= '0' && ((char)(c)) <= '9')
+#define isasciidigit(c) (((char) (c)) >= '0' && ((char) (c)) <= '9')
 
 
 /**
@@ -256,9 +256,9 @@ toxdigitvalue (char c)
  * @return boolean true if character is hexadecimal digit,
  *         boolean false otherwise
  */
-#define isasciixdigit(c) (isasciidigit((c)) || \
-                          (((char)(c)) >= 'A' && ((char)(c)) <= 'F') || \
-                          (((char)(c)) >= 'a' && ((char)(c)) <= 'f') )
+#define isasciixdigit(c) (isasciidigit ((c)) || \
+                          (((char) (c)) >= 'A' && ((char) (c)) <= 'F') || \
+                          (((char) (c)) >= 'a' && ((char) (c)) <= 'f') )
 
 
 /**
@@ -268,7 +268,7 @@ toxdigitvalue (char c)
  * @return boolean true if character is decimal digit or letter,
  *         boolean false otherwise
  */
-#define isasciialnum(c) (isasciialpha(c) || isasciidigit(c))
+#define isasciialnum(c) (isasciialpha (c) || isasciidigit (c))
 
 
 /**
@@ -280,7 +280,8 @@ toxdigitvalue (char c)
  * @param c character to convert
  * @return converted to lower case character
  */
-#define toasciilower(c) ((isasciiupper(c)) ? (((char)(c)) - 'A' + 'a') : ((char)(c)))
+#define toasciilower(c) ((isasciiupper (c)) ? (((char) (c)) - 'A' + 'a') : \
+                         ((char) (c)))
 
 
 /**
@@ -292,7 +293,8 @@ toxdigitvalue (char c)
  * @param c character to convert
  * @return converted to upper case character
  */
-#define toasciiupper(c) ((isasciilower(c)) ? (((char)(c)) - 'a' + 'A') : ((char)(c)))
+#define toasciiupper(c) ((isasciilower (c)) ? (((char) (c)) - 'a' + 'A') : \
+                         ((char) (c)))
 
 
 /**
@@ -301,7 +303,8 @@ toxdigitvalue (char c)
  * @param c character to convert
  * @return value of hexadecimal digit or -1 if @ c is not hexadecimal digit
  */
-#define todigitvalue(c) (isasciidigit(c) ? (int)(((char)(c)) - '0') : (int)(-1))
+#define todigitvalue(c) (isasciidigit (c) ? (int) (((char) (c)) - '0') : \
+                         (int) (-1))
 
 
 /**
@@ -309,11 +312,12 @@ toxdigitvalue (char c)
  * @param c character to convert
  * @return value of hexadecimal digit or -1 if @ c is not hexadecimal digit
  */
-#define toxdigitvalue(c) ( isasciidigit(c) ? (int)(((char)(c)) - '0') : \
-                           ( (((char)(c)) >= 'A' && ((char)(c)) <= 'F') ? \
-                             (int)(((unsigned char)(c)) - 'A' + 10) : \
-                             ( (((char)(c)) >= 'a' && ((char)(c)) <= 'f') ? \
-                               (int)(((unsigned char)(c)) - 'a' + 10) : (int)(-1) )))
+#define toxdigitvalue(c) (isasciidigit (c) ? (int) (((char) (c)) - '0') : \
+                          ( (((char) (c)) >= 'A' && ((char) (c)) <= 'F') ? \
+                            (int) (((unsigned char) (c)) - 'A' + 10) : \
+                            ( (((char) (c)) >= 'a' && ((char) (c)) <= 'f') ? \
+                              (int) (((unsigned char) (c)) - 'a' + 10) : \
+                              (int) (-1) )))
 #endif /* !INLINE_FUNC */
 
 
@@ -326,19 +330,19 @@ toxdigitvalue (char c)
  * @return non-zero if two strings are equal, zero otherwise.
  */
 int
-MHD_str_equal_caseless_ (const char * str1,
-                         const char * str2)
+MHD_str_equal_caseless_ (const char *str1,
+                         const char *str2)
 {
   while (0 != (*str1))
-    {
-      const char c1 = *str1;
-      const char c2 = *str2;
-      if ( (c1 != c2) &&
-           (toasciilower (c1) != toasciilower (c2)) )
-        return 0;
-      str1++;
-      str2++;
-    }
+  {
+    const char c1 = *str1;
+    const char c2 = *str2;
+    if ( (c1 != c2) &&
+         (toasciilower (c1) != toasciilower (c2)) )
+      return 0;
+    str1++;
+    str2++;
+  }
   return 0 == (*str2);
 }
 #endif /* ! MHD_FAVOR_SMALL_CODE */
@@ -356,23 +360,23 @@ MHD_str_equal_caseless_ (const char * str1,
  * @return non-zero if two strings are equal, zero otherwise.
  */
 int
-MHD_str_equal_caseless_n_ (const char * const str1,
-                           const char * const str2,
+MHD_str_equal_caseless_n_ (const char *const str1,
+                           const char *const str2,
                            size_t maxlen)
 {
   size_t i;
 
   for (i = 0; i < maxlen; ++i)
-    {
-      const char c1 = str1[i];
-      const char c2 = str2[i];
-      if (0 == c2)
-        return 0 == c1;
-      if ( (c1 != c2) &&
-           (toasciilower (c1) != toasciilower (c2)) )
-        return 0;
-    }
-  return !0;
+  {
+    const char c1 = str1[i];
+    const char c2 = str2[i];
+    if (0 == c2)
+      return 0 == c1;
+    if ( (c1 != c2) &&
+         (toasciilower (c1) != toasciilower (c2)) )
+      return 0;
+  }
+  return ! 0;
 }
 
 
@@ -390,46 +394,49 @@ MHD_str_equal_caseless_n_ (const char * const str1,
  * @return non-zero if two strings are equal, zero otherwise.
  */
 bool
-MHD_str_has_token_caseless_ (const char * str,
-                             const char * const token,
+MHD_str_has_token_caseless_ (const char *str,
+                             const char *const token,
                              size_t token_len)
 {
   if (0 == token_len)
     return false;
 
   while (0 != *str)
+  {
+    size_t i;
+    /* Skip all whitespaces and empty tokens. */
+    while (' ' == *str || '\t' == *str || ',' == *str)
+      str++;
+
+    /* Check for token match. */
+    i = 0;
+    while (1)
     {
-      size_t i;
-      /* Skip all whitespaces and empty tokens. */
-      while (' ' == *str || '\t' == *str || ',' == *str) str++;
-
-      /* Check for token match. */
-      i = 0;
-      while (1)
-        {
-          const char sc = *(str++);
-          const char tc = token[i++];
-
-          if (0 == sc)
-            return false;
-          if ( (sc != tc) &&
-               (toasciilower (sc) != toasciilower (tc)) )
-            break;
-          if (i >= token_len)
-            {
-              /* Check whether substring match token fully or
-               * has additional unmatched chars at tail. */
-              while (' ' == *str || '\t' == *str) str++;
-              /* End of (sub)string? */
-              if (0 == *str || ',' == *str)
-                return true;
-              /* Unmatched chars at end of substring. */
-              break;
-            }
-        }
-       /* Find next substring. */
-      while (0 != *str && ',' != *str) str++;
+      const char sc = *(str++);
+      const char tc = token[i++];
+
+      if (0 == sc)
+        return false;
+      if ( (sc != tc) &&
+           (toasciilower (sc) != toasciilower (tc)) )
+        break;
+      if (i >= token_len)
+      {
+        /* Check whether substring match token fully or
+         * has additional unmatched chars at tail. */
+        while (' ' == *str || '\t' == *str)
+          str++;
+        /* End of (sub)string? */
+        if ((0 == *str) ||(',' == *str) )
+          return true;
+        /* Unmatched chars at end of substring. */
+        break;
+      }
     }
+    /* Find next substring. */
+    while (0 != *str && ',' != *str)
+      str++;
+  }
   return false;
 }
 
@@ -450,25 +457,25 @@ size_t
 MHD_str_to_uint64_ (const char *str,
                     uint64_t *out_val)
 {
-  const char * const start = str;
+  const char *const start = str;
   uint64_t res;
 
-  if (!str || !out_val || !isasciidigit(str[0]))
+  if (! str || ! out_val || ! isasciidigit (str[0]))
     return 0;
 
   res = 0;
   do
-    {
-      const int digit = (unsigned char)(*str) - '0';
-      if ( (res > (UINT64_MAX / 10)) ||
-           ( (res == (UINT64_MAX / 10)) &&
-             ((uint64_t)digit > (UINT64_MAX % 10)) ) )
-        return 0;
-
-      res *= 10;
-      res += digit;
-      str++;
-    } while (isasciidigit (*str));
+  {
+    const int digit = (unsigned char) (*str) - '0';
+    if ( (res > (UINT64_MAX / 10)) ||
+         ( (res == (UINT64_MAX / 10)) &&
+           ((uint64_t) digit > (UINT64_MAX % 10)) ) )
+      return 0;
+
+    res *= 10;
+    res += digit;
+    str++;
+  } while (isasciidigit (*str));
 
   *out_val = res;
   return str - start;
@@ -489,34 +496,34 @@ MHD_str_to_uint64_ (const char *str,
  *         then possible to store in uint64_t or @a out_val is NULL
  */
 size_t
-MHD_str_to_uint64_n_ (const char * str,
+MHD_str_to_uint64_n_ (const char *str,
                       size_t maxlen,
                       uint64_t *out_val)
 {
   uint64_t res;
   size_t i;
 
-  if (!str || !maxlen || !out_val || !isasciidigit (str[0]))
+  if (! str || ! maxlen || ! out_val || ! isasciidigit (str[0]))
     return 0;
 
   res = 0;
   i = 0;
   do
-    {
-      const int digit = (unsigned char)str[i] - '0';
+  {
+    const int digit = (unsigned char) str[i] - '0';
 
-      if ( (res > (UINT64_MAX / 10)) ||
-           ( (res == (UINT64_MAX / 10)) &&
-             ((uint64_t)digit > (UINT64_MAX % 10)) ) )
-        return 0;
+    if ( (res > (UINT64_MAX / 10)) ||
+         ( (res == (UINT64_MAX / 10)) &&
+           ((uint64_t) digit > (UINT64_MAX % 10)) ) )
+      return 0;
 
-      res *= 10;
-      res += digit;
-      i++;
-    } while ( (i < maxlen) &&
-              isasciidigit (str[i]) );
+    res *= 10;
+    res += digit;
+    i++;
+  } while ( (i < maxlen) &&
+            isasciidigit (str[i]) );
 
-  *out_val= res;
+  *out_val = res;
   return i;
 }
 
@@ -532,31 +539,32 @@ MHD_str_to_uint64_n_ (const char * str,
  *         then possible to store in uint32_t or @a out_val is NULL
  */
 size_t
-MHD_strx_to_uint32_ (const char * str,
+MHD_strx_to_uint32_ (const char *str,
                      uint32_t *out_val)
 {
-  const char * const start = str;
+  const char *const start = str;
   uint32_t res;
   int digit;
 
-  if (!str || !out_val)
+  if (! str || ! out_val)
     return 0;
 
   res = 0;
   digit = toxdigitvalue (*str);
   while (digit >= 0)
+  {
+    if ( (res < (UINT32_MAX / 16)) ||
+         ((res == (UINT32_MAX / 16)) &&( (uint32_t) digit <= (UINT32_MAX
+                                                              % 16)) ) )
     {
-      if ( (res < (UINT32_MAX / 16)) ||
-           (res == (UINT32_MAX / 16) && (uint32_t)digit <= (UINT32_MAX % 16)) )
-        {
-          res *= 16;
-          res += digit;
-        }
-      else
-        return 0;
-      str++;
-      digit = toxdigitvalue (*str);
+      res *= 16;
+      res += digit;
     }
+    else
+      return 0;
+    str++;
+    digit = toxdigitvalue (*str);
+  }
 
   if (str - start > 0)
     *out_val = res;
@@ -585,21 +593,22 @@ MHD_strx_to_uint32_n_ (const char *str,
   size_t i;
   uint32_t res;
   int digit;
-  if (!str || !out_val)
+  if (! str || ! out_val)
     return 0;
 
   res = 0;
   i = 0;
   while (i < maxlen && (digit = toxdigitvalue (str[i])) >= 0)
-    {
-      if ( (res > (UINT32_MAX / 16)) ||
-           (res == (UINT32_MAX / 16) && (uint32_t)digit > (UINT32_MAX % 16)) )
-        return 0;
+  {
+    if ( (res > (UINT32_MAX / 16)) ||
+         ((res == (UINT32_MAX / 16)) &&( (uint32_t) digit > (UINT32_MAX
+                                                             % 16)) ) )
+      return 0;
 
-      res *= 16;
-      res += digit;
-      i++;
-    }
+    res *= 16;
+    res += digit;
+    i++;
+  }
 
   if (i)
     *out_val = res;
@@ -621,27 +630,28 @@ size_t
 MHD_strx_to_uint64_ (const char *str,
                      uint64_t *out_val)
 {
-  const char * const start = str;
+  const char *const start = str;
   uint64_t res;
   int digit;
-  if (!str || !out_val)
+  if (! str || ! out_val)
     return 0;
 
   res = 0;
   digit = toxdigitvalue (*str);
   while (digit >= 0)
+  {
+    if ( (res < (UINT64_MAX / 16)) ||
+         ((res == (UINT64_MAX / 16)) &&( (uint64_t) digit <= (UINT64_MAX
+                                                              % 16)) ) )
     {
-      if ( (res < (UINT64_MAX / 16)) ||
-           (res == (UINT64_MAX / 16) && (uint64_t)digit <= (UINT64_MAX % 16)) )
-        {
-          res *= 16;
-          res += digit;
-        }
-      else
-        return 0;
-      str++;
-      digit = toxdigitvalue (*str);
+      res *= 16;
+      res += digit;
     }
+    else
+      return 0;
+    str++;
+    digit = toxdigitvalue (*str);
+  }
 
   if (str - start > 0)
     *out_val = res;
@@ -663,28 +673,29 @@ MHD_strx_to_uint64_ (const char *str,
  *         then possible to store in uint64_t or @a out_val is NULL
  */
 size_t
-MHD_strx_to_uint64_n_ (const char * str,
+MHD_strx_to_uint64_n_ (const char *str,
                        size_t maxlen,
                        uint64_t *out_val)
 {
   size_t i;
   uint64_t res;
   int digit;
-  if (!str || !out_val)
+  if (! str || ! out_val)
     return 0;
 
   res = 0;
   i = 0;
   while (i < maxlen && (digit = toxdigitvalue (str[i])) >= 0)
-    {
-      if ( (res > (UINT64_MAX / 16)) ||
-           (res == (UINT64_MAX / 16) && (uint64_t)digit > (UINT64_MAX % 16)) )
-        return 0;
+  {
+    if ( (res > (UINT64_MAX / 16)) ||
+         ((res == (UINT64_MAX / 16)) &&( (uint64_t) digit > (UINT64_MAX
+                                                             % 16)) ) )
+      return 0;
 
-      res *= 16;
-      res += digit;
-      i++;
-    }
+    res *= 16;
+    res += digit;
+    i++;
+  }
 
   if (i)
     *out_val = res;
@@ -713,7 +724,7 @@ MHD_strx_to_uint64_n_ (const char * str,
 size_t
 MHD_str_to_uvalue_n_ (const char *str,
                       size_t maxlen,
-                      void * out_val,
+                      void *out_val,
                       size_t val_size,
                       uint64_t max_val,
                       int base)
@@ -725,34 +736,34 @@ MHD_str_to_uvalue_n_ (const char *str,
   const uint64_t max_v_mod_b = max_val % base;
   /* 'digit->value' must be function, not macro */
   int (*const dfunc)(char) = (base == 16) ?
-                              toxdigitvalue : todigitvalue;
+                             toxdigitvalue : todigitvalue;
 
-  if ( !str || !out_val ||
-       (base != 16 && base != 10) )
+  if ( ! str || ! out_val ||
+       ((base != 16)&&(base != 10)) )
     return 0;
 
   res = 0;
   i = 0;
   while (maxlen > i && 0 <= (digit = dfunc (str[i])))
-    {
-      if ( ((max_v_div_b) < res) ||
-          ((max_v_div_b) == res && (max_v_mod_b) < (uint64_t)digit) )
-        return 0;
+  {
+    if ( ((max_v_div_b) < res) ||
+         (( (max_v_div_b) == res) &&( (max_v_mod_b) < (uint64_t) digit) ) )
+      return 0;
 
-      res *= base;
-      res += digit;
-      i++;
-    }
+    res *= base;
+    res += digit;
+    i++;
+  }
 
   if (i)
-    {
-      if (8 == val_size)
-        *(uint64_t*)out_val = res;
-      else if (4 == val_size)
-        *(uint32_t*)out_val = (uint32_t)res;
-      else
-        return 0;
-    }
+  {
+    if (8 == val_size)
+      *(uint64_t*) out_val = res;
+    else if (4 == val_size)
+      *(uint32_t*) out_val = (uint32_t) res;
+    else
+      return 0;
+  }
   return i;
 }
 #endif /* MHD_FAVOR_SMALL_CODE */
diff --git a/src/lib/mhd_str.h b/src/lib/mhd_str.h
index 410cc36e..f0f6511d 100644
--- a/src/lib/mhd_str.h
+++ b/src/lib/mhd_str.h
@@ -42,7 +42,7 @@
 /**
  * Determine length of static string / macro strings at compile time.
  */
-#define MHD_STATICSTR_LEN_(macro) (sizeof(macro)/sizeof(char) - 1)
+#define MHD_STATICSTR_LEN_(macro) (sizeof(macro) / sizeof(char) - 1)
 #endif /* ! MHD_STATICSTR_LEN_ */
 
 /*
@@ -58,11 +58,12 @@
  * @return non-zero if two strings are equal, zero otherwise.
  */
 int
-MHD_str_equal_caseless_ (const char * str1,
-                 const char * str2);
+MHD_str_equal_caseless_ (const char *str1,
+                         const char *str2);
 #else  /* MHD_FAVOR_SMALL_CODE */
 /* Reuse MHD_str_equal_caseless_n_() to reduce size */
-#define MHD_str_equal_caseless_(s1,s2) MHD_str_equal_caseless_n_((s1),(s2), SIZE_MAX)
+#define MHD_str_equal_caseless_(s1,s2) MHD_str_equal_caseless_n_ ((s1),(s2), \
+                                                                  SIZE_MAX)
 #endif /* MHD_FAVOR_SMALL_CODE */
 
 
@@ -77,9 +78,9 @@ MHD_str_equal_caseless_ (const char * str1,
  * @return non-zero if two strings are equal, zero otherwise.
  */
 int
-MHD_str_equal_caseless_n_ (const char * const str1,
-                  const char * const str2,
-                  size_t maxlen);
+MHD_str_equal_caseless_n_ (const char *const str1,
+                           const char *const str2,
+                           size_t maxlen);
 
 
 /**
@@ -96,8 +97,8 @@ MHD_str_equal_caseless_n_ (const char * const str1,
  * @return non-zero if two strings are equal, zero otherwise.
  */
 bool
-MHD_str_has_token_caseless_ (const char * str,
-                             const char * const token,
+MHD_str_has_token_caseless_ (const char *str,
+                             const char *const token,
                              size_t token_len);
 
 /**
@@ -111,7 +112,7 @@ MHD_str_has_token_caseless_ (const char * str,
  * @return non-zero if two strings are equal, zero otherwise.
  */
 #define MHD_str_has_s_token_caseless_(str,tkn) \
-    MHD_str_has_token_caseless_((str),(tkn),MHD_STATICSTR_LEN_(tkn))
+  MHD_str_has_token_caseless_ ((str),(tkn),MHD_STATICSTR_LEN_ (tkn))
 
 #ifndef MHD_FAVOR_SMALL_CODE
 /* Use individual function for each case to improve speed */
@@ -126,13 +127,13 @@ MHD_str_has_token_caseless_ (const char * str,
  *         then possible to store in uint64_t or @a out_val is NULL
  */
 size_t
-MHD_str_to_uint64_ (const char * str,
-                    uint64_t * out_val);
+MHD_str_to_uint64_ (const char *str,
+                    uint64_t *out_val);
 
 /**
  * Convert not more then @a maxlen decimal US-ASCII digits in string to
  * number in uint64_t.
- * Conversion stopped at first non-digit character or after @a maxlen 
+ * Conversion stopped at first non-digit character or after @a maxlen
  * digits.
  * @param str string to convert
  * @param maxlen maximum number of characters to process
@@ -142,9 +143,9 @@ MHD_str_to_uint64_ (const char * str,
  *         then possible to store in uint64_t or @a out_val is NULL
  */
 size_t
-MHD_str_to_uint64_n_ (const char * str,
+MHD_str_to_uint64_n_ (const char *str,
                       size_t maxlen,
-                      uint64_t * out_val);
+                      uint64_t *out_val);
 
 
 /**
@@ -152,19 +153,19 @@ MHD_str_to_uint64_n_ (const char * str,
  * Conversion stopped at first non-digit character.
  * @param str string to convert
  * @param out_val pointer to uint32_t to store result of conversion
- * @return non-zero number of characters processed on succeed, 
+ * @return non-zero number of characters processed on succeed,
  *         zero if no digit is found, resulting value is larger
  *         then possible to store in uint32_t or @a out_val is NULL
  */
 size_t
-MHD_strx_to_uint32_ (const char * str,
-                     uint32_t * out_val);
+MHD_strx_to_uint32_ (const char *str,
+                     uint32_t *out_val);
 
 
 /**
  * Convert not more then @a maxlen hexadecimal US-ASCII digits in string
  * to number in uint32_t.
- * Conversion stopped at first non-digit character or after @a maxlen 
+ * Conversion stopped at first non-digit character or after @a maxlen
  * digits.
  * @param str string to convert
  * @param maxlen maximum number of characters to process
@@ -174,9 +175,9 @@ MHD_strx_to_uint32_ (const char * str,
  *         then possible to store in uint32_t or @a out_val is NULL
  */
 size_t
-MHD_strx_to_uint32_n_ (const char * str,
-                      size_t maxlen,
-                      uint32_t * out_val);
+MHD_strx_to_uint32_n_ (const char *str,
+                       size_t maxlen,
+                       uint32_t *out_val);
 
 
 /**
@@ -184,19 +185,19 @@ MHD_strx_to_uint32_n_ (const char * str,
  * Conversion stopped at first non-digit character.
  * @param str string to convert
  * @param out_val pointer to uint64_t to store result of conversion
- * @return non-zero number of characters processed on succeed, 
+ * @return non-zero number of characters processed on succeed,
  *         zero if no digit is found, resulting value is larger
  *         then possible to store in uint64_t or @a out_val is NULL
  */
 size_t
-MHD_strx_to_uint64_ (const char * str,
-                     uint64_t * out_val);
+MHD_strx_to_uint64_ (const char *str,
+                     uint64_t *out_val);
 
 
 /**
  * Convert not more then @a maxlen hexadecimal US-ASCII digits in string
  * to number in uint64_t.
- * Conversion stopped at first non-digit character or after @a maxlen 
+ * Conversion stopped at first non-digit character or after @a maxlen
  * digits.
  * @param str string to convert
  * @param maxlen maximum number of characters to process
@@ -206,9 +207,9 @@ MHD_strx_to_uint64_ (const char * str,
  *         then possible to store in uint64_t or @a out_val is NULL
  */
 size_t
-MHD_strx_to_uint64_n_ (const char * str,
+MHD_strx_to_uint64_n_ (const char *str,
                        size_t maxlen,
-                       uint64_t * out_val);
+                       uint64_t *out_val);
 
 #else  /* MHD_FAVOR_SMALL_CODE */
 /* Use one universal function and macros to reduce size */
@@ -216,7 +217,7 @@ MHD_strx_to_uint64_n_ (const char * str,
 /**
  * Generic function for converting not more then @a maxlen
  * hexadecimal or decimal US-ASCII digits in string to number.
- * Conversion stopped at first non-digit character or after @a maxlen 
+ * Conversion stopped at first non-digit character or after @a maxlen
  * digits.
  * To be used only within macro.
  * @param str the string to convert
@@ -230,36 +231,44 @@ MHD_strx_to_uint64_n_ (const char * str,
  *         then @ max_val or @a out_val is NULL
  */
 size_t
-MHD_str_to_uvalue_n_ (const char * str,
+MHD_str_to_uvalue_n_ (const char *str,
                       size_t maxlen,
-                      void * out_val,
+                      void *out_val,
                       size_t val_size,
                       uint64_t max_val,
                       int base);
 
-#define MHD_str_to_uint64_(s,ov) MHD_str_to_uvalue_n_((s),SIZE_MAX,(ov),\
-                                             sizeof(uint64_t),UINT64_MAX,10)
+#define MHD_str_to_uint64_(s,ov) MHD_str_to_uvalue_n_ ((s),SIZE_MAX,(ov), \
+                                                       sizeof(uint64_t), \
+                                                       UINT64_MAX,10)
 
-#define MHD_str_to_uint64_n_(s,ml,ov) MHD_str_to_uvalue_n_((s),(ml),(ov),\
-                                             sizeof(uint64_t),UINT64_MAX,10)
+#define MHD_str_to_uint64_n_(s,ml,ov) MHD_str_to_uvalue_n_ ((s),(ml),(ov), \
+                                                            sizeof(uint64_t), \
+                                                            UINT64_MAX,10)
 
-#define MHD_strx_to_sizet_(s,ov) MHD_str_to_uvalue_n_((s),SIZE_MAX,(ov),\
-                                             sizeof(size_t),SIZE_MAX,16)
+#define MHD_strx_to_sizet_(s,ov) MHD_str_to_uvalue_n_ ((s),SIZE_MAX,(ov), \
+                                                       sizeof(size_t),SIZE_MAX, \
+                                                       16)
 
-#define MHD_strx_to_sizet_n_(s,ml,ov) MHD_str_to_uvalue_n_((s),(ml),(ov),\
-                                             sizeof(size_t),SIZE_MAX,16)
+#define MHD_strx_to_sizet_n_(s,ml,ov) MHD_str_to_uvalue_n_ ((s),(ml),(ov), \
+                                                            sizeof(size_t), \
+                                                            SIZE_MAX,16)
 
-#define MHD_strx_to_uint32_(s,ov) MHD_str_to_uvalue_n_((s),SIZE_MAX,(ov),\
-                                             sizeof(uint32_t),UINT32_MAX,16)
+#define MHD_strx_to_uint32_(s,ov) MHD_str_to_uvalue_n_ ((s),SIZE_MAX,(ov), \
+                                                        sizeof(uint32_t), \
+                                                        UINT32_MAX,16)
 
-#define MHD_strx_to_uint32_n_(s,ml,ov) MHD_str_to_uvalue_n_((s),(ml),(ov),\
-                                             sizeof(uint32_t),UINT32_MAX,16)
+#define MHD_strx_to_uint32_n_(s,ml,ov) MHD_str_to_uvalue_n_ ((s),(ml),(ov), \
+                                                             sizeof(uint32_t), \
+                                                             UINT32_MAX,16)
 
-#define MHD_strx_to_uint64_(s,ov) MHD_str_to_uvalue_n_((s),SIZE_MAX,(ov),\
-                                             sizeof(uint64_t),UINT64_MAX,16)
+#define MHD_strx_to_uint64_(s,ov) MHD_str_to_uvalue_n_ ((s),SIZE_MAX,(ov), \
+                                                        sizeof(uint64_t), \
+                                                        UINT64_MAX,16)
 
-#define MHD_strx_to_uint64_n_(s,ml,ov) MHD_str_to_uvalue_n_((s),(ml),(ov),\
-                                             sizeof(uint64_t),UINT64_MAX,16)
+#define MHD_strx_to_uint64_n_(s,ml,ov) MHD_str_to_uvalue_n_ ((s),(ml),(ov), \
+                                                             sizeof(uint64_t), \
+                                                             UINT64_MAX,16)
 
 #endif /* MHD_FAVOR_SMALL_CODE */
 
diff --git a/src/lib/mhd_threads.c b/src/lib/mhd_threads.c
index 6578e4b1..a90090f4 100644
--- a/src/lib/mhd_threads.c
+++ b/src/lib/mhd_threads.c
@@ -46,12 +46,14 @@
 #else  /* MHD_USE_THREAD_NAME_ */
 
 #if defined(MHD_USE_POSIX_THREADS)
-#if defined(HAVE_PTHREAD_ATTR_SETNAME_NP_NETBSD) || defined(HAVE_PTHREAD_ATTR_SETNAME_NP_IBMI)
+#if defined(HAVE_PTHREAD_ATTR_SETNAME_NP_NETBSD) || \
+  defined(HAVE_PTHREAD_ATTR_SETNAME_NP_IBMI)
 #  define MHD_USE_THREAD_ATTR_SETNAME 1
 #endif /* HAVE_PTHREAD_ATTR_SETNAME_NP_NETBSD || HAVE_PTHREAD_ATTR_SETNAME_NP_IBMI */
 
-#if defined(HAVE_PTHREAD_SETNAME_NP_GNU) || defined(HAVE_PTHREAD_SET_NAME_NP_FREEBSD) \
-    || defined(HAVE_PTHREAD_SETNAME_NP_NETBSD)
+#if defined(HAVE_PTHREAD_SETNAME_NP_GNU) || \
+  defined(HAVE_PTHREAD_SET_NAME_NP_FREEBSD) \
+  || defined(HAVE_PTHREAD_SETNAME_NP_NETBSD)
 
 /**
  * Set thread name
@@ -61,25 +63,25 @@
  * @return non-zero on success, zero otherwise
  */
 static int
-MHD_set_thread_name_(const MHD_thread_ID_ thread_id,
-                     const char *thread_name)
+MHD_set_thread_name_ (const MHD_thread_ID_ thread_id,
+                      const char *thread_name)
 {
   if (NULL == thread_name)
     return 0;
 
 #if defined(HAVE_PTHREAD_SETNAME_NP_GNU)
-  return !pthread_setname_np (thread_id, thread_name);
+  return ! pthread_setname_np (thread_id, thread_name);
 #elif defined(HAVE_PTHREAD_SET_NAME_NP_FREEBSD)
   /* FreeBSD and OpenBSD use different name and void return type */
   pthread_set_name_np (thread_id, thread_name);
-  return !0;
+  return ! 0;
 #elif defined(HAVE_PTHREAD_SETNAME_NP_NETBSD)
   /* NetBSD use 3 arguments: second argument is string in printf-like format,
    *                         third argument is single argument for printf;
    * OSF1 use 3 arguments too, but last one always must be zero (NULL).
    * MHD doesn't use '%' in thread names, so both form are used in same way.
    */
-  return !pthread_setname_np (thread_id, thread_name, 0);
+  return ! pthread_setname_np (thread_id, thread_name, 0);
 #endif /* HAVE_PTHREAD_SETNAME_NP_NETBSD */
 }
 
@@ -90,10 +92,10 @@ MHD_set_thread_name_(const MHD_thread_ID_ thread_id,
  * @param n name to set
  * @return non-zero on success, zero otherwise
  */
-#define MHD_set_cur_thread_name_(n) MHD_set_thread_name_(pthread_self(),(n))
+#define MHD_set_cur_thread_name_(n) MHD_set_thread_name_ (pthread_self (),(n))
 #else  /* __QNXNTO__ */
 /* Special case for QNX Neutrino - using zero for thread ID sets name faster. */
-#define MHD_set_cur_thread_name_(n) MHD_set_thread_name_(0,(n))
+#define MHD_set_cur_thread_name_(n) MHD_set_thread_name_ (0,(n))
 #endif /* __QNXNTO__ */
 #elif defined(HAVE_PTHREAD_SETNAME_NP_DARWIN)
 
@@ -102,7 +104,7 @@ MHD_set_thread_name_(const MHD_thread_ID_ thread_id,
  * @param n name to set
  * @return non-zero on success, zero otherwise
  */
-#define MHD_set_cur_thread_name_(n) (!(pthread_setname_np((n))))
+#define MHD_set_cur_thread_name_(n) (! (pthread_setname_np ((n))))
 #endif /* HAVE_PTHREAD_SETNAME_NP_DARWIN */
 
 #elif defined(MHD_USE_W32_THREADS)
@@ -117,8 +119,8 @@ MHD_set_thread_name_(const MHD_thread_ID_ thread_id,
  * @return non-zero on success, zero otherwise
  */
 static int
-MHD_set_thread_name_(const MHD_thread_ID_ thread_id,
-                     const char *thread_name)
+MHD_set_thread_name_ (const MHD_thread_ID_ thread_id,
+                      const char *thread_name)
 {
   static const DWORD VC_SETNAME_EXC = 0x406D1388;
 #pragma pack(push,8)
@@ -149,7 +151,7 @@ MHD_set_thread_name_(const MHD_thread_ID_ thread_id,
   __except (EXCEPTION_EXECUTE_HANDLER)
   {}
 
-  return !0;
+  return ! 0;
 }
 
 
@@ -158,7 +160,7 @@ MHD_set_thread_name_(const MHD_thread_ID_ thread_id,
  * @param n name to set
  * @return non-zero on success, zero otherwise
  */
-#define MHD_set_cur_thread_name_(n) MHD_set_thread_name_(-1,(n))
+#define MHD_set_cur_thread_name_(n) MHD_set_thread_name_ (-1,(n))
 #endif /* _MSC_FULL_VER */
 #endif /* MHD_USE_W32_THREADS */
 
@@ -184,21 +186,21 @@ MHD_create_thread_ (MHD_thread_handle_ID_ *thread,
   int res;
 
   if (0 != stack_size)
+  {
+    pthread_attr_t attr;
+    res = pthread_attr_init (&attr);
+    if (0 == res)
     {
-      pthread_attr_t attr;
-      res = pthread_attr_init (&attr);
+      res = pthread_attr_setstacksize (&attr,
+                                       stack_size);
       if (0 == res)
-        {
-          res = pthread_attr_setstacksize (&attr,
-                                           stack_size);
-          if (0 == res)
-              res = pthread_create (&(thread->handle),
-                                    &attr,
-                                    start_routine,
-                                    arg);
-          pthread_attr_destroy (&attr);
-        }
+        res = pthread_create (&(thread->handle),
+                              &attr,
+                              start_routine,
+                              arg);
+      pthread_attr_destroy (&attr);
     }
+  }
   else
     res = pthread_create (&(thread->handle),
                           NULL,
@@ -208,28 +210,28 @@ MHD_create_thread_ (MHD_thread_handle_ID_ *thread,
   if (0 != res)
     errno = res;
 
-  return !res;
+  return ! res;
 #elif defined(MHD_USE_W32_THREADS)
 #if SIZE_MAX != UINT_MAX
   if (stack_size > UINT_MAX)
-    {
-      errno = EINVAL;
-      return 0;
-    }
+  {
+    errno = EINVAL;
+    return 0;
+  }
 #endif /* SIZE_MAX != UINT_MAX */
 
   thread->handle = (MHD_thread_handle_)
-                     _beginthreadex (NULL,
-                                     (unsigned int) stack_size,
-                                     start_routine,
-                                     arg,
-                                     0,
-                                     NULL);
-
-  if ((MHD_thread_handle_)-1 == thread->handle)
+                   _beginthreadex (NULL,
+                                   (unsigned int) stack_size,
+                                   start_routine,
+                                   arg,
+                                   0,
+                                   NULL);
+
+  if ((MHD_thread_handle_) - 1 == thread->handle)
     return 0;
 
-  return !0;
+  return ! 0;
 #endif
 }
 
@@ -258,21 +260,21 @@ struct MHD_named_helper_param_
 static MHD_THRD_RTRN_TYPE_ MHD_THRD_CALL_SPEC_
 named_thread_starter (void *data)
 {
-  struct MHD_named_helper_param_ * const param =
-      (struct MHD_named_helper_param_ *) data;
-  void * arg;
+  struct MHD_named_helper_param_ *const param =
+    (struct MHD_named_helper_param_ *) data;
+  void *arg;
   MHD_THREAD_START_ROUTINE_ thr_func;
 
   if (NULL == data)
-    return (MHD_THRD_RTRN_TYPE_)0;
+    return (MHD_THRD_RTRN_TYPE_) 0;
 
   MHD_set_cur_thread_name_ (param->name);
 
   arg = param->arg;
   thr_func = param->start_routine;
-  free(data);
+  free (data);
 
-  return thr_func(arg);
+  return thr_func (arg);
 }
 #endif /* ! MHD_USE_THREAD_ATTR_SETNAME */
 
@@ -289,7 +291,7 @@ named_thread_starter (void *data)
  */
 int
 MHD_create_named_thread_ (MHD_thread_handle_ID_ *thread,
-                          const char* thread_name,
+                          const char*thread_name,
                           size_t stack_size,
                           MHD_THREAD_START_ROUTINE_ start_routine,
                           void *arg)
@@ -300,41 +302,41 @@ MHD_create_named_thread_ (MHD_thread_handle_ID_ *thread,
 
   res = pthread_attr_init (&attr);
   if (0 == res)
-    {
+  {
 #if defined(HAVE_PTHREAD_ATTR_SETNAME_NP_NETBSD)
-  /* NetBSD use 3 arguments: second argument is string in printf-like format,
-   *                         third argument is single argument for printf;
-   * OSF1 use 3 arguments too, but last one always must be zero (NULL).
-   * MHD doesn't use '%' in thread names, so both form are used in same way.
-   */
-      res = pthread_attr_setname_np (&attr, thread_name, 0);
+    /* NetBSD use 3 arguments: second argument is string in printf-like format,
+     *                         third argument is single argument for printf;
+     * OSF1 use 3 arguments too, but last one always must be zero (NULL).
+     * MHD doesn't use '%' in thread names, so both form are used in same way.
+     */
+    res = pthread_attr_setname_np (&attr, thread_name, 0);
 #elif defined(HAVE_PTHREAD_ATTR_SETNAME_NP_IBMI)
-      res = pthread_attr_setname_np (&attr, thread_name);
+    res = pthread_attr_setname_np (&attr, thread_name);
 #else
 #error No pthread_attr_setname_np() function.
 #endif
-      if (res == 0 && 0 != stack_size)
-        res = pthread_attr_setstacksize (&attr,
-                                         stack_size);
-      if (0 == res)
-          res = pthread_create (&(thread->handle),
-                                &attr,
-                                start_routine,
-                                arg);
-      pthread_attr_destroy (&attr);
-    }
+    if ((res == 0) &&(0 != stack_size) )
+      res = pthread_attr_setstacksize (&attr,
+                                       stack_size);
+    if (0 == res)
+      res = pthread_create (&(thread->handle),
+                            &attr,
+                            start_routine,
+                            arg);
+    pthread_attr_destroy (&attr);
+  }
   if (0 != res)
     errno = res;
 
-  return !res;
+  return ! res;
 #else  /* ! MHD_USE_THREAD_ATTR_SETNAME */
   struct MHD_named_helper_param_ *param;
 
   if (NULL == thread_name)
-    {
-      errno = EINVAL;
-      return 0;
-    }
+  {
+    errno = EINVAL;
+    return 0;
+  }
 
   param = malloc (sizeof (struct MHD_named_helper_param_));
   if (NULL == param)
@@ -347,16 +349,16 @@ MHD_create_named_thread_ (MHD_thread_handle_ID_ *thread,
   /* Set thread name in thread itself to avoid problems with
    * threads which terminated before name is set in other thread.
    */
-  if (! MHD_create_thread_(thread,
-                           stack_size,
-                           &named_thread_starter,
-                           (void*)param))
-    {
-      free (param);
-      return 0;
-    }
+  if (! MHD_create_thread_ (thread,
+                            stack_size,
+                            &named_thread_starter,
+                            (void*) param))
+  {
+    free (param);
+    return 0;
+  }
 
-  return !0;
+  return ! 0;
 #endif /* ! MHD_USE_THREAD_ATTR_SETNAME */
 }
 
diff --git a/src/lib/mhd_threads.h b/src/lib/mhd_threads.h
index 6d69b9ed..79520d53 100644
--- a/src/lib/mhd_threads.h
+++ b/src/lib/mhd_threads.h
@@ -58,23 +58,26 @@
 
 #ifndef MHD_NO_THREAD_NAMES
 #  if defined(MHD_USE_POSIX_THREADS)
-#    if defined(HAVE_PTHREAD_SETNAME_NP_GNU) || defined(HAVE_PTHREAD_SET_NAME_NP_FREEBSD) || \
-        defined(HAVE_PTHREAD_SETNAME_NP_DARWIN) || defined(HAVE_PTHREAD_SETNAME_NP_NETBSD) || \
-        defined(HAVE_PTHREAD_ATTR_SETNAME_NP_NETBSD) || defined(HAVE_PTHREAD_ATTR_SETNAME_NP_IBMI)
+#    if defined(HAVE_PTHREAD_SETNAME_NP_GNU) || \
+  defined(HAVE_PTHREAD_SET_NAME_NP_FREEBSD) || \
+  defined(HAVE_PTHREAD_SETNAME_NP_DARWIN) || \
+  defined(HAVE_PTHREAD_SETNAME_NP_NETBSD) || \
+  defined(HAVE_PTHREAD_ATTR_SETNAME_NP_NETBSD) || \
+  defined(HAVE_PTHREAD_ATTR_SETNAME_NP_IBMI)
 #      define MHD_USE_THREAD_NAME_
 #    endif /* HAVE_PTHREAD_SETNAME_NP */
 #  elif defined(MHD_USE_W32_THREADS)
 #    ifdef _MSC_FULL_VER
-       /* Thread names only available with VC compiler */
+/* Thread names only available with VC compiler */
 #      define MHD_USE_THREAD_NAME_
 #    endif /* _MSC_FULL_VER */
 #  endif
 #endif
 
 #if defined(MHD_USE_POSIX_THREADS)
-  typedef pthread_t MHD_thread_handle_;
+typedef pthread_t MHD_thread_handle_;
 #elif defined(MHD_USE_W32_THREADS)
-  typedef HANDLE MHD_thread_handle_;
+typedef HANDLE MHD_thread_handle_;
 #endif
 
 #if defined(MHD_USE_POSIX_THREADS)
@@ -86,9 +89,9 @@
 #endif
 
 #if defined(MHD_USE_POSIX_THREADS)
-  typedef pthread_t MHD_thread_ID_;
+typedef pthread_t MHD_thread_ID_;
 #elif defined(MHD_USE_W32_THREADS)
-  typedef DWORD MHD_thread_ID_;
+typedef DWORD MHD_thread_ID_;
 #endif
 
 /* Depending on implementation, pthread_create() MAY set thread ID into
@@ -100,27 +103,27 @@
  * to save some resources. */
 #if defined(MHD_USE_POSIX_THREADS)
 #  ifdef MHD_PTHREAD_CREATE__SET_ID_BEFORE_START_THREAD
-  union _MHD_thread_handle_ID_
-  {
-    MHD_thread_handle_  handle; /**< To be used in other threads */
-    MHD_thread_ID_      ID;     /**< To be used in thread itself */
-  };
-  typedef union _MHD_thread_handle_ID_ MHD_thread_handle_ID_;
+union _MHD_thread_handle_ID_
+{
+  MHD_thread_handle_ handle;    /**< To be used in other threads */
+  MHD_thread_ID_ ID;            /**< To be used in thread itself */
+};
+typedef union _MHD_thread_handle_ID_ MHD_thread_handle_ID_;
 #  else  /* ! MHD_PTHREAD_CREATE__SET_ID_BEFORE_START_THREAD */
-  struct _MHD_thread_handle_ID_
-  {
-    MHD_thread_handle_  handle; /**< To be used in other threads */
-    MHD_thread_ID_      ID;     /**< To be used in thread itself */
-  };
-  typedef struct _MHD_thread_handle_ID_ MHD_thread_handle_ID_;
+struct _MHD_thread_handle_ID_
+{
+  MHD_thread_handle_ handle;    /**< To be used in other threads */
+  MHD_thread_ID_ ID;            /**< To be used in thread itself */
+};
+typedef struct _MHD_thread_handle_ID_ MHD_thread_handle_ID_;
 #  endif /* ! MHD_PTHREAD_CREATE__SET_ID_BEFORE_START_THREAD */
 #elif defined(MHD_USE_W32_THREADS)
-  struct _MHD_thread_handle_ID_
-  {
-    MHD_thread_handle_  handle; /**< To be used in other threads */
-    MHD_thread_ID_      ID;     /**< To be used in thread itself */
-  };
-  typedef struct _MHD_thread_handle_ID_ MHD_thread_handle_ID_;
+struct _MHD_thread_handle_ID_
+{
+  MHD_thread_handle_ handle;    /**< To be used in other threads */
+  MHD_thread_ID_ ID;            /**< To be used in thread itself */
+};
+typedef struct _MHD_thread_handle_ID_ MHD_thread_handle_ID_;
 #endif
 
 #if defined(MHD_USE_POSIX_THREADS)
@@ -129,14 +132,17 @@
  * @param thread handle to watch
  * @return nonzero on success, zero otherwise
  */
-#define MHD_join_thread_(thread) (!pthread_join((thread), NULL))
+#define MHD_join_thread_(thread) (! pthread_join ((thread), NULL))
 #elif defined(MHD_USE_W32_THREADS)
 /**
  * Wait until specified thread is ended and free thread handle on success.
  * @param thread handle to watch
  * @return nonzero on success, zero otherwise
  */
-#define MHD_join_thread_(thread) (WAIT_OBJECT_0 == WaitForSingleObject((thread), INFINITE) ? (CloseHandle((thread)), !0) : 0)
+#define MHD_join_thread_(thread) (WAIT_OBJECT_0 == WaitForSingleObject ( \
+                                    (thread), INFINITE) ? (CloseHandle ( \
+                                                             (thread)), ! 0) : \
+                                  0)
 #endif
 
 #if defined(MHD_USE_POSIX_THREADS)
@@ -145,14 +151,14 @@
  * @param ID thread ID to match
  * @return nonzero on match, zero otherwise
  */
-#define MHD_thread_ID_match_current_(ID) (pthread_equal((ID), pthread_self()))
+#define MHD_thread_ID_match_current_(ID) (pthread_equal ((ID), pthread_self ()))
 #elif defined(MHD_USE_W32_THREADS)
 /**
  * Check whether provided thread ID match current thread.
  * @param ID thread ID to match
  * @return nonzero on match, zero otherwise
  */
-#define MHD_thread_ID_match_current_(ID) (GetCurrentThreadId() == (ID))
+#define MHD_thread_ID_match_current_(ID) (GetCurrentThreadId () == (ID))
 #endif
 
 #if defined(MHD_USE_POSIX_THREADS)
@@ -161,20 +167,22 @@
  * Initialise thread ID.
  * @param thread_handle_ID_ptr pointer to thread handle-ID
  */
-#define MHD_thread_init_(thread_handle_ID_ptr) (void)0
+#define MHD_thread_init_(thread_handle_ID_ptr) (void) 0
 #  else  /* ! MHD_PTHREAD_CREATE__SET_ID_BEFORE_START_THREAD */
 /**
  * Initialise thread ID.
  * @param thread_handle_ID_ptr pointer to thread handle-ID
  */
-#define MHD_thread_init_(thread_handle_ID_ptr) ((thread_handle_ID_ptr)->ID=pthread_self())
+#define MHD_thread_init_(thread_handle_ID_ptr) ((thread_handle_ID_ptr)->ID = \
+                                                  pthread_self ())
 #  endif /* ! MHD_PTHREAD_CREATE__SET_ID_BEFORE_START_THREAD */
 #elif defined(MHD_USE_W32_THREADS)
 /**
  * Initialise thread ID.
  * @param thread_handle_ID_ptr pointer to thread handle-ID
  */
-#define MHD_thread_init_(thread_handle_ID_ptr) ((thread_handle_ID_ptr)->ID=GetCurrentThreadId())
+#define MHD_thread_init_(thread_handle_ID_ptr) ((thread_handle_ID_ptr)->ID = \
+                                                  GetCurrentThreadId ())
 #endif
 
 /**
@@ -205,7 +213,7 @@ MHD_create_thread_ (MHD_thread_handle_ID_ *thread,
                     void *arg);
 
 #ifndef MHD_USE_THREAD_NAME_
-#define MHD_create_named_thread_(t,n,s,r,a) MHD_create_thread_((t),(s),(r),(a))
+#define MHD_create_named_thread_(t,n,s,r,a) MHD_create_thread_ ((t),(s),(r),(a))
 #else  /* MHD_USE_THREAD_NAME_ */
 /**
  * Create a named thread and set the attributes according to our options.
@@ -219,7 +227,7 @@ MHD_create_thread_ (MHD_thread_handle_ID_ *thread,
  */
 int
 MHD_create_named_thread_ (MHD_thread_handle_ID_ *thread,
-                          const char* thread_name,
+                          const char*thread_name,
                           size_t stack_size,
                           MHD_THREAD_START_ROUTINE_ start_routine,
                           void *arg);
diff --git a/src/lib/reason_phrase.c b/src/lib/reason_phrase.c
index 97ace0a3..e3692837 100644
--- a/src/lib/reason_phrase.c
+++ b/src/lib/reason_phrase.c
@@ -27,7 +27,7 @@
 #include "internal.h"
 
 #ifndef NULL
-#define NULL ((void*)0)
+#define NULL ((void*) 0)
 #endif
 
 static const char *const invalid_hundred[] = {
diff --git a/src/lib/request.c b/src/lib/request.c
index 02cce55c..5b932bfa 100644
--- a/src/lib/request.c
+++ b/src/lib/request.c
@@ -40,9 +40,9 @@
  */
 unsigned int
 MHD_request_get_values (struct MHD_Request *request,
-                        enum MHD_ValueKind kind,
-                        MHD_KeyValueIterator iterator,
-                        void *iterator_cls)
+                        enum MHD_ValueKind kind,
+                        MHD_KeyValueIterator iterator,
+                        void *iterator_cls)
 {
   int ret;
   struct MHD_HTTP_Header *pos;
@@ -51,18 +51,18 @@ MHD_request_get_values (struct MHD_Request *request,
   for (pos = request->headers_received;
        NULL != pos;
        pos = pos->next)
+  {
+    if (0 != (pos->kind & kind))
     {
-      if (0 != (pos->kind & kind))
-        {
-          ret++;
-          if ( (NULL != iterator) &&
-               (MHD_YES != iterator (iterator_cls,
-                                     pos->kind,
-                                     pos->header,
-                                     pos->value)) )
-            return ret;
-        }
+      ret++;
+      if ( (NULL != iterator) &&
+           (MHD_YES != iterator (iterator_cls,
+                                 pos->kind,
+                                 pos->header,
+                                 pos->value)) )
+        return ret;
     }
+  }
   return ret;
 }
 
@@ -94,9 +94,9 @@ MHD_request_get_values (struct MHD_Request *request,
  */
 enum MHD_Bool
 MHD_request_set_value (struct MHD_Request *request,
-                       enum MHD_ValueKind kind,
-                       const char *key,
-                       const char *value)
+                       enum MHD_ValueKind kind,
+                       const char *key,
+                       const char *value)
 {
   struct MHD_HTTP_Header *pos;
 
@@ -111,15 +111,15 @@ MHD_request_set_value (struct MHD_Request *request,
   pos->next = NULL;
   /* append 'pos' to the linked list of headers */
   if (NULL == request->headers_received_tail)
-    {
-      request->headers_received = pos;
-      request->headers_received_tail = pos;
-    }
+  {
+    request->headers_received = pos;
+    request->headers_received_tail = pos;
+  }
   else
-    {
-      request->headers_received_tail->next = pos;
-      request->headers_received_tail = pos;
-    }
+  {
+    request->headers_received_tail->next = pos;
+    request->headers_received_tail = pos;
+  }
   return MHD_YES;
 }
 
@@ -136,27 +136,25 @@ MHD_request_set_value (struct MHD_Request *request,
  */
 const char *
 MHD_request_lookup_value (struct MHD_Request *request,
-                          enum MHD_ValueKind kind,
-                          const char *key)
+                          enum MHD_ValueKind kind,
+                          const char *key)
 {
   struct MHD_HTTP_Header *pos;
 
   for (pos = request->headers_received;
        NULL != pos;
        pos = pos->next)
-    {
-      if ((0 != (pos->kind & kind)) &&
-          ( (key == pos->header) ||
-            ( (NULL != pos->header) &&
-              (NULL != key) &&
-              (MHD_str_equal_caseless_(key,
-                                       pos->header)))))
-        return pos->value;
-    }
+  {
+    if ((0 != (pos->kind & kind)) &&
+        ( (key == pos->header) ||
+          ( (NULL != pos->header) &&
+            (NULL != key) &&
+            (MHD_str_equal_caseless_ (key,
+                                      pos->header)))))
+      return pos->value;
+  }
   return NULL;
 }
 
 
 /* end of request.c */
-
-
diff --git a/src/lib/request_info.c b/src/lib/request_info.c
index 5f481d98..51aae075 100644
--- a/src/lib/request_info.c
+++ b/src/lib/request_info.c
@@ -42,11 +42,11 @@
  */
 enum MHD_Bool
 MHD_request_get_information_sz (struct MHD_Request *request,
-                                enum MHD_RequestInformationType info_type,
-                                union MHD_RequestInformation *return_value,
-                                size_t return_value_size)
+                                enum MHD_RequestInformationType info_type,
+                                union MHD_RequestInformation *return_value,
+                                size_t return_value_size)
 {
-#define CHECK_SIZE(type) if (sizeof(type) < return_value_size)  \
+#define CHECK_SIZE(type) if (sizeof(type) < return_value_size)  \
     return MHD_NO
 
   switch (info_type)
@@ -70,8 +70,8 @@ MHD_request_get_information_sz (struct MHD_Request *request,
   case MHD_REQUEST_INFORMATION_HEADER_SIZE:
     CHECK_SIZE (size_t);
     if ( (MHD_REQUEST_HEADERS_RECEIVED > request->state) ||
-         (MHD_REQUEST_CLOSED == request->state) )
-        return MHD_NO; /* invalid, too early! */
+         (MHD_REQUEST_CLOSED == request->state) )
+      return MHD_NO;   /* invalid, too early! */
     return_value->header_size = request->header_size;
     return MHD_YES;
 
diff --git a/src/lib/request_resume.c b/src/lib/request_resume.c
index a69107b9..be513f53 100644
--- a/src/lib/request_resume.c
+++ b/src/lib/request_resume.c
@@ -45,21 +45,23 @@ MHD_request_resume (struct MHD_Request *request)
   struct MHD_Daemon *daemon = request->daemon;
 
   if (daemon->disallow_suspend_resume)
-    MHD_PANIC (_("Cannot resume connections without enabling MHD_ALLOW_SUSPEND_RESUME!\n"));
+    MHD_PANIC (_ (
+                 "Cannot resume connections without enabling MHD_ALLOW_SUSPEND_RESUME!\n"));
   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
   request->connection->resuming = true;
   daemon->resuming = true;
   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
-  if ( (MHD_ITC_IS_VALID_(daemon->itc)) &&
+  if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
        (! MHD_itc_activate_ (daemon->itc,
-                             "r")) )
-    {
+                             "r")) )
+  {
 #ifdef HAVE_MESSAGES
-      MHD_DLOG (daemon,
-                MHD_SC_ITC_USE_FAILED,
-                _("Failed to signal resume via inter-thread communication channel."));
+    MHD_DLOG (daemon,
+              MHD_SC_ITC_USE_FAILED,
+              _ (
+                "Failed to signal resume via inter-thread communication channel."));
 #endif
-    }
+  }
 }
 
 
@@ -80,115 +82,118 @@ MHD_resume_suspended_connections_ (struct MHD_Daemon *daemon)
   struct MHD_Connection *pos;
   struct MHD_Connection *prev = NULL;
   bool ret;
-  const bool used_thr_p_c = (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode);
+  const bool used_thr_p_c = (MHD_TM_THREAD_PER_CONNECTION ==
+                             daemon->threading_mode);
 
   mhd_assert (NULL == daemon->worker_pool);
   ret = false;
   MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
 
   if (daemon->resuming)
-    {
-      prev = daemon->suspended_connections_tail;
-      /* During shutdown check for resuming is forced. */
-      mhd_assert((NULL != prev) || (daemon->shutdown));
-    }
+  {
+    prev = daemon->suspended_connections_tail;
+    /* During shutdown check for resuming is forced. */
+    mhd_assert ((NULL != prev) || (daemon->shutdown));
+  }
 
   daemon->resuming = false;
 
   while (NULL != (pos = prev))
-    {
+  {
 #ifdef UPGRADE_SUPPORT
-      struct MHD_UpgradeResponseHandle * const urh = pos->request.urh;
+    struct MHD_UpgradeResponseHandle *const urh = pos->request.urh;
 #else  /* ! UPGRADE_SUPPORT */
-      static const void * const urh = NULL;
+    static const void *const urh = NULL;
 #endif /* ! UPGRADE_SUPPORT */
-      prev = pos->prev;
-      if ( (! pos->resuming)
+    prev = pos->prev;
+    if ( (! pos->resuming)
 #ifdef UPGRADE_SUPPORT
-          || ( (NULL != urh) &&
-               ( (! urh->was_closed) ||
-                 (! urh->clean_ready) ) )
+         || ( (NULL != urh) &&
+              ( (! urh->was_closed) ||
+                (! urh->clean_ready) ) )
 #endif /* UPGRADE_SUPPORT */
          )
-        continue;
-      ret = true;
-      mhd_assert (pos->suspended);
-      DLL_remove (daemon->suspended_connections_head,
-                  daemon->suspended_connections_tail,
+      continue;
+    ret = true;
+    mhd_assert (pos->suspended);
+    DLL_remove (daemon->suspended_connections_head,
+                daemon->suspended_connections_tail,
+                pos);
+    pos->suspended = false;
+    if (NULL == urh)
+    {
+      DLL_insert (daemon->connections_head,
+                  daemon->connections_tail,
                   pos);
-      pos->suspended = false;
-      if (NULL == urh)
-        {
-          DLL_insert (daemon->connections_head,
-                      daemon->connections_tail,
-                      pos);
-          if (! used_thr_p_c)
-            {
-              /* Reset timeout timer on resume. */
-              if (0 != pos->connection_timeout)
-                pos->last_activity = MHD_monotonic_sec_counter();
-
-              if (pos->connection_timeout == daemon->connection_default_timeout)
-                XDLL_insert (daemon->normal_timeout_head,
-                             daemon->normal_timeout_tail,
-                             pos);
-              else
-                XDLL_insert (daemon->manual_timeout_head,
-                             daemon->manual_timeout_tail,
-                             pos);
-            }
+      if (! used_thr_p_c)
+      {
+        /* Reset timeout timer on resume. */
+        if (0 != pos->connection_timeout)
+          pos->last_activity = MHD_monotonic_sec_counter ();
+
+        if (pos->connection_timeout == daemon->connection_default_timeout)
+          XDLL_insert (daemon->normal_timeout_head,
+                       daemon->normal_timeout_tail,
+                       pos);
+        else
+          XDLL_insert (daemon->manual_timeout_head,
+                       daemon->manual_timeout_tail,
+                       pos);
+      }
 #ifdef EPOLL_SUPPORT
-          if (MHD_ELS_EPOLL == daemon->event_loop_syscall)
-            {
-              if (0 != (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL))
-                MHD_PANIC ("Resumed connection was already in EREADY set\n");
-              /* we always mark resumed connections as ready, as we
-                 might have missed the edge poll event during suspension */
-              EDLL_insert (daemon->eready_head,
-                           daemon->eready_tail,
-                           pos);
-              pos->epoll_state |= MHD_EPOLL_STATE_IN_EREADY_EDLL | \
-                  MHD_EPOLL_STATE_READ_READY | MHD_EPOLL_STATE_WRITE_READY;
-              pos->epoll_state &= ~MHD_EPOLL_STATE_SUSPENDED;
-            }
+      if (MHD_ELS_EPOLL == daemon->event_loop_syscall)
+      {
+        if (0 != (pos->epoll_state & MHD_EPOLL_STATE_IN_EREADY_EDLL))
+          MHD_PANIC ("Resumed connection was already in EREADY set\n");
+        /* we always mark resumed connections as ready, as we
+           might have missed the edge poll event during suspension */
+        EDLL_insert (daemon->eready_head,
+                     daemon->eready_tail,
+                     pos);
+        pos->epoll_state |= MHD_EPOLL_STATE_IN_EREADY_EDLL   \
+                            | MHD_EPOLL_STATE_READ_READY
+                            | MHD_EPOLL_STATE_WRITE_READY;
+        pos->epoll_state &= ~MHD_EPOLL_STATE_SUSPENDED;
+      }
 #endif
-        }
+    }
 #ifdef UPGRADE_SUPPORT
-      else
-        {
-          struct MHD_Response *response = pos->request.response;
-
-          /* Data forwarding was finished (for TLS connections) AND
-           * application was closed upgraded connection.
-           * Insert connection into cleanup list. */
-          if ( (NULL != response) &&
-               (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_mode) &&
-               (NULL != response->termination_cb) )
-            response->termination_cb (response->termination_cb_cls,
-                                      MHD_REQUEST_TERMINATED_COMPLETED_OK,
-                                      &pos->request.client_context);
-          DLL_insert (daemon->cleanup_head,
-                      daemon->cleanup_tail,
-                      pos);
-
-        }
-#endif /* UPGRADE_SUPPORT */
-      pos->resuming = false;
+    else
+    {
+      struct MHD_Response *response = pos->request.response;
+
+      /* Data forwarding was finished (for TLS connections) AND
+       * application was closed upgraded connection.
+       * Insert connection into cleanup list. */
+      if ( (NULL != response) &&
+           (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_mode) &&
+           (NULL != response->termination_cb) )
+        response->termination_cb (response->termination_cb_cls,
+                                  MHD_REQUEST_TERMINATED_COMPLETED_OK,
+                                  &pos->request.client_context);
+      DLL_insert (daemon->cleanup_head,
+                  daemon->cleanup_tail,
+                  pos);
+
     }
+#endif /* UPGRADE_SUPPORT */
+    pos->resuming = false;
+  }
   MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
   if ( (used_thr_p_c) &&
        (ret) )
-    { /* Wake up suspended connections. */
-      if (! MHD_itc_activate_(daemon->itc,
-                              "w"))
-        {
+  {   /* Wake up suspended connections. */
+    if (! MHD_itc_activate_ (daemon->itc,
+                             "w"))
+    {
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    MHD_SC_ITC_USE_FAILED,
-                    _("Failed to signal resume of connection via inter-thread communication channel."));
+      MHD_DLOG (daemon,
+                MHD_SC_ITC_USE_FAILED,
+                _ (
+                  "Failed to signal resume of connection via inter-thread communication channel."));
 #endif
-        }
     }
+  }
   return ret;
 }
 
diff --git a/src/lib/request_resume.h b/src/lib/request_resume.h
index d23ff9e8..dad43467 100644
--- a/src/lib/request_resume.h
+++ b/src/lib/request_resume.h
@@ -38,6 +38,6 @@
  */
 bool
 MHD_resume_suspended_connections_ (struct MHD_Daemon *daemon)
-  MHD_NONNULL(1);
+MHD_NONNULL (1);
 
 #endif
diff --git a/src/lib/response.c b/src/lib/response.c
index ff23c7fd..47dd98d6 100644
--- a/src/lib/response.c
+++ b/src/lib/response.c
@@ -38,9 +38,9 @@
  */
 static bool
 add_response_entry (struct MHD_Response *response,
-                    enum MHD_ValueKind kind,
-                    const char *header,
-                    const char *content)
+                    enum MHD_ValueKind kind,
+                    const char *header,
+                    const char *content)
 {
   struct MHD_HTTP_Header *hdr;
 
@@ -58,16 +58,16 @@ add_response_entry (struct MHD_Response *response,
   if (NULL == (hdr = malloc (sizeof (struct MHD_HTTP_Header))))
     return false;
   if (NULL == (hdr->header = strdup (header)))
-    {
-      free (hdr);
-      return false;
-    }
+  {
+    free (hdr);
+    return false;
+  }
   if (NULL == (hdr->value = strdup (content)))
-    {
-      free (hdr->header);
-      free (hdr);
-      return false;
-    }
+  {
+    free (hdr->header);
+    free (hdr);
+    return false;
+  }
   hdr->kind = kind;
   hdr->next = response->first_header;
   response->first_header = hdr;
@@ -91,22 +91,22 @@ MHD_response_queue_for_destroy (struct MHD_Response *response)
 
   MHD_mutex_lock_chk_ (&response->mutex);
   if (0 != --(response->reference_count))
-    {
-      MHD_mutex_unlock_chk_ (&response->mutex);
-      return;
-    }
+  {
+    MHD_mutex_unlock_chk_ (&response->mutex);
+    return;
+  }
   MHD_mutex_unlock_chk_ (&response->mutex);
   MHD_mutex_destroy_chk_ (&response->mutex);
   if (NULL != response->crfc)
     response->crfc (response->crc_cls);
   while (NULL != response->first_header)
-    {
-      pos = response->first_header;
-      response->first_header = pos->next;
-      free (pos->header);
-      free (pos->value);
-      free (pos);
-    }
+  {
+    pos = response->first_header;
+    response->first_header = pos->next;
+    free (pos->header);
+    free (pos->value);
+    free (pos);
+  }
   free (response);
 }
 
@@ -124,12 +124,12 @@ MHD_response_queue_for_destroy (struct MHD_Response *response)
 enum MHD_Bool
 MHD_response_add_header (struct MHD_Response *response,
                          const char *header,
-                         const char *content)
+                         const char *content)
 {
   return add_response_entry (response,
-                             MHD_HEADER_KIND,
-                             header,
-                             content) ? MHD_YES : MHD_NO;
+                             MHD_HEADER_KIND,
+                             header,
+                             content) ? MHD_YES : MHD_NO;
 }
 
 
@@ -149,9 +149,9 @@ MHD_response_add_trailer (struct MHD_Response *response,
                           const char *content)
 {
   return add_response_entry (response,
-                             MHD_FOOTER_KIND,
-                             footer,
-                             content) ? MHD_YES : MHD_NO;
+                             MHD_FOOTER_KIND,
+                             footer,
+                             content) ? MHD_YES : MHD_NO;
 }
 
 
@@ -167,7 +167,7 @@ MHD_response_add_trailer (struct MHD_Response *response,
 enum MHD_Bool
 MHD_response_del_header (struct MHD_Response *response,
                          const char *header,
-                         const char *content)
+                         const char *content)
 {
   struct MHD_HTTP_Header *pos;
   struct MHD_HTTP_Header *prev;
@@ -175,24 +175,24 @@ MHD_response_del_header (struct MHD_Response *response,
   prev = NULL;
   pos = response->first_header;
   while (NULL != pos)
+  {
+    if ((0 == strcmp (header,
+                      pos->header)) &&
+        (0 == strcmp (content,
+                      pos->value)))
     {
-      if ((0 == strcmp (header,
-                        pos->header)) &&
-          (0 == strcmp (content,
-                        pos->value)))
-        {
-          free (pos->header);
-          free (pos->value);
-          if (NULL == prev)
-            response->first_header = pos->next;
-          else
-            prev->next = pos->next;
-          free (pos);
-          return MHD_YES;
-        }
-      prev = pos;
-      pos = pos->next;
+      free (pos->header);
+      free (pos->value);
+      if (NULL == prev)
+        response->first_header = pos->next;
+      else
+        prev->next = pos->next;
+      free (pos);
+      return MHD_YES;
     }
+    prev = pos;
+    pos = pos->next;
+  }
   return MHD_NO;
 }
 
@@ -210,7 +210,7 @@ MHD_response_del_header (struct MHD_Response *response,
 unsigned int
 MHD_response_get_headers (struct MHD_Response *response,
                           MHD_KeyValueIterator iterator,
-                          void *iterator_cls)
+                          void *iterator_cls)
 {
   unsigned int numHeaders = 0;
   struct MHD_HTTP_Header *pos;
@@ -218,15 +218,15 @@ MHD_response_get_headers (struct MHD_Response *response,
   for (pos = response->first_header;
        NULL != pos;
        pos = pos->next)
-    {
-      numHeaders++;
-      if ( (NULL != iterator) &&
-           (MHD_YES != iterator (iterator_cls,
-                                 pos->kind,
-                                 pos->header,
-                                 pos->value)) )
-        break;
-    }
+  {
+    numHeaders++;
+    if ( (NULL != iterator) &&
+         (MHD_YES != iterator (iterator_cls,
+                               pos->kind,
+                               pos->header,
+                               pos->value)) )
+      break;
+  }
   return numHeaders;
 }
 
@@ -241,18 +241,18 @@ MHD_response_get_headers (struct MHD_Response *response,
  */
 const char *
 MHD_response_get_header (struct MHD_Response *response,
-                         const char *key)
+                         const char *key)
 {
   struct MHD_HTTP_Header *pos;
 
   for (pos = response->first_header;
        NULL != pos;
        pos = pos->next)
-    {
-      if (MHD_str_equal_caseless_ (pos->header,
-                                   key))
-        return pos->value;
-    }
+  {
+    if (MHD_str_equal_caseless_ (pos->header,
+                                 key))
+      return pos->value;
+  }
   return NULL;
 }
 
diff --git a/src/lib/response_for_upgrade.c b/src/lib/response_for_upgrade.c
index 0d843b8e..ef66b029 100644
--- a/src/lib/response_for_upgrade.c
+++ b/src/lib/response_for_upgrade.c
@@ -57,21 +57,21 @@
  */
 struct MHD_Response *
 MHD_response_for_upgrade (MHD_UpgradeHandler upgrade_handler,
-                          void *upgrade_handler_cls)
+                          void *upgrade_handler_cls)
 {
 #ifdef UPGRADE_SUPPORT
   struct MHD_Response *response;
 
   mhd_assert (NULL != upgrade_handler);
   response = MHD_calloc_ (1,
-                          sizeof (struct MHD_Response));
+                          sizeof (struct MHD_Response));
   if (NULL == response)
     return NULL;
   if (! MHD_mutex_init_ (&response->mutex))
-    {
-      free (response);
-      return NULL;
-    }
+  {
+    free (response);
+    return NULL;
+  }
   response->upgrade_handler = upgrade_handler;
   response->upgrade_handler_cls = upgrade_handler_cls;
   response->status_code = MHD_HTTP_SWITCHING_PROTOCOLS;
@@ -81,10 +81,10 @@ MHD_response_for_upgrade (MHD_UpgradeHandler upgrade_handler,
       MHD_response_add_header (response,
                                MHD_HTTP_HEADER_CONNECTION,
                                "Upgrade"))
-    {
-      MHD_response_queue_for_destroy (response);
-      return NULL;
-    }
+  {
+    MHD_response_queue_for_destroy (response);
+    return NULL;
+  }
   return response;
 #else
   return NULL;
diff --git a/src/lib/response_from_buffer.c b/src/lib/response_from_buffer.c
index a53537b0..a65a0298 100644
--- a/src/lib/response_from_buffer.c
+++ b/src/lib/response_from_buffer.c
@@ -39,44 +39,44 @@
  */
 struct MHD_Response *
 MHD_response_from_buffer (enum MHD_HTTP_StatusCode sc,
-                          size_t size,
-                          void *buffer,
-                          enum MHD_ResponseMemoryMode mode)
+                          size_t size,
+                          void *buffer,
+                          enum MHD_ResponseMemoryMode mode)
 {
   struct MHD_Response *response;
   void *tmp;
 
   mhd_assert ( (NULL != buffer) ||
-               (0 == size) );
+               (0 == size) );
   if (NULL ==
       (response = MHD_calloc_ (1,
-                               sizeof (struct MHD_Response))))
+                               sizeof (struct MHD_Response))))
     return NULL;
   response->fd = -1;
   if (! MHD_mutex_init_ (&response->mutex))
-    {
-      free (response);
-      return NULL;
-    }
+  {
+    free (response);
+    return NULL;
+  }
   if ( (MHD_RESPMEM_MUST_COPY == mode) &&
        (size > 0) )
+  {
+    if (NULL == (tmp = malloc (size)))
     {
-      if (NULL == (tmp = malloc (size)))
-        {
-          MHD_mutex_destroy_chk_ (&response->mutex);
-          free (response);
-          return NULL;
-        }
-      memcpy (tmp,
-              buffer,
-              size);
-      buffer = tmp;
+      MHD_mutex_destroy_chk_ (&response->mutex);
+      free (response);
+      return NULL;
     }
+    memcpy (tmp,
+            buffer,
+            size);
+    buffer = tmp;
+  }
   if (MHD_RESPMEM_PERSISTENT != mode)
-    {
-      response->crfc = &free;
-      response->crc_cls = buffer;
-    }
+  {
+    response->crfc = &free;
+    response->crc_cls = buffer;
+  }
   response->status_code = sc;
   response->reference_count = 1;
   response->total_size = size;
diff --git a/src/lib/response_from_callback.c b/src/lib/response_from_callback.c
index 1fd65bf0..e00033ce 100644
--- a/src/lib/response_from_callback.c
+++ b/src/lib/response_from_callback.c
@@ -44,11 +44,11 @@
  */
 struct MHD_Response *
 MHD_response_from_callback (enum MHD_HTTP_StatusCode sc,
-                            uint64_t size,
-                            size_t block_size,
-                            MHD_ContentReaderCallback crc,
-                            void *crc_cls,
-                            MHD_ContentReaderFreeCallback crfc)
+                            uint64_t size,
+                            size_t block_size,
+                            MHD_ContentReaderCallback crc,
+                            void *crc_cls,
+                            MHD_ContentReaderFreeCallback crfc)
 {
   struct MHD_Response *response;
 
@@ -56,8 +56,8 @@ MHD_response_from_callback (enum MHD_HTTP_StatusCode sc,
   mhd_assert (0 != block_size);
   if (NULL ==
       (response = MHD_calloc_ (1,
-                               sizeof (struct MHD_Response) +
-                               block_size)))
+                               sizeof (struct MHD_Response)
+                               + block_size)))
     return NULL;
   response->fd = -1;
   response->status_code = sc;
diff --git a/src/lib/response_from_fd.c b/src/lib/response_from_fd.c
index ac0a54d1..ffeb2b91 100644
--- a/src/lib/response_from_fd.c
+++ b/src/lib/response_from_fd.c
@@ -57,34 +57,34 @@ file_reader (void *cls,
              size_t max)
 {
   struct MHD_Response *response = cls;
-#if !defined(_WIN32) || defined(__CYGWIN__)
+#if ! defined(_WIN32) || defined(__CYGWIN__)
   ssize_t n;
 #else  /* _WIN32 && !__CYGWIN__ */
   const HANDLE fh = (HANDLE) _get_osfhandle (response->fd);
 #endif /* _WIN32 && !__CYGWIN__ */
-  const int64_t offset64 = (int64_t)(pos + response->fd_off);
+  const int64_t offset64 = (int64_t) (pos + response->fd_off);
 
   if (offset64 < 0)
     return MHD_CONTENT_READER_END_WITH_ERROR; /* seek to required position is not possible */
 
-#if !defined(_WIN32) || defined(__CYGWIN__)
+#if ! defined(_WIN32) || defined(__CYGWIN__)
   if (max > SSIZE_MAX)
     max = SSIZE_MAX; /* Clamp to maximum return value. */
 
 #if defined(HAVE_PREAD64)
   n = pread64 (response->fd,
-               buf,
-               max,
-               offset64);
+               buf,
+               max,
+               offset64);
 #elif defined(HAVE_PREAD)
   if ( (sizeof(off_t) < sizeof (uint64_t)) &&
-       (offset64 > (uint64_t)INT32_MAX) )
+       (offset64 > (uint64_t) INT32_MAX) )
     return MHD_CONTENT_READER_END_WITH_ERROR; /* Read at required position is not possible. */
 
   n = pread (response->fd,
-             buf,
-             max,
-             (off_t) offset64);
+             buf,
+             max,
+             (off_t) offset64);
 #else  /* ! HAVE_PREAD */
 #if defined(HAVE_LSEEK64)
   if (lseek64 (response->fd,
@@ -93,7 +93,7 @@ file_reader (void *cls,
     return MHD_CONTENT_READER_END_WITH_ERROR; /* can't seek to required position */
 #else  /* ! HAVE_LSEEK64 */
   if ( (sizeof(off_t) < sizeof (uint64_t)) &&
-       (offset64 > (uint64_t)INT32_MAX) )
+       (offset64 > (uint64_t) INT32_MAX) )
     return MHD_CONTENT_READER_END_WITH_ERROR; /* seek to required position is not possible */
 
   if (lseek (response->fd,
@@ -115,25 +115,25 @@ file_reader (void *cls,
   if (INVALID_HANDLE_VALUE == fh)
     return MHD_CONTENT_READER_END_WITH_ERROR; /* Value of 'response->fd' is not valid. */
   else
-    {
-      OVERLAPPED f_ol = {0, 0, {{0, 0}}, 0}; /* Initialize to zero. */
-      ULARGE_INTEGER pos_uli;
-      DWORD toRead = (max > INT32_MAX) ? INT32_MAX : (DWORD) max;
-      DWORD resRead;
-
-      pos_uli.QuadPart = (uint64_t) offset64; /* Simple transformation 64bit -> 2x32bit. */
-      f_ol.Offset = pos_uli.LowPart;
-      f_ol.OffsetHigh = pos_uli.HighPart;
-      if (! ReadFile (fh,
-                      (void*)buf,
-                      toRead,
-                      &resRead,
-                      &f_ol))
-        return MHD_CONTENT_READER_END_WITH_ERROR; /* Read error. */
-      if (0 == resRead)
-        return MHD_CONTENT_READER_END_OF_STREAM;
-      return (ssize_t) resRead;
-    }
+  {
+    OVERLAPPED f_ol = {0, 0, {{0, 0}}, 0};   /* Initialize to zero. */
+    ULARGE_INTEGER pos_uli;
+    DWORD toRead = (max > INT32_MAX) ? INT32_MAX : (DWORD) max;
+    DWORD resRead;
+
+    pos_uli.QuadPart = (uint64_t) offset64;   /* Simple transformation 64bit -> 2x32bit. */
+    f_ol.Offset = pos_uli.LowPart;
+    f_ol.OffsetHigh = pos_uli.HighPart;
+    if (! ReadFile (fh,
+                    (void*) buf,
+                    toRead,
+                    &resRead,
+                    &f_ol))
+      return MHD_CONTENT_READER_END_WITH_ERROR;   /* Read error. */
+    if (0 == resRead)
+      return MHD_CONTENT_READER_END_OF_STREAM;
+    return (ssize_t) resRead;
+  }
 #endif /* _WIN32 && !__CYGWIN__ */
 }
 
@@ -174,18 +174,18 @@ free_callback (void *cls)
  */
 struct MHD_Response *
 MHD_response_from_fd (enum MHD_HTTP_StatusCode sc,
-                      int fd,
-                      uint64_t offset,
-                      uint64_t size)
+                      int fd,
+                      uint64_t offset,
+                      uint64_t size)
 {
   struct MHD_Response *response;
 
   mhd_assert (-1 != fd);
-#if !defined(HAVE___LSEEKI64) && !defined(HAVE_LSEEK64)
+#if ! defined(HAVE___LSEEKI64) && ! defined(HAVE_LSEEK64)
   if ( (sizeof (uint64_t) > sizeof (off_t)) &&
-       ( (size > (uint64_t)INT32_MAX) ||
-         (offset > (uint64_t)INT32_MAX) ||
-         ((size + offset) >= (uint64_t)INT32_MAX) ) )
+       ( (size > (uint64_t) INT32_MAX) ||
+         (offset > (uint64_t) INT32_MAX) ||
+         ((size + offset) >= (uint64_t) INT32_MAX) ) )
     return NULL;
 #endif
   if ( ((int64_t) size < 0) ||
@@ -194,11 +194,11 @@ MHD_response_from_fd (enum MHD_HTTP_StatusCode sc,
     return NULL;
 
   response = MHD_response_from_callback (sc,
-                                         size,
-                                         MHD_FILE_READ_BLOCK_SIZE,
-                                         &file_reader,
-                                         NULL,
-                                         &free_callback);
+                                         size,
+                                         MHD_FILE_READ_BLOCK_SIZE,
+                                         &file_reader,
+                                         NULL,
+                                         &free_callback);
   if (NULL == response)
     return NULL;
   response->fd = fd;
@@ -208,4 +208,3 @@ MHD_response_from_fd (enum MHD_HTTP_StatusCode sc,
 }
 
 /* end of response_from_fd.c */
-
diff --git a/src/lib/response_options.c b/src/lib/response_options.c
index 406d1d32..e349627a 100644
--- a/src/lib/response_options.c
+++ b/src/lib/response_options.c
@@ -49,8 +49,9 @@ MHD_response_option_v10_only (struct MHD_Response *response)
  */
 void
 MHD_response_option_termination_callback (struct MHD_Response *response,
-                                          MHD_RequestTerminationCallback termination_cb,
-                                          void *termination_cb_cls)
+                                          MHD_RequestTerminationCallback
+                                          termination_cb,
+                                          void *termination_cb_cls)
 {
   /* Q: should we assert termination_cb non-NULL? */
   response->termination_cb = termination_cb;
diff --git a/src/lib/sysfdsetsize.c b/src/lib/sysfdsetsize.c
index fe7fba75..4929b3d2 100644
--- a/src/lib/sysfdsetsize.c
+++ b/src/lib/sysfdsetsize.c
@@ -56,7 +56,7 @@
 #include <sys/socket.h>
 #endif /* HAVE_SYS_SOCKET_H */
 
-#if defined(_WIN32) && !defined(__CYGWIN__)
+#if defined(_WIN32) && ! defined(__CYGWIN__)
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN 1
 #endif /* !WIN32_LEAN_AND_MEAN */
diff --git a/src/lib/tsearch.c b/src/lib/tsearch.c
index fe5fcd5b..e43d758f 100644
--- a/src/lib/tsearch.c
+++ b/src/lib/tsearch.c
@@ -13,7 +13,7 @@
 #include <stdlib.h>
 
 
-typedef struct node
+typedef struct node
 {
   const void   *key;
   struct node  *llink;
@@ -24,35 +24,35 @@ typedef	struct node
 /*      $NetBSD: tsearch.c,v 1.5 2005/11/29 03:12:00 christos Exp $     */
 /* find or insert datum into search tree */
 void *
-tsearch (const void *vkey,              /* key to be located */
-         void **vrootp,                 /* address of tree root */
+tsearch (const void *vkey,    /* key to be located */
+         void **vrootp,     /* address of tree root */
          int (*compar)(const void *, const void *))
 {
   node_t *q;
-  node_t **rootp = (node_t **)vrootp;
+  node_t **rootp = (node_t **) vrootp;
 
   if (NULL == rootp)
     return NULL;
 
   while (*rootp != NULL)
-    {   /* Knuth's T1: */
-      int r;
+  {   /* Knuth's T1: */
+    int r;
 
-      if ((r = (*compar)(vkey, (*rootp)->key)) == 0)    /* T2: */
-        return *rootp;          /* we found it! */
+    if ((r = (*compar)(vkey, (*rootp)->key)) == 0)    /* T2: */
+      return *rootp;      /* we found it! */
 
-      rootp = (r < 0) ?
-        &(*rootp)->llink :              /* T3: follow left branch */
-        &(*rootp)->rlink;               /* T4: follow right branch */
-    }
+    rootp = (r < 0) ?
+            &(*rootp)->llink : /* T3: follow left branch */
+            &(*rootp)->rlink; /* T4: follow right branch */
+  }
 
-  q = malloc (sizeof(node_t));          /* T5: key not found */
+  q = malloc (sizeof(node_t));    /* T5: key not found */
   if (q)
-    {                           /* make new node */
-      *rootp = q;                       /* link new node to old */
-      q->key = vkey;            /* initialize new node */
-      q->llink = q->rlink = NULL;
-    }
+  {         /* make new node */
+    *rootp = q;       /* link new node to old */
+    q->key = vkey;      /* initialize new node */
+    q->llink = q->rlink = NULL;
+  }
   return q;
 }
 
@@ -61,24 +61,24 @@ tsearch (const void *vkey,		/* key to be located */
 /* find a node, or return NULL */
 void *
 tfind (const void *vkey,         /* key to be found */
-       void * const *vrootp,     /* address of the tree root */
+       void *const *vrootp,      /* address of the tree root */
        int (*compar)(const void *, const void *))
 {
-  node_t * const *rootp = (node_t * const*)vrootp;
+  node_t *const *rootp = (node_t *const*) vrootp;
 
   if (NULL == rootp)
     return NULL;
 
   while (*rootp != NULL)
-    {           /* T1: */
-      int r;
-
-      if ((r = (*compar)(vkey, (*rootp)->key)) == 0)    /* T2: */
-        return *rootp;          /* key found */
-      rootp = (r < 0) ?
-        &(*rootp)->llink :              /* T3: follow left branch */
-        &(*rootp)->rlink;               /* T4: follow right branch */
-    }
+  {     /* T1: */
+    int r;
+
+    if ((r = (*compar)(vkey, (*rootp)->key)) == 0)    /* T2: */
+      return *rootp;      /* key found */
+    rootp = (r < 0) ?
+            &(*rootp)->llink : /* T3: follow left branch */
+            &(*rootp)->rlink; /* T4: follow right branch */
+  }
   return NULL;
 }
 
@@ -92,51 +92,51 @@ tfind (const void *vkey,         /* key to be found */
  * compar: function to carry out node comparisons
  */
 void *
-tdelete (const void * __restrict vkey,
-         void ** __restrict vrootp,
+tdelete (const void *__restrict vkey,
+         void **__restrict vrootp,
          int (*compar)(const void *, const void *))
 {
-  node_t **rootp = (node_t **)vrootp;
+  node_t **rootp = (node_t **) vrootp;
   node_t *p;
   node_t *q;
   node_t *r;
   int cmp;
 
-  if (rootp == NULL || (p = *rootp) == NULL)
+  if ((rootp == NULL)||((p = *rootp) == NULL))
     return NULL;
 
   while ((cmp = (*compar)(vkey, (*rootp)->key)) != 0)
-    {
-      p = *rootp;
-      rootp = (cmp < 0) ?
-        &(*rootp)->llink :              /* follow llink branch */
-        &(*rootp)->rlink;               /* follow rlink branch */
-      if (*rootp == NULL)
-        return NULL;            /* key not found */
-    }
-  r = (*rootp)->rlink;                  /* D1: */
-  if ((q = (*rootp)->llink) == NULL)    /* Left NULL? */
-    {
+  {
+    p = *rootp;
+    rootp = (cmp < 0) ?
+            &(*rootp)->llink : /* follow llink branch */
+            &(*rootp)->rlink; /* follow rlink branch */
+    if (*rootp == NULL)
+      return NULL;      /* key not found */
+  }
+  r = (*rootp)->rlink;      /* D1: */
+  if ((q = (*rootp)->llink) == NULL)  /* Left NULL? */
+  {
+    q = r;
+  }
+  else if (r != NULL)
+  {       /* Right link is NULL? */
+    if (r->llink == NULL)
+    {       /* D2: Find successor */
+      r->llink = q;
       q = r;
     }
-  else if (r != NULL)
-    {                   /* Right link is NULL? */
-      if (r->llink == NULL)
-        {               /* D2: Find successor */
-          r->llink = q;
-          q = r;
-        }
-      else
-        {                       /* D3: Find NULL link */
-          for (q = r->llink; q->llink != NULL; q = r->llink)
-            r = q;
-          r->llink = q->rlink;
-          q->llink = (*rootp)->llink;
-          q->rlink = (*rootp)->rlink;
-        }
+    else
+    {         /* D3: Find NULL link */
+      for (q = r->llink; q->llink != NULL; q = r->llink)
+        r = q;
+      r->llink = q->rlink;
+      q->llink = (*rootp)->llink;
+      q->rlink = (*rootp)->rlink;
     }
-  free(*rootp);                         /* D4: Free node */
-  *rootp = q;                           /* link parent to new node */
+  }
+  free (*rootp);       /* D4: Free node */
+  *rootp = q;       /* link parent to new node */
   return p;
 }
 
diff --git a/src/lib/tsearch.h b/src/lib/tsearch.h
index aa186495..0cfe16a7 100644
--- a/src/lib/tsearch.h
+++ b/src/lib/tsearch.h
@@ -14,22 +14,22 @@ extern "C" {
 #endif /* __cplusplus */
 
 
-void    *
-tdelete (const void * __restrict,
-         void ** __restrict,
-         int (*)(const void *, const void *));
+void  *
+  tdelete (const void *__restrict,
+           void **__restrict,
+           int (*)(const void *, const void *));
 
 
-void    *
-tfind (const void *,
-       void * const *,
-       int (*)(const void *, const void *));
+void  *
+  tfind (const void *,
+         void *const *,
+         int (*)(const void *, const void *));
 
 
-void    *
-tsearch (const void *,
-         void **,
-         int (*)(const void *, const void *));
+void  *
+  tsearch (const void *,
+           void **,
+           int (*)(const void *, const void *));
 
 #if defined(__cplusplus)
 };
diff --git a/src/lib/upgrade_process.c b/src/lib/upgrade_process.c
index 75924eee..353f2753 100644
--- a/src/lib/upgrade_process.c
+++ b/src/lib/upgrade_process.c
@@ -41,59 +41,62 @@ MHD_upgrade_response_handle_process_ (struct MHD_UpgradeResponseHandle *urh)
    * pointers to 'connection' and 'daemon' are not changed
    * during this processing, so no need to chain dereference
    * each time. */
-  struct MHD_Connection * const connection = urh->connection;
-  struct MHD_Daemon * const daemon = connection->daemon;
+  struct MHD_Connection *const connection = urh->connection;
+  struct MHD_Daemon *const daemon = connection->daemon;
   /* Prevent data races: use same value of 'was_closed' throughout
    * this function. If 'was_closed' changed externally in the middle
    * of processing - it will be processed on next iteration. */
   bool was_closed;
   struct MHD_TLS_Plugin *tls = daemon->tls_api;
-  
+
   if (daemon->shutdown)
-    {
-      /* Daemon shutting down, application will not receive any more data. */
+  {
+    /* Daemon shutting down, application will not receive any more data. */
 #ifdef HAVE_MESSAGES
-      if (! urh->was_closed)
-        {
-          MHD_DLOG (daemon,
-                    MHD_SC_DAEMON_ALREADY_SHUTDOWN,
-                    _("Initiated daemon shutdown while \"upgraded\" connection was not closed.\n"));
-        }
-#endif
-      urh->was_closed = true;
+    if (! urh->was_closed)
+    {
+      MHD_DLOG (daemon,
+                MHD_SC_DAEMON_ALREADY_SHUTDOWN,
+                _ (
+                  "Initiated daemon shutdown while \"upgraded\" connection was not closed.\n"));
     }
+#endif
+    urh->was_closed = true;
+  }
   was_closed = urh->was_closed;
   if (was_closed)
+  {
+    /* Application was closed connections: no more data
+     * can be forwarded to application socket. */
+    if (0 < urh->in_buffer_used)
     {
-      /* Application was closed connections: no more data
-       * can be forwarded to application socket. */
-      if (0 < urh->in_buffer_used)
-        {
 #ifdef HAVE_MESSAGES
-          MHD_DLOG (daemon,
-                    MHD_SC_UPGRADE_FORWARD_INCOMPLETE,
-                    _("Failed to forward to application " MHD_UNSIGNED_LONG_LONG_PRINTF \
-                        " bytes of data received from remote side: application shut down socket\n"),
-                    (MHD_UNSIGNED_LONG_LONG) urh->in_buffer_used);
+      MHD_DLOG (daemon,
+                MHD_SC_UPGRADE_FORWARD_INCOMPLETE,
+                _ (
+                  "Failed to forward to application "
+                  MHD_UNSIGNED_LONG_LONG_PRINTF \
+                  " bytes of data received from remote side: application shut down socket\n"),
+                (MHD_UNSIGNED_LONG_LONG) urh->in_buffer_used);
 #endif
 
-        }
-      /* If application signaled MHD about socket closure then
-       * check for any pending data even if socket is not marked
-       * as 'ready' (signal may arrive after poll()/select()).
-       * Socketpair for forwarding is always in non-blocking mode
-       * so no risk that recv() will block the thread. */
-      if (0 != urh->out_buffer_size)
-        urh->mhd.celi |= MHD_EPOLL_STATE_READ_READY;
-      /* Discard any data received form remote. */
-      urh->in_buffer_used = 0;
-      /* Do not try to push data to application. */
-      urh->mhd.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
-      /* Reading from remote client is not required anymore. */
-      urh->in_buffer_size = 0;
-      urh->app.celi &= ~MHD_EPOLL_STATE_READ_READY;
-      connection->tls_read_ready = false;
     }
+    /* If application signaled MHD about socket closure then
+     * check for any pending data even if socket is not marked
+     * as 'ready' (signal may arrive after poll()/select()).
+     * Socketpair for forwarding is always in non-blocking mode
+     * so no risk that recv() will block the thread. */
+    if (0 != urh->out_buffer_size)
+      urh->mhd.celi |= MHD_EPOLL_STATE_READ_READY;
+    /* Discard any data received form remote. */
+    urh->in_buffer_used = 0;
+    /* Do not try to push data to application. */
+    urh->mhd.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
+    /* Reading from remote client is not required anymore. */
+    urh->in_buffer_size = 0;
+    urh->app.celi &= ~MHD_EPOLL_STATE_READ_READY;
+    connection->tls_read_ready = false;
+  }
 
   /* On some platforms (W32, possibly Darwin) failed send() (send() will always
    * fail after remote disconnect was detected) may discard data in system
@@ -114,245 +117,249 @@ MHD_upgrade_response_handle_process_ (struct MHD_UpgradeResponseHandle *urh)
   if ( ( (0 != (MHD_EPOLL_STATE_READ_READY & urh->app.celi)) ||
          (connection->tls_read_ready) ) &&
        (urh->in_buffer_used < urh->in_buffer_size) )
-    {
-      ssize_t res;
-      size_t buf_size;
+  {
+    ssize_t res;
+    size_t buf_size;
 
-      buf_size = urh->in_buffer_size - urh->in_buffer_used;
-      if (buf_size > SSIZE_MAX)
-        buf_size = SSIZE_MAX;
+    buf_size = urh->in_buffer_size - urh->in_buffer_used;
+    if (buf_size > SSIZE_MAX)
+      buf_size = SSIZE_MAX;
 
-      connection->tls_read_ready = false;
-      res = tls->recv (tls->cls,
-                       connection->tls_cs,
-                       &urh->in_buffer[urh->in_buffer_used],
-                       buf_size);
-      if (0 >= res)
-        {
-          // FIXME: define GNUTLS-independent error codes!
-          if (GNUTLS_E_INTERRUPTED != res)
-            {
-              urh->app.celi &= ~MHD_EPOLL_STATE_READ_READY;
-              if (GNUTLS_E_AGAIN != res)
-                {
-                  /* Unrecoverable error on socket was detected or
-                   * socket was disconnected/shut down. */
-                  /* Stop trying to read from this TLS socket. */
-                  urh->in_buffer_size = 0;
-                }
-            }
-        }
-      else /* 0 < res */
-        {
-          urh->in_buffer_used += res;
-          if (buf_size > (size_t)res)
-            urh->app.celi &= ~MHD_EPOLL_STATE_READ_READY;
-          else if (0 < tls->check_record_pending (tls->cls,
-                                                  connection->tls_cs))
-            connection->tls_read_ready = true;
-        }
-      if (MHD_EPOLL_STATE_ERROR ==
-          ((MHD_EPOLL_STATE_ERROR | MHD_EPOLL_STATE_READ_READY) & urh->app.celi))
+    connection->tls_read_ready = false;
+    res = tls->recv (tls->cls,
+                     connection->tls_cs,
+                     &urh->in_buffer[urh->in_buffer_used],
+                     buf_size);
+    if (0 >= res)
+    {
+      // FIXME: define GNUTLS-independent error codes!
+      if (GNUTLS_E_INTERRUPTED != res)
+      {
+        urh->app.celi &= ~MHD_EPOLL_STATE_READ_READY;
+        if (GNUTLS_E_AGAIN != res)
         {
-          /* Unrecoverable error on socket was detected and all
-           * pending data was read from system buffers. */
+          /* Unrecoverable error on socket was detected or
+           * socket was disconnected/shut down. */
           /* Stop trying to read from this TLS socket. */
           urh->in_buffer_size = 0;
         }
+      }
     }
+    else   /* 0 < res */
+    {
+      urh->in_buffer_used += res;
+      if (buf_size > (size_t) res)
+        urh->app.celi &= ~MHD_EPOLL_STATE_READ_READY;
+      else if (0 < tls->check_record_pending (tls->cls,
+                                              connection->tls_cs))
+        connection->tls_read_ready = true;
+    }
+    if (MHD_EPOLL_STATE_ERROR ==
+        ((MHD_EPOLL_STATE_ERROR | MHD_EPOLL_STATE_READ_READY) & urh->app.celi))
+    {
+      /* Unrecoverable error on socket was detected and all
+       * pending data was read from system buffers. */
+      /* Stop trying to read from this TLS socket. */
+      urh->in_buffer_size = 0;
+    }
+  }
 
   /*
    * handle reading from application
    */
   if ( (0 != (MHD_EPOLL_STATE_READ_READY & urh->mhd.celi)) &&
        (urh->out_buffer_used < urh->out_buffer_size) )
-    {
-      ssize_t res;
-      size_t buf_size;
+  {
+    ssize_t res;
+    size_t buf_size;
 
-      buf_size = urh->out_buffer_size - urh->out_buffer_used;
-      if (buf_size > MHD_SCKT_SEND_MAX_SIZE_)
-        buf_size = MHD_SCKT_SEND_MAX_SIZE_;
+    buf_size = urh->out_buffer_size - urh->out_buffer_used;
+    if (buf_size > MHD_SCKT_SEND_MAX_SIZE_)
+      buf_size = MHD_SCKT_SEND_MAX_SIZE_;
 
-      res = MHD_recv_ (urh->mhd.socket,
-                       &urh->out_buffer[urh->out_buffer_used],
-                       buf_size);
-      if (0 >= res)
-        {
-          const int err = MHD_socket_get_error_ ();
-          if ((0 == res) ||
-              ((! MHD_SCKT_ERR_IS_EINTR_ (err)) &&
-               (! MHD_SCKT_ERR_IS_LOW_RESOURCES_(err))))
-            {
-              urh->mhd.celi &= ~MHD_EPOLL_STATE_READ_READY;
-              if ((0 == res) ||
-                  (was_closed) ||
-                  (0 != (MHD_EPOLL_STATE_ERROR & urh->mhd.celi)) ||
-                  (! MHD_SCKT_ERR_IS_EAGAIN_ (err)))
-                {
-                  /* Socket disconnect/shutdown was detected;
-                   * Application signaled about closure of 'upgraded' socket;
-                   * or persistent / unrecoverable error. */
-                  /* Do not try to pull more data from application. */
-                  urh->out_buffer_size = 0;
-                }
-            }
-        }
-      else /* 0 < res */
-        {
-          urh->out_buffer_used += res;
-          if (buf_size > (size_t)res)
-            urh->mhd.celi &= ~MHD_EPOLL_STATE_READ_READY;
-        }
-      if ( (0 == (MHD_EPOLL_STATE_READ_READY & urh->mhd.celi)) &&
-           ( (0 != (MHD_EPOLL_STATE_ERROR & urh->mhd.celi)) ||
-             (was_closed) ) )
+    res = MHD_recv_ (urh->mhd.socket,
+                     &urh->out_buffer[urh->out_buffer_used],
+                     buf_size);
+    if (0 >= res)
+    {
+      const int err = MHD_socket_get_error_ ();
+      if ((0 == res) ||
+          ((! MHD_SCKT_ERR_IS_EINTR_ (err)) &&
+           (! MHD_SCKT_ERR_IS_LOW_RESOURCES_ (err))))
+      {
+        urh->mhd.celi &= ~MHD_EPOLL_STATE_READ_READY;
+        if ((0 == res) ||
+            (was_closed) ||
+            (0 != (MHD_EPOLL_STATE_ERROR & urh->mhd.celi)) ||
+            (! MHD_SCKT_ERR_IS_EAGAIN_ (err)))
         {
-          /* Unrecoverable error on socket was detected and all
-           * pending data was read from system buffers. */
+          /* Socket disconnect/shutdown was detected;
+           * Application signaled about closure of 'upgraded' socket;
+           * or persistent / unrecoverable error. */
           /* Do not try to pull more data from application. */
           urh->out_buffer_size = 0;
         }
+      }
+    }
+    else   /* 0 < res */
+    {
+      urh->out_buffer_used += res;
+      if (buf_size > (size_t) res)
+        urh->mhd.celi &= ~MHD_EPOLL_STATE_READ_READY;
     }
+    if ( (0 == (MHD_EPOLL_STATE_READ_READY & urh->mhd.celi)) &&
+         ( (0 != (MHD_EPOLL_STATE_ERROR & urh->mhd.celi)) ||
+           (was_closed) ) )
+    {
+      /* Unrecoverable error on socket was detected and all
+       * pending data was read from system buffers. */
+      /* Do not try to pull more data from application. */
+      urh->out_buffer_size = 0;
+    }
+  }
 
   /*
    * handle writing to remote HTTPS client
    */
   if ( (0 != (MHD_EPOLL_STATE_WRITE_READY & urh->app.celi)) &&
        (urh->out_buffer_used > 0) )
-    {
-      ssize_t res;
-      size_t data_size;
+  {
+    ssize_t res;
+    size_t data_size;
 
-      data_size = urh->out_buffer_used;
-      if (data_size > SSIZE_MAX)
-        data_size = SSIZE_MAX;
+    data_size = urh->out_buffer_used;
+    if (data_size > SSIZE_MAX)
+      data_size = SSIZE_MAX;
 
-      res = tls->send (tls->cls,
-                       connection->tls_cs,
-                       urh->out_buffer,
-                       data_size);
-      if (0 >= res)
+    res = tls->send (tls->cls,
+                     connection->tls_cs,
+                     urh->out_buffer,
+                     data_size);
+    if (0 >= res)
+    {
+      // FIXME: define GNUTLS-independent error codes!
+      if (GNUTLS_E_INTERRUPTED != res)
+      {
+        urh->app.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
+        if (GNUTLS_E_INTERRUPTED != res)
         {
-          // FIXME: define GNUTLS-independent error codes!
-          if (GNUTLS_E_INTERRUPTED != res)
-            {
-              urh->app.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
-              if (GNUTLS_E_INTERRUPTED != res)
-                {
-                  /* TLS connection shut down or
-                   * persistent / unrecoverable error. */
+          /* TLS connection shut down or
+           * persistent / unrecoverable error. */
 #ifdef HAVE_MESSAGES
-                  MHD_DLOG (daemon,
-                            MHD_SC_UPGRADE_FORWARD_INCOMPLETE,
-                            _("Failed to forward to remote client " MHD_UNSIGNED_LONG_LONG_PRINTF \
-                                " bytes of data received from application: %s\n"),
-                            (MHD_UNSIGNED_LONG_LONG) urh->out_buffer_used,
-                            tls->strerror (tls->cls,
-                                           res));
+          MHD_DLOG (daemon,
+                    MHD_SC_UPGRADE_FORWARD_INCOMPLETE,
+                    _ (
+                      "Failed to forward to remote client "
+                      MHD_UNSIGNED_LONG_LONG_PRINTF \
+                      " bytes of data received from application: %s\n"),
+                    (MHD_UNSIGNED_LONG_LONG) urh->out_buffer_used,
+                    tls->strerror (tls->cls,
+                                   res));
 #endif
-                  /* Discard any data unsent to remote. */
-                  urh->out_buffer_used = 0;
-                  /* Do not try to pull more data from application. */
-                  urh->out_buffer_size = 0;
-                  urh->mhd.celi &= ~MHD_EPOLL_STATE_READ_READY;
-                }
-            }
-        }
-      else /* 0 < res */
-        {
-          const size_t next_out_buffer_used = urh->out_buffer_used - res;
-          if (0 != next_out_buffer_used)
-            {
-              memmove (urh->out_buffer,
-                       &urh->out_buffer[res],
-                       next_out_buffer_used);
-              if (data_size > (size_t)res)
-                urh->app.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
-            }
-          urh->out_buffer_used = next_out_buffer_used;
-        }
-      if ( (0 == urh->out_buffer_used) &&
-           (0 != (MHD_EPOLL_STATE_ERROR & urh->app.celi)) )
-        {
-          /* Unrecoverable error on socket was detected and all
-           * pending data was sent to remote. */
-          /* Do not try to send to remote anymore. */
-          urh->app.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
+          /* Discard any data unsent to remote. */
+          urh->out_buffer_used = 0;
           /* Do not try to pull more data from application. */
           urh->out_buffer_size = 0;
           urh->mhd.celi &= ~MHD_EPOLL_STATE_READ_READY;
         }
+      }
     }
+    else   /* 0 < res */
+    {
+      const size_t next_out_buffer_used = urh->out_buffer_used - res;
+      if (0 != next_out_buffer_used)
+      {
+        memmove (urh->out_buffer,
+                 &urh->out_buffer[res],
+                 next_out_buffer_used);
+        if (data_size > (size_t) res)
+          urh->app.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
+      }
+      urh->out_buffer_used = next_out_buffer_used;
+    }
+    if ( (0 == urh->out_buffer_used) &&
+         (0 != (MHD_EPOLL_STATE_ERROR & urh->app.celi)) )
+    {
+      /* Unrecoverable error on socket was detected and all
+       * pending data was sent to remote. */
+      /* Do not try to send to remote anymore. */
+      urh->app.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
+      /* Do not try to pull more data from application. */
+      urh->out_buffer_size = 0;
+      urh->mhd.celi &= ~MHD_EPOLL_STATE_READ_READY;
+    }
+  }
 
   /*
    * handle writing to application
    */
   if ( (0 != (MHD_EPOLL_STATE_WRITE_READY & urh->mhd.celi)) &&
-         (urh->in_buffer_used > 0) )
-    {
-      ssize_t res;
-      size_t data_size;
+       (urh->in_buffer_used > 0) )
+  {
+    ssize_t res;
+    size_t data_size;
 
-      data_size = urh->in_buffer_used;
-      if (data_size > MHD_SCKT_SEND_MAX_SIZE_)
-        data_size = MHD_SCKT_SEND_MAX_SIZE_;
+    data_size = urh->in_buffer_used;
+    if (data_size > MHD_SCKT_SEND_MAX_SIZE_)
+      data_size = MHD_SCKT_SEND_MAX_SIZE_;
 
-      res = MHD_send_ (urh->mhd.socket,
-                       urh->in_buffer,
-                       data_size);
-      if (0 >= res)
+    res = MHD_send_ (urh->mhd.socket,
+                     urh->in_buffer,
+                     data_size);
+    if (0 >= res)
+    {
+      const int err = MHD_socket_get_error_ ();
+      if ( (! MHD_SCKT_ERR_IS_EINTR_ (err)) &&
+           (! MHD_SCKT_ERR_IS_LOW_RESOURCES_ (err)) )
+      {
+        urh->mhd.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
+        if (! MHD_SCKT_ERR_IS_EAGAIN_ (err))
         {
-          const int err = MHD_socket_get_error_ ();
-          if ( (! MHD_SCKT_ERR_IS_EINTR_ (err)) &&
-               (! MHD_SCKT_ERR_IS_LOW_RESOURCES_(err)) )
-            {
-              urh->mhd.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
-              if (! MHD_SCKT_ERR_IS_EAGAIN_ (err))
-                {
-                  /* Socketpair connection shut down or
-                   * persistent / unrecoverable error. */
+          /* Socketpair connection shut down or
+           * persistent / unrecoverable error. */
 #ifdef HAVE_MESSAGES
-                  MHD_DLOG (daemon,
-                            MHD_SC_UPGRADE_FORWARD_INCOMPLETE,
-                            _("Failed to forward to application " MHD_UNSIGNED_LONG_LONG_PRINTF \
-                                " bytes of data received from remote side: %s\n"),
-                            (MHD_UNSIGNED_LONG_LONG) urh->in_buffer_used,
-                            MHD_socket_strerr_ (err));
+          MHD_DLOG (daemon,
+                    MHD_SC_UPGRADE_FORWARD_INCOMPLETE,
+                    _ (
+                      "Failed to forward to application "
+                      MHD_UNSIGNED_LONG_LONG_PRINTF \
+                      " bytes of data received from remote side: %s\n"),
+                    (MHD_UNSIGNED_LONG_LONG) urh->in_buffer_used,
+                    MHD_socket_strerr_ (err));
 #endif
-                  /* Discard any data received form remote. */
-                  urh->in_buffer_used = 0;
-                  /* Reading from remote client is not required anymore. */
-                  urh->in_buffer_size = 0;
-                  urh->app.celi &= ~MHD_EPOLL_STATE_READ_READY;
-                  connection->tls_read_ready = false;
-                }
-            }
-        }
-      else /* 0 < res */
-        {
-          const size_t next_in_buffer_used = urh->in_buffer_used - res;
-          if (0 != next_in_buffer_used)
-            {
-              memmove (urh->in_buffer,
-                       &urh->in_buffer[res],
-                       next_in_buffer_used);
-              if (data_size > (size_t)res)
-                urh->mhd.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
-            }
-          urh->in_buffer_used = next_in_buffer_used;
-        }
-      if ( (0 == urh->in_buffer_used) &&
-           (0 != (MHD_EPOLL_STATE_ERROR & urh->mhd.celi)) )
-        {
-          /* Do not try to push data to application. */
-          urh->mhd.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
+          /* Discard any data received form remote. */
+          urh->in_buffer_used = 0;
           /* Reading from remote client is not required anymore. */
           urh->in_buffer_size = 0;
           urh->app.celi &= ~MHD_EPOLL_STATE_READ_READY;
           connection->tls_read_ready = false;
         }
+      }
+    }
+    else   /* 0 < res */
+    {
+      const size_t next_in_buffer_used = urh->in_buffer_used - res;
+      if (0 != next_in_buffer_used)
+      {
+        memmove (urh->in_buffer,
+                 &urh->in_buffer[res],
+                 next_in_buffer_used);
+        if (data_size > (size_t) res)
+          urh->mhd.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
+      }
+      urh->in_buffer_used = next_in_buffer_used;
+    }
+    if ( (0 == urh->in_buffer_used) &&
+         (0 != (MHD_EPOLL_STATE_ERROR & urh->mhd.celi)) )
+    {
+      /* Do not try to push data to application. */
+      urh->mhd.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
+      /* Reading from remote client is not required anymore. */
+      urh->in_buffer_size = 0;
+      urh->app.celi &= ~MHD_EPOLL_STATE_READ_READY;
+      connection->tls_read_ready = false;
     }
+  }
 
   /* Check whether data is present in TLS buffers
    * and incoming forward buffer have some space. */
@@ -364,24 +371,26 @@ MHD_upgrade_response_handle_process_ (struct MHD_UpgradeResponseHandle *urh)
   if ( (daemon->shutdown) &&
        ( (0 != urh->out_buffer_size) ||
          (0 != urh->out_buffer_used) ) )
-    {
-      /* Daemon shutting down, discard any remaining forward data. */
+  {
+    /* Daemon shutting down, discard any remaining forward data. */
 #ifdef HAVE_MESSAGES
-      if (0 < urh->out_buffer_used)
-        MHD_DLOG (daemon,
-                  MHD_SC_UPGRADE_FORWARD_INCOMPLETE,
-                  _("Failed to forward to remote client " MHD_UNSIGNED_LONG_LONG_PRINTF \
-                      " bytes of data received from application: daemon shut down\n"),
-                  (MHD_UNSIGNED_LONG_LONG) urh->out_buffer_used);
+    if (0 < urh->out_buffer_used)
+      MHD_DLOG (daemon,
+                MHD_SC_UPGRADE_FORWARD_INCOMPLETE,
+                _ (
+                  "Failed to forward to remote client "
+                  MHD_UNSIGNED_LONG_LONG_PRINTF \
+                  " bytes of data received from application: daemon shut down\n"),
+                (MHD_UNSIGNED_LONG_LONG) urh->out_buffer_used);
 #endif
-      /* Discard any data unsent to remote. */
-      urh->out_buffer_used = 0;
-      /* Do not try to sent to remote anymore. */
-      urh->app.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
-      /* Do not try to pull more data from application. */
-      urh->out_buffer_size = 0;
-      urh->mhd.celi &= ~MHD_EPOLL_STATE_READ_READY;
-    }
+    /* Discard any data unsent to remote. */
+    urh->out_buffer_used = 0;
+    /* Do not try to sent to remote anymore. */
+    urh->app.celi &= ~MHD_EPOLL_STATE_WRITE_READY;
+    /* Do not try to pull more data from application. */
+    urh->out_buffer_size = 0;
+    urh->mhd.celi &= ~MHD_EPOLL_STATE_READ_READY;
+  }
 }
 #endif /* HTTPS_SUPPORT  && UPGRADE_SUPPORT */
 
diff --git a/src/lib/upgrade_process.h b/src/lib/upgrade_process.h
index 36a7ddff..8b0d4119 100644
--- a/src/lib/upgrade_process.h
+++ b/src/lib/upgrade_process.h
@@ -36,7 +36,7 @@
  */
 void
 MHD_upgrade_response_handle_process_ (struct MHD_UpgradeResponseHandle *urh)
-  MHD_NONNULL(1);
+MHD_NONNULL (1);
 
 
 #endif
diff --git a/src/lib/version.c b/src/lib/version.c
index 472a8c04..5bf4ab01 100644
--- a/src/lib/version.c
+++ b/src/lib/version.c
@@ -40,13 +40,13 @@ MHD_get_version (void)
   static char ver[12] = "\0\0\0\0\0\0\0\0\0\0\0";
   if (0 == ver[0])
   {
-    int res = MHD_snprintf_(ver,
-                            sizeof(ver),
-                            "%x.%x.%x",
-                            (((int)MHD_VERSION >> 24) & 0xFF),
-                            (((int)MHD_VERSION >> 16) & 0xFF),
-                            (((int)MHD_VERSION >> 8) & 0xFF));
-    if (0 >= res || sizeof(ver) <= res)
+    int res = MHD_snprintf_ (ver,
+                             sizeof(ver),
+                             "%x.%x.%x",
+                             (((int) MHD_VERSION >> 24) & 0xFF),
+                             (((int) MHD_VERSION >> 16) & 0xFF),
+                             (((int) MHD_VERSION >> 8) & 0xFF));
+    if ((0 >= res)||(sizeof(ver) <= res))
       return "0.0.0"; /* Can't return real version*/
   }
   return ver;
@@ -66,141 +66,142 @@ MHD_get_version (void)
  * @ingroup specialized
  */
 _MHD_EXTERN enum MHD_Bool
-MHD_is_feature_supported(enum MHD_Feature feature)
+MHD_is_feature_supported (enum MHD_Feature feature)
 {
-  switch(feature)
-    {
-    case MHD_FEATURE_MESSAGES:
+  switch (feature)
+  {
+  case MHD_FEATURE_MESSAGES:
 #ifdef HAVE_MESSAGES
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_TLS:
+  case MHD_FEATURE_TLS:
 #ifdef HTTPS_SUPPORT
-      return MHD_YES;
+    return MHD_YES;
 #else  /* ! HTTPS_SUPPORT */
-      return MHD_NO;
+    return MHD_NO;
 #endif  /* ! HTTPS_SUPPORT */
-    case MHD_FEATURE_HTTPS_CERT_CALLBACK:
+  case MHD_FEATURE_HTTPS_CERT_CALLBACK:
 #if defined(HTTPS_SUPPORT) && GNUTLS_VERSION_MAJOR >= 3
-      return MHD_YES;
+    return MHD_YES;
 #else  /* !HTTPS_SUPPORT || GNUTLS_VERSION_MAJOR < 3 */
-      return MHD_NO;
+    return MHD_NO;
 #endif /* !HTTPS_SUPPORT || GNUTLS_VERSION_MAJOR < 3 */
-    case MHD_FEATURE_IPv6:
+  case MHD_FEATURE_IPv6:
 #ifdef HAVE_INET6
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_IPv6_ONLY:
+  case MHD_FEATURE_IPv6_ONLY:
 #if defined(IPPROTO_IPV6) && defined(IPV6_V6ONLY)
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_POLL:
+  case MHD_FEATURE_POLL:
 #ifdef HAVE_POLL
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_EPOLL:
+  case MHD_FEATURE_EPOLL:
 #ifdef EPOLL_SUPPORT
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_SHUTDOWN_LISTEN_SOCKET:
+  case MHD_FEATURE_SHUTDOWN_LISTEN_SOCKET:
 #ifdef HAVE_LISTEN_SHUTDOWN
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_SOCKETPAIR:
+  case MHD_FEATURE_SOCKETPAIR:
 #ifdef _MHD_ITC_SOCKETPAIR
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_TCP_FASTOPEN:
+  case MHD_FEATURE_TCP_FASTOPEN:
 #ifdef TCP_FASTOPEN
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_BASIC_AUTH:
+  case MHD_FEATURE_BASIC_AUTH:
 #ifdef BAUTH_SUPPORT
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_DIGEST_AUTH:
+  case MHD_FEATURE_DIGEST_AUTH:
 #ifdef DAUTH_SUPPORT
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_POSTPROCESSOR:
+  case MHD_FEATURE_POSTPROCESSOR:
 #ifdef HAVE_POSTPROCESSOR
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_HTTPS_KEY_PASSWORD:
+  case MHD_FEATURE_HTTPS_KEY_PASSWORD:
 #if defined(HTTPS_SUPPORT) && GNUTLS_VERSION_NUMBER >= 0x030111
-      return MHD_YES;
+    return MHD_YES;
 #else  /* !HTTPS_SUPPORT || GNUTLS_VERSION_NUMBER < 0x030111 */
-      return MHD_NO;
+    return MHD_NO;
 #endif /* !HTTPS_SUPPORT || GNUTLS_VERSION_NUMBER < 0x030111 */
-    case MHD_FEATURE_LARGE_FILE:
+  case MHD_FEATURE_LARGE_FILE:
 #if defined(HAVE_PREAD64) || defined(_WIN32)
-      return MHD_YES;
+    return MHD_YES;
 #elif defined(HAVE_PREAD)
-      return (sizeof(uint64_t) > sizeof(off_t)) ? MHD_NO : MHD_YES;
+    return (sizeof(uint64_t) > sizeof(off_t)) ? MHD_NO : MHD_YES;
 #elif defined(HAVE_LSEEK64)
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return (sizeof(uint64_t) > sizeof(off_t)) ? MHD_NO : MHD_YES;
+    return (sizeof(uint64_t) > sizeof(off_t)) ? MHD_NO : MHD_YES;
 #endif
-    case MHD_FEATURE_THREAD_NAMES:
+  case MHD_FEATURE_THREAD_NAMES:
 #if defined(MHD_USE_THREAD_NAME_)
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_UPGRADE:
+  case MHD_FEATURE_UPGRADE:
 #if defined(UPGRADE_SUPPORT)
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_RESPONSES_SHARED_FD:
+  case MHD_FEATURE_RESPONSES_SHARED_FD:
 #if defined(HAVE_PREAD64) || defined(HAVE_PREAD) || defined(_WIN32)
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_AUTODETECT_BIND_PORT:
+  case MHD_FEATURE_AUTODETECT_BIND_PORT:
 #ifdef MHD_USE_GETSOCKNAME
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_AUTOSUPPRESS_SIGPIPE:
-#if defined(MHD_WINSOCK_SOCKETS) || defined(MHD_socket_nosignal_) || defined (MSG_NOSIGNAL)
-      return MHD_YES;
+  case MHD_FEATURE_AUTOSUPPRESS_SIGPIPE:
+#if defined(MHD_WINSOCK_SOCKETS) || defined(MHD_socket_nosignal_) || \
+    defined (MSG_NOSIGNAL)
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
-    case MHD_FEATURE_SENDFILE:
+  case MHD_FEATURE_SENDFILE:
 #ifdef _MHD_HAVE_SENDFILE
-      return MHD_YES;
+    return MHD_YES;
 #else
-      return MHD_NO;
+    return MHD_NO;
 #endif
 
-    }
+  }
   return MHD_NO;
 }