[thirdparty/openssl.git] / crypto / engine / eng_list.c

/* crypto/engine/eng_list.c */
/* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL
 * project 2000.
 */
/* ====================================================================
 * Copyright (c) 1999-2001 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    licensing@OpenSSL.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */

#include <openssl/crypto.h>
#include "cryptlib.h"
#include "eng_int.h"
#include <openssl/engine.h>

/* The linked-list of pointers to engine types. engine_list_head
 * incorporates an implicit structural reference but engine_list_tail
 * does not - the latter is a computational niceity and only points
 * to something that is already pointed to by its predecessor in the
 * list (or engine_list_head itself). In the same way, the use of the
 * "prev" pointer in each ENGINE is to save excessive list iteration,
 * it doesn't correspond to an extra structural reference. Hence,
 * engine_list_head, and each non-null "next" pointer account for
 * the list itself assuming exactly 1 structural reference on each
 * list member. */
static ENGINE *engine_list_head = NULL;
static ENGINE *engine_list_tail = NULL;

/* This cleanup function is only needed internally. If it should be called, we
 * register it with the "ENGINE_cleanup()" stack to be called during cleanup. */

static void engine_list_cleanup(void)
	{
	ENGINE *iterator = engine_list_head;

	while(iterator != NULL)
		{
		ENGINE_remove(iterator);
		iterator = engine_list_head;
		}
	return;
	}

/* These static functions starting with a lower case "engine_" always
 * take place when CRYPTO_LOCK_ENGINE has been locked up. */
static int engine_list_add(ENGINE *e)
	{
	int conflict = 0;
	ENGINE *iterator = NULL;

	if(e == NULL)
		{
		ENGINEerr(ENGINE_F_ENGINE_LIST_ADD,
			ERR_R_PASSED_NULL_PARAMETER);
		return 0;
		}
	iterator = engine_list_head;
	while(iterator && !conflict)
		{
		conflict = (strcmp(iterator->id, e->id) == 0);
		iterator = iterator->next;
		}
	if(conflict)
		{
		ENGINEerr(ENGINE_F_ENGINE_LIST_ADD,
			ENGINE_R_CONFLICTING_ENGINE_ID);
		return 0;
		}
	if(engine_list_head == NULL)
		{
		/* We are adding to an empty list. */
		if(engine_list_tail)
			{
			ENGINEerr(ENGINE_F_ENGINE_LIST_ADD,
				ENGINE_R_INTERNAL_LIST_ERROR);
			return 0;
			}
		engine_list_head = e;
		e->prev = NULL;
		/* The first time the list allocates, we should register the
		 * cleanup. */
		engine_cleanup_add_last(engine_list_cleanup);
		}
	else
		{
		/* We are adding to the tail of an existing list. */
		if((engine_list_tail == NULL) ||
				(engine_list_tail->next != NULL))
			{
			ENGINEerr(ENGINE_F_ENGINE_LIST_ADD,
				ENGINE_R_INTERNAL_LIST_ERROR);
			return 0;
			}
		engine_list_tail->next = e;
		e->prev = engine_list_tail;
		}
	/* Having the engine in the list assumes a structural
	 * reference. */
	e->struct_ref++;
	engine_ref_debug(e, 0, 1)
	/* However it came to be, e is the last item in the list. */
	engine_list_tail = e;
	e->next = NULL;
	return 1;
	}

static int engine_list_remove(ENGINE *e)
	{
	ENGINE *iterator;

	if(e == NULL)
		{
		ENGINEerr(ENGINE_F_ENGINE_LIST_REMOVE,
			ERR_R_PASSED_NULL_PARAMETER);
		return 0;
		}
	/* We need to check that e is in our linked list! */
	iterator = engine_list_head;
	while(iterator && (iterator != e))
		iterator = iterator->next;
	if(iterator == NULL)
		{
		ENGINEerr(ENGINE_F_ENGINE_LIST_REMOVE,
			ENGINE_R_ENGINE_IS_NOT_IN_LIST);
		return 0;
		}
	/* un-link e from the chain. */
	if(e->next)
		e->next->prev = e->prev;
	if(e->prev)
		e->prev->next = e->next;
	/* Correct our head/tail if necessary. */
	if(engine_list_head == e)
		engine_list_head = e->next;
	if(engine_list_tail == e)
		engine_list_tail = e->prev;
	engine_free_util(e, 0);
	return 1;
	}

