X-Git-Url: https://git.openssl.org/?p=openssl.git;a=blobdiff_plain;f=crypto%2Fex_data.c;h=ff32ad5be6b35ed724b4ada6bff2c9e8b555d883;hp=42b8b9d1baeabc99b58b52f9932807027740c07e;hb=4dc719fc37cb2201c8e211c6a684d71477c20f50;hpb=dfeab0689f69c0b4bd3480ffd37a9cacc2f17d9c

diff --git a/crypto/ex_data.c b/crypto/ex_data.c
index 42b8b9d1ba..ff32ad5be6 100644
--- a/crypto/ex_data.c
+++ b/crypto/ex_data.c
@@ -1,4 +1,19 @@
 /* crypto/ex_data.c */
+
+/*
+ * This is not thread-safe, nor can it be changed to become thread-safe
+ * without changing various function prototypes and using a lot of locking.
+ * Luckily, it's not really used anywhere except in ssl_verify_cert_chain
+ * via SSL_get_ex_data_X509_STORE_CTX_idx (ssl/ssl_cert.c),
+ * where new_func, dup_func, and free_func all are 0, and in
+ * hwcrhk_init (crypto/engine/hw_ncipher.c), which is hopefully only
+ * ever used during program initialization.
+ *
+ * Any multi-threaded application crazy enough to use ex_data for its own
+ * purposes had better make sure that SSL_get_ex_data_X509_STORE_CTX_idx
+ * is called once before multiple threads are created.
+ */
+
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -58,32 +73,26 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "buffer.h"
-#include "bio.h"
-#include "lhash.h"
+#include <openssl/buffer.h>
+#include <openssl/bio.h>
+#include <openssl/lhash.h>
 #include "cryptlib.h"
 
-int CRYPTO_get_ex_new_index(idx,skp,argl,argp,new_func,dup_func,free_func)
-int idx;
-STACK **skp;
-long argl;
-char *argp;
-int (*new_func)();
-int (*dup_func)();
-void (*free_func)();
+int CRYPTO_get_ex_new_index(int idx, STACK_OF(CRYPTO_EX_DATA_FUNCS) **skp, long argl, void *argp,
+	     CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
 	{
 	int ret= -1;
 	CRYPTO_EX_DATA_FUNCS *a;
 
 	MemCheck_off();
 	if (*skp == NULL)
-		*skp=sk_new_null();
+		*skp=sk_CRYPTO_EX_DATA_FUNCS_new_null();
 	if (*skp == NULL)
 		{
 		CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);
 		goto err;
 		}
-	a=(CRYPTO_EX_DATA_FUNCS *)Malloc(sizeof(CRYPTO_EX_DATA_FUNCS));
+	a=(CRYPTO_EX_DATA_FUNCS *)OPENSSL_malloc(sizeof(CRYPTO_EX_DATA_FUNCS));
 	if (a == NULL)
 		{
 		CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);
@@ -94,26 +103,23 @@ void (*free_func)();
 	a->new_func=new_func;
 	a->dup_func=dup_func;
 	a->free_func=free_func;
-	while (sk_num(*skp) <= idx)
+	while (sk_CRYPTO_EX_DATA_FUNCS_num(*skp) <= idx)
 		{
-		if (!sk_push(*skp,NULL))
+		if (!sk_CRYPTO_EX_DATA_FUNCS_push(*skp,NULL))
 			{
 			CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);
-			Free(a);
+			OPENSSL_free(a);
 			goto err;
 			}
 		}
-	sk_value(*skp,idx)=(char *)a;
+	sk_CRYPTO_EX_DATA_FUNCS_set(*skp,idx, a);
 	ret=idx;
 err:
 	MemCheck_on();
-	return(idx);
+	return(ret);
 	}
 
-int CRYPTO_set_ex_data(ad,idx,val)
-CRYPTO_EX_DATA *ad;
-int idx;
-char *val;
+int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val)
 	{
 	int i;
 
@@ -136,13 +142,11 @@ char *val;
 			}
 		i++;
 		}
-	sk_value(ad->sk,idx)=val;
+	sk_set(ad->sk,idx,val);
 	return(1);
 	}
 
