The callbacks in the NAME_FUNCS structure are not used directly as LHASH

[openssl.git] / crypto / ex_data.c

diff --git a/crypto/ex_data.c b/crypto/ex_data.c
index c858b518ffaed0ece67ed736fe4e8ed4fce78c7d..ff32ad5be6b35ed724b4ada6bff2c9e8b555d883 100644 (file)
--- a/crypto/ex_data.c
+++ b/crypto/ex_data.c
@@ -1,4 +1,19 @@
 /* crypto/ex_data.c */
 /* 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.
  *
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *


@@ -58,57 +73,53 @@
 
 #include <stdio.h>
 #include <stdlib.h>
 
 #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"
 
 #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;
 
        CRYPTO_EX_DATA_FUNCS *a;
 

+       MemCheck_off();

        if (*skp == NULL)
        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);
        if (*skp == NULL)
                {
                CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);

-               return(-1);
+               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);
        if (a == NULL)
                {
                CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);

-               return(-1);
+               goto err;

                }
        a->argl=argl;
        a->argp=argp;
        a->new_func=new_func;
        a->dup_func=dup_func;
        a->free_func=free_func;
                }
        a->argl=argl;
        a->argp=argp;
        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);
                        {
                        CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);

-                       Free(a);
-                       return(-1);
+                       OPENSSL_free(a);
+                       goto err;

                        }
                }
                        }
                }

-       sk_value(*skp,idx)=(char *)a;
-       return(idx);
+       sk_CRYPTO_EX_DATA_FUNCS_set(*skp,idx, a);
+       ret=idx;
+err:
+       MemCheck_on();
+       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;
 
        {
        int i;
 


@@ -131,13 +142,11 @@ char *val;
                        }
                i++;
                }
                        }
                i++;
                }

-       sk_value(ad->sk,idx)=val;
+       sk_set(ad->sk,idx,val);

        return(1);
        }
 
        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);
        {
        if (ad->sk == NULL)
                return(0);


@@ -147,13 +156,12 @@ int idx;
                return(sk_value(ad->sk,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
  */
  * 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;
        {
        int i,j,m,r;
        CRYPTO_EX_DATA_FUNCS *mm;


@@ -161,14 +169,14 @@ CRYPTO_EX_DATA *to,*from;
 
        if (meth == NULL) return(1);
        if (from->sk == NULL) return(1);
 
        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)
                        {
        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);
                        if (mm->dup_func != NULL)
                                r=mm->dup_func(to,from,(char **)&from_d,i,
                                        mm->argl,mm->argp);


@@ -179,21 +187,18 @@ CRYPTO_EX_DATA *to,*from;
        }
 
 /* Call each free callback */
        }
 
 /* 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;
        {
        CRYPTO_EX_DATA_FUNCS *m;

-       char *ptr;
+       void *ptr;

        int i,max;
 
        if (meth != NULL)
                {
        int i,max;
 
        if (meth != NULL)
                {

-               max=sk_num(meth);
+               max=sk_CRYPTO_EX_DATA_FUNCS_num(meth);

                for (i=0; i<max; i++)
                        {
                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);
                        if ((m != NULL) && (m->free_func != NULL))
                                {
                                ptr=CRYPTO_get_ex_data(ad,i);


@@ -208,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;
        {
        CRYPTO_EX_DATA_FUNCS *m;

-       char *ptr;
+       void *ptr;

        int i,max;
 
        ad->sk=NULL;
        if (meth != NULL)
                {
        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++)
                        {
                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);
                        if ((m != NULL) && (m->new_func != NULL))
                                {
                                ptr=CRYPTO_get_ex_data(ad,i);


@@ -233,4 +235,4 @@ CRYPTO_EX_DATA *ad;
                }
        }
 
                }
        }
 

-
+IMPLEMENT_STACK_OF(CRYPTO_EX_DATA_FUNCS)