/* Get the first/last "ENGINE" type available. */
ENGINE *ENGINE_get_first(void)
	{
	ENGINE *ret;

	CRYPTO_r_lock(CRYPTO_LOCK_ENGINE);
	ret = engine_list_head;
	if(ret)
		{
		ret->struct_ref++;
		engine_ref_debug(ret, 0, 1)
		}
	CRYPTO_r_unlock(CRYPTO_LOCK_ENGINE);
	return ret;
	}

ENGINE *ENGINE_get_last(void)
	{
	ENGINE *ret;

	CRYPTO_r_lock(CRYPTO_LOCK_ENGINE);
		ret = engine_list_tail;
	if(ret)
		{
		ret->struct_ref++;
		engine_ref_debug(ret, 0, 1)
		}
	CRYPTO_r_unlock(CRYPTO_LOCK_ENGINE);
	return ret;
	}

/* Iterate to the next/previous "ENGINE" type (NULL = end of the list). */
ENGINE *ENGINE_get_next(ENGINE *e)
	{
	ENGINE *ret = NULL;
	if(e == NULL)
		{
		ENGINEerr(ENGINE_F_ENGINE_GET_NEXT,
			ERR_R_PASSED_NULL_PARAMETER);
		return 0;
		}
	CRYPTO_r_lock(CRYPTO_LOCK_ENGINE);
	ret = e->next;
	if(ret)
		{
		/* Return a valid structural refernce to the next ENGINE */
		ret->struct_ref++;
		engine_ref_debug(ret, 0, 1)
		}
	CRYPTO_r_unlock(CRYPTO_LOCK_ENGINE);
	/* Release the structural reference to the previous ENGINE */
	ENGINE_free(e);
	return ret;
	}

ENGINE *ENGINE_get_prev(ENGINE *e)
	{
	ENGINE *ret = NULL;
	if(e == NULL)
		{
		ENGINEerr(ENGINE_F_ENGINE_GET_PREV,
			ERR_R_PASSED_NULL_PARAMETER);
		return 0;
		}
	CRYPTO_r_lock(CRYPTO_LOCK_ENGINE);
	ret = e->prev;
	if(ret)
		{
		/* Return a valid structural reference to the next ENGINE */
		ret->struct_ref++;
		engine_ref_debug(ret, 0, 1)
		}
	CRYPTO_r_unlock(CRYPTO_LOCK_ENGINE);
	/* Release the structural reference to the previous ENGINE */
	ENGINE_free(e);
	return ret;
	}

/* Add another "ENGINE" type into the list. */
int ENGINE_add(ENGINE *e)
	{
	int to_return = 1;
	if(e == NULL)
		{
		ENGINEerr(ENGINE_F_ENGINE_ADD,
			ERR_R_PASSED_NULL_PARAMETER);
		return 0;
		}
	if((e->id == NULL) || (e->name == NULL))
		{
		ENGINEerr(ENGINE_F_ENGINE_ADD,
			ENGINE_R_ID_OR_NAME_MISSING);
		}
	CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
	if(!engine_list_add(e))
		{
		ENGINEerr(ENGINE_F_ENGINE_ADD,
			ENGINE_R_INTERNAL_LIST_ERROR);
		to_return = 0;
		}
	CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
	return to_return;
	}

/* Remove an existing "ENGINE" type from the array. */
int ENGINE_remove(ENGINE *e)
	{
	int to_return = 1;
	if(e == NULL)
		{
		ENGINEerr(ENGINE_F_ENGINE_REMOVE,
			ERR_R_PASSED_NULL_PARAMETER);
		return 0;
		}
	CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
	if(!engine_list_remove(e))
		{
		ENGINEerr(ENGINE_F_ENGINE_REMOVE,
			ENGINE_R_INTERNAL_LIST_ERROR);
		to_return = 0;
		}
	CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
	return to_return;
	}

static void engine_cpy(ENGINE *dest, const ENGINE *src)
	{
	dest->id = src->id;
	dest->name = src->name;
#ifndef OPENSSL_NO_RSA
	dest->rsa_meth = src->rsa_meth;
#endif
#ifndef OPENSSL_NO_DSA
	dest->dsa_meth = src->dsa_meth;
#endif
#ifndef OPENSSL_NO_DH
	dest->dh_meth = src->dh_meth;
#endif
#ifndef OPENSSL_NO_ECDSA
	dest->ecdsa_meth = src->ecdsa_meth;
#endif
	dest->rand_meth = src->rand_meth;
	dest->ciphers = src->ciphers;
	dest->digests = src->digests;
	dest->destroy = src->destroy;
	dest->init = src->init;
	dest->finish = src->finish;
	dest->ctrl = src->ctrl;
	dest->load_privkey = src->load_privkey;
	dest->load_pubkey = src->load_pubkey;
	dest->cmd_defns = src->cmd_defns;
	dest->flags = src->flags;
	}

