1 files changed, 85 insertions, 80 deletions

diff --git a/src/microhttpd/mhd_threads.c b/src/microhttpd/mhd_threads.c
index 6578e4b1..6be4cb44 100644
--- a/src/microhttpd/mhd_threads.c
+++ b/src/microhttpd/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,44 @@ 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 +352,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 */
 }