OpenSSL 0.9.5 merge

*warning* this bumps shared lib minors for libssl and libcrypto from 2.1 to 2.2
if you are using the ssl26 packages for ssh and other things to work you will
need to get new ones (see ~beck/libsslsnap/<arch>) on cvs or ~beck/src-patent.tar.gz on cvs

1 files changed, 80 insertions, 42 deletions

diff --git a/src/lib/libcrypto/threads/mttest.c b/src/lib/libcrypto/threads/mttest.c
index 142623edda..24713a3157 100644
--- a/src/lib/libcrypto/threads/mttest.c
+++ b/src/lib/libcrypto/threads/mttest.c
@@ -74,26 +74,29 @@
 #include <ulocks.h>
 #include <sys/prctl.h>
 #endif
+#ifdef PTHREADS
+#include <pthread.h>
+#endif
 #include <openssl/lhash.h>
 #include <openssl/crypto.h>
 #include <openssl/buffer.h>
-#include "../e_os.h"
+#include "../../e_os.h"
 #include <openssl/x509.h>
 #include <openssl/ssl.h>
 #include <openssl/err.h>
+#include <openssl/rand.h>
 
 #ifdef NO_FP_API
 #define APPS_WIN16
-#include "../crypto/buffer/bss_file.c"
+#include "../buffer/bss_file.c"
 #endif
 
-#define TEST_SERVER_CERT "../apps/server.pem"
-#define TEST_CLIENT_CERT "../apps/client.pem"
+#define TEST_SERVER_CERT "../../apps/server.pem"
+#define TEST_CLIENT_CERT "../../apps/client.pem"
 
 #define MAX_THREAD_NUMBER       100
 
-int MS_CALLBACK verify_callback(int ok, X509 *xs, X509 *xi, int depth,
-        int error,char *arg);
+int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *xs);
 void thread_setup(void);
 void thread_cleanup(void);
 void do_threads(SSL_CTX *s_ctx,SSL_CTX *c_ctx);
@@ -121,6 +124,8 @@ int number_of_loops=10;
 int reconnect=0;
 int cache_stats=0;
 
+static const char rnd_seed[] = "string to make the random number generator think it has entropy";
+
 int doit(char *ctx[4]);
 static void print_stats(FILE *fp, SSL_CTX *ctx)
 {
@@ -170,6 +175,8 @@ int main(int argc, char *argv[])
         char *ccert=TEST_CLIENT_CERT;
         SSL_METHOD *ssl_method=SSLv23_method();
 
+        RAND_seed(rnd_seed, sizeof rnd_seed);
+
         if (bio_err == NULL)
                 bio_err=BIO_new_fp(stderr,BIO_NOCLOSE);
         if (bio_stdout == NULL)
@@ -244,7 +251,7 @@ bad:
         if (cipher == NULL) cipher=getenv("SSL_CIPHER");
 
         SSL_load_error_strings();
-        SSLeay_add_ssl_algorithms();
+        OpenSSL_add_ssl_algorithms();
 
         c_ctx=SSL_CTX_new(ssl_method);
         s_ctx=SSL_CTX_new(ssl_method);
@@ -259,8 +266,15 @@ bad:
         SSL_CTX_set_session_cache_mode(c_ctx,
                 SSL_SESS_CACHE_NO_AUTO_CLEAR|SSL_SESS_CACHE_SERVER);
 
-        SSL_CTX_use_certificate_file(s_ctx,scert,SSL_FILETYPE_PEM);
-        SSL_CTX_use_RSAPrivateKey_file(s_ctx,scert,SSL_FILETYPE_PEM);
+        if (!SSL_CTX_use_certificate_file(s_ctx,scert,SSL_FILETYPE_PEM))
+                {
+                ERR_print_errors(bio_err);
+                }
+        else if (!SSL_CTX_use_RSAPrivateKey_file(s_ctx,scert,SSL_FILETYPE_PEM))
+                {
+                ERR_print_errors(bio_err);
+                goto end;
+                }
 
         if (client_auth)
                 {
@@ -489,6 +503,7 @@ int doit(char *ctx[4])
                                         else
                                                 {
                                                 fprintf(stderr,"ERROR in CLIENT\n");
+                                                ERR_print_errors_fp(stderr);
                                                 return(1);
                                                 }
                                         }
@@ -520,6 +535,7 @@ int doit(char *ctx[4])
                                         else
                                                 {
                                                 fprintf(stderr,"ERROR in CLIENT\n");
+                                                ERR_print_errors_fp(stderr);
                                                 return(1);
                                                 }
                                         }
