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 */
61typedef 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
73DECLARE_LHASH_OF(ENGINE_PILE);
74
75/* The type exposed in eng_int.h */
76struct st_engine_table
77	{
78	LHASH_OF(ENGINE_PILE) piles;
79	}; /* ENGINE_TABLE */
80
81
82typedef 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_***). */
90static unsigned int table_flags = 0;
91
92/* API function manipulating 'table_flags' */
93unsigned int ENGINE_get_table_flags(void)
94	{
95	return table_flags;
96	}
97
98void ENGINE_set_table_flags(unsigned int flags)
99	{
100	table_flags = flags;
101	}
102
103/* Internal functions for the "piles" hash table */
104static unsigned long engine_pile_hash(const ENGINE_PILE *c)
105	{
106	return c->nid;
107	}
108
109static int engine_pile_cmp(const ENGINE_PILE *a, const ENGINE_PILE *b)
110	{
111	return a->nid - b->nid;
112	}
113static IMPLEMENT_LHASH_HASH_FN(engine_pile, ENGINE_PILE)
114static IMPLEMENT_LHASH_COMP_FN(engine_pile, ENGINE_PILE)
115
116static 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 */
130int 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;
185end:
186	CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
187	return ret;
188	}
189static 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	}
204static IMPLEMENT_LHASH_DOALL_ARG_FN(int_unregister_cb, ENGINE_PILE, ENGINE)
205
206void 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
216static 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	}
223static IMPLEMENT_LHASH_DOALL_FN(int_cleanup_cb, ENGINE_PILE)
224
225void 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
240ENGINE *engine_table_select(ENGINE_TABLE **table, int nid)
241#else
242ENGINE *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		}
279trynext:
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;
316end:
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
337static 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	}
341static IMPLEMENT_LHASH_DOALL_ARG_FN(int_cb, ENGINE_PILE,ENGINE_PILE_DOALL)
342
343void 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	}
352