Give DH, DSA, and RSA functions to "up" their reference counts. Otherwise,
authorGeoff Thorpe <geoff@openssl.org>
Sat, 25 Aug 2001 17:24:21 +0000 (17:24 +0000)
committerGeoff Thorpe <geoff@openssl.org>
Sat, 25 Aug 2001 17:24:21 +0000 (17:24 +0000)
dependant code has to directly increment the "references" value of each
such structure using the corresponding lock. Apart from code duplication,
this provided no "REF_CHECK/REF_PRINT" checking and violated
encapsulation.

crypto/dh/dh.h
crypto/dh/dh_lib.c
crypto/dsa/dsa.h
crypto/dsa/dsa_lib.c
crypto/rsa/rsa.h
crypto/rsa/rsa_lib.c

index 2b9a059..b6601c6 100644 (file)
@@ -166,6 +166,7 @@ DH *DH_new_method(struct engine_st *engine);
 
 DH *   DH_new(void);
 void   DH_free(DH *dh);
+int    DH_up(DH *dh);
 int    DH_size(const DH *dh);
 int DH_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
             CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
index 7a6e620..f96b454 100644 (file)
@@ -219,6 +219,22 @@ void DH_free(DH *r)
        OPENSSL_free(r);
        }
 
+int DH_up(DH *r)
+       {
+       int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_DH);
+#ifdef REF_PRINT
+       REF_PRINT("DH",r);
+#endif
+#ifdef REF_CHECK
+       if (i < 2)
+               {
+               fprintf(stderr, "DH_up, bad reference count\n");
+               abort();
+               }
+#endif
+       return ((i > 1) ? 1 : 0);
+       }
+
 int DH_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
             CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
         {
index 58cf7b5..7fc8fd3 100644 (file)
@@ -177,6 +177,9 @@ DSA *       DSA_new_method(DSA_METHOD *meth);
 #else
 DSA *  DSA_new_method(struct engine_st *engine);
 #endif
+void   DSA_free (DSA *r);
+/* "up" the DSA object's reference count */
+int    DSA_up(DSA *r);
 int    DSA_size(const DSA *);
        /* next 4 return -1 on error */
 int    DSA_sign_setup( DSA *dsa,BN_CTX *ctx_in,BIGNUM **kinvp,BIGNUM **rp);
@@ -184,7 +187,6 @@ int DSA_sign(int type,const unsigned char *dgst,int dlen,
                unsigned char *sig, unsigned int *siglen, DSA *dsa);
 int    DSA_verify(int type,const unsigned char *dgst,int dgst_len,
                const unsigned char *sigbuf, int siglen, DSA *dsa);
-void   DSA_free (DSA *r);
 int DSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
             CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
 int DSA_set_ex_data(DSA *d, int idx, void *arg);
index 5855568..98878df 100644 (file)
@@ -228,6 +228,22 @@ void DSA_free(DSA *r)
        OPENSSL_free(r);
        }
 
+int DSA_up(DSA *r)
+       {
+       int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_DSA);
+#ifdef REF_PRINT
+       REF_PRINT("DSA",r);
+#endif
+#ifdef REF_CHECK
+       if (i < 2)
+               {
+               fprintf(stderr, "DSA_up, bad reference count\n");
+               abort();
+               }
+#endif
+       return ((i > 1) ? 1 : 0);
+       }
+
 int DSA_size(const DSA *r)
        {
        int ret,i;
index 488f679..9116a6e 100644 (file)
@@ -199,6 +199,8 @@ int RSA_public_decrypt(int flen, const unsigned char *from,
 int    RSA_private_decrypt(int flen, const unsigned char *from, 
                unsigned char *to, RSA *rsa,int padding);
 void   RSA_free (RSA *r);
+/* "up" the RSA object's reference count */
+int    RSA_up(RSA *r);
 
 int    RSA_flags(const RSA *r);
 
index 4fd9198..3accf01 100644 (file)
@@ -248,6 +248,22 @@ void RSA_free(RSA *r)
        OPENSSL_free(r);
        }
 
+int RSA_up(RSA *r)
+       {
+       int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_RSA);
+#ifdef REF_PRINT
+       REF_PRINT("RSA",r);
+#endif
+#ifdef REF_CHECK
+       if (i < 2)
+               {
+               fprintf(stderr, "RSA_up, bad reference count\n");
+               abort();
+               }
+#endif
+       return ((i > 1) ? 1 : 0);
+       }
+
 int RSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
             CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
         {