@@ -652,18 +668,23 @@ err:
         return(0);
         }
 
-int MS_CALLBACK verify_callback(int ok, X509 *xs, X509 *xi, int depth,
-             int error, char *arg)
+int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx)
         {
-        char buf[256];
+        char *s, buf[256];
 
         if (verbose)
                 {
-                X509_NAME_oneline(X509_get_subject_name(xs),buf,256);
-                if (ok)
-                        fprintf(stderr,"depth=%d %s\n",depth,buf);
-                else
-                        fprintf(stderr,"depth=%d error=%d %s\n",depth,error,buf);
+                s=X509_NAME_oneline(X509_get_subject_name(ctx->current_cert),
+                                    buf,256);
+                if (s != NULL)
+                        {
+                        if (ok)
+                                fprintf(stderr,"depth=%d %s\n",
+                                        ctx->error_depth,buf);
+                        else
+                                fprintf(stderr,"depth=%d error=%d %s\n",
+                                        ctx->error_depth,ctx->error,buf);
+                        }
                 }
         return(ok);
         }
@@ -672,13 +693,14 @@ int MS_CALLBACK verify_callback(int ok, X509 *xs, X509 *xi, int depth,
 
 #ifdef WIN32
 
-static HANDLE lock_cs[CRYPTO_NUM_LOCKS];
+static HANDLE *lock_cs;
 
 void thread_setup(void)
         {
         int i;
 
-        for (i=0; i<CRYPTO_NUM_LOCKS; i++)
+        lock_cs=Malloc(CRYPTO_num_locks() * sizeof(HANDLE));
+        for (i=0; i<CRYPTO_num_locks(); i++)
                 {
                 lock_cs[i]=CreateMutex(NULL,FALSE,NULL);
                 }
@@ -692,8 +714,9 @@ void thread_cleanup(void)
         int i;
 
         CRYPTO_set_locking_callback(NULL);
-        for (i=0; i<CRYPTO_NUM_LOCKS; i++)
+        for (i=0; i<CRYPTO_num_locks(); i++)
                 CloseHandle(lock_cs[i]);
+        Free(lock_cs);
         }
 
 void win32_locking_callback(int mode, int type, char *file, int line)
@@ -763,15 +786,17 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
 
 #ifdef SOLARIS
 
-static mutex_t lock_cs[CRYPTO_NUM_LOCKS];
-/*static rwlock_t lock_cs[CRYPTO_NUM_LOCKS]; */
-static long lock_count[CRYPTO_NUM_LOCKS];
+static mutex_t *lock_cs;
+/*static rwlock_t *lock_cs; */
+static long *lock_count;
 
 void thread_setup(void)
         {
         int i;
 
-        for (i=0; i<CRYPTO_NUM_LOCKS; i++)
+        lock_cs=Malloc(CRYPTO_num_locks() * sizeof(mutex_t));
+        lock_count=Malloc(CRYPTO_num_locks() * sizeof(long));
+        for (i=0; i<CRYPTO_num_locks(); i++)
                 {
                 lock_count[i]=0;
                 /* rwlock_init(&(lock_cs[i]),USYNC_THREAD,NULL); */
@@ -787,31 +812,37 @@ void thread_cleanup(void)
         int i;
 
         CRYPTO_set_locking_callback(NULL);
-fprintf(stderr,"cleanup\n");
-        for (i=0; i<CRYPTO_NUM_LOCKS; i++)
+
+        fprintf(stderr,"cleanup\n");
+
+        for (i=0; i<CRYPTO_num_locks(); i++)
                 {
                 /* rwlock_destroy(&(lock_cs[i])); */
                 mutex_destroy(&(lock_cs[i]));
                 fprintf(stderr,"%8ld:%s\n",lock_count[i],CRYPTO_get_lock_name(i));
                 }
-fprintf(stderr,"done cleanup\n");
+        Free(lock_cs);
+        Free(lock_count);
+
+        fprintf(stderr,"done cleanup\n");
+
         }
 
 void solaris_locking_callback(int mode, int type, char *file, int line)
         {
 #ifdef undef
-fprintf(stderr,"thread=%4d mode=%s lock=%s %s:%d\n",
-        CRYPTO_thread_id(),
-        (mode&CRYPTO_LOCK)?"l":"u",
-        (type&CRYPTO_READ)?"r":"w",file,line);
+        fprintf(stderr,"thread=%4d mode=%s lock=%s %s:%d\n",
+                CRYPTO_thread_id(),
+                (mode&CRYPTO_LOCK)?"l":"u",
+                (type&CRYPTO_READ)?"r":"w",file,line);
 #endif
 
-/*
-if (CRYPTO_LOCK_SSL_CERT == type)
+        /*
+        if (CRYPTO_LOCK_SSL_CERT == type)
         fprintf(stderr,"(t,m,f,l) %ld %d %s %d\n",
                 CRYPTO_thread_id(),
                 mode,file,line);
-*/
+        */
         if (mode & CRYPTO_LOCK)
                 {
         /*      if (mode & CRYPTO_READ)
@@ -871,7 +902,7 @@ unsigned long solaris_thread_id(void)
 
 
 static usptr_t *arena;
-static usema_t *lock_cs[CRYPTO_NUM_LOCKS];
+static usema_t **lock_cs;
 
 void thread_setup(void)
         {
@@ -888,7 +919,8 @@ void thread_setup(void)
         arena=usinit(filename);
         unlink(filename);
 
-        for (i=0; i<CRYPTO_NUM_LOCKS; i++)
+        lock_cs=Malloc(CRYPTO_num_locks() * sizeof(usema_t *));
+        for (i=0; i<CRYPTO_num_locks(); i++)
                 {
                 lock_cs[i]=usnewsema(arena,1);
                 }
@@ -902,7 +934,7 @@ void thread_cleanup(void)
         int i;
 
         CRYPTO_set_locking_callback(NULL);
-        for (i=0; i<CRYPTO_NUM_LOCKS; i++)
+        for (i=0; i<CRYPTO_num_locks(); i++)
                 {
                 char buf[10];
 
@@ -910,6 +942,7 @@ void thread_cleanup(void)
                 usdumpsema(lock_cs[i],stdout,buf);
                 usfreesema(lock_cs[i],arena);
                 }
+        Free(lock_cs);
         }
 
 void irix_locking_callback(int mode, int type, char *file, int line)
@@ -962,14 +995,16 @@ unsigned long irix_thread_id(void)
 
 #ifdef PTHREADS
 
-static pthread_mutex_t lock_cs[CRYPTO_NUM_LOCKS];
-static long lock_count[CRYPTO_NUM_LOCKS];
+static pthread_mutex_t *lock_cs;
+static long *lock_count;
 
 void thread_setup(void)
         {
         int i;
 
-        for (i=0; i<CRYPTO_NUM_LOCKS; i++)
+        lock_cs=Malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
+        lock_count=Malloc(CRYPTO_num_locks() * sizeof(long));
+        for (i=0; i<CRYPTO_num_locks(); i++)
                 {
                 lock_count[i]=0;
                 pthread_mutex_init(&(lock_cs[i]),NULL);
@@ -985,12 +1020,15 @@ void thread_cleanup(void)
 
         CRYPTO_set_locking_callback(NULL);
         fprintf(stderr,"cleanup\n");
-        for (i=0; i<CRYPTO_NUM_LOCKS; i++)
+        for (i=0; i<CRYPTO_num_locks(); i++)
                 {
                 pthread_mutex_destroy(&(lock_cs[i]));
                 fprintf(stderr,"%8ld:%s\n",lock_count[i],
                         CRYPTO_get_lock_name(i));
                 }
+        Free(lock_cs);
+        Free(lock_count);
+
         fprintf(stderr,"done cleanup\n");
         }
 
@@ -1045,7 +1083,7 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
                 }
 
         printf("pthreads threads done (%d,%d)\n",
-        s_ctx->references,c_ctx->references);
+                s_ctx->references,c_ctx->references);
         }
 
 unsigned long pthreads_thread_id(void)