Changes to allow building a W32 DLL
[gpgme.git] / gpgme / ath-compat.c
1 /* ath.c - self-adapting thread-safeness library
2    Copyright (C) 2002, 2004 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 Lesser General Public License as
8    published by the Free Software Foundation; either version 2.1 of
9    the License, or (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    Lesser General Public License for more details.
15    
16    You should have received a copy of the GNU Lesser General Public
17    License along with this program; if not, write to the Free Software
18    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19    02111-1307, USA.  */
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24
25 #include <stdio.h>
26 #include <unistd.h>
27 #ifdef HAVE_SYS_SELECT_H
28 # include <sys/select.h>
29 #else
30 # include <sys/time.h>
31 #endif
32 #include <sys/types.h>
33 #ifndef HAVE_W32_SYSTEM
34 #include <sys/wait.h>
35 #endif /*!HAVE_W32_SYSTEM*/
36
37
38 #include "ath.h"
39
40 static struct ath_ops *ath_ops;
41
42 void
43 ath_init (void)
44 {
45   if (0)
46     ;
47 #ifdef HAVE_PTHREAD
48   else if (!ath_ops)
49     ath_ops = ath_pthread_available ();
50 #endif
51 #ifdef HAVE_PTH
52   else if (!ath_ops)
53     ath_ops = ath_pth_available ();
54 #endif
55 }
56
57
58 int
59 ath_mutex_init (ath_mutex_t *lock)
60 {
61   if (!ath_ops)
62     return 0;
63
64   return ath_ops->mutex_init (lock, 0);
65 }
66
67
68 int
69 ath_mutex_destroy (ath_mutex_t *lock)
70 {
71   int err;
72   if (!ath_ops)
73     return 0;
74   err = ath_ops->mutex_init (lock, 1);
75   if (!err)
76     err = ath_ops->mutex_destroy (*lock);
77   return err;
78 }
79
80
81 int
82 ath_mutex_lock (ath_mutex_t *lock)
83 {
84   int err;
85
86   if (!ath_ops)
87     return 0;
88   err = ath_ops->mutex_init (lock, 1);
89   if (!err)
90     err = ath_ops->mutex_lock (*lock);
91   return err;
92 }
93
94
95 int
96 ath_mutex_unlock (ath_mutex_t *lock)
97 {
98   int err;
99
100   if (!ath_ops)
101     return 0;
102   err = ath_ops->mutex_init (lock, 1);
103   if (!err)
104     err = ath_ops->mutex_unlock (*lock);
105   return err;
106 }
107
108
109 ssize_t
110 ath_read (int fd, void *buf, size_t nbytes)
111 {
112   if (ath_ops && ath_ops->read)
113     return ath_ops->read (fd, buf, nbytes);
114   else
115     return read (fd, buf, nbytes);
116 }
117
118
119 ssize_t
120 ath_write (int fd, const void *buf, size_t nbytes)
121 {
122   if (ath_ops && ath_ops->write)
123     return ath_ops->write (fd, buf, nbytes);
124   else
125     return write (fd, buf, nbytes);
126 }
127
128
129 ssize_t
130 ath_select (int nfd, fd_set *rset, fd_set *wset, fd_set *eset,
131             struct timeval *timeout)
132 {
133   if (ath_ops && ath_ops->select)
134     return ath_ops->select (nfd, rset, wset, eset, timeout);
135   else
136 #ifdef HAVE_W32_SYSTEM
137     return -1; /* We don't support this yet. */
138 #else
139     return select (nfd, rset, wset, eset, timeout);
140 #endif
141 }
142
143  
144 ssize_t
145 ath_waitpid (pid_t pid, int *status, int options)
146 {
147   if (ath_ops && ath_ops->waitpid)
148     return ath_ops->waitpid (pid, status, options);
149   else
150 #ifdef HAVE_W32_SYSTEM
151     return -1; /* We don't support this yet. */
152 #else
153     return waitpid (pid, status, options);
154 #endif
155 }
156
157
158 int
159 ath_accept (int s, struct sockaddr *addr, socklen_t *length_ptr)
160 {
161   if (ath_ops && ath_ops->accept)
162     return ath_ops->accept (s, addr, length_ptr);
163   else
164 #ifdef HAVE_W32_SYSTEM
165     return -1; /* We don't support this yet. */
166 #else
167     return accept (s, addr, length_ptr);
168 #endif
169 }
170
171
172 int
173 ath_connect (int s, const struct sockaddr *addr, socklen_t length)
174 {
175   if (ath_ops && ath_ops->connect)
176     return ath_ops->connect (s, addr, length);
177   else
178 #ifdef HAVE_W32_SYSTEM
179     return -1; /* We don't support this yet. */
180 #else
181     return connect (s, addr, length);
182 #endif
183 }
184
185
186 int
187 ath_sendmsg (int s, const struct msghdr *msg, int flags)
188 {
189   if (ath_ops && ath_ops->sendmsg)
190     return ath_ops->sendmsg (s, msg, flags);
191   else
192 #ifdef HAVE_W32_SYSTEM
193     return -1; /* We don't support this yet. */
194 #else
195     return sendmsg (s, msg, flags);
196 #endif
197 }
198
199
200 int
201 ath_recvmsg (int s, struct msghdr *msg, int flags)
202 {
203   if (ath_ops && ath_ops->recvmsg)
204     return ath_ops->recvmsg (s, msg, flags);
205   else
206 #ifdef HAVE_W32_SYSTEM
207     return -1; /* We don't support this yet. */
208 #else
209     return recvmsg (s, msg, flags);
210 #endif
211 }