-char *CRYPTO_get_ex_data(ad,idx)
-CRYPTO_EX_DATA *ad;
-int idx;
+void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx)
 	{
 	if (ad->sk == NULL)
 		return(0);
@@ -152,13 +156,12 @@ int idx;
 		return(sk_value(ad->sk,idx));
 	}
 
-/* The callback is called with the 'object', which is the origional data object
+/* The callback is called with the 'object', which is the original data object
  * being duplicated, a pointer to the
  * 'new' object to be inserted, the index, and the argi/argp
  */
-int CRYPTO_dup_ex_data(meth,to,from)
-STACK *meth;
-CRYPTO_EX_DATA *to,*from;
+int CRYPTO_dup_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, CRYPTO_EX_DATA *to,
+	     CRYPTO_EX_DATA *from)
 	{
 	int i,j,m,r;
 	CRYPTO_EX_DATA_FUNCS *mm;
@@ -166,14 +169,14 @@ CRYPTO_EX_DATA *to,*from;
 
 	if (meth == NULL) return(1);
 	if (from->sk == NULL) return(1);
-	m=sk_num(meth);
+	m=sk_CRYPTO_EX_DATA_FUNCS_num(meth);
 	j=sk_num(from->sk);
 	for (i=0; i<j; i++)
 		{
 		from_d=CRYPTO_get_ex_data(from,i);
 		if (i < m)
 			{
-			mm=(CRYPTO_EX_DATA_FUNCS *)sk_value(meth,i);
+			mm=sk_CRYPTO_EX_DATA_FUNCS_value(meth,i);
 			if (mm->dup_func != NULL)
 				r=mm->dup_func(to,from,(char **)&from_d,i,
 					mm->argl,mm->argp);
@@ -184,21 +187,18 @@ CRYPTO_EX_DATA *to,*from;
 	}
 
 /* Call each free callback */
-void CRYPTO_free_ex_data(meth,obj,ad)
-STACK *meth;
-char *obj;
-CRYPTO_EX_DATA *ad;
+void CRYPTO_free_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, void *obj, CRYPTO_EX_DATA *ad)
 	{
 	CRYPTO_EX_DATA_FUNCS *m;
-	char *ptr;
+	void *ptr;
 	int i,max;
 
 	if (meth != NULL)
 		{
-		max=sk_num(meth);
+		max=sk_CRYPTO_EX_DATA_FUNCS_num(meth);
 		for (i=0; i<max; i++)
 			{
-			m=(CRYPTO_EX_DATA_FUNCS *)sk_value(meth,i);
+			m=sk_CRYPTO_EX_DATA_FUNCS_value(meth,i);
 			if ((m != NULL) && (m->free_func != NULL))
 				{
 				ptr=CRYPTO_get_ex_data(ad,i);
@@ -213,22 +213,19 @@ CRYPTO_EX_DATA *ad;
 		}
 	}
 
-void CRYPTO_new_ex_data(meth,obj,ad)
-STACK *meth;
-char *obj;
-CRYPTO_EX_DATA *ad;
+void CRYPTO_new_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, void *obj, CRYPTO_EX_DATA *ad)
 	{
 	CRYPTO_EX_DATA_FUNCS *m;
-	char *ptr;
+	void *ptr;
 	int i,max;
 
 	ad->sk=NULL;
 	if (meth != NULL)
 		{
-		max=sk_num(meth);
+		max=sk_CRYPTO_EX_DATA_FUNCS_num(meth);
 		for (i=0; i<max; i++)
 			{
-			m=(CRYPTO_EX_DATA_FUNCS *)sk_value(meth,i);
+			m=sk_CRYPTO_EX_DATA_FUNCS_value(meth,i);
 			if ((m != NULL) && (m->new_func != NULL))
 				{
 				ptr=CRYPTO_get_ex_data(ad,i);
@@ -238,4 +235,4 @@ CRYPTO_EX_DATA *ad;
 		}
 	}
 
-
+IMPLEMENT_STACK_OF(CRYPTO_EX_DATA_FUNCS)