/* ath.c - A Thread-safeness library.
 *  Copyright (C) 2002, 2003, 2004, 2011 Free Software Foundation, Inc.
 *  Copyright (C) 2014 g10 Code GmbH
 *
 * This file is part of Libgcrypt.
 *
 * Libgcrypt 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.
 *
 * Libgcrypt 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 program; if not, see <http://www.gnu.org/licenses/>.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <assert.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#if USE_POSIX_THREADS
# include <pthread.h>
#endif

#include "ath.h"

#if USE_POSIX_THREADS_WEAK
# if  !USE_POSIX_THREADS
#  error USE_POSIX_THREADS_WEAK but no USE_POSIX_THREADS
# endif
#endif


/* On an ELF system it is easy to use pthreads using weak references.
   Take care not to test the address of a weak referenced function we
   actually use; some GCC versions have a bug were &foo != NULL is
   always evaluated to true in PIC mode.  USING_PTHREAD_AS_DEFAULT is
   used by ath_install to detect the default usage of pthread.  */
#if USE_POSIX_THREADS_WEAK
# pragma weak pthread_cancel
# pragma weak pthread_mutex_init
# pragma weak pthread_mutex_lock
# pragma weak pthread_mutex_unlock
# pragma weak pthread_mutex_destroy
#endif

/* For the dummy interface.  The MUTEX_NOTINIT value is used to check
   that a mutex has been initialized.  */
#define MUTEX_NOTINIT	((ath_mutex_t) 0)
#define MUTEX_UNLOCKED	((ath_mutex_t) 1)
#define MUTEX_LOCKED	((ath_mutex_t) 2)
#define MUTEX_DESTROYED	((ath_mutex_t) 3)


/* Return the thread type from the option field. */
#define GET_OPTION(a)    ((a) & 0xff)



enum ath_thread_model {
  ath_model_undefined = 0,
  ath_model_none,          /* No thread support.  */
  ath_model_pthreads_weak, /* POSIX threads using weak symbols.  */
  ath_model_pthreads,      /* POSIX threads directly linked.  */
  ath_model_w32            /* Microsoft Windows threads.  */
};


/* The thread model in use.  */
static enum ath_thread_model thread_model;


/* Initialize the ath subsystem.  This is called as part of the
   Libgcrypt initialization.  It's purpose is to initialize the
   locking system.  It returns 0 on sucess or an ERRNO value on error.
   In the latter case it is not defined whether ERRNO was changed.

   Note: This should be called as early as possible because it is not
   always possible to detect the thread model to use while already
   running multi threaded.  */
int
ath_init (void)
{
  int err = 0;

  if (thread_model)
    return 0; /* Already initialized - no error.  */

  if (0)
    ;
#if USE_POSIX_THREADS_WEAK
  else if (pthread_cancel)
    {
      thread_model = ath_model_pthreads_weak;
    }
#endif
  else
    {
#if HAVE_W32_SYSTEM
      thread_model = ath_model_w32;
#elif USE_POSIX_THREADS && !USE_POSIX_THREADS_WEAK
      thread_model = ath_model_pthreads;
#else /*!USE_POSIX_THREADS*/
      /* Assume a single threaded application.  */
      thread_model = ath_model_none;
#endif /*!USE_POSIX_THREADS*/
    }

  return err;
}


/* Return the used thread model as string for display purposes an if
   R_MODEL is not null store its internal number at R_MODEL.  */
const char *
ath_get_model (int *r_model)
{
  if (r_model)
    *r_model = thread_model;
  switch (thread_model)
    {
    case ath_model_undefined:     return "undefined";
    case ath_model_none:          return "none";
    case ath_model_pthreads_weak: return "pthread(weak)";
    case ath_model_pthreads:      return "pthread";
    case ath_model_w32:           return "w32";
    default:                      return "?";
    }
}


/* This function was used in old Libgcrypt versions (via
   GCRYCTL_SET_THREAD_CBS) to register the thread callback functions.
   It is not anymore required.  However to allow existing code to
   continue to work, we keep this function and check that no user
   defined callbacks are used and that the requested thread system
   matches the one Libgcrypt is using.  */
gpg_err_code_t
ath_install (struct ath_ops *ath_ops)
{
  gpg_err_code_t rc;
  unsigned int thread_option;

  /* Fist call ath_init so that we know our thread model.  */
  rc = ath_init ();
  if (rc)
    return rc;

  /* Check if the requested thread option is compatible to the
     thread option we are already committed to.  */
  thread_option = ath_ops? GET_OPTION (ath_ops->option) : 0;

  /* Return an error if the requested thread model does not match the
     configured one.  */
  if (0)
    ;
#if USE_POSIX_THREADS
  else if (thread_model == ath_model_pthreads
           || thread_model == ath_model_pthreads_weak)
    {
      if (thread_option == ATH_THREAD_OPTION_PTHREAD)
        return 0; /* Okay - compatible.  */
      if (thread_option == ATH_THREAD_OPTION_PTH)
        return 0; /* Okay - compatible.  */
    }
#endif /*USE_POSIX_THREADS*/
  else if (thread_option == ATH_THREAD_OPTION_PTH)
    {
      if (thread_model == ath_model_none)
        return 0; /* Okay - compatible.  */
    }
  else if (thread_option == ATH_THREAD_OPTION_DEFAULT)
    return 0; /* No thread support requested.  */
#if HAVE_W32_SYSTEM
  else
    return 0; /* It is always enabled.  */
#endif /*HAVE_W32_SYSTEM*/

  return GPG_ERR_NOT_SUPPORTED;
}


