release/src/router/openssl/crypto/engine/eng_table.c

   1 /* ====================================================================
   2  * Copyright (c) 2001 The OpenSSL Project.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  *
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in
  13  *    the documentation and/or other materials provided with the
  14  *    distribution.
  15  *
  16  * 3. All advertising materials mentioning features or use of this
  17  *    software must display the following acknowledgment:
  18  *    "This product includes software developed by the OpenSSL Project
  19  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  20  *
  21  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  22  *    endorse or promote products derived from this software without
  23  *    prior written permission. For written permission, please contact
  24  *    licensing@OpenSSL.org.
  25  *
  26  * 5. Products derived from this software may not be called "OpenSSL"
  27  *    nor may "OpenSSL" appear in their names without prior written
  28  *    permission of the OpenSSL Project.
  29  *
  30  * 6. Redistributions of any form whatsoever must retain the following
  31  *    acknowledgment:
  32  *    "This product includes software developed by the OpenSSL Project
  33  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  34  *
  35  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  36  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  37  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  38  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  39  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  41  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  42  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  43  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  44  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  45  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  46  * OF THE POSSIBILITY OF SUCH DAMAGE.
  47  * ====================================================================
  48  *
  49  * This product includes cryptographic software written by Eric Young
  50  * (eay@cryptsoft.com).  This product includes software written by Tim
  51  * Hudson (tjh@cryptsoft.com).
  52  *
  53  */
  54
  55 #include "cryptlib.h"
  56 #include <openssl/evp.h>
  57 #include <openssl/lhash.h>
  58 #include "eng_int.h"
  59
  60 /* The type of the items in the table */
  61 typedef struct st_engine_pile
  62         {
  63         /* The 'nid' of this algorithm/mode */
  64         int nid;
  65         /* ENGINEs that implement this algorithm/mode. */
  66         STACK_OF(ENGINE) *sk;
  67         /* The default ENGINE to perform this algorithm/mode. */
  68         ENGINE *funct;
  69         /* Zero if 'sk' is newer than the cached 'funct', non-zero otherwise */
  70         int uptodate;
  71         } ENGINE_PILE;
  72
  73 DECLARE_LHASH_OF(ENGINE_PILE);
  74
  75 /* The type exposed in eng_int.h */
  76 struct st_engine_table
  77         {
  78         LHASH_OF(ENGINE_PILE) piles;
  79         }; /* ENGINE_TABLE */
  80
  81
  82 typedef struct st_engine_pile_doall
  83         {
  84         engine_table_doall_cb *cb;
  85         void *arg;
  86         } ENGINE_PILE_DOALL;
  87
  88
  89 /* Global flags (ENGINE_TABLE_FLAG_***). */
  90 static unsigned int table_flags = 0;
  91
  92 /* API function manipulating 'table_flags' */
  93 unsigned int ENGINE_get_table_flags(void)
  94         {
  95         return table_flags;
  96         }
  97
  98 void ENGINE_set_table_flags(unsigned int flags)
  99         {
 100         table_flags = flags;
 101         }
 102
 103 /* Internal functions for the "piles" hash table */
 104 static unsigned long engine_pile_hash(const ENGINE_PILE *c)
 105         {
 106         return c->nid;
 107         }
 108
 109 static int engine_pile_cmp(const ENGINE_PILE *a, const ENGINE_PILE *b)
 110         {
 111         return a->nid - b->nid;
 112         }
 113 static IMPLEMENT_LHASH_HASH_FN(engine_pile, ENGINE_PILE)
 114 static IMPLEMENT_LHASH_COMP_FN(engine_pile, ENGINE_PILE)
 115
 116 static int int_table_check(ENGINE_TABLE **t, int create)
 117         {
 118         LHASH_OF(ENGINE_PILE) *lh;
 119
 120         if(*t) return 1;
 121         if(!create) return 0;
 122         if((lh = lh_ENGINE_PILE_new()) == NULL)
 123                 return 0;
 124         *t = (ENGINE_TABLE *)lh;
 125         return 1;
 126         }
 127
 128 /* Privately exposed (via eng_int.h) functions for adding and/or removing
 129  * ENGINEs from the implementation table */
 130 int engine_table_register(ENGINE_TABLE **table, ENGINE_CLEANUP_CB *cleanup,
 131                 ENGINE *e, const int *nids, int num_nids, int setdefault)
 132         {
 133         int ret = 0, added = 0;
 134         ENGINE_PILE tmplate, *fnd;
 135         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
 136         if(!(*table))
 137                 added = 1;
 138         if(!int_table_check(table, 1))
 139                 goto end;
 140         if(added)
 141                 /* The cleanup callback needs to be added */
 142                 engine_cleanup_add_first(cleanup);
 143         while(num_nids--)
 144                 {
 145                 tmplate.nid = *nids;
 146                 fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate);
 147                 if(!fnd)
 148                         {
 149                         fnd = OPENSSL_malloc(sizeof(ENGINE_PILE));
 150                         if(!fnd) goto end;
 151                         fnd->uptodate = 1;
 152                         fnd->nid = *nids;
 153                         fnd->sk = sk_ENGINE_new_null();
 154                         if(!fnd->sk)
 155                                 {
 156                                 OPENSSL_free(fnd);
 157                                 goto end;
 158                                 }
 159                         fnd->funct = NULL;
 160                         (void)lh_ENGINE_PILE_insert(&(*table)->piles, fnd);
 161                         }
 162                 /* A registration shouldn't add duplciate entries */
 163                 (void)sk_ENGINE_delete_ptr(fnd->sk, e);
 164                 /* if 'setdefault', this ENGINE goes to the head of the list */
 165                 if(!sk_ENGINE_push(fnd->sk, e))
 166                         goto end;
 167                 /* "touch" this ENGINE_PILE */
 168                 fnd->uptodate = 0;
 169                 if(setdefault)
 170                         {
 171                         if(!engine_unlocked_init(e))
 172                                 {
 173                                 ENGINEerr(ENGINE_F_ENGINE_TABLE_REGISTER,
 174                                                 ENGINE_R_INIT_FAILED);
 175                                 goto end;
 176                                 }
 177                         if(fnd->funct)
 178                                 engine_unlocked_finish(fnd->funct, 0);
 179                         fnd->funct = e;
 180                         fnd->uptodate = 1;
 181                         }
 182                 nids++;
 183                 }
 184         ret = 1;
 185 end:
 186         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 187         return ret;
 188         }
 189 static void int_unregister_cb_doall_arg(ENGINE_PILE *pile, ENGINE *e)
 190         {
 191         int n;
 192         /* Iterate the 'c->sk' stack removing any occurance of 'e' */
 193         while((n = sk_ENGINE_find(pile->sk, e)) >= 0)
 194                 {
 195                 (void)sk_ENGINE_delete(pile->sk, n);
 196                 pile->uptodate = 0;
 197                 }
 198         if(pile->funct == e)
 199                 {
 200                 engine_unlocked_finish(e, 0);
 201                 pile->funct = NULL;
 202                 }
 203         }
 204 static IMPLEMENT_LHASH_DOALL_ARG_FN(int_unregister_cb, ENGINE_PILE, ENGINE)
 205
 206 void engine_table_unregister(ENGINE_TABLE **table, ENGINE *e)
 207         {
 208         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
 209         if(int_table_check(table, 0))
 210                 lh_ENGINE_PILE_doall_arg(&(*table)->piles,
 211                                          LHASH_DOALL_ARG_FN(int_unregister_cb),
 212                                          ENGINE, e);
 213         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 214         }
 215
 216 static void int_cleanup_cb_doall(ENGINE_PILE *p)
 217         {
 218         sk_ENGINE_free(p->sk);
 219         if(p->funct)
 220                 engine_unlocked_finish(p->funct, 0);
 221         OPENSSL_free(p);
 222         }
 223 static IMPLEMENT_LHASH_DOALL_FN(int_cleanup_cb, ENGINE_PILE)
 224
 225 void engine_table_cleanup(ENGINE_TABLE **table)
 226         {
 227         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
 228         if(*table)
 229                 {
 230                 lh_ENGINE_PILE_doall(&(*table)->piles,
 231                                      LHASH_DOALL_FN(int_cleanup_cb));
 232                 lh_ENGINE_PILE_free(&(*table)->piles);
 233                 *table = NULL;
 234                 }
 235         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 236         }
 237
 238 /* return a functional reference for a given 'nid' */
 239 #ifndef ENGINE_TABLE_DEBUG
 240 ENGINE *engine_table_select(ENGINE_TABLE **table, int nid)
 241 #else
 242 ENGINE *engine_table_select_tmp(ENGINE_TABLE **table, int nid, const char *f, int l)
 243 #endif
 244         {
 245         ENGINE *ret = NULL;
 246         ENGINE_PILE tmplate, *fnd=NULL;
 247         int initres, loop = 0;
 248
 249         if(!(*table))
 250                 {
 251 #ifdef ENGINE_TABLE_DEBUG
 252                 fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, nothing "
 253                         "registered!\n", f, l, nid);
 254 #endif
 255                 return NULL;
 256                 }
 257         ERR_set_mark();
 258         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
 259         /* Check again inside the lock otherwise we could race against cleanup
 260          * operations. But don't worry about a fprintf(stderr). */
 261         if(!int_table_check(table, 0)) goto end;
 262         tmplate.nid = nid;
 263         fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate);
 264         if(!fnd) goto end;
 265         if(fnd->funct && engine_unlocked_init(fnd->funct))
 266                 {
 267 #ifdef ENGINE_TABLE_DEBUG
 268                 fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, using "
 269                         "ENGINE '%s' cached\n", f, l, nid, fnd->funct->id);
 270 #endif
 271                 ret = fnd->funct;
 272                 goto end;
 273                 }
 274         if(fnd->uptodate)
 275                 {
 276                 ret = fnd->funct;
 277                 goto end;
 278                 }
 279 trynext:
 280         ret = sk_ENGINE_value(fnd->sk, loop++);
 281         if(!ret)
 282                 {
 283 #ifdef ENGINE_TABLE_DEBUG
 284                 fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, no "
 285                                 "registered implementations would initialise\n",
 286                                 f, l, nid);
 287 #endif
 288                 goto end;
 289                 }
 290         /* Try to initialise the ENGINE? */
 291         if((ret->funct_ref > 0) || !(table_flags & ENGINE_TABLE_FLAG_NOINIT))
 292                 initres = engine_unlocked_init(ret);
 293         else
 294                 initres = 0;
 295         if(initres)
 296                 {
 297                 /* Update 'funct' */
 298                 if((fnd->funct != ret) && engine_unlocked_init(ret))
 299                         {
 300                         /* If there was a previous default we release it. */
 301                         if(fnd->funct)
 302                                 engine_unlocked_finish(fnd->funct, 0);
 303                         fnd->funct = ret;
 304 #ifdef ENGINE_TABLE_DEBUG
 305                         fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, "
 306                                 "setting default to '%s'\n", f, l, nid, ret->id);
 307 #endif
 308                         }
 309 #ifdef ENGINE_TABLE_DEBUG
 310                 fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, using "
 311                                 "newly initialised '%s'\n", f, l, nid, ret->id);
 312 #endif
 313                 goto end;
 314                 }
 315         goto trynext;
 316 end:
 317         /* If it failed, it is unlikely to succeed again until some future
 318          * registrations have taken place. In all cases, we cache. */
 319         if(fnd) fnd->uptodate = 1;
 320 #ifdef ENGINE_TABLE_DEBUG
 321         if(ret)
 322                 fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, caching "
 323                                 "ENGINE '%s'\n", f, l, nid, ret->id);
 324         else
 325                 fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, caching "
 326                                 "'no matching ENGINE'\n", f, l, nid);
 327 #endif
 328         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 329         /* Whatever happened, any failed init()s are not failures in this
 330          * context, so clear our error state. */
 331         ERR_pop_to_mark();
 332         return ret;
 333         }
 334
 335 /* Table enumeration */
 336
 337 static void int_cb_doall_arg(ENGINE_PILE *pile, ENGINE_PILE_DOALL *dall)
 338         {
 339         dall->cb(pile->nid, pile->sk, pile->funct, dall->arg);
 340         }
 341 static IMPLEMENT_LHASH_DOALL_ARG_FN(int_cb, ENGINE_PILE,ENGINE_PILE_DOALL)
 342
 343 void engine_table_doall(ENGINE_TABLE *table, engine_table_doall_cb *cb,
 344                                                                 void *arg)
 345         {
 346         ENGINE_PILE_DOALL dall;
 347         dall.cb = cb;
 348         dall.arg = arg;
 349         lh_ENGINE_PILE_doall_arg(&table->piles, LHASH_DOALL_ARG_FN(int_cb),
 350                                  ENGINE_PILE_DOALL, &dall);
 351         }