1 files changed, 363 insertions, 0 deletions

diff --git a/src/lib/mhd_threads.c b/src/lib/mhd_threads.c
new file mode 100644
index 00000000..6578e4b1
--- /dev/null
+++ b/src/lib/mhd_threads.c
@@ -0,0 +1,363 @@
+/*
+  This file is part of libmicrohttpd
+  Copyright (C) 2016 Karlson2k (Evgeny Grin)
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+
+/**
+ * @file microhttpd/mhd_threads.c
+ * @brief  Implementation for thread functions
+ * @author Karlson2k (Evgeny Grin)
+ */
+
+#include "mhd_threads.h"
+#ifdef MHD_USE_W32_THREADS
+#include "mhd_limits.h"
+#include <process.h>
+#endif
+#ifdef MHD_USE_THREAD_NAME_
+#include <stdlib.h>
+#ifdef HAVE_PTHREAD_NP_H
+#include <pthread_np.h>
+#endif /* HAVE_PTHREAD_NP_H */
+#endif /* MHD_USE_THREAD_NAME_ */
+#include <errno.h>
+
+
+#ifndef MHD_USE_THREAD_NAME_
+
+#define MHD_set_thread_name_(t, n) (void)
+#define MHD_set_cur_thread_name_(n) (void)
+
+#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)
+#  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)
+
+/**
+ * Set thread name
+ *
+ * @param thread_id ID of thread
+ * @param thread_name name to set
+ * @return non-zero on success, zero otherwise
+ */
+static int
+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);
+#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;
+#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);
+#endif /* HAVE_PTHREAD_SETNAME_NP_NETBSD */
+}
+
+
+#ifndef __QNXNTO__
+/**
+ * Set current thread name
+ * @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))
+#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))
+#endif /* __QNXNTO__ */
+#elif defined(HAVE_PTHREAD_SETNAME_NP_DARWIN)
+
+/**
+ * Set current thread name
+ * @param n name to set
+ * @return non-zero on success, zero otherwise
+ */
+#define MHD_set_cur_thread_name_(n) (!(pthread_setname_np((n))))
+#endif /* HAVE_PTHREAD_SETNAME_NP_DARWIN */
+
+#elif defined(MHD_USE_W32_THREADS)
+#ifndef _MSC_FULL_VER
+/* Thread name available only for VC-compiler */
+#else  /* _MSC_FULL_VER */
+/**
+ * Set thread name
+ *
+ * @param thread_id ID of thread, -1 for current thread
+ * @param thread_name name to set
+ * @return non-zero on success, zero otherwise
+ */
+static int
+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)
+  struct thread_info_struct
+  {
+    DWORD type;   /* Must be 0x1000. */
+    LPCSTR name;  /* Pointer to name (in user address space). */
+    DWORD ID;     /* Thread ID (-1 = caller thread). */
+    DWORD flags;  /* Reserved for future use, must be zero. */
+  } thread_info;
+#pragma pack(pop)
+
+  if (NULL == thread_name)
+    return 0;
+
+  thread_info.type  = 0x1000;
+  thread_info.name  = thread_name;
+  thread_info.ID    = thread_id;
+  thread_info.flags = 0;
+
+  __try
+  { /* This exception is intercepted by debugger */
+    RaiseException (VC_SETNAME_EXC,
+                    0,
+                    sizeof (thread_info) / sizeof(ULONG_PTR),
+                    (ULONG_PTR *) &thread_info);
+  }
+  __except (EXCEPTION_EXECUTE_HANDLER)
+  {}
+
+  return !0;
+}
+
+
+/**
+ * Set current thread name
+ * @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))
+#endif /* _MSC_FULL_VER */
+#endif /* MHD_USE_W32_THREADS */
+
+#endif /* MHD_USE_THREAD_NAME_ */
+
+
+/**
+ * Create a thread and set the attributes according to our options.
+ *
+ * @param thread        handle to initialize
+ * @param stack_size    size of stack for new thread, 0 for default
+ * @param start_routine main function of thread
+ * @param arg argument  for start_routine
+ * @return non-zero on success; zero otherwise (with errno set)
+ */
+int
+MHD_create_thread_ (MHD_thread_handle_ID_ *thread,
+                    size_t stack_size,
+                    MHD_THREAD_START_ROUTINE_ start_routine,
+                    void *arg)
+{
+#if defined(MHD_USE_POSIX_THREADS)
+  int res;
+
+  if (0 != stack_size)
+    {
+      pthread_attr_t attr;
+      res = pthread_attr_init (&attr);
+      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);
+        }
+    }
+  else
+    res = pthread_create (&(thread->handle),
+                          NULL,
+                          start_routine,
+                          arg);
+
+  if (0 != res)
+    errno = res;
+
+  return !res;
+#elif defined(MHD_USE_W32_THREADS)
+#if SIZE_MAX != UINT_MAX
+  if (stack_size > UINT_MAX)
+    {
+      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)
+    return 0;
+
+  return !0;
+#endif
+}
+
+#ifdef MHD_USE_THREAD_NAME_
+
+#ifndef MHD_USE_THREAD_ATTR_SETNAME
+struct MHD_named_helper_param_
+{
+  /**
+   * Real thread start routine
+   */
+  MHD_THREAD_START_ROUTINE_ start_routine;
+
+  /**
+   * Argument for thread start routine
+   */
+  void *arg;
+
+  /**
+   * Name for thread
+   */
+  const char *name;
+};
+
+
+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;
+  MHD_THREAD_START_ROUTINE_ thr_func;
+
+  if (NULL == data)
+    return (MHD_THRD_RTRN_TYPE_)0;
+
+  MHD_set_cur_thread_name_ (param->name);
+
+  arg = param->arg;
+  thr_func = param->start_routine;
+  free(data);
+
+  return thr_func(arg);
+}
+#endif /* ! MHD_USE_THREAD_ATTR_SETNAME */
+
+
+/**
+ * Create a named thread and set the attributes according to our options.
+ *
+ * @param thread        handle to initialize
+ * @param thread_name   name for new thread
+ * @param stack_size    size of stack for new thread, 0 for default
+ * @param start_routine main function of thread
+ * @param arg argument  for start_routine
+ * @return non-zero on success; zero otherwise (with errno set)
+ */
+int
+MHD_create_named_thread_ (MHD_thread_handle_ID_ *thread,
+                          const char* thread_name,
+                          size_t stack_size,
+                          MHD_THREAD_START_ROUTINE_ start_routine,
+                          void *arg)
+{
+#if defined(MHD_USE_THREAD_ATTR_SETNAME)
+  int res;
+  pthread_attr_t attr;
+
+  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);
+#elif defined(HAVE_PTHREAD_ATTR_SETNAME_NP_IBMI)
+      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 (0 != res)
+    errno = res;
+
+  return !res;
+#else  /* ! MHD_USE_THREAD_ATTR_SETNAME */
+  struct MHD_named_helper_param_ *param;
+
+  if (NULL == thread_name)
+    {
+      errno = EINVAL;
+      return 0;
+    }
+
+  param = malloc (sizeof (struct MHD_named_helper_param_));
+  if (NULL == param)
+    return 0;
+
+  param->start_routine = start_routine;
+  param->arg = arg;
+  param->name = thread_name;
+
+  /* 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;
+    }
+
+  return !0;
+#endif /* ! MHD_USE_THREAD_ATTR_SETNAME */
+}
+
+#endif /* MHD_USE_THREAD_NAME_ */