1 files changed, 511 insertions, 502 deletions

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) */