ENGINE *ENGINE_by_id(const char *id)
	{
	ENGINE *iterator;
	if(id == NULL)
		{
		ENGINEerr(ENGINE_F_ENGINE_BY_ID,
			ERR_R_PASSED_NULL_PARAMETER);
		return NULL;
		}
	CRYPTO_r_lock(CRYPTO_LOCK_ENGINE);
	iterator = engine_list_head;
	while(iterator && (strcmp(id, iterator->id) != 0))
		iterator = iterator->next;
	if(iterator)
		{
		/* We need to return a structural reference. If this is an
		 * ENGINE type that returns copies, make a duplicate - otherwise
		 * increment the existing ENGINE's reference count. */
		if(iterator->flags & ENGINE_FLAGS_BY_ID_COPY)
			{
			ENGINE *cp = ENGINE_new();
			if(!cp)
				iterator = NULL;
			else
				{
				engine_cpy(cp, iterator);
				iterator = cp;
				}
			}
		else
			{
			iterator->struct_ref++;
			engine_ref_debug(iterator, 0, 1)
			}
		}
	CRYPTO_r_unlock(CRYPTO_LOCK_ENGINE);
	if(iterator == NULL)
		{
		ENGINEerr(ENGINE_F_ENGINE_BY_ID,
			ENGINE_R_NO_SUCH_ENGINE);
		ERR_add_error_data(2, "id=", id);
		}
	return iterator;
	}
Commit	Line	Data
2b671586	1	/* crypto/engine/eng_list.c */
5270e702 RL	2	/* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL
	3	* project 2000.
	4	*/
	5	/* ====================================================================
2b671586	6	* Copyright (c) 1999-2001 The OpenSSL Project. All rights reserved.
5270e702 RL	7	*
	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted provided that the following conditions
	10	* are met:
	11	*
	12	* 1. Redistributions of source code must retain the above copyright
	13	* notice, this list of conditions and the following disclaimer.
	14	*
	15	* 2. Redistributions in binary form must reproduce the above copyright
	16	* notice, this list of conditions and the following disclaimer in
	17	* the documentation and/or other materials provided with the
	18	* distribution.
	19	*
	20	* 3. All advertising materials mentioning features or use of this
	21	* software must display the following acknowledgment:
	22	* "This product includes software developed by the OpenSSL Project
	23	* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
	24	*
	25	* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
	26	* endorse or promote products derived from this software without
	27	* prior written permission. For written permission, please contact
	28	* licensing@OpenSSL.org.
	29	*
	30	* 5. Products derived from this software may not be called "OpenSSL"
	31	* nor may "OpenSSL" appear in their names without prior written
	32	* permission of the OpenSSL Project.
	33	*
	34	* 6. Redistributions of any form whatsoever must retain the following
	35	* acknowledgment:
	36	* "This product includes software developed by the OpenSSL Project
	37	* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
	38	*
	39	* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
	40	* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	41	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	42	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
	43	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	44	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	45	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	46	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	47	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	48	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	49	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	50	* OF THE POSSIBILITY OF SUCH DAMAGE.
	51	* ====================================================================
	52	*
	53	* This product includes cryptographic software written by Eric Young
	54	* (eay@cryptsoft.com). This product includes software written by Tim
	55	* Hudson (tjh@cryptsoft.com).
	56	*
	57	*/
	58
	59	#include <openssl/crypto.h>
	60	#include "cryptlib.h"
14cfde9c	61	#include "eng_int.h"
5270e702 RL	62	#include <openssl/engine.h>
	63
	64	/* The linked-list of pointers to engine types. engine_list_head
	65	* incorporates an implicit structural reference but engine_list_tail
	66	* does not - the latter is a computational niceity and only points
	67	* to something that is already pointed to by its predecessor in the
	68	* list (or engine_list_head itself). In the same way, the use of the
	69	* "prev" pointer in each ENGINE is to save excessive list iteration,
	70	* it doesn't correspond to an extra structural reference. Hence,
	71	* engine_list_head, and each non-null "next" pointer account for
	72	* the list itself assuming exactly 1 structural reference on each
	73	* list member. */
	74	static ENGINE *engine_list_head = NULL;
	75	static ENGINE *engine_list_tail = NULL;
