3a927a293754129acd4706fd0227684eec8855c6
[openssl.git] / mt / mttest.c
1 /* mt/mttest.c */
2 /* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  * 
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  * 
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  * 
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from 
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  * 
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  * 
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58
59 #include <stdio.h>
60 #include <stdlib.h>
61 #include <string.h>
62 #include <errno.h>
63 #ifdef LINUX
64 #include <typedefs.h>
65 #endif
66 #ifdef WIN32
67 #include <windows.h>
68 #endif
69 #ifdef SOLARIS
70 #include <synch.h>
71 #include <thread.h>
72 #endif
73 #ifdef IRIX
74 #include <ulocks.h>
75 #include <sys/prctl.h>
76 #endif
77 #include "lhash.h"
78 #include "crypto.h"
79 #include "buffer.h"
80 #include "../e_os.h"
81 #include "x509.h"
82 #include "ssl.h"
83 #include "err.h"
84
85 #ifdef WIN16
86 #define APPS_WIN16
87 #include "../crypto/buffer/bss_file.c"
88 #endif
89
90 #define TEST_SERVER_CERT "../apps/server.pem"
91 #define TEST_CLIENT_CERT "../apps/client.pem"
92
93 #define MAX_THREAD_NUMBER       100
94
95 #ifndef NOPROTO
96 int MS_CALLBACK verify_callback(int ok, X509 *xs, X509 *xi, int depth,
97         int error,char *arg);
98 void thread_setup(void);
99 void thread_cleanup(void);
100 void do_threads(SSL_CTX *s_ctx,SSL_CTX *c_ctx);
101 void irix_locking_callback(int mode,int type,char *file,int line);
102 void solaris_locking_callback(int mode,int type,char *file,int line);
103 void win32_locking_callback(int mode,int type,char *file,int line);
104 void linux_locking_callback(int mode,int type,char *file,int line);
105 unsigned long irix_thread_id(void );
106 unsigned long solaris_thread_id(void );
107 unsigned long linix_thread_id(void );
108 #else
109 int MS_CALLBACK verify_callback();
110 void thread_setup();
111 void thread_cleanup();
112 void do_threads();
113 void irix_locking_callback();
114 void solaris_locking_callback();
115 void win32_locking_callback();
116 void linux_locking_callback();
117 unsigned long irix_thread_id();
118 unsigned long solaris_thread_id();
119 unsigned long linix_thread_id();
120 #endif
121
122 BIO *bio_err=NULL;
123 BIO *bio_stdout=NULL;
124
125 static char *cipher=NULL;
126 int verbose=0;
127 #ifdef FIONBIO
128 static int s_nbio=0;
129 #endif
130
131 int thread_number=10;
132 int number_of_loops=10;
133 int reconnect=0;
134 int cache_stats=0;
135
136 #ifndef  NOPROTO
137 int doit(char *ctx[4]);
138 #else
139 int doit();
140 #endif
141
142 static void print_stats(fp,ctx)
143 FILE *fp;
144 SSL_CTX *ctx;
145 {
146         fprintf(fp,"%4ld items in the session cache\n",
147                 SSL_CTX_sess_number(ctx));
148         fprintf(fp,"%4d client connects (SSL_connect())\n",
149                 SSL_CTX_sess_connect(ctx));
150         fprintf(fp,"%4d client connects that finished\n",
151                 SSL_CTX_sess_connect_good(ctx));
152         fprintf(fp,"%4d server connects (SSL_accept())\n",
153                 SSL_CTX_sess_accept(ctx));
154         fprintf(fp,"%4d server connects that finished\n",
155                 SSL_CTX_sess_accept_good(ctx));
156         fprintf(fp,"%4d session cache hits\n",SSL_CTX_sess_hits(ctx));
157         fprintf(fp,"%4d session cache misses\n",SSL_CTX_sess_misses(ctx));
158         fprintf(fp,"%4d session cache timeouts\n",SSL_CTX_sess_timeouts(ctx));
159         }
160
161 static void sv_usage()
162         {
163         fprintf(stderr,"usage: ssltest [args ...]\n");
164         fprintf(stderr,"\n");
165         fprintf(stderr," -server_auth  - check server certificate\n");
166         fprintf(stderr," -client_auth  - do client authentication\n");
167         fprintf(stderr," -v            - more output\n");
168         fprintf(stderr," -CApath arg   - PEM format directory of CA's\n");
169         fprintf(stderr," -CAfile arg   - PEM format file of CA's\n");
170         fprintf(stderr," -threads arg  - number of threads\n");
171         fprintf(stderr," -loops arg    - number of 'connections', per thread\n");
172         fprintf(stderr," -reconnect    - reuse session-id's\n");
173         fprintf(stderr," -stats        - server session-id cache stats\n");
174         fprintf(stderr," -cert arg     - server certificate/key\n");
175         fprintf(stderr," -ccert arg    - client certificate/key\n");
176         fprintf(stderr," -ssl3         - just SSLv3n\n");
177         }
178
179 int main(argc, argv)
180 int argc;
181 char *argv[];
182         {
183         char *CApath=NULL,*CAfile=NULL;
184         int badop=0;
185         int ret=1;
186         int client_auth=0;
187         int server_auth=0;
188         SSL_CTX *s_ctx=NULL;
189         SSL_CTX *c_ctx=NULL;
190         char *scert=TEST_SERVER_CERT;
191         char *ccert=TEST_CLIENT_CERT;
192         SSL_METHOD *ssl_method=SSLv23_method();
193
194         if (bio_err == NULL)
195                 bio_err=BIO_new_fp(stderr,BIO_NOCLOSE);
196         if (bio_stdout == NULL)
197                 bio_stdout=BIO_new_fp(stdout,BIO_NOCLOSE);
198         argc--;
199         argv++;
200
201         while (argc >= 1)
202                 {
203                 if      (strcmp(*argv,"-server_auth") == 0)
204                         server_auth=1;
205                 else if (strcmp(*argv,"-client_auth") == 0)
206                         client_auth=1;
207                 else if (strcmp(*argv,"-reconnect") == 0)
208                         reconnect=1;
209                 else if (strcmp(*argv,"-stats") == 0)
210                         cache_stats=1;
211                 else if (strcmp(*argv,"-ssl3") == 0)
212                         ssl_method=SSLv3_method();
213                 else if (strcmp(*argv,"-ssl2") == 0)
214                         ssl_method=SSLv2_method();
215                 else if (strcmp(*argv,"-CApath") == 0)
216                         {
217                         if (--argc < 1) goto bad;
218                         CApath= *(++argv);
219                         }
220                 else if (strcmp(*argv,"-CAfile") == 0)
221                         {
222                         if (--argc < 1) goto bad;
223                         CAfile= *(++argv);
224                         }
225                 else if (strcmp(*argv,"-cert") == 0)
226                         {
227                         if (--argc < 1) goto bad;
228                         scert= *(++argv);
229                         }
230                 else if (strcmp(*argv,"-ccert") == 0)
231                         {
232                         if (--argc < 1) goto bad;
233                         ccert= *(++argv);
234                         }
235                 else if (strcmp(*argv,"-threads") == 0)
236                         {
237                         if (--argc < 1) goto bad;
238                         thread_number= atoi(*(++argv));
239                         if (thread_number == 0) thread_number=1;
240                         if (thread_number > MAX_THREAD_NUMBER)
241                                 thread_number=MAX_THREAD_NUMBER;
242                         }
243                 else if (strcmp(*argv,"-loops") == 0)
244                         {
245                         if (--argc < 1) goto bad;
246                         number_of_loops= atoi(*(++argv));
247                         if (number_of_loops == 0) number_of_loops=1;
248                         }
249                 else
250                         {
251                         fprintf(stderr,"unknown option %s\n",*argv);
252                         badop=1;
253                         break;
254                         }
255                 argc--;
256                 argv++;
257                 }
258         if (badop)
259                 {
260 bad:
261                 sv_usage();
262                 goto end;
263                 }
264
265         if (cipher == NULL) cipher=getenv("SSL_CIPHER");
266
267         SSL_load_error_strings();
268         SSLeay_add_ssl_algorithms();
269
270         c_ctx=SSL_CTX_new(ssl_method);
271         s_ctx=SSL_CTX_new(ssl_method);
272         if ((c_ctx == NULL) || (s_ctx == NULL))
273                 {
274                 ERR_print_errors(bio_err);
275                 goto end;
276                 }
277
278         SSL_CTX_set_session_cache_mode(s_ctx,
279                 SSL_SESS_CACHE_NO_AUTO_CLEAR|SSL_SESS_CACHE_SERVER);
280         SSL_CTX_set_session_cache_mode(c_ctx,
281                 SSL_SESS_CACHE_NO_AUTO_CLEAR|SSL_SESS_CACHE_SERVER);
282
283         SSL_CTX_use_certificate_file(s_ctx,scert,SSL_FILETYPE_PEM);
284         SSL_CTX_use_RSAPrivateKey_file(s_ctx,scert,SSL_FILETYPE_PEM);
285
286         if (client_auth)
287                 {
288                 SSL_CTX_use_certificate_file(c_ctx,ccert,
289                         SSL_FILETYPE_PEM);
290                 SSL_CTX_use_RSAPrivateKey_file(c_ctx,ccert,
291                         SSL_FILETYPE_PEM);
292                 }
293
294         if (    (!SSL_CTX_load_verify_locations(s_ctx,CAfile,CApath)) ||
295                 (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
296                 (!SSL_CTX_load_verify_locations(c_ctx,CAfile,CApath)) ||
297                 (!SSL_CTX_set_default_verify_paths(c_ctx)))
298                 {
299                 fprintf(stderr,"SSL_load_verify_locations\n");
300                 ERR_print_errors(bio_err);
301                 goto end;
302                 }
303
304         if (client_auth)
305                 {
306                 fprintf(stderr,"client authentication\n");
307                 SSL_CTX_set_verify(s_ctx,
308                         SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
309                         verify_callback);
310                 }
311         if (server_auth)
312                 {
313                 fprintf(stderr,"server authentication\n");
314                 SSL_CTX_set_verify(c_ctx,SSL_VERIFY_PEER,
315                         verify_callback);
316                 }
317
318         thread_setup();
319         do_threads(s_ctx,c_ctx);
320         thread_cleanup();
321 end:
322         
323         if (c_ctx != NULL) 
324                 {
325                 fprintf(stderr,"Client SSL_CTX stats then free it\n");
326                 print_stats(stderr,c_ctx);
327                 SSL_CTX_free(c_ctx);
328                 }
329         if (s_ctx != NULL)
330                 {
331                 fprintf(stderr,"Server SSL_CTX stats then free it\n");
332                 print_stats(stderr,s_ctx);
333                 if (cache_stats)
334                         {
335                         fprintf(stderr,"-----\n");
336                         lh_stats(SSL_CTX_sessions(s_ctx),stderr);
337                         fprintf(stderr,"-----\n");
338                 /*      lh_node_stats(SSL_CTX_sessions(s_ctx),stderr);
339                         fprintf(stderr,"-----\n"); */
340                         lh_node_usage_stats(SSL_CTX_sessions(s_ctx),stderr);
341                         fprintf(stderr,"-----\n");
342                         }
343                 SSL_CTX_free(s_ctx);
344                 fprintf(stderr,"done free\n");
345                 }
346         exit(ret);
347         return(0);
348         }
349
350 #define W_READ  1
351 #define W_WRITE 2
352 #define C_DONE  1
353 #define S_DONE  2
354
355 int ndoit(ssl_ctx)
356 SSL_CTX *ssl_ctx[2];
357         {
358         int i;
359         int ret;
360         char *ctx[4];
361
362         ctx[0]=(char *)ssl_ctx[0];
363         ctx[1]=(char *)ssl_ctx[1];
364
365         if (reconnect)
366                 {
367                 ctx[2]=(char *)SSL_new(ssl_ctx[0]);
368                 ctx[3]=(char *)SSL_new(ssl_ctx[1]);
369                 }
370         else
371                 {
372                 ctx[2]=NULL;
373                 ctx[3]=NULL;
374                 }
375
376         fprintf(stdout,"started thread %lu\n",CRYPTO_thread_id());
377         for (i=0; i<number_of_loops; i++)
378                 {
379 /*              fprintf(stderr,"%4d %2d ctx->ref (%3d,%3d)\n",
380                         CRYPTO_thread_id(),i,
381                         ssl_ctx[0]->references,
382                         ssl_ctx[1]->references); */
383         /*      pthread_delay_np(&tm);*/
384
385                 ret=doit(ctx);
386                 if (ret != 0)
387                         {
388                         fprintf(stdout,"error[%d] %lu - %d\n",
389                                 i,CRYPTO_thread_id(),ret);
390                         return(ret);
391                         }
392                 }
393         fprintf(stdout,"DONE %lu\n",CRYPTO_thread_id());
394         if (reconnect)
395                 {
396                 SSL_free((SSL *)ctx[2]);
397                 SSL_free((SSL *)ctx[3]);
398                 }
399         return(0);
400         }
401
402 int doit(ctx)
403 char *ctx[4];
404         {
405         SSL_CTX *s_ctx,*c_ctx;
406         static char cbuf[200],sbuf[200];
407         SSL *c_ssl=NULL;
408         SSL *s_ssl=NULL;
409         BIO *c_to_s=NULL;
410         BIO *s_to_c=NULL;
411         BIO *c_bio=NULL;
412         BIO *s_bio=NULL;
413         int c_r,c_w,s_r,s_w;
414         int c_want,s_want;
415         int i;
416         int done=0;
417         int c_write,s_write;
418         int do_server=0,do_client=0;
419
420         s_ctx=(SSL_CTX *)ctx[0];
421         c_ctx=(SSL_CTX *)ctx[1];
422
423         if (ctx[2] != NULL)
424                 s_ssl=(SSL *)ctx[2];
425         else
426                 s_ssl=SSL_new(s_ctx);
427
428         if (ctx[3] != NULL)
429                 c_ssl=(SSL *)ctx[3];
430         else
431                 c_ssl=SSL_new(c_ctx);
432
433         if ((s_ssl == NULL) || (c_ssl == NULL)) goto err;
434
435         c_to_s=BIO_new(BIO_s_mem());
436         s_to_c=BIO_new(BIO_s_mem());
437         if ((s_to_c == NULL) || (c_to_s == NULL)) goto err;
438
439         c_bio=BIO_new(BIO_f_ssl());
440         s_bio=BIO_new(BIO_f_ssl());
441         if ((c_bio == NULL) || (s_bio == NULL)) goto err;
442
443         SSL_set_connect_state(c_ssl);
444         SSL_set_bio(c_ssl,s_to_c,c_to_s);
445         BIO_set_ssl(c_bio,c_ssl,(ctx[2] == NULL)?BIO_CLOSE:BIO_NOCLOSE);
446
447         SSL_set_accept_state(s_ssl);
448         SSL_set_bio(s_ssl,c_to_s,s_to_c);
449         BIO_set_ssl(s_bio,s_ssl,(ctx[3] == NULL)?BIO_CLOSE:BIO_NOCLOSE);
450
451         c_r=0; s_r=1;
452         c_w=1; s_w=0;
453         c_want=W_WRITE;
454         s_want=0;
455         c_write=1,s_write=0;
456
457         /* We can always do writes */
458         for (;;)
459                 {
460                 do_server=0;
461                 do_client=0;
462
463                 i=(int)BIO_pending(s_bio);
464                 if ((i && s_r) || s_w) do_server=1;
465
466                 i=(int)BIO_pending(c_bio);
467                 if ((i && c_r) || c_w) do_client=1;
468
469                 if (do_server && verbose)
470                         {
471                         if (SSL_in_init(s_ssl))
472                                 printf("server waiting in SSL_accept - %s\n",
473                                         SSL_state_string_long(s_ssl));
474                         else if (s_write)
475                                 printf("server:SSL_write()\n");
476                         else 
477                                 printf("server:SSL_read()\n");
478                         }
479
480                 if (do_client && verbose)
481                         {
482                         if (SSL_in_init(c_ssl))
483                                 printf("client waiting in SSL_connect - %s\n",
484                                         SSL_state_string_long(c_ssl));
485                         else if (c_write)
486                                 printf("client:SSL_write()\n");
487                         else
488                                 printf("client:SSL_read()\n");
489                         }
490
491                 if (!do_client && !do_server)
492                         {
493                         fprintf(stdout,"ERROR IN STARTUP\n");
494                         break;
495                         }
496                 if (do_client && !(done & C_DONE))
497                         {
498                         if (c_write)
499                                 {
500                                 i=BIO_write(c_bio,"hello from client\n",18);
501                                 if (i < 0)
502                                         {
503                                         c_r=0;
504                                         c_w=0;
505                                         if (BIO_should_retry(c_bio))
506                                                 {
507                                                 if (BIO_should_read(c_bio))
508                                                         c_r=1;
509                                                 if (BIO_should_write(c_bio))
510                                                         c_w=1;
511                                                 }
512                                         else
513                                                 {
514                                                 fprintf(stderr,"ERROR in CLIENT\n");
515                                                 return(1);
516                                                 }
517                                         }
518                                 else if (i == 0)
519                                         {
520                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
521                                         return(1);
522                                         }
523                                 else
524                                         {
525                                         /* ok */
526                                         c_write=0;
527                                         }
528                                 }
529                         else
530                                 {
531                                 i=BIO_read(c_bio,cbuf,100);
532                                 if (i < 0)
533                                         {
534                                         c_r=0;
535                                         c_w=0;
536                                         if (BIO_should_retry(c_bio))
537                                                 {
538                                                 if (BIO_should_read(c_bio))
539                                                         c_r=1;
540                                                 if (BIO_should_write(c_bio))
541                                                         c_w=1;
542                                                 }
543                                         else
544                                                 {
545                                                 fprintf(stderr,"ERROR in CLIENT\n");
546                                                 return(1);
547                                                 }
548                                         }
549                                 else if (i == 0)
550                                         {
551                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
552                                         return(1);
553                                         }
554                                 else
555                                         {
556                                         done|=C_DONE;
557 #ifdef undef
558                                         fprintf(stdout,"CLIENT:from server:");
559                                         fwrite(cbuf,1,i,stdout);
560                                         fflush(stdout);
561 #endif
562                                         }
563                                 }
564                         }
565
566                 if (do_server && !(done & S_DONE))
567                         {
568                         if (!s_write)
569                                 {
570                                 i=BIO_read(s_bio,sbuf,100);
571                                 if (i < 0)
572                                         {
573                                         s_r=0;
574                                         s_w=0;
575                                         if (BIO_should_retry(s_bio))
576                                                 {
577                                                 if (BIO_should_read(s_bio))
578                                                         s_r=1;
579                                                 if (BIO_should_write(s_bio))
580                                                         s_w=1;
581                                                 }
582                                         else
583                                                 {
584                                                 fprintf(stderr,"ERROR in SERVER\n");
585                                                 ERR_print_errors_fp(stderr);
586                                                 return(1);
587                                                 }
588                                         }
589                                 else if (i == 0)
590                                         {
591                                         fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
592                                         return(1);
593                                         }
594                                 else
595                                         {
596                                         s_write=1;
597                                         s_w=1;
598 #ifdef undef
599                                         fprintf(stdout,"SERVER:from client:");
600                                         fwrite(sbuf,1,i,stdout);
601                                         fflush(stdout);
602 #endif
603                                         }
604                                 }
605                         else
606                                 {
607                                 i=BIO_write(s_bio,"hello from server\n",18);
608                                 if (i < 0)
609                                         {
610                                         s_r=0;
611                                         s_w=0;
612                                         if (BIO_should_retry(s_bio))
613                                                 {
614                                                 if (BIO_should_read(s_bio))
615                                                         s_r=1;
616                                                 if (BIO_should_write(s_bio))
617                                                         s_w=1;
618                                                 }
619                                         else
620                                                 {
621                                                 fprintf(stderr,"ERROR in SERVER\n");
622                                                 ERR_print_errors_fp(stderr);
623                                                 return(1);
624                                                 }
625                                         }
626                                 else if (i == 0)
627                                         {
628                                         fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
629                                         return(1);
630                                         }
631                                 else
632                                         {
633                                         s_write=0;
634                                         s_r=1;
635                                         done|=S_DONE;
636                                         }
637                                 }
638                         }
639
640                 if ((done & S_DONE) && (done & C_DONE)) break;
641                 }
642
643         SSL_set_shutdown(c_ssl,SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN);
644         SSL_set_shutdown(s_ssl,SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN);
645
646 #ifdef undef
647         fprintf(stdout,"DONE\n");
648 #endif
649 err:
650         /* We have to set the BIO's to NULL otherwise they will be
651          * free()ed twice.  Once when th s_ssl is SSL_free()ed and
652          * again when c_ssl is SSL_free()ed.
653          * This is a hack required because s_ssl and c_ssl are sharing the same
654          * BIO structure and SSL_set_bio() and SSL_free() automatically
655          * BIO_free non NULL entries.
656          * You should not normally do this or be required to do this */
657
658         if (s_ssl != NULL)
659                 {
660                 s_ssl->rbio=NULL;
661                 s_ssl->wbio=NULL;
662                 }
663         if (c_ssl != NULL)
664                 {
665                 c_ssl->rbio=NULL;
666                 c_ssl->wbio=NULL;
667                 }
668
669         /* The SSL's are optionally freed in the following calls */
670         if (c_to_s != NULL) BIO_free(c_to_s);
671         if (s_to_c != NULL) BIO_free(s_to_c);
672
673         if (c_bio != NULL) BIO_free(c_bio);
674         if (s_bio != NULL) BIO_free(s_bio);
675         return(0);
676         }
677
678 int MS_CALLBACK verify_callback(ok, xs, xi, depth, error, arg)
679 int ok;
680 X509 *xs;
681 X509 *xi;
682 int depth;
683 int error;
684 char *arg;
685         {
686         char buf[256];
687
688         if (verbose)
689                 {
690                 X509_NAME_oneline(X509_get_subject_name(xs),buf,256);
691                 if (ok)
692                         fprintf(stderr,"depth=%d %s\n",depth,buf);
693                 else
694                         fprintf(stderr,"depth=%d error=%d %s\n",depth,error,buf);
695                 }
696         return(ok);
697         }
698
699 #define THREAD_STACK_SIZE (16*1024)
700
701 #ifdef WIN32
702
703 static HANDLE lock_cs[CRYPTO_NUM_LOCKS];
704
705 void thread_setup()
706         {
707         int i;
708
709         for (i=0; i<CRYPTO_NUM_LOCKS; i++)
710                 {
711                 lock_cs[i]=CreateMutex(NULL,FALSE,NULL);
712                 }
713
714         CRYPTO_set_locking_callback((void (*)(int,int,char *,int))win32_locking_callback);
715         /* id callback defined */
716         }
717
718 void thread_cleanup()
719         {
720         int i;
721
722         CRYPTO_set_locking_callback(NULL);
723         for (i=0; i<CRYPTO_NUM_LOCKS; i++)
724                 CloseHandle(lock_cs[i]);
725         }
726
727 void win32_locking_callback(mode,type,file,line)
728 int mode;
729 int type;
730 char *file;
731 int line;
732         {
733         if (mode & CRYPTO_LOCK)
734                 {
735                 WaitForSingleObject(lock_cs[type],INFINITE);
736                 }
737         else
738                 {
739                 ReleaseMutex(lock_cs[type]);
740                 }
741         }
742
743 void do_threads(s_ctx,c_ctx)
744 SSL_CTX *s_ctx,*c_ctx;
745         {
746         double ret;
747         SSL_CTX *ssl_ctx[2];
748         DWORD thread_id[MAX_THREAD_NUMBER];
749         HANDLE thread_handle[MAX_THREAD_NUMBER];
750         int i;
751         SYSTEMTIME start,end;
752
753         ssl_ctx[0]=s_ctx;
754         ssl_ctx[1]=c_ctx;
755
756         GetSystemTime(&start);
757         for (i=0; i<thread_number; i++)
758                 {
759                 thread_handle[i]=CreateThread(NULL,
760                         THREAD_STACK_SIZE,
761                         (LPTHREAD_START_ROUTINE)ndoit,
762                         (void *)ssl_ctx,
763                         0L,
764                         &(thread_id[i]));
765                 }
766
767         printf("reaping\n");
768         for (i=0; i<thread_number; i+=50)
769                 {
770                 int j;
771
772                 j=(thread_number < (i+50))?(thread_number-i):50;
773
774                 if (WaitForMultipleObjects(j,
775                         (CONST HANDLE *)&(thread_handle[i]),TRUE,INFINITE)
776                         == WAIT_FAILED)
777                         {
778                         fprintf(stderr,"WaitForMultipleObjects failed:%d\n",GetLastError());
779                         exit(1);
780                         }
781                 }
782         GetSystemTime(&end);
783
784         if (start.wDayOfWeek > end.wDayOfWeek) end.wDayOfWeek+=7;
785         ret=(end.wDayOfWeek-start.wDayOfWeek)*24;
786
787         ret=(ret+end.wHour-start.wHour)*60;
788         ret=(ret+end.wMinute-start.wMinute)*60;
789         ret=(ret+end.wSecond-start.wSecond);
790         ret+=(end.wMilliseconds-start.wMilliseconds)/1000.0;
791
792         printf("win32 threads done - %.3f seconds\n",ret);
793         }
794
795 #endif
796
797 #ifdef SOLARIS
798
799 static mutex_t lock_cs[CRYPTO_NUM_LOCKS];
800 /*static rwlock_t lock_cs[CRYPTO_NUM_LOCKS]; */
801 static long lock_count[CRYPTO_NUM_LOCKS];
802
803 void thread_setup()
804         {
805         int i;
806
807         for (i=0; i<CRYPTO_NUM_LOCKS; i++)
808                 {
809                 lock_count[i]=0;
810                 /* rwlock_init(&(lock_cs[i]),USYNC_THREAD,NULL); */
811                 mutex_init(&(lock_cs[i]),USYNC_THREAD,NULL);
812                 }
813
814         CRYPTO_set_id_callback((unsigned long (*)())solaris_thread_id);
815         CRYPTO_set_locking_callback((void (*)())solaris_locking_callback);
816         }
817
818 void thread_cleanup()
819         {
820         int i;
821
822         CRYPTO_set_locking_callback(NULL);
823 fprintf(stderr,"cleanup\n");
824         for (i=0; i<CRYPTO_NUM_LOCKS; i++)
825                 {
826                 /* rwlock_destroy(&(lock_cs[i])); */
827                 mutex_destroy(&(lock_cs[i]));
828                 fprintf(stderr,"%8ld:%s\n",lock_count[i],CRYPTO_get_lock_name(i));
829                 }
830 fprintf(stderr,"done cleanup\n");
831         }
832
833 void solaris_locking_callback(mode,type,file,line)
834 int mode;
835 int type;
836 char *file;
837 int line;
838         {
839 #ifdef undef
840 fprintf(stderr,"thread=%4d mode=%s lock=%s %s:%d\n",
841         CRYPTO_thread_id(),
842         (mode&CRYPTO_LOCK)?"l":"u",
843         (type&CRYPTO_READ)?"r":"w",file,line);
844 #endif
845
846 /*
847 if (CRYPTO_LOCK_SSL_CERT == type)
848         fprintf(stderr,"(t,m,f,l) %ld %d %s %d\n",
849                 CRYPTO_thread_id(),
850                 mode,file,line);
851 */
852         if (mode & CRYPTO_LOCK)
853                 {
854         /*      if (mode & CRYPTO_READ)
855                         rw_rdlock(&(lock_cs[type]));
856                 else
857                         rw_wrlock(&(lock_cs[type])); */
858
859                 mutex_lock(&(lock_cs[type]));
860                 lock_count[type]++;
861                 }
862         else
863                 {
864 /*              rw_unlock(&(lock_cs[type]));  */
865                 mutex_unlock(&(lock_cs[type]));
866                 }
867         }
868
869 void do_threads(s_ctx,c_ctx)
870 SSL_CTX *s_ctx,*c_ctx;
871         {
872         SSL_CTX *ssl_ctx[2];
873         thread_t thread_ctx[MAX_THREAD_NUMBER];
874         int i;
875
876         ssl_ctx[0]=s_ctx;
877         ssl_ctx[1]=c_ctx;
878
879         thr_setconcurrency(thread_number);
880         for (i=0; i<thread_number; i++)
881                 {
882                 thr_create(NULL, THREAD_STACK_SIZE,
883                         (void *(*)())ndoit,
884                         (void *)ssl_ctx,
885                         0L,
886                         &(thread_ctx[i]));
887                 }
888
889         printf("reaping\n");
890         for (i=0; i<thread_number; i++)
891                 {
892                 thr_join(thread_ctx[i],NULL,NULL);
893                 }
894
895         printf("solaris threads done (%d,%d)\n",
896                 s_ctx->references,c_ctx->references);
897         }
898
899 unsigned long solaris_thread_id()
900         {
901         unsigned long ret;
902
903         ret=(unsigned long)thr_self();
904         return(ret);
905         }
906 #endif
907
908 #ifdef IRIX
909
910
911 static usptr_t *arena;
912 static usema_t *lock_cs[CRYPTO_NUM_LOCKS];
913
914 void thread_setup()
915         {
916         int i;
917         char filename[20];
918
919         strcpy(filename,"/tmp/mttest.XXXXXX");
920         mktemp(filename);
921
922         usconfig(CONF_STHREADIOOFF);
923         usconfig(CONF_STHREADMALLOCOFF);
924         usconfig(CONF_INITUSERS,100);
925         usconfig(CONF_LOCKTYPE,US_DEBUGPLUS);
926         arena=usinit(filename);
927         unlink(filename);
928
929         for (i=0; i<CRYPTO_NUM_LOCKS; i++)
930                 {
931                 lock_cs[i]=usnewsema(arena,1);
932                 }
933
934         CRYPTO_set_id_callback((unsigned long (*)())irix_thread_id);
935         CRYPTO_set_locking_callback((void (*)())irix_locking_callback);
936         }
937
938 void thread_cleanup()
939         {
940         int i;
941
942         CRYPTO_set_locking_callback(NULL);
943         for (i=0; i<CRYPTO_NUM_LOCKS; i++)
944                 {
945                 char buf[10];
946
947                 sprintf(buf,"%2d:",i);
948                 usdumpsema(lock_cs[i],stdout,buf);
949                 usfreesema(lock_cs[i],arena);
950                 }
951         }
952
953 void irix_locking_callback(mode,type,file,line)
954 int mode;
955 int type;
956 char *file;
957 int line;
958         {
959         if (mode & CRYPTO_LOCK)
960                 {
961                 printf("lock %d\n",type);
962                 uspsema(lock_cs[type]);
963                 }
964         else
965                 {
966                 printf("unlock %d\n",type);
967                 usvsema(lock_cs[type]);
968                 }
969         }
970
971 void do_threads(s_ctx,c_ctx)
972 SSL_CTX *s_ctx,*c_ctx;
973         {
974         SSL_CTX *ssl_ctx[2];
975         int thread_ctx[MAX_THREAD_NUMBER];
976         int i;
977
978         ssl_ctx[0]=s_ctx;
979         ssl_ctx[1]=c_ctx;
980
981         for (i=0; i<thread_number; i++)
982                 {
983                 thread_ctx[i]=sproc((void (*)())ndoit,
984                         PR_SADDR|PR_SFDS,(void *)ssl_ctx);
985                 }
986
987         printf("reaping\n");
988         for (i=0; i<thread_number; i++)
989                 {
990                 wait(NULL);
991                 }
992
993         printf("irix threads done (%d,%d)\n",
994                 s_ctx->references,c_ctx->references);
995         }
996
997 unsigned long irix_thread_id()
998         {
999         unsigned long ret;
1000
1001         ret=(unsigned long)getpid();
1002         return(ret);
1003         }
1004 #endif
1005