1/* crypto/engine/eng_int.h */ 2/* 3 * Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL project 4 * 2000. 5 */ 6/* ==================================================================== 7 * Copyright (c) 1999-2001 The OpenSSL Project. All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in 18 * the documentation and/or other materials provided with the 19 * distribution. 20 * 21 * 3. All advertising materials mentioning features or use of this 22 * software must display the following acknowledgment: 23 * "This product includes software developed by the OpenSSL Project 24 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" 25 * 26 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 27 * endorse or promote products derived from this software without 28 * prior written permission. For written permission, please contact 29 * licensing@OpenSSL.org. 30 * 31 * 5. Products derived from this software may not be called "OpenSSL" 32 * nor may "OpenSSL" appear in their names without prior written 33 * permission of the OpenSSL Project. 34 * 35 * 6. Redistributions of any form whatsoever must retain the following 36 * acknowledgment: 37 * "This product includes software developed by the OpenSSL Project 38 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" 39 * 40 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 41 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 43 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 44 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 45 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 46 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 47 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 49 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 50 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 51 * OF THE POSSIBILITY OF SUCH DAMAGE. 52 * ==================================================================== 53 * 54 * This product includes cryptographic software written by Eric Young 55 * (eay@cryptsoft.com). This product includes software written by Tim 56 * Hudson (tjh@cryptsoft.com). 57 * 58 */ 59/* ==================================================================== 60 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. 61 * ECDH support in OpenSSL originally developed by 62 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project. 63 */ 64 65#ifndef HEADER_ENGINE_INT_H 66# define HEADER_ENGINE_INT_H 67 68# include "cryptlib.h" 69/* Take public definitions from engine.h */ 70# include <openssl/engine.h> 71 72#ifdef __cplusplus 73extern "C" { 74#endif 75 76/* 77 * If we compile with this symbol defined, then both reference counts in the 78 * ENGINE structure will be monitored with a line of output on stderr for 79 * each change. This prints the engine's pointer address (truncated to 80 * unsigned int), "struct" or "funct" to indicate the reference type, the 81 * before and after reference count, and the file:line-number pair. The 82 * "engine_ref_debug" statements must come *after* the change. 83 */ 84# ifdef ENGINE_REF_COUNT_DEBUG 85 86# define engine_ref_debug(e, isfunct, diff) \ 87 fprintf(stderr, "engine: %08x %s from %d to %d (%s:%d)\n", \ 88 (unsigned int)(e), (isfunct ? "funct" : "struct"), \ 89 ((isfunct) ? ((e)->funct_ref - (diff)) : ((e)->struct_ref - (diff))), \ 90 ((isfunct) ? (e)->funct_ref : (e)->struct_ref), \ 91 (__FILE__), (__LINE__)); 92 93# else 94 95# define engine_ref_debug(e, isfunct, diff) 96 97# endif 98 99/* 100 * Any code that will need cleanup operations should use these functions to 101 * register callbacks. ENGINE_cleanup() will call all registered callbacks in 102 * order. NB: both the "add" functions assume CRYPTO_LOCK_ENGINE to already be 103 * held (in "write" mode). 104 */ 105typedef void (ENGINE_CLEANUP_CB) (void); 106typedef struct st_engine_cleanup_item { 107 ENGINE_CLEANUP_CB *cb; 108} ENGINE_CLEANUP_ITEM; 109DECLARE_STACK_OF(ENGINE_CLEANUP_ITEM) 110void engine_cleanup_add_first(ENGINE_CLEANUP_CB *cb); 111void engine_cleanup_add_last(ENGINE_CLEANUP_CB *cb); 112 113/* We need stacks of ENGINEs for use in eng_table.c */ 114DECLARE_STACK_OF(ENGINE) 115 116/* 117 * If this symbol is defined then engine_table_select(), the function that is 118 * used by RSA, DSA (etc) code to select registered ENGINEs, cache defaults 119 * and functional references (etc), will display debugging summaries to 120 * stderr. 121 */ 122/* #define ENGINE_TABLE_DEBUG */ 123 124/* 125 * This represents an implementation table. Dependent code should instantiate 126 * it as a (ENGINE_TABLE *) pointer value set initially to NULL. 127 */ 128typedef struct st_engine_table ENGINE_TABLE; 129int engine_table_register(ENGINE_TABLE **table, ENGINE_CLEANUP_CB *cleanup, 130 ENGINE *e, const int *nids, int num_nids, 131 int setdefault); 132void engine_table_unregister(ENGINE_TABLE **table, ENGINE *e); 133void engine_table_cleanup(ENGINE_TABLE **table); 134# ifndef ENGINE_TABLE_DEBUG 135ENGINE *engine_table_select(ENGINE_TABLE **table, int nid); 136# else 137ENGINE *engine_table_select_tmp(ENGINE_TABLE **table, int nid, const char *f, 138 int l); 139# define engine_table_select(t,n) engine_table_select_tmp(t,n,__FILE__,__LINE__) 140# endif 141typedef void (engine_table_doall_cb) (int nid, STACK_OF(ENGINE) *sk, 142 ENGINE *def, void *arg); 143void engine_table_doall(ENGINE_TABLE *table, engine_table_doall_cb *cb, 144 void *arg); 145 146/* 147 * Internal versions of API functions that have control over locking. These 148 * are used between C files when functionality needs to be shared but the 149 * caller may already be controlling of the CRYPTO_LOCK_ENGINE lock. 150 */ 151int engine_unlocked_init(ENGINE *e); 152int engine_unlocked_finish(ENGINE *e, int unlock_for_handlers); 153int engine_free_util(ENGINE *e, int locked); 154 155/* 156 * This function will reset all "set"able values in an ENGINE to NULL. This 157 * won't touch reference counts or ex_data, but is equivalent to calling all 158 * the ENGINE_set_***() functions with a NULL value. 159 */ 160void engine_set_all_null(ENGINE *e); 161 162/* 163 * NB: Bitwise OR-able values for the "flags" variable in ENGINE are now 164 * exposed in engine.h. 165 */ 166 167/* Free up dynamically allocated public key methods associated with ENGINE */ 168 169void engine_pkey_meths_free(ENGINE *e); 170void engine_pkey_asn1_meths_free(ENGINE *e); 171 172/* 173 * This is a structure for storing implementations of various crypto 174 * algorithms and functions. 175 */ 176struct engine_st { 177 const char *id; 178 const char *name; 179 const RSA_METHOD *rsa_meth; 180 const DSA_METHOD *dsa_meth; 181 const DH_METHOD *dh_meth; 182 const ECDH_METHOD *ecdh_meth; 183 const ECDSA_METHOD *ecdsa_meth; 184 const RAND_METHOD *rand_meth; 185 const STORE_METHOD *store_meth; 186 /* Cipher handling is via this callback */ 187 ENGINE_CIPHERS_PTR ciphers; 188 /* Digest handling is via this callback */ 189 ENGINE_DIGESTS_PTR digests; 190 /* Public key handling via this callback */ 191 ENGINE_PKEY_METHS_PTR pkey_meths; 192 /* ASN1 public key handling via this callback */ 193 ENGINE_PKEY_ASN1_METHS_PTR pkey_asn1_meths; 194 ENGINE_GEN_INT_FUNC_PTR destroy; 195 ENGINE_GEN_INT_FUNC_PTR init; 196 ENGINE_GEN_INT_FUNC_PTR finish; 197 ENGINE_CTRL_FUNC_PTR ctrl; 198 ENGINE_LOAD_KEY_PTR load_privkey; 199 ENGINE_LOAD_KEY_PTR load_pubkey; 200 ENGINE_SSL_CLIENT_CERT_PTR load_ssl_client_cert; 201 const ENGINE_CMD_DEFN *cmd_defns; 202 int flags; 203 /* reference count on the structure itself */ 204 int struct_ref; 205 /* 206 * reference count on usability of the engine type. NB: This controls the 207 * loading and initialisation of any functionlity required by this 208 * engine, whereas the previous count is simply to cope with 209 * (de)allocation of this structure. Hence, running_ref <= struct_ref at 210 * all times. 211 */ 212 int funct_ref; 213 /* A place to store per-ENGINE data */ 214 CRYPTO_EX_DATA ex_data; 215 /* Used to maintain the linked-list of engines. */ 216 struct engine_st *prev; 217 struct engine_st *next; 218}; 219 220#ifdef __cplusplus 221} 222#endif 223 224#endif /* HEADER_ENGINE_INT_H */ 225