b6d1e52d GT	76
	77	/* This cleanup function is only needed internally. If it should be called, we
	78	* register it with the "ENGINE_cleanup()" stack to be called during cleanup. */
	79
	80	static void engine_list_cleanup(void)
	81	{
	82	ENGINE *iterator = engine_list_head;
	83
	84	while(iterator != NULL)
	85	{
	86	ENGINE_remove(iterator);
	87	iterator = engine_list_head;
	88	}
	89	return;
	90	}
5270e702 RL	91
	92	/* These static functions starting with a lower case "engine_" always
	93	* take place when CRYPTO_LOCK_ENGINE has been locked up. */
	94	static int engine_list_add(ENGINE *e)
	95	{
	96	int conflict = 0;
	97	ENGINE *iterator = NULL;
	98
	99	if(e == NULL)
	100	{
	101	ENGINEerr(ENGINE_F_ENGINE_LIST_ADD,
	102	ERR_R_PASSED_NULL_PARAMETER);
	103	return 0;
	104	}
	105	iterator = engine_list_head;
	106	while(iterator && !conflict)
	107	{
	108	conflict = (strcmp(iterator->id, e->id) == 0);
	109	iterator = iterator->next;
	110	}
	111	if(conflict)
	112	{
	113	ENGINEerr(ENGINE_F_ENGINE_LIST_ADD,
	114	ENGINE_R_CONFLICTING_ENGINE_ID);
	115	return 0;
	116	}
	117	if(engine_list_head == NULL)
	118	{
	119	/* We are adding to an empty list. */
	120	if(engine_list_tail)
	121	{
	122	ENGINEerr(ENGINE_F_ENGINE_LIST_ADD,
	123	ENGINE_R_INTERNAL_LIST_ERROR);
	124	return 0;
	125	}
	126	engine_list_head = e;
	127	e->prev = NULL;
b6d1e52d GT	128	/* The first time the list allocates, we should register the
	129	* cleanup. */
	130	engine_cleanup_add_last(engine_list_cleanup);
5270e702 RL	131	}
	132	else
	133	{
	134	/* We are adding to the tail of an existing list. */
	135	if((engine_list_tail == NULL) \|\|
	136	(engine_list_tail->next != NULL))
	137	{
	138	ENGINEerr(ENGINE_F_ENGINE_LIST_ADD,
	139	ENGINE_R_INTERNAL_LIST_ERROR);
	140	return 0;
	141	}
	142	engine_list_tail->next = e;
	143	e->prev = engine_list_tail;
	144	}
	145	/* Having the engine in the list assumes a structural
	146	* reference. */
	147	e->struct_ref++;
b41f836e	148	engine_ref_debug(e, 0, 1)
5270e702 RL	149	/* However it came to be, e is the last item in the list. */
	150	engine_list_tail = e;
	151	e->next = NULL;
	152	return 1;
	153	}
	154
	155	static int engine_list_remove(ENGINE *e)
	156	{
	157	ENGINE *iterator;
	158
	159	if(e == NULL)
	160	{
	161	ENGINEerr(ENGINE_F_ENGINE_LIST_REMOVE,
	162	ERR_R_PASSED_NULL_PARAMETER);
	163	return 0;
	164	}
	165	/* We need to check that e is in our linked list! */
	166	iterator = engine_list_head;
	167	while(iterator && (iterator != e))
	168	iterator = iterator->next;
	169	if(iterator == NULL)
	170	{
	171	ENGINEerr(ENGINE_F_ENGINE_LIST_REMOVE,
	172	ENGINE_R_ENGINE_IS_NOT_IN_LIST);
	173	return 0;
	174	}
	175	/* un-link e from the chain. */
	176	if(e->next)
	177	e->next->prev = e->prev;
	178	if(e->prev)
	179	e->prev->next = e->next;
	180	/* Correct our head/tail if necessary. */
	181	if(engine_list_head == e)
	182	engine_list_head = e->next;
	183	if(engine_list_tail == e)
	184	engine_list_tail = e->prev;
b6d1e52d	185	engine_free_util(e, 0);
5270e702 RL	186	return 1;
	187	}
	188
	189	/* Get the first/last "ENGINE" type available. */
	190	ENGINE *ENGINE_get_first(void)
	191	{
b6d1e52d	192	ENGINE *ret;
5270e702 RL	193
5270e702 RL	194	CRYPTO_r_lock(CRYPTO_LOCK_ENGINE);
b6d1e52d GT	195	ret = engine_list_head;
b6d1e52d GT	196	if(ret)
5270e702	197	{
b6d1e52d GT	198	ret->struct_ref++;
b6d1e52d GT	199	engine_ref_debug(ret, 0, 1)
5270e702 RL	200	}
	201	CRYPTO_r_unlock(CRYPTO_LOCK_ENGINE);
	202	return ret;
	203	}
