@ -56,7 +56,6 @@
* [ including the GNU Public Licence . ]
*/
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include <errno.h>
@ -86,17 +85,11 @@
# include <openssl/lhash.h>
# include <openssl/crypto.h>
# include <openssl/buffer.h>
# include "../../e_os.h"
# include <openssl/x509.h>
# include <openssl/ssl.h>
# include <openssl/err.h>
# include <openssl/rand.h>
# ifdef OPENSSL_NO_FP_API
# define APPS_WIN16
# include ".. / buffer / bss_file.c"
# endif
# ifdef OPENSSL_SYS_NETWARE
# define TEST_SERVER_CERT " / openssl / apps / server.pem"
# define TEST_CLIENT_CERT " / openssl / apps / client.pem"
@ -107,23 +100,23 @@
# define MAX_THREAD_NUMBER 100
int MS_CALLBACK verify_callback ( int ok , X509_STORE_CTX * xs ) ;
int 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 ) ;
void irix_locking_callback ( int mode , int type , char * file , int line ) ;
void solaris_locking_callback ( int mode , int type , char * file , int line ) ;
void win32_locking_callback ( int mode , int type , char * file , int line ) ;
void pthreads_locking_callback ( int mode , int type , char * file , int line ) ;
void netware_locking_callback ( int mode , int type , char * file , int line ) ;
void irix_locking_callback ( int mode , int type , const char * file , int line ) ;
void solaris_locking_callback ( int mode , int type , const char * file , int line ) ;
void win32_locking_callback ( int mode , int type , const char * file , int line ) ;
void pthreads_locking_callback ( int mode , int type , const char * file , int line ) ;
void netware_locking_callback ( int mode , int type , const char * file , int line ) ;
void beos_locking_callback ( int mode , int type , const char * file , int line ) ;
unsigned long irix_thread_id ( vo id) ;
unsigned long solaris_thread_id ( vo id) ;
unsigned long pthreads_thread_id ( vo id) ;
unsigned long netware_thread_id ( vo id) ;
unsigned long beos_thread_id ( vo id) ;
void irix_thread_id ( CRYPTO_THREADID * t id) ;
void solaris_thread_id ( CRYPTO_THREADID * t id) ;
void pthreads_thread_id ( CRYPTO_THREADID * t id) ;
void netware_thread_id ( CRYPTO_THREADID * t id) ;
void beos_thread_id ( CRYPTO_THREADID * t id) ;
# if defined(OPENSSL_SYS_NETWARE)
static MPKMutex * lock_cs ;
@ -149,39 +142,39 @@ 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 )
static void print_stats ( BIO * bio , SSL_CTX * ctx )
{
fprintf ( fp , " %4ld items in the session cache \n " ,
SSL_CTX_sess_number ( ctx ) ) ;
fprintf ( fp , " %4d client connects (SSL_connect()) \n " ,
SSL_CTX_sess_connect ( ctx ) ) ;
fprintf ( fp , " %4d client connects that finished \n " ,
SSL_CTX_sess_connect_good ( ctx ) ) ;
fprintf ( fp , " %4d server connects (SSL_accept()) \n " ,
SSL_CTX_sess_accept ( ctx ) ) ;
fprintf ( fp , " %4d server connects that finished \n " ,
SSL_CTX_sess_accept_good ( ctx ) ) ;
fprintf ( fp , " %4d session cache hits \n " , SSL_CTX_sess_hits ( ctx ) ) ;
fprintf ( fp , " %4d session cache misses \n " , SSL_CTX_sess_misses ( ctx ) ) ;
fprintf ( fp , " %4d session cache timeouts \n " , SSL_CTX_sess_timeouts ( ctx ) ) ;
BIO_printf ( bio , " %4ld items in the session cache \n " ,
SSL_CTX_sess_number ( ctx ) ) ;
BIO_printf ( bio , " %4d client connects (SSL_connect()) \n " ,
SSL_CTX_sess_connect ( ctx ) ) ;
BIO_printf ( bio , " %4d client connects that finished \n " ,
SSL_CTX_sess_connect_good ( ctx ) ) ;
BIO_printf ( bio , " %4d server connects (SSL_accept()) \n " ,
SSL_CTX_sess_accept ( ctx ) ) ;
BIO_printf ( bio , " %4d server connects that finished \n " ,
SSL_CTX_sess_accept_good ( ctx ) ) ;
BIO_printf ( bio , " %4d session cache hits \n " , SSL_CTX_sess_hits ( ctx ) ) ;
BIO_printf ( bio , " %4d session cache misses \n " , SSL_CTX_sess_misses ( ctx ) ) ;
BIO_printf ( bio , " %4d session cache timeouts \n " , SSL_CTX_sess_timeouts ( ctx ) ) ;
}
static void sv_usage ( void )
{
fprintf ( std err, " usage: ssltest [args ...] \n " ) ;
fprintf ( std err, " \n " ) ;
fprintf ( std err, " -server_auth - check server certificate \n " ) ;
fprintf ( std err, " -client_auth - do client authentication \n " ) ;
fprintf ( std err, " -v - more output \n " ) ;
fprintf ( std err, " -CApath arg - PEM format directory of CA's \n " ) ;
fprintf ( std err, " -CAfile arg - PEM format file of CA's \n " ) ;
fprintf ( std err, " -threads arg - number of threads \n " ) ;
fprintf ( std err, " -loops arg - number of 'connections', per thread \n " ) ;
fprintf ( std err, " -reconnect - reuse session-id's \n " ) ;
fprintf ( std err, " -stats - server session-id cache stats \n " ) ;
fprintf ( std err, " -cert arg - server certificate/key \n " ) ;
fprintf ( std err, " -ccert arg - client certificate/key \n " ) ;
fprintf ( std err, " -ssl3 - just SSLv3n \n " ) ;
BIO_printf ( bio_ err, " usage: ssltest [args ...] \n " ) ;
BIO_printf ( bio_ err, " \n " ) ;
BIO_printf ( bio_ err, " -server_auth - check server certificate \n " ) ;
BIO_printf ( bio_ err, " -client_auth - do client authentication \n " ) ;
BIO_printf ( bio_ err, " -v - more output \n " ) ;
BIO_printf ( bio_ err, " -CApath arg - PEM format directory of CA's \n " ) ;
BIO_printf ( bio_ err, " -CAfile arg - PEM format file of CA's \n " ) ;
BIO_printf ( bio_ err, " -threads arg - number of threads \n " ) ;
BIO_printf ( bio_ err, " -loops arg - number of 'connections', per thread \n " ) ;
BIO_printf ( bio_ err, " -reconnect - reuse session-id's \n " ) ;
BIO_printf ( bio_ err, " -stats - server session-id cache stats \n " ) ;
BIO_printf ( bio_ err, " -cert arg - server certificate/key \n " ) ;
BIO_printf ( bio_ err, " -ccert arg - client certificate/key \n " ) ;
BIO_printf ( bio_ err, " -ssl3 - just SSLv3n \n " ) ;
}
int main ( int argc , char * argv [ ] )
@ -195,14 +188,14 @@ int main(int argc, char *argv[])
SSL_CTX * c_ctx = NULL ;
char * scert = TEST_SERVER_CERT ;
char * ccert = TEST_CLIENT_CERT ;
SSL_METHOD * ssl_method = SSLv23_method ( ) ;
const 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 ) ;
bio_err = BIO_new_fd ( 2 , BIO_NOCLOSE ) ;
if ( bio_stdout = = NULL )
bio_stdout = BIO_new_fp ( stdout , BIO_NOCLOSE ) ;
bio_stdout = BIO_new_fd ( 1 , BIO_NOCLOSE ) ;
argc - - ;
argv + + ;
@ -250,7 +243,7 @@ int main(int argc, char *argv[])
if ( number_of_loops = = 0 )
number_of_loops = 1 ;
} else {
fprintf ( std err, " unknown option %s \n " , * argv ) ;
BIO_printf ( bio_ err, " unknown option %s \n " , * argv ) ;
badop = 1 ;
break ;
}
@ -284,9 +277,12 @@ int main(int argc, char *argv[])
SSL_SESS_CACHE_SERVER ) ;
if ( ! SSL_CTX_use_certificate_file ( s_ctx , scert , SSL_FILETYPE_PEM ) ) {
BIO_printf ( bio_err , " SSL_CTX_use_certificate_file (%s) \n " , scert ) ;
ERR_print_errors ( bio_err ) ;
goto end ;
} else
if ( ! SSL_CTX_use_RSAPrivateKey_file ( s_ctx , scert , SSL_FILETYPE_PEM ) ) {
BIO_printf ( bio_err , " SSL_CTX_use_RSAPrivateKey_file (%s) \n " , scert ) ;
ERR_print_errors ( bio_err ) ;
goto end ;
}
@ -300,19 +296,19 @@ int main(int argc, char *argv[])
( ! SSL_CTX_set_default_verify_paths ( s_ctx ) ) | |
( ! SSL_CTX_load_verify_locations ( c_ctx , CAfile , CApath ) ) | |
( ! SSL_CTX_set_default_verify_paths ( c_ctx ) ) ) {
fprintf ( std err, " SSL_load_verify_locations \n " ) ;
BIO_printf ( bio_ err, " SSL_load_verify_locations \n " ) ;
ERR_print_errors ( bio_err ) ;
goto end ;
}
if ( client_auth ) {
fprintf ( std err, " client authentication \n " ) ;
BIO_printf ( bio_ err, " client authentication \n " ) ;
SSL_CTX_set_verify ( s_ctx ,
SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT ,
verify_callback ) ;
}
if ( server_auth ) {
fprintf ( std err, " server authentication \n " ) ;
BIO_printf ( bio_ err, " server authentication \n " ) ;
SSL_CTX_set_verify ( c_ctx , SSL_VERIFY_PEER , verify_callback ) ;
}
@ -322,24 +318,24 @@ int main(int argc, char *argv[])
end :
if ( c_ctx ! = NULL ) {
fprintf ( std err, " Client SSL_CTX stats then free it \n " ) ;
print_stats ( std err, c_ctx ) ;
BIO_printf ( bio_ err, " Client SSL_CTX stats then free it \n " ) ;
print_stats ( bio_ err, c_ctx ) ;
SSL_CTX_free ( c_ctx ) ;
}
if ( s_ctx ! = NULL ) {
fprintf ( std err, " Server SSL_CTX stats then free it \n " ) ;
print_stats ( std err, s_ctx ) ;
BIO_printf ( bio_ err, " Server SSL_CTX stats then free it \n " ) ;
print_stats ( bio_ err, s_ctx ) ;
if ( cache_stats ) {
fprintf ( std err, " ----- \n " ) ;
lh_stats ( SSL_CTX_sessions ( s_ctx ) , std err) ;
fprintf ( std err, " ----- \n " ) ;
/*- lh_node_stats(SSL_CTX_sessions(s_ctx),std err);
fprintf ( std err, " ----- \n " ) ; */
lh_node_usage_stats ( SSL_CTX_sessions ( s_ctx ) , std err) ;
fprintf ( std err, " ----- \n " ) ;
BIO_printf ( bio_ err, " ----- \n " ) ;
lh_SSL_SESSION_ stats_bio ( SSL_CTX_sessions ( s_ctx ) , bio_ err) ;
BIO_printf ( bio_ err, " ----- \n " ) ;
/*- lh_SSL_SESSION_node_stats_bio(SSL_CTX_sessions(s_ctx),bio_ err);
BIO_printf ( bio_ err, " ----- \n " ) ; */
lh_SSL_SESSION_ node_usage_stats_bio ( SSL_CTX_sessions ( s_ctx ) , bio_ err) ;
BIO_printf ( bio_ err, " ----- \n " ) ;
}
SSL_CTX_free ( s_ctx ) ;
fprintf ( std err, " done free \n " ) ;
BIO_printf ( bio_ err, " done free \n " ) ;
}
exit ( ret ) ;
return ( 0 ) ;
@ -355,6 +351,7 @@ int ndoit(SSL_CTX *ssl_ctx[2])
int i ;
int ret ;
char * ctx [ 4 ] ;
CRYPTO_THREADID thread_id ;
ctx [ 0 ] = ( char * ) ssl_ctx [ 0 ] ;
ctx [ 1 ] = ( char * ) ssl_ctx [ 1 ] ;
@ -367,22 +364,24 @@ int ndoit(SSL_CTX *ssl_ctx[2])
ctx [ 3 ] = NULL ;
}
fprintf ( stdout , " started thread %lu \n " , CRYPTO_thread_id ( ) ) ;
CRYPTO_THREADID_current ( & thread_id ) ;
BIO_printf ( bio_stdout , " started thread %lu \n " ,
CRYPTO_THREADID_hash ( & thread_id ) ) ;
for ( i = 0 ; i < number_of_loops ; i + + ) {
/*- fprintf(stderr,"%4d %2d ctx->ref (%3d,%3d)\n",
CRYPTO_thread_id ( ) , i ,
ssl_ctx [ 0 ] - > references ,
ssl_ctx [ 1 ] - > references ) ; */
/*- BIO_printf(bio_ err,"%4d %2d ctx->ref (%3d,%3d)\n",
CRYPTO_THREADID_hash ( & thread_id ) , i ,
ssl_ctx [ 0 ] - > references ,
ssl_ctx [ 1 ] - > references ) ; */
/* pthread_delay_np(&tm); */
ret = doit ( ctx ) ;
if ( ret ! = 0 ) {
f printf( stdout , " error[%d] %lu - %d \n " ,
i , CRYPTO_thread_id ( ) , ret ) ;
BIO_ printf( bio_ stdout, " error[%d] %lu - %d \n " ,
i , CRYPTO_THREADID_hash ( & thread_id ) , ret ) ;
return ( ret ) ;
}
}
f printf( stdout , " DONE %lu \n " , CRYPTO_thread_id ( ) ) ;
BIO_ printf( bio_ stdout, " DONE %lu \n " , CRYPTO_THREADID_hash ( & thread_id ) ) ;
if ( reconnect ) {
SSL_free ( ( SSL * ) ctx [ 2 ] ) ;
SSL_free ( ( SSL * ) ctx [ 3 ] ) ;
@ -467,26 +466,26 @@ int doit(char *ctx[4])
if ( do_server & & verbose ) {
if ( SSL_in_init ( s_ssl ) )
printf ( " server waiting in SSL_accept - %s \n " ,
SSL_state_string_long ( s_ssl ) ) ;
BIO_ printf( bio_stdout , " server waiting in SSL_accept - %s \n " ,
SSL_state_string_long ( s_ssl ) ) ;
else if ( s_write )
printf ( " server:SSL_write() \n " ) ;
BIO_ printf( bio_stdout , " server:SSL_write() \n " ) ;
else
printf ( " server:SSL_read() \n " ) ;
BIO_ printf( bio_stdout , " server:SSL_read() \n " ) ;
}
if ( do_client & & verbose ) {
if ( SSL_in_init ( c_ssl ) )
printf ( " client waiting in SSL_connect - %s \n " ,
SSL_state_string_long ( c_ssl ) ) ;
BIO_ printf( bio_stdout , " client waiting in SSL_connect - %s \n " ,
SSL_state_string_long ( c_ssl ) ) ;
else if ( c_write )
printf ( " client:SSL_write() \n " ) ;
BIO_ printf( bio_stdout , " client:SSL_write() \n " ) ;
else
printf ( " client:SSL_read() \n " ) ;
BIO_ printf( bio_stdout , " client:SSL_read() \n " ) ;
}
if ( ! do_client & & ! do_server ) {
f printf( stdout , " ERROR IN STARTUP \n " ) ;
BIO_ printf( bio_ stdout, " ERROR IN STARTUP \n " ) ;
break ;
}
if ( do_client & & ! ( done & C_DONE ) ) {
@ -501,12 +500,12 @@ int doit(char *ctx[4])
if ( BIO_should_write ( c_bio ) )
c_w = 1 ;
} else {
fprintf ( std err, " ERROR in CLIENT \n " ) ;
BIO_printf ( bio_ err, " ERROR in CLIENT \n " ) ;
ERR_print_errors_fp ( stderr ) ;
return ( 1 ) ;
}
} else if ( i = = 0 ) {
fprintf ( std err, " SSL CLIENT STARTUP FAILED \n " ) ;
BIO_printf ( bio_ err, " SSL CLIENT STARTUP FAILED \n " ) ;
return ( 1 ) ;
} else {
/* ok */
@ -523,19 +522,19 @@ int doit(char *ctx[4])
if ( BIO_should_write ( c_bio ) )
c_w = 1 ;
} else {
fprintf ( std err, " ERROR in CLIENT \n " ) ;
BIO_printf ( bio_ err, " ERROR in CLIENT \n " ) ;
ERR_print_errors_fp ( stderr ) ;
return ( 1 ) ;
}
} else if ( i = = 0 ) {
fprintf ( std err, " SSL CLIENT STARTUP FAILED \n " ) ;
BIO_printf ( bio_ err, " SSL CLIENT STARTUP FAILED \n " ) ;
return ( 1 ) ;
} else {
done | = C_DONE ;
# ifdef undef
f printf( stdout , " CLIENT:from server: " ) ;
fwrite ( cbuf , 1 , i , stdout ) ;
f flush( stdout ) ;
BIO_ printf( bio_ stdout, " CLIENT:from server: " ) ;
BIO_write ( bio_stdout , cbuf , i ) ;
BIO_ flush( bio_ stdout) ;
# endif
}
}
@ -553,20 +552,20 @@ int doit(char *ctx[4])
if ( BIO_should_write ( s_bio ) )
s_w = 1 ;
} else {
fprintf ( std err, " ERROR in SERVER \n " ) ;
BIO_printf ( bio_ err, " ERROR in SERVER \n " ) ;
ERR_print_errors_fp ( stderr ) ;
return ( 1 ) ;
}
} else if ( i = = 0 ) {
fprintf ( std err, " SSL SERVER STARTUP FAILED \n " ) ;
BIO_printf ( bio_ err, " SSL SERVER STARTUP FAILED \n " ) ;
return ( 1 ) ;
} else {
s_write = 1 ;
s_w = 1 ;
# ifdef undef
f printf( stdout , " SERVER:from client: " ) ;
fwrite ( sbuf , 1 , i , stdout ) ;
f flush( stdout ) ;
BIO_ printf( bio_ stdout, " SERVER:from client: " ) ;
BIO_write ( bio_stdout , sbuf , i ) ;
BIO_ flush( bio_ stdout) ;
# endif
}
} else {
@ -580,12 +579,12 @@ int doit(char *ctx[4])
if ( BIO_should_write ( s_bio ) )
s_w = 1 ;
} else {
fprintf ( std err, " ERROR in SERVER \n " ) ;
BIO_printf ( bio_ err, " ERROR in SERVER \n " ) ;
ERR_print_errors_fp ( stderr ) ;
return ( 1 ) ;
}
} else if ( i = = 0 ) {
fprintf ( std err, " SSL SERVER STARTUP FAILED \n " ) ;
BIO_printf ( bio_ err, " SSL SERVER STARTUP FAILED \n " ) ;
return ( 1 ) ;
} else {
s_write = 0 ;
@ -606,7 +605,7 @@ int doit(char *ctx[4])
SSL_set_shutdown ( s_ssl , SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN ) ;
# ifdef undef
f printf( stdout , " DONE \n " ) ;
BIO_ printf( bio_ stdout, " DONE \n " ) ;
# endif
err :
/*
@ -640,7 +639,7 @@ int doit(char *ctx[4])
return ( 0 ) ;
}
int MS_CALLBACK verify_callback ( int ok , X509_STORE_CTX * ctx )
int verify_callback ( int ok , X509_STORE_CTX * ctx )
{
char * s , buf [ 256 ] ;
@ -649,9 +648,9 @@ int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx)
buf , 256 ) ;
if ( s ! = NULL ) {
if ( ok )
fprintf ( std err, " depth=%d %s \n " , ctx - > error_depth , buf ) ;
BIO_printf ( bio_ err, " depth=%d %s \n " , ctx - > error_depth , buf ) ;
else
fprintf ( std err, " depth=%d error=%d %s \n " ,
BIO_printf ( bio_ err, " depth=%d error=%d %s \n " ,
ctx - > error_depth , ctx - > error , buf ) ;
}
}
@ -688,7 +687,7 @@ void thread_cleanup(void)
OPENSSL_free ( lock_cs ) ;
}
void win32_locking_callback ( int mode , int type , char * file , int line )
void win32_locking_callback ( int mode , int type , const char * file , int line )
{
if ( mode & CRYPTO_LOCK ) {
WaitForSingleObject ( lock_cs [ type ] , INFINITE ) ;
@ -717,7 +716,7 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
( void * ) ssl_ctx , 0L , & ( thread_id [ i ] ) ) ;
}
printf ( " reaping \n " ) ;
BIO_ printf( bio_stdout , " reaping \n " ) ;
for ( i = 0 ; i < thread_number ; i + = 50 ) {
int j ;
@ -727,7 +726,7 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
( CONST HANDLE * ) & ( thread_handle [ i ] ) ,
TRUE , INFINITE )
= = WAIT_FAILED ) {
fprintf ( std err, " WaitForMultipleObjects failed:%d \n " ,
BIO_printf ( bio_ err, " WaitForMultipleObjects failed:%d \n " ,
GetLastError ( ) ) ;
exit ( 1 ) ;
}
@ -743,7 +742,7 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
ret = ( ret + end . wSecond - start . wSecond ) ;
ret + = ( end . wMilliseconds - start . wMilliseconds ) / 1000.0 ;
printf ( " win32 threads done - %.3f seconds \n " , ret ) ;
BIO_ printf( bio_stdout , " win32 threads done - %.3f seconds \n " , ret ) ;
}
# endif /* OPENSSL_SYS_WIN32 */
@ -768,8 +767,8 @@ void thread_setup(void)
mutex_init ( & ( lock_cs [ i ] ) , USYNC_THREAD , NULL ) ;
}
CRYPTO_set_id_callback ( ( unsigned long ( * ) ( ) ) solaris_thread_id ) ;
CRYPTO_set_locking_callback ( ( void ( * ) ( ) ) solaris_locking_callback ) ;
CRYPTO_set_id_callback ( solaris_thread_id ) ;
CRYPTO_set_locking_callback ( solaris_locking_callback ) ;
}
void thread_cleanup ( void )
@ -778,34 +777,34 @@ void thread_cleanup(void)
CRYPTO_set_locking_callback ( NULL ) ;
fprintf ( std err, " cleanup \n " ) ;
BIO_printf ( bio_ err, " cleanup \n " ) ;
for ( i = 0 ; i < CRYPTO_num_locks ( ) ; i + + ) {
/* rwlock_destroy(&(lock_cs[i])); */
mutex_destroy ( & ( lock_cs [ i ] ) ) ;
fprintf ( std err, " %8ld:%s \n " , lock_count [ i ] , CRYPTO_get_lock_name ( i ) ) ;
BIO_printf ( bio_ err, " %8ld:%s \n " , lock_count [ i ] , CRYPTO_get_lock_name ( i ) ) ;
}
OPENSSL_free ( lock_cs ) ;
OPENSSL_free ( lock_count ) ;
fprintf ( std err, " done cleanup \n " ) ;
BIO_printf ( bio_ err, " done cleanup \n " ) ;
}
void solaris_locking_callback ( int mode , int type , char * file , int line )
void solaris_locking_callback ( int mode , int type , const char * file , int line )
{
# ifdef undef
fprintf ( std err, " thread=%4d mode=%s lock=%s %s:%d \n " ,
CRYPTO_thread_id ( ) ,
( mode & CRYPTO_LOCK ) ? " l " : " u " ,
( type & CRYPTO_READ ) ? " r " : " w " , file , line ) ;
BIO_printf ( bio_ err, " 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 )
fprintf ( std err, " (t,m,f,l) %ld %d %s %d \n " ,
CRYPTO_thread_id ( ) ,
mode , file , line ) ;
BIO_printf ( bio_ err, " (t,m,f,l) %ld %d %s %d \n " ,
CRYPTO_thread_id ( ) ,
mode , file , line ) ;
*/
if ( mode & CRYPTO_LOCK ) {
/*-
@ -837,21 +836,22 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
( void * ( * ) ( ) ) ndoit , ( void * ) ssl_ctx , 0L , & ( thread_ctx [ i ] ) ) ;
}
printf ( " reaping \n " ) ;
BIO_ printf( bio_stdout , " reaping \n " ) ;
for ( i = 0 ; i < thread_number ; i + + ) {
thr_join ( thread_ctx [ i ] , NULL , NULL ) ;
}
printf ( " solaris threads done (%d,%d) \n " ,
s_ctx - > references , c_ctx - > references ) ;
#if 0 /* We can't currently find out the reference amount */
BIO_printf ( bio_stdout , " solaris threads done (%d,%d) \n " ,
s_ctx - > references , c_ctx - > references ) ;
# else
BIO_printf ( bio_stdout , " solaris threads done \n " ) ;
# endif
}
unsigned long solaris_thread_id ( void )
void solaris_thread_id ( CRYPTO_THREADID * t id)
{
unsigned long ret ;
ret = ( unsigned long ) thr_self ( ) ;
return ( ret ) ;
CRYPTO_THREADID_set_numeric ( ( unsigned long ) thr_self ( ) ) ;
}
# endif /* SOLARIS */
@ -880,8 +880,8 @@ void thread_setup(void)
lock_cs [ i ] = usnewsema ( arena , 1 ) ;
}
CRYPTO_set_id_callback ( ( unsigned long ( * ) ( ) ) irix_thread_id ) ;
CRYPTO_set_locking_callback ( ( void ( * ) ( ) ) irix_locking_callback ) ;
CRYPTO_set_id_callback ( irix_thread_id ) ;
CRYPTO_set_locking_callback ( irix_locking_callback ) ;
}
void thread_cleanup ( void )
@ -899,13 +899,13 @@ void thread_cleanup(void)
OPENSSL_free ( lock_cs ) ;
}
void irix_locking_callback ( int mode , int type , char * file , int line )
void irix_locking_callback ( int mode , int type , const char * file , int line )
{
if ( mode & CRYPTO_LOCK ) {
printf ( " lock %d \n " , type ) ;
BIO_ printf( bio_stdout , " lock %d \n " , type ) ;
uspsema ( lock_cs [ type ] ) ;
} else {
printf ( " unlock %d \n " , type ) ;
BIO_ printf( bio_stdout , " unlock %d \n " , type ) ;
usvsema ( lock_cs [ type ] ) ;
}
}
@ -924,21 +924,22 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
PR_SADDR | PR_SFDS , ( void * ) ssl_ctx ) ;
}
printf ( " reaping \n " ) ;
BIO_ printf( bio_stdout , " reaping \n " ) ;
for ( i = 0 ; i < thread_number ; i + + ) {
wait ( NULL ) ;
}
printf ( " irix threads done (%d,%d) \n " ,
s_ctx - > references , c_ctx - > references ) ;
#if 0 /* We can't currently find out the reference amount */
BIO_printf ( bio_stdout , " irix threads done (%d,%d) \n " ,
s_ctx - > references , c_ctx - > references ) ;
# else
BIO_printf ( bio_stdout , " irix threads done \n " ) ;
# endif
}
unsigned long irix_thread_id ( void )
{
unsigned long ret ;
ret = ( unsigned long ) getpid ( ) ;
return ( ret ) ;
CRYPTO_THREADID_set_numeric ( ( unsigned long ) getpid ( ) ) ;
}
# endif /* IRIX */
@ -958,8 +959,8 @@ void thread_setup(void)
pthread_mutex_init ( & ( lock_cs [ i ] ) , NULL ) ;
}
CRYPTO_set_id _callback ( ( unsigned long ( * ) ( ) ) pthreads_thread_id ) ;
CRYPTO_set_locking_callback ( ( void ( * ) ( ) ) pthreads_locking_callback ) ;
CRYPTO_THREADID_ set_callback ( pthreads_thread_id ) ;
CRYPTO_set_locking_callback ( pthreads_locking_callback ) ;
}
void thread_cleanup ( void )
@ -967,30 +968,30 @@ void thread_cleanup(void)
int i ;
CRYPTO_set_locking_callback ( NULL ) ;
fprintf ( std err, " cleanup \n " ) ;
BIO_printf ( bio_ err, " cleanup \n " ) ;
for ( i = 0 ; i < CRYPTO_num_locks ( ) ; i + + ) {
pthread_mutex_destroy ( & ( lock_cs [ i ] ) ) ;
fprintf ( std err, " %8ld:%s \n " , lock_count [ i ] , CRYPTO_get_lock_name ( i ) ) ;
BIO_printf ( bio_ err, " %8ld:%s \n " , lock_count [ i ] , CRYPTO_get_lock_name ( i ) ) ;
}
OPENSSL_free ( lock_cs ) ;
OPENSSL_free ( lock_count ) ;
fprintf ( std err, " done cleanup \n " ) ;
BIO_printf ( bio_ err, " done cleanup \n " ) ;
}
void pthreads_locking_callback ( int mode , int type , char * file , int line )
void pthreads_locking_callback ( int mode , int type , const char * file , int line )
{
# ifdef undef
fprintf ( std err, " thread=%4d mode=%s lock=%s %s:%d \n " ,
CRYPTO_thread_id ( ) ,
( mode & CRYPTO_LOCK ) ? " l " : " u " ,
( type & CRYPTO_READ ) ? " r " : " w " , file , line ) ;
BIO_printf ( bio_ err, " 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 )
fprintf ( std err, " (t,m,f,l) %ld %d %s %d \n " ,
CRYPTO_thread_id ( ) ,
mode , file , line ) ;
BIO_printf ( bio_ err, " (t,m,f,l) %ld %d %s %d \n " ,
CRYPTO_thread_id ( ) ,
mode , file , line ) ;
*/
if ( mode & CRYPTO_LOCK ) {
pthread_mutex_lock ( & ( lock_cs [ type ] ) ) ;
@ -1017,21 +1018,22 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
( void * ( * ) ( ) ) ndoit , ( void * ) ssl_ctx ) ;
}
printf ( " reaping \n " ) ;
BIO_ printf( bio_stdout , " reaping \n " ) ;
for ( i = 0 ; i < thread_number ; i + + ) {
pthread_join ( thread_ctx [ i ] , NULL ) ;
}
printf ( " pthreads threads done (%d,%d) \n " ,
s_ctx - > references , c_ctx - > references ) ;
#if 0 /* We can't currently find out the reference amount */
BIO_printf ( bio_stdout , " pthreads threads done (%d,%d) \n " ,
s_ctx - > references , c_ctx - > references ) ;
# else
BIO_printf ( bio_stdout , " pthreads threads done \n " ) ;
# endif
}
unsigned long pthreads_thread_id ( void )
void pthreads_thread_id ( CRYPTO_THREADID * t id)
{
unsigned long ret ;
ret = ( unsigned long ) pthread_self ( ) ;
return ( ret ) ;
CRYPTO_THREADID_set_numeric ( tid , ( unsigned long ) pthread_self ( ) ) ;
}
# endif /* PTHREADS */
@ -1051,8 +1053,8 @@ void thread_setup(void)
ThreadSem = MPKSemaphoreAlloc ( " OpenSSL mttest semaphore " , 0 ) ;
CRYPTO_set_id_callback ( ( unsigned long ( * ) ( ) ) netware_thread_id ) ;
CRYPTO_set_locking_callback ( ( void ( * ) ( ) ) netware_locking_callback ) ;
CRYPTO_set_id_callback ( netware_thread_id ) ;
CRYPTO_set_locking_callback ( netware_locking_callback ) ;
}
void thread_cleanup ( void )
@ -1061,21 +1063,21 @@ void thread_cleanup(void)
CRYPTO_set_locking_callback ( NULL ) ;
f printf( stdout , " thread_cleanup \n " ) ;
BIO_ printf( bio_ stdout, " thread_cleanup \n " ) ;
for ( i = 0 ; i < CRYPTO_num_locks ( ) ; i + + ) {
MPKMutexFree ( lock_cs [ i ] ) ;
f printf( stdout , " %8ld:%s \n " , lock_count [ i ] , CRYPTO_get_lock_name ( i ) ) ;
BIO_ printf( bio_ stdout, " %8ld:%s \n " , lock_count [ i ] , CRYPTO_get_lock_name ( i ) ) ;
}
OPENSSL_free ( lock_cs ) ;
OPENSSL_free ( lock_count ) ;
MPKSemaphoreFree ( ThreadSem ) ;
f printf( stdout , " done cleanup \n " ) ;
BIO_ printf( bio_ stdout, " done cleanup \n " ) ;
}
void netware_locking_callback ( int mode , int type , char * file , int line )
void netware_locking_callback ( int mode , int type , const char * file , int line )
{
if ( mode & CRYPTO_LOCK ) {
MPKMutexLock ( lock_cs [ type ] ) ;
@ -1097,22 +1099,23 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
ThreadSwitchWithDelay ( ) ;
}
printf ( " reaping \n " ) ;
BIO_ printf( bio_stdout , " reaping \n " ) ;
/* loop until all threads have signaled the semaphore */
for ( i = 0 ; i < thread_number ; i + + ) {
MPKSemaphoreWait ( ThreadSem ) ;
}
printf ( " netware threads done (%d,%d) \n " ,
s_ctx - > references , c_ctx - > references ) ;
#if 0 /* We can't currently find out the reference amount */
BIO_printf ( bio_stdout , " netware threads done (%d,%d) \n " ,
s_ctx - > references , c_ctx - > references ) ;
# else
BIO_printf ( bio_stdout , " netware threads done \n " ) ;
# endif
}
unsigned long netware_thread_id ( void )
{
unsigned long ret ;
ret = ( unsigned long ) GetThreadID ( ) ;
return ( ret ) ;
CRYPTO_THREADID_set_numeric ( ( unsigned long ) GetThreadID ( ) ) ;
}
# endif /* NETWARE */
@ -1144,24 +1147,24 @@ void thread_cleanup(void)
int i ;
CRYPTO_set_locking_callback ( NULL ) ;
fprintf ( std err, " cleanup \n " ) ;
BIO_printf ( bio_ err, " cleanup \n " ) ;
for ( i = 0 ; i < CRYPTO_num_locks ( ) ; i + + ) {
delete lock_cs [ i ] ;
fprintf ( std err, " %8ld:%s \n " , lock_count [ i ] , CRYPTO_get_lock_name ( i ) ) ;
BIO_printf ( bio_ err, " %8ld:%s \n " , lock_count [ i ] , CRYPTO_get_lock_name ( i ) ) ;
}
OPENSSL_free ( lock_cs ) ;
OPENSSL_free ( lock_count ) ;
fprintf ( std err, " done cleanup \n " ) ;
BIO_printf ( bio_ err, " done cleanup \n " ) ;
}
void beos_locking_callback ( int mode , int type , const char * file , int line )
{
# if 0
fprintf ( std err, " thread=%4d mode=%s lock=%s %s:%d \n " ,
CRYPTO_thread_id ( ) ,
( mode & CRYPTO_LOCK ) ? " l " : " u " ,
( type & CRYPTO_READ ) ? " r " : " w " , file , line ) ;
BIO_printf ( bio_ err, " 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 ( mode & CRYPTO_LOCK ) {
lock_cs [ type ] - > Lock ( ) ;
@ -1187,14 +1190,14 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
resume_thread ( thread_ctx [ i ] ) ;
}
printf ( " waiting... \n " ) ;
BIO_ printf( bio_stdout , " waiting... \n " ) ;
for ( i = 0 ; i < thread_number ; i + + ) {
status_t result ;
wait_for_thread ( thread_ctx [ i ] , & result ) ;
}
printf ( " beos threads done (%d,%d) \n " ,
s_ctx - > references , c_ctx - > references ) ;
BIO_ printf( bio_stdout , " beos threads done (%d,%d) \n " ,
s_ctx - > references , c_ctx - > references ) ;
}
unsigned long beos_thread_id ( void )
Shigeki Ohtsu
10 years ago
Julien Gilli