test/asynctest.c

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