b6d1e52d	204
5270e702 RL	205	ENGINE *ENGINE_get_last(void)
5270e702 RL	206	{
b6d1e52d	207	ENGINE *ret;
5270e702 RL	208
5270e702 RL	209	CRYPTO_r_lock(CRYPTO_LOCK_ENGINE);
5270e702	210	ret = engine_list_tail;
b6d1e52d GT	211	if(ret)
	212	{
	213	ret->struct_ref++;
	214	engine_ref_debug(ret, 0, 1)
5270e702 RL	215	}
	216	CRYPTO_r_unlock(CRYPTO_LOCK_ENGINE);
	217	return ret;
	218	}
	219
	220	/* Iterate to the next/previous "ENGINE" type (NULL = end of the list). */
	221	ENGINE ENGINE_get_next(ENGINE e)
	222	{
	223	ENGINE *ret = NULL;
	224	if(e == NULL)
	225	{
	226	ENGINEerr(ENGINE_F_ENGINE_GET_NEXT,
	227	ERR_R_PASSED_NULL_PARAMETER);
	228	return 0;
	229	}
	230	CRYPTO_r_lock(CRYPTO_LOCK_ENGINE);
	231	ret = e->next;
5270e702	232	if(ret)
b41f836e	233	{
ea3a429e	234	/* Return a valid structural refernce to the next ENGINE */
5270e702	235	ret->struct_ref++;
b41f836e GT	236	engine_ref_debug(ret, 0, 1)
b41f836e GT	237	}
5270e702	238	CRYPTO_r_unlock(CRYPTO_LOCK_ENGINE);
ea3a429e GT	239	/* Release the structural reference to the previous ENGINE */
ea3a429e GT	240	ENGINE_free(e);
5270e702 RL	241	return ret;
5270e702 RL	242	}
b6d1e52d	243
5270e702 RL	244	ENGINE ENGINE_get_prev(ENGINE e)
	245	{
	246	ENGINE *ret = NULL;
	247	if(e == NULL)
	248	{
	249	ENGINEerr(ENGINE_F_ENGINE_GET_PREV,
	250	ERR_R_PASSED_NULL_PARAMETER);
	251	return 0;
	252	}
	253	CRYPTO_r_lock(CRYPTO_LOCK_ENGINE);
	254	ret = e->prev;
5270e702	255	if(ret)
b41f836e	256	{
ea3a429e	257	/* Return a valid structural reference to the next ENGINE */
5270e702	258	ret->struct_ref++;
b41f836e GT	259	engine_ref_debug(ret, 0, 1)
b41f836e GT	260	}
5270e702	261	CRYPTO_r_unlock(CRYPTO_LOCK_ENGINE);
ea3a429e GT	262	/* Release the structural reference to the previous ENGINE */
ea3a429e GT	263	ENGINE_free(e);
5270e702 RL	264	return ret;
	265	}
	266
	267	/* Add another "ENGINE" type into the list. */
	268	int ENGINE_add(ENGINE *e)
	269	{
	270	int to_return = 1;
	271	if(e == NULL)
	272	{
	273	ENGINEerr(ENGINE_F_ENGINE_ADD,
	274	ERR_R_PASSED_NULL_PARAMETER);
	275	return 0;
	276	}
	277	if((e->id == NULL) \|\| (e->name == NULL))
	278	{
	279	ENGINEerr(ENGINE_F_ENGINE_ADD,
	280	ENGINE_R_ID_OR_NAME_MISSING);
	281	}
	282	CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
b6d1e52d	283	if(!engine_list_add(e))
5270e702 RL	284	{
	285	ENGINEerr(ENGINE_F_ENGINE_ADD,
	286	ENGINE_R_INTERNAL_LIST_ERROR);
	287	to_return = 0;
	288	}
	289	CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
	290	return to_return;
	291	}
	292
	293	/* Remove an existing "ENGINE" type from the array. */
	294	int ENGINE_remove(ENGINE *e)
	295	{
	296	int to_return = 1;
	297	if(e == NULL)
	298	{
	299	ENGINEerr(ENGINE_F_ENGINE_REMOVE,
	300	ERR_R_PASSED_NULL_PARAMETER);
	301	return 0;
	302	}
	303	CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
b6d1e52d	304	if(!engine_list_remove(e))
5270e702 RL	305	{
	306	ENGINEerr(ENGINE_F_ENGINE_REMOVE,
	307	ENGINE_R_INTERNAL_LIST_ERROR);
	308	to_return = 0;
	309	}
	310	CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
	311	return to_return;
	312	}
	313