/* Initialize a new mutex.  This function returns 0 on success or an
   system error code (i.e. an ERRNO value).  ERRNO may or may not be
   changed on error.  */
int
ath_mutex_init (ath_mutex_t *lock)
{
  int err;

  switch (thread_model)
    {
    case ath_model_none:
      *lock = MUTEX_UNLOCKED;
      err = 0;
      break;

#if USE_POSIX_THREADS
    case ath_model_pthreads:
    case ath_model_pthreads_weak:
      {
        pthread_mutex_t *plck;

        plck = malloc (sizeof *plck);
        if (!plck)
          err = errno? errno : ENOMEM;
        else
          {
            err = pthread_mutex_init (plck, NULL);
            if (err)
              free (plck);
            else
              *lock = (void*)plck;
          }
      }
      break;
#endif /*USE_POSIX_THREADS*/

#if HAVE_W32_SYSTEM
    case ath_model_w32:
      {
        CRITICAL_SECTION *csec;

        csec = malloc (sizeof *csec);
        if (!csec)
          err = errno? errno : ENOMEM;
        else
          {
            InitializeCriticalSection (csec);
            *lock = (void*)csec;
            err = 0;
          }
      }
      break;
#endif /*HAVE_W32_SYSTEM*/

    default:
      err = EINVAL;
      break;
    }

  return err;
}


/* Destroy a mutex.  This function is a NOP if LOCK is NULL.  If the
   mutex is still locked it can't be destroyed and the function
   returns EBUSY.  ERRNO may or may not be changed on error.  */
int
ath_mutex_destroy (ath_mutex_t *lock)
{
  int err;

  if (!*lock)
    return 0;

  switch (thread_model)
    {
    case ath_model_none:
      if (*lock != MUTEX_UNLOCKED)
        err = EBUSY;
      else
        {
          *lock = MUTEX_DESTROYED;
          err = 0;
        }
      break;

#if USE_POSIX_THREADS
    case ath_model_pthreads:
    case ath_model_pthreads_weak:
      {
        pthread_mutex_t *plck = (pthread_mutex_t*) (*lock);

        err = pthread_mutex_destroy (plck);
        if (!err)
          {
            free (plck);
            lock = NULL;
          }
      }
      break;
#endif /*USE_POSIX_THREADS*/

#if HAVE_W32_SYSTEM
    case ath_model_w32:
      {
        CRITICAL_SECTION *csec = (CRITICAL_SECTION *)(*lock);

        DeleteCriticalSection (csec);
        free (csec);
        err = 0;
      }
      break;
#endif /*HAVE_W32_SYSTEM*/

    default:
      err = EINVAL;
      break;
    }

  return err;
}


/* Lock the mutex LOCK.  On success the function returns 0; on error
   an error code.  ERRNO may or may not be changed on error.  */
int
ath_mutex_lock (ath_mutex_t *lock)
{
  int err;

  switch (thread_model)
    {
    case ath_model_none:
      if (*lock == MUTEX_NOTINIT)
	err = EINVAL;
      else if (*lock == MUTEX_UNLOCKED)
        {
          *lock = MUTEX_LOCKED;
          err = 0;
        }
      else
        err = EDEADLK;
      break;

#if USE_POSIX_THREADS
    case ath_model_pthreads:
    case ath_model_pthreads_weak:
      err = pthread_mutex_lock ((pthread_mutex_t*)(*lock));
      break;
#endif /*USE_POSIX_THREADS*/

#if HAVE_W32_SYSTEM
    case ath_model_w32:
      {
        CRITICAL_SECTION *csec = (CRITICAL_SECTION *)(*lock);

        EnterCriticalSection (csec);
        err = 0;
      }
      break;
#endif /*HAVE_W32_SYSTEM*/

    default:
      err = EINVAL;
      break;
    }

  return err;
}

/* Unlock the mutex LOCK.  On success the function returns 0; on error
   an error code.  ERRNO may or may not be changed on error.  */
int
ath_mutex_unlock (ath_mutex_t *lock)
{
  int err;

  switch (thread_model)
    {
    case ath_model_none:
      if (*lock == MUTEX_NOTINIT)
	err = EINVAL;
      else if (*lock == MUTEX_LOCKED)
        {
          *lock = MUTEX_UNLOCKED;
          err = 0;
        }
      else
        err = EPERM;
      break;

#if USE_POSIX_THREADS
    case ath_model_pthreads:
    case ath_model_pthreads_weak:
      err = pthread_mutex_unlock ((pthread_mutex_t*)(*lock));
      break;
#endif /*USE_POSIX_THREADS*/

#if HAVE_W32_SYSTEM
    case ath_model_w32:
      {
        CRITICAL_SECTION *csec = (CRITICAL_SECTION *)(*lock);

        LeaveCriticalSection (csec);
        err = 0;
      }
      break;
#endif /*HAVE_W32_SYSTEM*/

    default:
      err = EINVAL;
      break;
    }

  return err;
}