wbrawner/openssl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Cleanup mttest.c : modernise output

Browse source 
Construct bio_err and bio_stdout from file handles instead of FILE
pointers, since the latter might not be implemented (when OPENSSL_NO_STDIO
is defined).
Convert all output to use BIO_printf.
Change lh_foo to lh_SSL_SESSION_foo.

Reviewed-by: Rich Salz <rsalz@openssl.org>
This commit is contained in:
Richard Levitte 2015-06-21 19:11:43 +02:00
parent 5c78e18352
commit bb8abd6735
1 changed files with 91 additions and 96 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

187
crypto/threads/mttest.c
View file

@ -86,16 +86,11 @@
#include <openssl/lhash.h> #include <openssl/lhash.h>
#include <openssl/crypto.h> #include <openssl/crypto.h>
#include <openssl/buffer.h> #include <openssl/buffer.h>
#include "../../e_os.h"
#include <openssl/x509.h> #include <openssl/x509.h>
#include <openssl/ssl.h> #include <openssl/ssl.h>
#include <openssl/err.h> #include <openssl/err.h>
#include <openssl/rand.h> #include <openssl/rand.h>
#ifdef OPENSSL_NO_STDIO
# include "../buffer/bss_file.c"
#endif
#ifdef OPENSSL_SYS_NETWARE #ifdef OPENSSL_SYS_NETWARE
# define TEST_SERVER_CERT "/openssl/apps/server.pem" # define TEST_SERVER_CERT "/openssl/apps/server.pem"
# define TEST_CLIENT_CERT "/openssl/apps/client.pem" # define TEST_CLIENT_CERT "/openssl/apps/client.pem"
@ -148,39 +143,39 @@ static const char rnd_seed[] =
"string to make the random number generator think it has entropy"; "string to make the random number generator think it has entropy";
int doit(char *ctx[4]); 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", BIO_printf(bio, "%4ld items in the session cache\n",
SSL_CTX_sess_number(ctx)); SSL_CTX_sess_number(ctx));
fprintf(fp, "%4d client connects (SSL_connect())\n", BIO_printf(bio, "%4d client connects (SSL_connect())\n",
SSL_CTX_sess_connect(ctx)); SSL_CTX_sess_connect(ctx));
fprintf(fp, "%4d client connects that finished\n", BIO_printf(bio, "%4d client connects that finished\n",
SSL_CTX_sess_connect_good(ctx)); SSL_CTX_sess_connect_good(ctx));
fprintf(fp, "%4d server connects (SSL_accept())\n", BIO_printf(bio, "%4d server connects (SSL_accept())\n",
SSL_CTX_sess_accept(ctx)); SSL_CTX_sess_accept(ctx));
fprintf(fp, "%4d server connects that finished\n", BIO_printf(bio, "%4d server connects that finished\n",
SSL_CTX_sess_accept_good(ctx)); SSL_CTX_sess_accept_good(ctx));
fprintf(fp, "%4d session cache hits\n", SSL_CTX_sess_hits(ctx)); BIO_printf(bio, "%4d session cache hits\n", SSL_CTX_sess_hits(ctx));
fprintf(fp, "%4d session cache misses\n", SSL_CTX_sess_misses(ctx)); BIO_printf(bio, "%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, "%4d session cache timeouts\n", SSL_CTX_sess_timeouts(ctx));
} }
static void sv_usage(void) static void sv_usage(void)
{ {
fprintf(stderr, "usage: ssltest [args ...]\n"); BIO_printf(bio_err, "usage: ssltest [args ...]\n");
fprintf(stderr, "\n"); BIO_printf(bio_err, "\n");
fprintf(stderr, " -server_auth - check server certificate\n"); BIO_printf(bio_err, " -server_auth - check server certificate\n");
fprintf(stderr, " -client_auth - do client authentication\n"); BIO_printf(bio_err, " -client_auth - do client authentication\n");
fprintf(stderr, " -v - more output\n"); BIO_printf(bio_err, " -v - more output\n");
fprintf(stderr, " -CApath arg - PEM format directory of CA's\n"); BIO_printf(bio_err, " -CApath arg - PEM format directory of CA's\n");
fprintf(stderr, " -CAfile arg - PEM format file of CA's\n"); BIO_printf(bio_err, " -CAfile arg - PEM format file of CA's\n");
fprintf(stderr, " -threads arg - number of threads\n"); BIO_printf(bio_err, " -threads arg - number of threads\n");
fprintf(stderr, " -loops arg - number of 'connections', per thread\n"); BIO_printf(bio_err, " -loops arg - number of 'connections', per thread\n");
fprintf(stderr, " -reconnect - reuse session-id's\n"); BIO_printf(bio_err, " -reconnect - reuse session-id's\n");
fprintf(stderr, " -stats - server session-id cache stats\n"); BIO_printf(bio_err, " -stats - server session-id cache stats\n");
fprintf(stderr, " -cert arg - server certificate/key\n"); BIO_printf(bio_err, " -cert arg - server certificate/key\n");
fprintf(stderr, " -ccert arg - client certificate/key\n"); BIO_printf(bio_err, " -ccert arg - client certificate/key\n");
fprintf(stderr, " -ssl3 - just SSLv3n\n"); BIO_printf(bio_err, " -ssl3 - just SSLv3n\n");
} }
int main(int argc, char *argv[]) int main(int argc, char *argv[])
@ -199,9 +194,9 @@ int main(int argc, char *argv[])
RAND_seed(rnd_seed, sizeof rnd_seed); RAND_seed(rnd_seed, sizeof rnd_seed);
if (bio_err == NULL) if (bio_err == NULL)
bio_err = BIO_new_fp(stderr, BIO_NOCLOSE); bio_err = BIO_new_fd(2, BIO_NOCLOSE);
if (bio_stdout == NULL) if (bio_stdout == NULL)
bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE); bio_stdout = BIO_new_fd(1, BIO_NOCLOSE);
argc--; argc--;
argv++; argv++;
@ -247,7 +242,7 @@ int main(int argc, char *argv[])
if (number_of_loops == 0) if (number_of_loops == 0)
number_of_loops = 1; number_of_loops = 1;
} else { } else {
fprintf(stderr, "unknown option %s\n", *argv); BIO_printf(bio_err, "unknown option %s\n", *argv);
badop = 1; badop = 1;
break; break;
} }
@ -297,19 +292,19 @@ int main(int argc, char *argv[])
(!SSL_CTX_set_default_verify_paths(s_ctx)) || (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
(!SSL_CTX_load_verify_locations(c_ctx, CAfile, CApath)) || (!SSL_CTX_load_verify_locations(c_ctx, CAfile, CApath)) ||
(!SSL_CTX_set_default_verify_paths(c_ctx))) { (!SSL_CTX_set_default_verify_paths(c_ctx))) {
fprintf(stderr, "SSL_load_verify_locations\n"); BIO_printf(bio_err, "SSL_load_verify_locations\n");
ERR_print_errors(bio_err); ERR_print_errors(bio_err);
goto end; goto end;
} }
if (client_auth) { if (client_auth) {
fprintf(stderr, "client authentication\n"); BIO_printf(bio_err, "client authentication\n");
SSL_CTX_set_verify(s_ctx, SSL_CTX_set_verify(s_ctx,
SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
verify_callback); verify_callback);
} }
if (server_auth) { if (server_auth) {
fprintf(stderr, "server authentication\n"); BIO_printf(bio_err, "server authentication\n");
SSL_CTX_set_verify(c_ctx, SSL_VERIFY_PEER, verify_callback); SSL_CTX_set_verify(c_ctx, SSL_VERIFY_PEER, verify_callback);
} }
@ -319,24 +314,24 @@ int main(int argc, char *argv[])
end: end:
if (c_ctx != NULL) { if (c_ctx != NULL) {
fprintf(stderr, "Client SSL_CTX stats then free it\n"); BIO_printf(bio_err, "Client SSL_CTX stats then free it\n");
print_stats(stderr, c_ctx); print_stats(bio_err, c_ctx);
SSL_CTX_free(c_ctx); SSL_CTX_free(c_ctx);
} }
if (s_ctx != NULL) { if (s_ctx != NULL) {
fprintf(stderr, "Server SSL_CTX stats then free it\n"); BIO_printf(bio_err, "Server SSL_CTX stats then free it\n");
print_stats(stderr, s_ctx); print_stats(bio_err, s_ctx);
if (cache_stats) { if (cache_stats) {
fprintf(stderr, "-----\n"); BIO_printf(bio_err, "-----\n");
lh_stats(SSL_CTX_sessions(s_ctx), stderr); lh_SSL_SESSION_stats_bio(SSL_CTX_sessions(s_ctx), bio_err);
fprintf(stderr, "-----\n"); BIO_printf(bio_err, "-----\n");
/*- lh_node_stats(SSL_CTX_sessions(s_ctx),stderr); /*- lh_SSL_SESSION_node_stats_bio(SSL_CTX_sessions(s_ctx),bio_err);
fprintf(stderr,"-----\n"); */ BIO_printf(bio_err,"-----\n"); */
lh_node_usage_stats(SSL_CTX_sessions(s_ctx), stderr); lh_SSL_SESSION_node_usage_stats_bio(SSL_CTX_sessions(s_ctx), bio_err);
fprintf(stderr, "-----\n"); BIO_printf(bio_err, "-----\n");
} }
SSL_CTX_free(s_ctx); SSL_CTX_free(s_ctx);
fprintf(stderr, "done free\n"); BIO_printf(bio_err, "done free\n");
} }
exit(ret); exit(ret);
return (0); return (0);
@ -467,26 +462,26 @@ int doit(char *ctx[4])
if (do_server && verbose) { if (do_server && verbose) {
if (SSL_in_init(s_ssl)) if (SSL_in_init(s_ssl))
printf("server waiting in SSL_accept - %s\n", BIO_printf(bio_stdout, "server waiting in SSL_accept - %s\n",
SSL_state_string_long(s_ssl)); SSL_state_string_long(s_ssl));
else if (s_write) else if (s_write)
printf("server:SSL_write()\n"); BIO_printf(bio_stdout, "server:SSL_write()\n");
else else
printf("server:SSL_read()\n"); BIO_printf(bio_stdout, "server:SSL_read()\n");
} }
if (do_client && verbose) { if (do_client && verbose) {
if (SSL_in_init(c_ssl)) if (SSL_in_init(c_ssl))
printf("client waiting in SSL_connect - %s\n", BIO_printf(bio_stdout, "client waiting in SSL_connect - %s\n",
SSL_state_string_long(c_ssl)); SSL_state_string_long(c_ssl));
else if (c_write) else if (c_write)
printf("client:SSL_write()\n"); BIO_printf(bio_stdout, "client:SSL_write()\n");
else else
printf("client:SSL_read()\n"); BIO_printf(bio_stdout, "client:SSL_read()\n");
} }
if (!do_client && !do_server) { if (!do_client && !do_server) {
fprintf(stdout, "ERROR IN STARTUP\n"); BIO_printf(bio_stdout, "ERROR IN STARTUP\n");
break; break;
} }
if (do_client && !(done & C_DONE)) { if (do_client && !(done & C_DONE)) {
@ -501,12 +496,12 @@ int doit(char *ctx[4])
if (BIO_should_write(c_bio)) if (BIO_should_write(c_bio))
c_w = 1; c_w = 1;
} else { } else {
fprintf(stderr, "ERROR in CLIENT\n"); BIO_printf(bio_err, "ERROR in CLIENT\n");
ERR_print_errors_fp(stderr); ERR_print_errors_fp(stderr);
return (1); return (1);
} }
} else if (i == 0) { } else if (i == 0) {
fprintf(stderr, "SSL CLIENT STARTUP FAILED\n"); BIO_printf(bio_err, "SSL CLIENT STARTUP FAILED\n");
return (1); return (1);
} else { } else {
/* ok */ /* ok */
@ -523,12 +518,12 @@ int doit(char *ctx[4])
if (BIO_should_write(c_bio)) if (BIO_should_write(c_bio))
c_w = 1; c_w = 1;
} else { } else {
fprintf(stderr, "ERROR in CLIENT\n"); BIO_printf(bio_err, "ERROR in CLIENT\n");
ERR_print_errors_fp(stderr); ERR_print_errors_fp(stderr);
return (1); return (1);
} }
} else if (i == 0) { } else if (i == 0) {
fprintf(stderr, "SSL CLIENT STARTUP FAILED\n"); BIO_printf(bio_err, "SSL CLIENT STARTUP FAILED\n");
return (1); return (1);
} else { } else {
done |= C_DONE; done |= C_DONE;
@ -548,12 +543,12 @@ int doit(char *ctx[4])
if (BIO_should_write(s_bio)) if (BIO_should_write(s_bio))
s_w = 1; s_w = 1;
} else { } else {
fprintf(stderr, "ERROR in SERVER\n"); BIO_printf(bio_err, "ERROR in SERVER\n");
ERR_print_errors_fp(stderr); ERR_print_errors_fp(stderr);
return (1); return (1);
} }
} else if (i == 0) { } else if (i == 0) {
fprintf(stderr, "SSL SERVER STARTUP FAILED\n"); BIO_printf(bio_err, "SSL SERVER STARTUP FAILED\n");
return (1); return (1);
} else { } else {
s_write = 1; s_write = 1;
@ -570,12 +565,12 @@ int doit(char *ctx[4])
if (BIO_should_write(s_bio)) if (BIO_should_write(s_bio))
s_w = 1; s_w = 1;
} else { } else {
fprintf(stderr, "ERROR in SERVER\n"); BIO_printf(bio_err, "ERROR in SERVER\n");
ERR_print_errors_fp(stderr); ERR_print_errors_fp(stderr);
return (1); return (1);
} }
} else if (i == 0) { } else if (i == 0) {
fprintf(stderr, "SSL SERVER STARTUP FAILED\n"); BIO_printf(bio_err, "SSL SERVER STARTUP FAILED\n");
return (1); return (1);
} else { } else {
s_write = 0; s_write = 0;
@ -632,9 +627,9 @@ int verify_callback(int ok, X509_STORE_CTX *ctx)
buf, 256); buf, 256);
if (s != NULL) { if (s != NULL) {
if (ok) if (ok)
fprintf(stderr, "depth=%d %s\n", ctx->error_depth, buf); BIO_printf(bio_err, "depth=%d %s\n", ctx->error_depth, buf);
else else
fprintf(stderr, "depth=%d error=%d %s\n", BIO_printf(bio_err, "depth=%d error=%d %s\n",
ctx->error_depth, ctx->error, buf); ctx->error_depth, ctx->error, buf);
} }
} }
@ -700,7 +695,7 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
(void *)ssl_ctx, 0L, &(thread_id[i])); (void *)ssl_ctx, 0L, &(thread_id[i]));
} }
printf("reaping\n"); BIO_printf(bio_stdout, "reaping\n");
for (i = 0; i < thread_number; i += 50) { for (i = 0; i < thread_number; i += 50) {
int j; int j;
@ -710,7 +705,7 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
(CONST HANDLE *) & (thread_handle[i]), (CONST HANDLE *) & (thread_handle[i]),
TRUE, INFINITE) TRUE, INFINITE)
== WAIT_FAILED) { == WAIT_FAILED) {
fprintf(stderr, "WaitForMultipleObjects failed:%d\n", BIO_printf(bio_err, "WaitForMultipleObjects failed:%d\n",
GetLastError()); GetLastError());
exit(1); exit(1);
} }
@ -726,7 +721,7 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
ret = (ret + end.wSecond - start.wSecond); ret = (ret + end.wSecond - start.wSecond);
ret += (end.wMilliseconds - start.wMilliseconds) / 1000.0; 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 */ #endif /* OPENSSL_SYS_WIN32 */
@ -761,17 +756,17 @@ void thread_cleanup(void)
CRYPTO_set_locking_callback(NULL); CRYPTO_set_locking_callback(NULL);
fprintf(stderr, "cleanup\n"); BIO_printf(bio_err, "cleanup\n");
for (i = 0; i < CRYPTO_num_locks(); i++) { for (i = 0; i < CRYPTO_num_locks(); i++) {
/* rwlock_destroy(&(lock_cs[i])); */ /* rwlock_destroy(&(lock_cs[i])); */
mutex_destroy(&(lock_cs[i])); mutex_destroy(&(lock_cs[i]));
fprintf(stderr, "%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_cs);
OPENSSL_free(lock_count); OPENSSL_free(lock_count);
fprintf(stderr, "done cleanup\n"); BIO_printf(bio_err, "done cleanup\n");
} }
@ -800,13 +795,13 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
(void *(*)())ndoit, (void *)ssl_ctx, 0L, &(thread_ctx[i])); (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++) { for (i = 0; i < thread_number; i++) {
thr_join(thread_ctx[i], NULL, NULL); thr_join(thread_ctx[i], NULL, NULL);
} }
printf("solaris threads done (%d,%d)\n", BIO_printf(bio_stdout, "solaris threads done (%d,%d)\n",
s_ctx->references, c_ctx->references); s_ctx->references, c_ctx->references);
} }
void solaris_thread_id(CRYPTO_THREADID *tid) void solaris_thread_id(CRYPTO_THREADID *tid)
@ -862,10 +857,10 @@ void thread_cleanup(void)
void irix_locking_callback(int mode, int type, const char *file, int line) void irix_locking_callback(int mode, int type, const char *file, int line)
{ {
if (mode & CRYPTO_LOCK) { if (mode & CRYPTO_LOCK) {
printf("lock %d\n", type); BIO_printf(bio_stdout, "lock %d\n", type);
uspsema(lock_cs[type]); uspsema(lock_cs[type]);
} else { } else {
printf("unlock %d\n", type); BIO_printf(bio_stdout, "unlock %d\n", type);
usvsema(lock_cs[type]); usvsema(lock_cs[type]);
} }
} }
@ -884,13 +879,13 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
PR_SADDR | PR_SFDS, (void *)ssl_ctx); PR_SADDR | PR_SFDS, (void *)ssl_ctx);
} }
printf("reaping\n"); BIO_printf(bio_stdout, "reaping\n");
for (i = 0; i < thread_number; i++) { for (i = 0; i < thread_number; i++) {
wait(NULL); wait(NULL);
} }
printf("irix threads done (%d,%d)\n", BIO_printf(bio_stdout, "irix threads done (%d,%d)\n",
s_ctx->references, c_ctx->references); s_ctx->references, c_ctx->references);
} }
unsigned long irix_thread_id(void) unsigned long irix_thread_id(void)
@ -924,15 +919,15 @@ void thread_cleanup(void)
int i; int i;
CRYPTO_set_locking_callback(NULL); CRYPTO_set_locking_callback(NULL);
fprintf(stderr, "cleanup\n"); BIO_printf(bio_err, "cleanup\n");
for (i = 0; i < CRYPTO_num_locks(); i++) { for (i = 0; i < CRYPTO_num_locks(); i++) {
pthread_mutex_destroy(&(lock_cs[i])); pthread_mutex_destroy(&(lock_cs[i]));
fprintf(stderr, "%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_cs);
OPENSSL_free(lock_count); OPENSSL_free(lock_count);
fprintf(stderr, "done cleanup\n"); BIO_printf(bio_err, "done cleanup\n");
} }
void pthreads_locking_callback(int mode, int type, const char *file, int line) void pthreads_locking_callback(int mode, int type, const char *file, int line)
@ -962,13 +957,13 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
(void *(*)())ndoit, (void *)ssl_ctx); (void *(*)())ndoit, (void *)ssl_ctx);
} }
printf("reaping\n"); BIO_printf(bio_stdout, "reaping\n");
for (i = 0; i < thread_number; i++) { for (i = 0; i < thread_number; i++) {
pthread_join(thread_ctx[i], NULL); pthread_join(thread_ctx[i], NULL);
} }
printf("pthreads threads done (%d,%d)\n", BIO_printf(bio_stdout, "pthreads threads done (%d,%d)\n",
s_ctx->references, c_ctx->references); s_ctx->references, c_ctx->references);
} }
void pthreads_thread_id(CRYPTO_THREADID *tid) void pthreads_thread_id(CRYPTO_THREADID *tid)
@ -1003,18 +998,18 @@ void thread_cleanup(void)
CRYPTO_set_locking_callback(NULL); CRYPTO_set_locking_callback(NULL);
fprintf(stdout, "thread_cleanup\n"); BIO_printf(bio_stdout, "thread_cleanup\n");
for (i = 0; i < CRYPTO_num_locks(); i++) { for (i = 0; i < CRYPTO_num_locks(); i++) {
MPKMutexFree(lock_cs[i]); MPKMutexFree(lock_cs[i]);
fprintf(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_cs);
OPENSSL_free(lock_count); OPENSSL_free(lock_count);
MPKSemaphoreFree(ThreadSem); MPKSemaphoreFree(ThreadSem);
fprintf(stdout, "done cleanup\n"); BIO_printf(bio_stdout, "done cleanup\n");
} }
void netware_locking_callback(int mode, int type, const char *file, int line) void netware_locking_callback(int mode, int type, const char *file, int line)
@ -1039,14 +1034,14 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
ThreadSwitchWithDelay(); ThreadSwitchWithDelay();
} }
printf("reaping\n"); BIO_printf(bio_stdout, "reaping\n");
/* loop until all threads have signaled the semaphore */ /* loop until all threads have signaled the semaphore */
for (i = 0; i < thread_number; i++) { for (i = 0; i < thread_number; i++) {
MPKSemaphoreWait(ThreadSem); MPKSemaphoreWait(ThreadSem);
} }
printf("netware threads done (%d,%d)\n", BIO_printf(bio_stdout, "netware threads done (%d,%d)\n",
s_ctx->references, c_ctx->references); s_ctx->references, c_ctx->references);
} }
unsigned long netware_thread_id(void) unsigned long netware_thread_id(void)