0c25c209396fd488b3eee78c669267176a343e91
[gpgme.git] / gpgme / ath-compat.c
1 /* ath.c - self-adapting thread-safeness library
2  *      Copyright (C) 2002 g10 Code GmbH
3  *
4  * This file is part of GPGME.
5  *
6  * GPGME is free software; you can redistribute it and/or modify
7  * it 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,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, 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 <unistd.h>
26 #ifdef HAVE_SYS_SELECT_H
27 # include <sys/select.h>
28 #else
29 # include <sys/time.h>
30 #endif
31 #include <sys/types.h>
32 #include <sys/wait.h>
33
34 #include "ath.h"
35
36 static struct ath_ops *ath_ops;
37
38 void
39 ath_init (void)
40 {
41   if (0)
42     ;
43 #ifdef HAVE_PTHREAD
44   else if (!ath_ops)
45     ath_ops = ath_pthread_available ();
46 #endif
47 #ifdef HAVE_PTH
48   else if (!ath_ops)
49     ath_ops = ath_pth_available ();
50 #endif
51 }
52
53
54 int
55 ath_mutex_init (ath_mutex_t *lock)
56 {
57   if (!ath_ops)
58     return 0;
59
60   return ath_ops->mutex_init (lock, 0);
61 }
62
63
64 int
65 ath_mutex_destroy (ath_mutex_t *lock)
66 {
67   int err;
68   if (!ath_ops)
69     return 0;
70   err = ath_ops->mutex_init (lock, 1);
71   if (!err)
72     err = ath_ops->mutex_destroy (*lock);
73   return err;
74 }
75
76
77 int
78 ath_mutex_lock (ath_mutex_t *lock)
79 {
80   int err;
81
82   if (!ath_ops)
83     return 0;
84   err = ath_ops->mutex_init (lock, 1);
85   if (!err)
86     err = ath_ops->mutex_lock (*lock);
87   return err;
88 }
89
90
91 int
92 ath_mutex_unlock (ath_mutex_t *lock)
93 {
94   int err;
95
96   if (!ath_ops)
97     return 0;
98   err = ath_ops->mutex_init (lock, 1);
99   if (!err)
100     err = ath_ops->mutex_unlock (*lock);
101   return err;
102 }
103
104
105 ssize_t
106 ath_read (int fd, void *buf, size_t nbytes)
107 {
108   if (ath_ops && ath_ops->read)
109     return ath_ops->read (fd, buf, nbytes);
110   else
111     return read (fd, buf, nbytes);
112 }
113
114
115 ssize_t
116 ath_write (int fd, const void *buf, size_t nbytes)
117 {
118   if (ath_ops && ath_ops->write)
119     return ath_ops->write (fd, buf, nbytes);
120   else
121     return write (fd, buf, nbytes);
122 }
123
124
125 ssize_t
126 ath_select (int nfd, fd_set *rset, fd_set *wset, fd_set *eset,
127             struct timeval *timeout)
128 {
129   if (ath_ops && ath_ops->select)
130     return ath_ops->select (nfd, rset, wset, eset, timeout);
131   else
132     return select (nfd, rset, wset, eset, timeout);
133 }
134
135  
136 ssize_t
137 ath_waitpid (pid_t pid, int *status, int options)
138 {
139   if (ath_ops && ath_ops->waitpid)
140     return ath_ops->waitpid (pid, status, options);
141   else
142     return waitpid (pid, status, options);
143 }
144
145
146 int
147 ath_accept (int s, struct sockaddr *addr, socklen_t *length_ptr)
148 {
149   if (ath_ops && ath_ops->accept)
150     return ath_ops->accept (s, addr, length_ptr);
151   else
152     return accept (s, addr, length_ptr);
153 }
154
155
156 int
157 ath_connect (int s, struct sockaddr *addr, socklen_t length)
158 {
159   if (ath_ops && ath_ops->connect)
160     return ath_ops->connect (s, addr, length);
161   else
162     return connect (s, addr, length);
163 }
164
165
166 int
167 ath_sendmsg (int s, const struct msghdr *msg, int flags)
168 {
169   if (ath_ops && ath_ops->sendmsg)
170     return ath_ops->sendmsg (s, msg, flags);
171   else
172     return sendmsg (s, msg, flags);
173 }
174
175
176 int
177 ath_recvmsg (int s, struct msghdr *msg, int flags)
178 {
179   if (ath_ops && ath_ops->recvmsg)
180     return ath_ops->recvmsg (s, msg, flags);
181   else
182     return recvmsg (s, msg, flags);
183 }