b6d1e52d GT	314	static void engine_cpy(ENGINE dest, const ENGINE src)
	315	{
	316	dest->id = src->id;
	317	dest->name = src->name;
	318	#ifndef OPENSSL_NO_RSA
	319	dest->rsa_meth = src->rsa_meth;
	320	#endif
	321	#ifndef OPENSSL_NO_DSA
	322	dest->dsa_meth = src->dsa_meth;
	323	#endif
	324	#ifndef OPENSSL_NO_DH
	325	dest->dh_meth = src->dh_meth;
4d94ae00 BM	326	#endif
	327	#ifndef OPENSSL_NO_ECDSA
	328	dest->ecdsa_meth = src->ecdsa_meth;
b6d1e52d GT	329	#endif
b6d1e52d GT	330	dest->rand_meth = src->rand_meth;
b370230b GT	331	dest->ciphers = src->ciphers;
b370230b GT	332	dest->digests = src->digests;
b6d1e52d GT	333	dest->destroy = src->destroy;
	334	dest->init = src->init;
	335	dest->finish = src->finish;
	336	dest->ctrl = src->ctrl;
	337	dest->load_privkey = src->load_privkey;
	338	dest->load_pubkey = src->load_pubkey;
	339	dest->cmd_defns = src->cmd_defns;
	340	dest->flags = src->flags;
	341	}
	342
5270e702 RL	343	ENGINE ENGINE_by_id(const char id)
5270e702 RL	344	{
b6d1e52d	345	ENGINE *iterator;
5270e702 RL	346	if(id == NULL)
	347	{
	348	ENGINEerr(ENGINE_F_ENGINE_BY_ID,
	349	ERR_R_PASSED_NULL_PARAMETER);
	350	return NULL;
	351	}
	352	CRYPTO_r_lock(CRYPTO_LOCK_ENGINE);
b6d1e52d GT	353	iterator = engine_list_head;
	354	while(iterator && (strcmp(id, iterator->id) != 0))
	355	iterator = iterator->next;
	356	if(iterator)
5270e702	357	{
b6d1e52d GT	358	/* We need to return a structural reference. If this is an
	359	* ENGINE type that returns copies, make a duplicate - otherwise
	360	* increment the existing ENGINE's reference count. */
	361	if(iterator->flags & ENGINE_FLAGS_BY_ID_COPY)
0ce5f3e4	362	{
b6d1e52d GT	363	ENGINE *cp = ENGINE_new();
	364	if(!cp)
	365	iterator = NULL;
0ce5f3e4	366	else
b41f836e	367	{
b6d1e52d GT	368	engine_cpy(cp, iterator);
b6d1e52d GT	369	iterator = cp;
b41f836e	370	}
0ce5f3e4	371	}
b6d1e52d GT	372	else
	373	{
	374	iterator->struct_ref++;
	375	engine_ref_debug(iterator, 0, 1)
	376	}
5270e702 RL	377	}
	378	CRYPTO_r_unlock(CRYPTO_LOCK_ENGINE);
	379	if(iterator == NULL)
c9501c22	380	{
5270e702 RL	381	ENGINEerr(ENGINE_F_ENGINE_BY_ID,
5270e702 RL	382	ENGINE_R_NO_SUCH_ENGINE);
c9501c22 DSH	383	ERR_add_error_data(2, "id=", id);
c9501c22 DSH	384	}
5270e702 RL	385	return iterator;
5270e702 RL	386	}