crypto/engine/eng_init.c

   1 /* crypto/engine/eng_init.c */
   2 /* ====================================================================
   3  * Copyright (c) 1999-2001 The OpenSSL Project.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in
  14  *    the documentation and/or other materials provided with the
  15  *    distribution.
  16  *
  17  * 3. All advertising materials mentioning features or use of this
  18  *    software must display the following acknowledgment:
  19  *    "This product includes software developed by the OpenSSL Project
  20  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  21  *
  22  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  23  *    endorse or promote products derived from this software without
  24  *    prior written permission. For written permission, please contact
  25  *    licensing@OpenSSL.org.
  26  *
  27  * 5. Products derived from this software may not be called "OpenSSL"
  28  *    nor may "OpenSSL" appear in their names without prior written
  29  *    permission of the OpenSSL Project.
  30  *
  31  * 6. Redistributions of any form whatsoever must retain the following
  32  *    acknowledgment:
  33  *    "This product includes software developed by the OpenSSL Project
  34  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  35  *
  36  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  37  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  38  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  39  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  40  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  41  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  42  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  43  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  44  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  45  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  46  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  47  * OF THE POSSIBILITY OF SUCH DAMAGE.
  48  * ====================================================================
  49  *
  50  * This product includes cryptographic software written by Eric Young
  51  * (eay@cryptsoft.com).  This product includes software written by Tim
  52  * Hudson (tjh@cryptsoft.com).
  53  *
  54  */
  55
  56 #include "eng_int.h"
  57
  58 /*
  59  * Initialise a engine type for use (or up its functional reference count if
  60  * it's already in use). This version is only used internally.
  61  */
  62 int engine_unlocked_init(ENGINE *e)
  63 {
  64     int to_return = 1;
  65
  66     if ((e->funct_ref == 0) && e->init)
  67         /*
  68          * This is the first functional reference and the engine requires
  69          * initialisation so we do it now.
  70          */
  71         to_return = e->init(e);
  72     if (to_return) {
  73         /*
  74          * OK, we return a functional reference which is also a structural
  75          * reference.
  76          */
  77         e->struct_ref++;
  78         e->funct_ref++;
  79         engine_ref_debug(e, 0, 1)
  80             engine_ref_debug(e, 1, 1)
  81     }
  82     return to_return;
  83 }
  84
  85 /*
  86  * Free a functional reference to a engine type. This version is only used
  87  * internally.
  88  */
  89 int engine_unlocked_finish(ENGINE *e, int unlock_for_handlers)
  90 {
  91     int to_return = 1;
  92
  93     /*
  94      * Reduce the functional reference count here so if it's the terminating
  95      * case, we can release the lock safely and call the finish() handler
  96      * without risk of a race. We get a race if we leave the count until
  97      * after and something else is calling "finish" at the same time -
  98      * there's a chance that both threads will together take the count from 2
  99      * to 0 without either calling finish().
 100      */
 101     e->funct_ref--;
 102     engine_ref_debug(e, 1, -1);
 103     if ((e->funct_ref == 0) && e->finish) {
 104         if (unlock_for_handlers)
 105             CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 106         to_return = e->finish(e);
 107         if (unlock_for_handlers)
 108             CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
 109         if (!to_return)
 110             return 0;
 111     }
 112 #ifdef REF_CHECK
 113     if (e->funct_ref < 0) {
 114         fprintf(stderr, "ENGINE_finish, bad functional reference count\n");
 115         abort();
 116     }
 117 #endif
 118     /* Release the structural reference too */
 119     if (!engine_free_util(e, 0)) {
 120         ENGINEerr(ENGINE_F_ENGINE_UNLOCKED_FINISH, ENGINE_R_FINISH_FAILED);
 121         return 0;
 122     }
 123     return to_return;
 124 }
 125
 126 /* The API (locked) version of "init" */
 127 int ENGINE_init(ENGINE *e)
 128 {
 129     int ret;
 130     if (e == NULL) {
 131         ENGINEerr(ENGINE_F_ENGINE_INIT, ERR_R_PASSED_NULL_PARAMETER);
 132         return 0;
 133     }
 134     CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
 135     ret = engine_unlocked_init(e);
 136     CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 137     return ret;
 138 }
 139
 140 /* The API (locked) version of "finish" */
 141 int ENGINE_finish(ENGINE *e)
 142 {
 143     int to_return = 1;
 144
 145     if (e == NULL) {
 146         ENGINEerr(ENGINE_F_ENGINE_FINISH, ERR_R_PASSED_NULL_PARAMETER);
 147         return 0;
 148     }
 149     CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
 150     to_return = engine_unlocked_finish(e, 1);
 151     CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 152     if (!to_return) {
 153         ENGINEerr(ENGINE_F_ENGINE_FINISH, ENGINE_R_FINISH_FAILED);
 154         return 0;
 155     }
 156     return to_return;
 157 }