9ce23fbec2d26bb9c038092b87d045357638a397
[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 #ifdef OPENSSL_SYS_UNIX
66 # include <unistd.h>
67 # if _POSIX_VERSION >= 200112L
68 #  define ASYNC_POSIX
69 # endif
70 #elif (defined(_WIN32) || defined(__CYGWIN__)) && defined(_WINDLL)
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 test_ASYNC_init_pool()
118 {
119     ASYNC_JOB *job1 = NULL, *job2 = NULL, *job3 = NULL;
120     int funcret1, funcret2, funcret3;
121
122     if (       !ASYNC_init_pool(2, 0)
123             || ASYNC_start_job(&job1, &funcret1, only_pause, NULL, 0)
124                 != ASYNC_PAUSE
125             || ASYNC_start_job(&job2, &funcret2, only_pause, NULL, 0)
126                 != ASYNC_PAUSE
127             || ASYNC_start_job(&job3, &funcret3, only_pause, NULL, 0)
128                 != ASYNC_NO_JOBS
129             || ASYNC_start_job(&job1, &funcret1, only_pause, NULL, 0)
130                 != ASYNC_FINISH
131             || ASYNC_start_job(&job3, &funcret3, only_pause, NULL, 0)
132                 != ASYNC_PAUSE
133             || ASYNC_start_job(&job2, &funcret2, only_pause, NULL, 0)
134                 != ASYNC_FINISH
135             || ASYNC_start_job(&job3, &funcret3, only_pause, NULL, 0)
136                 != ASYNC_FINISH
137             || funcret1 != 1
138             || funcret2 != 1
139             || funcret3 != 1) {
140         fprintf(stderr, "test_ASYNC_init_pool() failed\n");
141         ASYNC_free_pool();
142         return 0;
143     }
144
145     ASYNC_free_pool();
146     return 1;
147 }
148
149 static int test_ASYNC_start_job()
150 {
151     ASYNC_JOB *job = NULL;
152     int funcret;
153
154     ctr = 0;
155
156     if (       !ASYNC_init_pool(1, 0)
157             || ASYNC_start_job(&job, &funcret, add_two, NULL, 0) != ASYNC_PAUSE
158             || ctr != 1
159             || ASYNC_start_job(&job, &funcret, add_two, NULL, 0) != ASYNC_FINISH
160             || ctr != 2
161             || funcret != 2) {
162         fprintf(stderr, "test_ASYNC_start_job() failed\n");
163         ASYNC_free_pool();
164         return 0;
165     }
166
167     ASYNC_free_pool();
168     return 1;
169 }
170
171 static int test_ASYNC_get_current_job()
172 {
173     ASYNC_JOB *job = NULL;
174     int funcret;
175
176     currjob = NULL;
177
178     if (       !ASYNC_init_pool(1, 0)
179             || ASYNC_start_job(&job, &funcret, save_current, NULL, 0)
180                 != ASYNC_PAUSE
181             || currjob != job
182             || ASYNC_start_job(&job, &funcret, save_current, NULL, 0)
183                 != ASYNC_FINISH
184             || funcret != 1) {
185         fprintf(stderr, "test_ASYNC_get_current_job() failed\n");
186         ASYNC_free_pool();
187         return 0;
188     }
189
190     ASYNC_free_pool();
191     return 1;
192 }
193
194 static int hasdata(int fd)
195 {
196     fd_set checkfds;
197     struct timeval tv;
198     FD_ZERO(&checkfds);
199     openssl_fdset(fd, &checkfds);
200     memset(&tv, 0, sizeof tv);
201     if (select(fd + 1, (void *)&checkfds, NULL, NULL, &tv) < 0)
202         return -1;
203     if (FD_ISSET(fd, &checkfds))
204         return 1;
205     return 0;
206 }
207
208 static int test_ASYNC_get_wait_fd()
209 {
210     ASYNC_JOB *job = NULL;
211     int funcret, fd;
212
213     currjob = NULL;
214
215     if (       !ASYNC_init_pool(1, 0)
216             || ASYNC_start_job(&job, &funcret, wake, NULL, 0)
217                 != ASYNC_PAUSE
218             || (fd = ASYNC_get_wait_fd(job)) < 0
219             || hasdata(fd) != 0
220             || ASYNC_start_job(&job, &funcret, save_current, NULL, 0)
221                 != ASYNC_PAUSE
222             || hasdata(fd) != 1
223             || (ASYNC_clear_wake(job), 0)
224             || hasdata(fd) != 0
225             || (ASYNC_wake(job), 0)
226             || hasdata(fd) != 1
227             || ASYNC_start_job(&job, &funcret, save_current, NULL, 0)
228                 != ASYNC_FINISH
229             || funcret != 1) {
230         fprintf(stderr, "test_ASYNC_get_wait_fd() failed\n");
231         ASYNC_free_pool();
232         return 0;
233     }
234
235     ASYNC_free_pool();
236     return 1;
237 }
238 #endif
239
240 int main(int argc, char **argv)
241 {
242
243 #ifdef ASYNC_NULL
244     fprintf(stderr, "NULL implementation - skipping async tests\n");
245 #else
246     CRYPTO_malloc_debug_init();
247     CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
248     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
249
250     if (       !test_ASYNC_init_pool()
251             || !test_ASYNC_start_job()
252             || !test_ASYNC_get_current_job()
253             || !test_ASYNC_get_wait_fd()) {
254         return 1;
255     }
256 #endif
257     printf("PASS\n");
258     return 0;
259 }