gpgme/ath-pth.c

   1 /* ath-pth.c - Pth module for self-adapting thread-safeness library
   2    Copyright (C) 2002, 2003 g10 Code GmbH
   3
   4    This file is part of GPGME.
   5
   6    GPGME is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    GPGME is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GPGME; if not, write to the Free Software Foundation,
  18    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include <stdlib.h>
  26 #include <errno.h>
  27
  28 #include <pth.h>
  29
  30 #include "ath.h"
  31
  32
  33 /* The lock we take while checking for lazy lock initialization.  */
  34 static pth_mutex_t check_init_lock = PTH_MUTEX_INIT;
  35
  36 /* Initialize the mutex *PRIV.  If JUST_CHECK is true, only do this if
  37    it is not already initialized.  */
  38 static int
  39 mutex_pth_init (ath_mutex_t *priv, int just_check)
  40 {
  41   int err = 0;
  42
  43   if (just_check)
  44     pth_mutex_acquire (&check_init_lock, 0, NULL);
  45   if (!*priv || !just_check)
  46     {
  47       pth_mutex_t *lock = malloc (sizeof (pth_mutex_t));
  48       if (!lock)
  49         err = ENOMEM;
  50       if (!err)
  51         {
  52           err = pth_mutex_init (lock);
  53           if (err == FALSE)
  54             err = errno;
  55           else
  56             err = 0;
  57
  58           if (err)
  59             free (lock);
  60           else
  61             *priv = (ath_mutex_t) lock;
  62         }
  63     }
  64   if (just_check)
  65     pth_mutex_release (&check_init_lock);
  66   return err;
  67 }
  68
  69
  70 void
  71 ath_init (void)
  72 {
  73   /* Nothing to do.  */
  74 }
  75
  76
  77 int
  78 ath_mutex_init (ath_mutex_t *lock)
  79 {
  80   return mutex_pth_init (lock, 0);
  81 }
  82
  83
  84 int
  85 ath_mutex_destroy (ath_mutex_t *lock)
  86 {
  87   int err = mutex_pth_init (lock, 1);
  88   if (!err)
  89     {
  90       /* GNU Pth has no destructor function.  */
  91       free (*lock);
  92     }
  93   return err;
  94 }
  95
  96
  97 int
  98 ath_mutex_lock (ath_mutex_t *lock)
  99 {
 100   int ret = mutex_pth_init (lock, 1);
 101   if (ret)
 102     return ret;
 103
 104   ret = pth_mutex_acquire ((pth_mutex_t *) *lock, 0, NULL);
 105   return ret == FALSE ? errno : 0;
 106 }
 107
 108
 109 int
 110 ath_mutex_unlock (ath_mutex_t *lock)
 111 {
 112   int ret = mutex_pth_init (lock, 1);
 113   if (ret)
 114     return ret;
 115
 116   ret = pth_mutex_release ((pth_mutex_t *) *lock);
 117   return ret == FALSE ? errno : 0;
 118 }
 119
 120
 121 ssize_t
 122 ath_read (int fd, void *buf, size_t nbytes)
 123 {
 124   return pth_read (fd, buf, nbytes);
 125 }
 126
 127
 128 ssize_t
 129 ath_write (int fd, const void *buf, size_t nbytes)
 130 {
 131   return pth_write (fd, buf, nbytes);
 132 }
 133
 134
 135 ssize_t
 136 ath_select (int nfd, fd_set *rset, fd_set *wset, fd_set *eset,
 137             struct timeval *timeout)
 138 {
 139   return pth_select (nfd, rset, wset, eset, timeout);
 140 }
 141
 142
 143 ssize_t
 144 ath_waitpid (pid_t pid, int *status, int options)
 145 {
 146   return pth_waitpid (pid, status, options);
 147 }
 148
 149
 150 int
 151 ath_accept (int s, struct sockaddr *addr, socklen_t *length_ptr)
 152 {
 153   return pth_accept (s, addr, length_ptr);
 154 }
 155
 156
 157 int
 158 ath_connect (int s, struct sockaddr *addr, socklen_t length)
 159 {
 160   return pth_connect (s, addr, length);
 161 }
 162
 163 int
 164 ath_sendmsg (int s, const struct msghdr *msg, int flags)
 165 {
 166   /* FIXME: GNU Pth is missing pth_sendmsg.  */
 167   return sendmsg (s, msg, flags);
 168 }
 169
 170
 171 int
 172 ath_recvmsg (int s, struct msghdr *msg, int flags)
 173 {
 174   /* FIXME: GNU Pth is missing pth_recvmsg.  */
 175   return recvmsg (s, msg, flags);
 176 }
 177