Use POSIX functions on Cygwin, not Win32 function
[openssl.git] / test / asynctest.c
1 /* test/asynctest.c */
2 /*
3  * Written by Matt Caswell for the OpenSSL project.
4  */
5 /* ====================================================================
6  * Copyright (c) 2015 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    openssl-core@openssl.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  *
53  * This product includes cryptographic software written by Eric Young
54  * (eay@cryptsoft.com).  This product includes software written by Tim
55  * Hudson (tjh@cryptsoft.com).
56  *
57  */
58
59 #include <stdio.h>
60 #include <string.h>
61 #include <openssl/async.h>
62 #include <openssl/crypto.h>
63 #include <../apps/apps.h>
64
65 #if (defined(OPENSSL_SYS_UNIX) || defined(OPENSSL_SYS_CYGWIN)) && defined(OPENSSL_THREADS)
66 # include <unistd.h>
67 # if _POSIX_VERSION >= 200112L
68 #  define ASYNC_POSIX
69 # endif
70 #elif defined(_WIN32)
71 # define ASYNC_WIN
72 #endif
73
74 #if !defined(ASYNC_POSIX) && !defined(ASYNC_WIN)
75 # define ASYNC_NULL
76 #endif
77
78 #ifndef ASYNC_NULL
79
80 static int ctr = 0;
81 static ASYNC_JOB *currjob = NULL;
82
83 static int only_pause(void *args)
84 {
85     ASYNC_pause_job();
86
87     return 1;
88 }
89
90 static int add_two(void *args)
91 {
92     ctr++;
93     ASYNC_pause_job();
94     ctr++;
95
96     return 2;
97 }
98
99 static int save_current(void *args)
100 {
101     currjob = ASYNC_get_current_job();
102     ASYNC_pause_job();
103
104     return 1;
105 }
106
107 static int wake(void *args)
108 {
109     ASYNC_pause_job();
110     ASYNC_wake(ASYNC_get_current_job());
111     ASYNC_pause_job();
112     ASYNC_clear_wake(ASYNC_get_current_job());
113
114     return 1;
115 }
116
117 static int blockpause(void *args)
118 {
119     ASYNC_block_pause();
120     ASYNC_pause_job();
121     ASYNC_unblock_pause();
122     ASYNC_pause_job();
123
124     return 1;
125 }
126
127 static int test_ASYNC_init()
128 {
129     ASYNC_JOB *job1 = NULL, *job2 = NULL, *job3 = NULL;
130     int funcret1, funcret2, funcret3;
131
132     if (       !ASYNC_init(1, 2, 0)
133             || ASYNC_start_job(&job1, &funcret1, only_pause, NULL, 0)
134                 != ASYNC_PAUSE
135             || ASYNC_start_job(&job2, &funcret2, only_pause, NULL, 0)
136                 != ASYNC_PAUSE
137             || ASYNC_start_job(&job3, &funcret3, only_pause, NULL, 0)
138                 != ASYNC_NO_JOBS
139             || ASYNC_start_job(&job1, &funcret1, only_pause, NULL, 0)
140                 != ASYNC_FINISH
141             || ASYNC_start_job(&job3, &funcret3, only_pause, NULL, 0)
142                 != ASYNC_PAUSE
143             || ASYNC_start_job(&job2, &funcret2, only_pause, NULL, 0)
144                 != ASYNC_FINISH
145             || ASYNC_start_job(&job3, &funcret3, only_pause, NULL, 0)
146                 != ASYNC_FINISH
147             || funcret1 != 1
148             || funcret2 != 1
149             || funcret3 != 1) {
150         fprintf(stderr, "test_ASYNC_init() failed\n");
151         ASYNC_cleanup(1);
152         return 0;
153     }
154
155     ASYNC_cleanup(1);
156     return 1;
157 }
158
159 static int test_ASYNC_start_job()
160 {
161     ASYNC_JOB *job = NULL;
162     int funcret;
163
164     ctr = 0;
165
166     if (       !ASYNC_init(1, 1, 0)
167             || ASYNC_start_job(&job, &funcret, add_two, NULL, 0) != ASYNC_PAUSE
168             || ctr != 1
169             || ASYNC_start_job(&job, &funcret, add_two, NULL, 0) != ASYNC_FINISH
170             || ctr != 2
171             || funcret != 2) {
172         fprintf(stderr, "test_ASYNC_start_job() failed\n");
173         ASYNC_cleanup(1);
174         return 0;
175     }
176
177     ASYNC_cleanup(1);
178     return 1;
179 }
180
181 static int test_ASYNC_get_current_job()
182 {
183     ASYNC_JOB *job = NULL;
184     int funcret;
185
186     currjob = NULL;
187
188     if (       !ASYNC_init(1, 1, 0)
189             || ASYNC_start_job(&job, &funcret, save_current, NULL, 0)
190                 != ASYNC_PAUSE
191             || currjob != job
192             || ASYNC_start_job(&job, &funcret, save_current, NULL, 0)
193                 != ASYNC_FINISH
194             || funcret != 1) {
195         fprintf(stderr, "test_ASYNC_get_current_job() failed\n");
196         ASYNC_cleanup(1);
197         return 0;
198     }
199
200     ASYNC_cleanup(1);
201     return 1;
202 }
203
204 static int hasdata(OSSL_ASYNC_FD fd)
205 {
206 #ifdef ASYNC_POSIX
207     fd_set checkfds;
208     struct timeval tv;
209     FD_ZERO(&checkfds);
210     openssl_fdset(fd, &checkfds);
211     memset(&tv, 0, sizeof tv);
212     if (select(fd + 1, (void *)&checkfds, NULL, NULL, &tv) < 0)
213         return -1;
214     if (FD_ISSET(fd, &checkfds))
215         return 1;
216     return 0;
217 #else
218     DWORD avail = 0;
219
220     if (PeekNamedPipe(fd, NULL, 0, NULL, &avail, NULL) && avail > 0)
221         return 1;
222
223     return 0;
224 #endif
225 }
226
227 static int test_ASYNC_get_wait_fd()
228 {
229     ASYNC_JOB *job = NULL;
230     int funcret;
231     OSSL_ASYNC_FD fd;
232
233     if (       !ASYNC_init(1, 1, 0)
234             || ASYNC_start_job(&job, &funcret, wake, NULL, 0)
235                 != ASYNC_PAUSE
236             || (fd = ASYNC_get_wait_fd(job)) < 0
237             || hasdata(fd) != 0
238             || ASYNC_start_job(&job, &funcret, save_current, NULL, 0)
239                 != ASYNC_PAUSE
240             || hasdata(fd) != 1
241             || (ASYNC_clear_wake(job), 0)
242             || hasdata(fd) != 0
243             || (ASYNC_wake(job), 0)
244             || hasdata(fd) != 1
245             || ASYNC_start_job(&job, &funcret, save_current, NULL, 0)
246                 != ASYNC_FINISH
247             || funcret != 1) {
248         fprintf(stderr, "test_ASYNC_get_wait_fd() failed\n");
249         ASYNC_cleanup(1);
250         return 0;
251     }
252
253     ASYNC_cleanup(1);
254     return 1;
255 }
256
257 static int test_ASYNC_block_pause()
258 {
259     ASYNC_JOB *job = NULL;
260     int funcret;
261
262     if (       !ASYNC_init(1, 1, 0)
263             || ASYNC_start_job(&job, &funcret, blockpause, NULL, 0)
264                 != ASYNC_PAUSE
265             || ASYNC_start_job(&job, &funcret, blockpause, NULL, 0)
266                 != ASYNC_FINISH
267             || funcret != 1) {
268         fprintf(stderr, "test_ASYNC_block_pause() failed\n");
269         ASYNC_cleanup(1);
270         return 0;
271     }
272
273     ASYNC_cleanup(1);
274     return 1;
275 }
276
277 #endif
278
279 int main(int argc, char **argv)
280 {
281
282 #ifdef ASYNC_NULL
283     fprintf(stderr, "NULL implementation - skipping async tests\n");
284 #else
285     CRYPTO_set_mem_debug(1);
286     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
287
288     if (       !test_ASYNC_init()
289             || !test_ASYNC_start_job()
290             || !test_ASYNC_get_current_job()
291             || !test_ASYNC_get_wait_fd()
292             || !test_ASYNC_block_pause()) {
293         return 1;
294     }
295 #endif
296     printf("PASS\n");
297     return 0;
298 }