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