ssl/ssl_lib.c

   1 /*! \file ssl/ssl_lib.c
   2  *  \brief Version independent SSL functions.
   3  */
   4 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   5  * All rights reserved.
   6  *
   7  * This package is an SSL implementation written
   8  * by Eric Young (eay@cryptsoft.com).
   9  * The implementation was written so as to conform with Netscapes SSL.
  10  *
  11  * This library is free for commercial and non-commercial use as long as
  12  * the following conditions are aheared to.  The following conditions
  13  * apply to all code found in this distribution, be it the RC4, RSA,
  14  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  15  * included with this distribution is covered by the same copyright terms
  16  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  17  *
  18  * Copyright remains Eric Young's, and as such any Copyright notices in
  19  * the code are not to be removed.
  20  * If this package is used in a product, Eric Young should be given attribution
  21  * as the author of the parts of the library used.
  22  * This can be in the form of a textual message at program startup or
  23  * in documentation (online or textual) provided with the package.
  24  *
  25  * Redistribution and use in source and binary forms, with or without
  26  * modification, are permitted provided that the following conditions
  27  * are met:
  28  * 1. Redistributions of source code must retain the copyright
  29  *    notice, this list of conditions and the following disclaimer.
  30  * 2. Redistributions in binary form must reproduce the above copyright
  31  *    notice, this list of conditions and the following disclaimer in the
  32  *    documentation and/or other materials provided with the distribution.
  33  * 3. All advertising materials mentioning features or use of this software
  34  *    must display the following acknowledgement:
  35  *    "This product includes cryptographic software written by
  36  *     Eric Young (eay@cryptsoft.com)"
  37  *    The word 'cryptographic' can be left out if the rouines from the library
  38  *    being used are not cryptographic related :-).
  39  * 4. If you include any Windows specific code (or a derivative thereof) from
  40  *    the apps directory (application code) you must include an acknowledgement:
  41  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  42  *
  43  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  46  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  53  * SUCH DAMAGE.
  54  *
  55  * The licence and distribution terms for any publically available version or
  56  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  57  * copied and put under another distribution licence
  58  * [including the GNU Public Licence.]
  59  */
  60
  61 #include <stdio.h>
  62 #include <openssl/objects.h>
  63 #include <openssl/lhash.h>
  64 #include <openssl/x509v3.h>
  65 #include "ssl_locl.h"
  66
  67 const char *SSL_version_str=OPENSSL_VERSION_TEXT;
  68
  69 static STACK_OF(CRYPTO_EX_DATA_FUNCS) *ssl_meth=NULL;
  70 static STACK_OF(CRYPTO_EX_DATA_FUNCS) *ssl_ctx_meth=NULL;
  71 static int ssl_meth_num=0;
  72 static int ssl_ctx_meth_num=0;
  73
  74 OPENSSL_GLOBAL SSL3_ENC_METHOD ssl3_undef_enc_method={
  75         /* evil casts, but these functions are only called if there's a library bug */
  76         (int (*)(SSL *,int))ssl_undefined_function,
  77         (int (*)(SSL *, unsigned char *, int))ssl_undefined_function,
  78         ssl_undefined_function,
  79         (int (*)(SSL *, unsigned char *, unsigned char *, int))ssl_undefined_function,
  80         (int (*)(SSL*, int))ssl_undefined_function,
  81         (int (*)(SSL *, EVP_MD_CTX *, EVP_MD_CTX *, const char*, int, unsigned char *))ssl_undefined_function
  82         };
  83
  84 union rsa_fn_to_char_u
  85         {
  86         char *char_p;
  87         RSA *(*fn_p)(SSL *, int, int);
  88         };
  89
  90 union dh_fn_to_char_u
  91         {
  92         char *char_p;
  93         DH *(*fn_p)(SSL *, int, int);
  94         };
  95
  96 int SSL_clear(SSL *s)
  97         {
  98         int state;
  99
 100         if (s->method == NULL)
 101                 {
 102                 SSLerr(SSL_F_SSL_CLEAR,SSL_R_NO_METHOD_SPECIFIED);
 103                 return(0);
 104                 }
 105
 106         s->error=0;
 107         s->hit=0;
 108         s->shutdown=0;
 109
 110 #if 0 /* Disabled since version 1.10 of this file (early return not
 111        * needed because SSL_clear is not called when doing renegotiation) */
 112         /* This is set if we are doing dynamic renegotiation so keep
 113          * the old cipher.  It is sort of a SSL_clear_lite :-) */
 114         if (s->new_session) return(1);
 115 #else
 116         if (s->new_session)
 117                 {
 118                 SSLerr(SSL_F_SSL_CLEAR,SSL_R_INTERNAL_ERROR);
 119                 return 0;
 120                 }
 121 #endif
 122
 123         state=s->state; /* Keep to check if we throw away the session-id */
 124         s->type=0;
 125
 126         s->state=SSL_ST_BEFORE|((s->server)?SSL_ST_ACCEPT:SSL_ST_CONNECT);
 127
 128         s->version=s->method->version;
 129         s->client_version=s->version;
 130         s->rwstate=SSL_NOTHING;
 131         s->rstate=SSL_ST_READ_HEADER;
 132         s->read_ahead=s->ctx->read_ahead;
 133
 134         if (s->init_buf != NULL)
 135                 {
 136                 BUF_MEM_free(s->init_buf);
 137                 s->init_buf=NULL;
 138                 }
 139
 140         ssl_clear_cipher_ctx(s);
 141
 142         if (ssl_clear_bad_session(s))
 143                 {
 144                 SSL_SESSION_free(s->session);
 145                 s->session=NULL;
 146                 }
 147
 148         s->first_packet=0;
 149
 150 #if 1
 151         /* Check to see if we were changed into a different method, if
 152          * so, revert back if we are not doing session-id reuse. */
 153         if ((s->session == NULL) && (s->method != s->ctx->method))
 154                 {
 155                 s->method->ssl_free(s);
 156                 s->method=s->ctx->method;
 157                 if (!s->method->ssl_new(s))
 158                         return(0);
 159                 }
 160         else
 161 #endif
 162                 s->method->ssl_clear(s);
 163         return(1);
 164         }
 165
 166 /** Used to change an SSL_CTXs default SSL method type */
 167 int SSL_CTX_set_ssl_version(SSL_CTX *ctx,SSL_METHOD *meth)
 168         {
 169         STACK_OF(SSL_CIPHER) *sk;
 170
 171         ctx->method=meth;
 172
 173         sk=ssl_create_cipher_list(ctx->method,&(ctx->cipher_list),
 174                 &(ctx->cipher_list_by_id),SSL_DEFAULT_CIPHER_LIST);
 175         if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= 0))
 176                 {
 177                 SSLerr(SSL_F_SSL_CTX_SET_SSL_VERSION,SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
 178                 return(0);
 179                 }
 180         return(1);
 181         }
 182
 183 SSL *SSL_new(SSL_CTX *ctx)
 184         {
 185         SSL *s;
 186
 187         if (ctx == NULL)
 188                 {
 189                 SSLerr(SSL_F_SSL_NEW,SSL_R_NULL_SSL_CTX);
 190                 return(NULL);
 191                 }
 192         if (ctx->method == NULL)
 193                 {
 194                 SSLerr(SSL_F_SSL_NEW,SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION);
 195                 return(NULL);
 196                 }
 197
 198         s=(SSL *)Malloc(sizeof(SSL));
 199         if (s == NULL) goto err;
 200         memset(s,0,sizeof(SSL));
 201
 202         if (ctx->cert != NULL)
 203                 {
 204                 /* Earlier library versions used to copy the pointer to
 205                  * the CERT, not its contents; only when setting new
 206                  * parameters for the per-SSL copy, ssl_cert_new would be
 207                  * called (and the direct reference to the per-SSL_CTX
 208                  * settings would be lost, but those still were indirectly
 209                  * accessed for various purposes, and for that reason they
 210                  * used to be known as s->ctx->default_cert).
 211                  * Now we don't look at the SSL_CTX's CERT after having
 212                  * duplicated it once. */
 213
 214                 s->cert = ssl_cert_dup(ctx->cert);
 215                 if (s->cert == NULL)
 216                         goto err;
 217                 }
 218         else
 219                 s->cert=NULL; /* Cannot really happen (see SSL_CTX_new) */
 220         s->sid_ctx_length=ctx->sid_ctx_length;
 221         memcpy(&s->sid_ctx,&ctx->sid_ctx,sizeof(s->sid_ctx));
 222         s->verify_mode=ctx->verify_mode;
 223         s->verify_depth=ctx->verify_depth;
 224         s->verify_callback=ctx->default_verify_callback;
 225         s->purpose = ctx->purpose;
 226         s->trust = ctx->trust;
 227         CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
 228         s->ctx=ctx;
 229
 230         s->verify_result=X509_V_OK;
 231
 232         s->method=ctx->method;
 233
 234         if (!s->method->ssl_new(s))
 235                 goto err;
 236
 237         s->quiet_shutdown=ctx->quiet_shutdown;
 238         s->references=1;
 239         s->server=(ctx->method->ssl_accept == ssl_undefined_function)?0:1;
 240         s->options=ctx->options;
 241         s->mode=ctx->mode;
 242         SSL_clear(s);
 243
 244         CRYPTO_new_ex_data(ssl_meth,s,&s->ex_data);
 245
 246         return(s);
 247 err:
 248         if (s != NULL)
 249                 {
 250                 if (s->cert != NULL)
 251                         ssl_cert_free(s->cert);
 252                 if (s->ctx != NULL)
 253                         SSL_CTX_free(s->ctx); /* decrement reference count */
 254                 Free(s);
 255                 }
 256         SSLerr(SSL_F_SSL_NEW,ERR_R_MALLOC_FAILURE);
 257         return(NULL);
 258         }
 259
 260 int SSL_CTX_set_session_id_context(SSL_CTX *ctx,const unsigned char *sid_ctx,
 261                                    unsigned int sid_ctx_len)
 262     {
 263     if(sid_ctx_len > SSL_MAX_SID_CTX_LENGTH)
 264         {
 265         SSLerr(SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT,SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
 266         return 0;
 267         }
 268     ctx->sid_ctx_length=sid_ctx_len;
 269     memcpy(ctx->sid_ctx,sid_ctx,sid_ctx_len);
 270
 271     return 1;
 272     }
 273
 274 int SSL_set_session_id_context(SSL *ssl,const unsigned char *sid_ctx,
 275                                unsigned int sid_ctx_len)
 276     {
 277     if(sid_ctx_len > SSL_MAX_SID_CTX_LENGTH)
 278         {
 279         SSLerr(SSL_F_SSL_SET_SESSION_ID_CONTEXT,SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
 280         return 0;
 281         }
 282     ssl->sid_ctx_length=sid_ctx_len;
 283     memcpy(ssl->sid_ctx,sid_ctx,sid_ctx_len);
 284
 285     return 1;
 286     }
 287
 288 int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
 289 {
 290         if(X509_PURPOSE_get_by_id(purpose) == -1) {
 291                 SSLerr(SSL_F_SSL_CTX_SET_PURPOSE, SSL_R_INVALID_PURPOSE);
 292                 return 0;
 293         }
 294         s->purpose = purpose;
 295         return 1;
 296 }
 297
 298 int SSL_set_purpose(SSL *s, int purpose)
 299 {
 300         if(X509_PURPOSE_get_by_id(purpose) == -1) {
 301                 SSLerr(SSL_F_SSL_SET_PURPOSE, SSL_R_INVALID_PURPOSE);
 302                 return 0;
 303         }
 304         s->purpose = purpose;
 305         return 1;
 306 }
 307
 308 int SSL_CTX_set_trust(SSL_CTX *s, int trust)
 309 {
 310         if(X509_TRUST_get_by_id(trust) == -1) {
 311                 SSLerr(SSL_F_SSL_CTX_SET_TRUST, SSL_R_INVALID_TRUST);
 312                 return 0;
 313         }
 314         s->trust = trust;
 315         return 1;
 316 }
 317
 318 int SSL_set_trust(SSL *s, int trust)
 319 {
 320         if(X509_TRUST_get_by_id(trust) == -1) {
 321                 SSLerr(SSL_F_SSL_SET_TRUST, SSL_R_INVALID_TRUST);
 322                 return 0;
 323         }
 324         s->trust = trust;
 325         return 1;
 326 }
 327
 328 void SSL_free(SSL *s)
 329         {
 330         int i;
 331
 332         if(s == NULL)
 333             return;
 334
 335         i=CRYPTO_add(&s->references,-1,CRYPTO_LOCK_SSL);
 336 #ifdef REF_PRINT
 337         REF_PRINT("SSL",s);
 338 #endif
 339         if (i > 0) return;
 340 #ifdef REF_CHECK
 341         if (i < 0)
 342                 {
 343                 fprintf(stderr,"SSL_free, bad reference count\n");
 344                 abort(); /* ok */
 345                 }
 346 #endif
 347
 348         CRYPTO_free_ex_data(ssl_meth,(char *)s,&s->ex_data);
 349
 350         if (s->bbio != NULL)
 351                 {
 352                 /* If the buffering BIO is in place, pop it off */
 353                 if (s->bbio == s->wbio)
 354                         {
 355                         s->wbio=BIO_pop(s->wbio);
 356                         }
 357                 BIO_free(s->bbio);
 358                 s->bbio=NULL;
 359                 }
 360         if (s->rbio != NULL)
 361                 BIO_free_all(s->rbio);
 362         if ((s->wbio != NULL) && (s->wbio != s->rbio))
 363                 BIO_free_all(s->wbio);
 364
 365         if (s->init_buf != NULL) BUF_MEM_free(s->init_buf);
 366
 367         /* add extra stuff */
 368         if (s->cipher_list != NULL) sk_SSL_CIPHER_free(s->cipher_list);
 369         if (s->cipher_list_by_id != NULL) sk_SSL_CIPHER_free(s->cipher_list_by_id);
 370
 371         /* Make the next call work :-) */
 372         if (s->session != NULL)
 373                 {
 374                 ssl_clear_bad_session(s);
 375                 SSL_SESSION_free(s->session);
 376                 }
 377
 378         ssl_clear_cipher_ctx(s);
 379
 380         if (s->cert != NULL) ssl_cert_free(s->cert);
 381         /* Free up if allocated */
 382
 383         if (s->ctx) SSL_CTX_free(s->ctx);
 384
 385         if (s->client_CA != NULL)
 386                 sk_X509_NAME_pop_free(s->client_CA,X509_NAME_free);
 387
 388         if (s->method != NULL) s->method->ssl_free(s);
 389
 390         Free(s);
 391         }
 392
 393 void SSL_set_bio(SSL *s,BIO *rbio,BIO *wbio)
 394         {
 395         /* If the output buffering BIO is still in place, remove it
 396          */
 397         if (s->bbio != NULL)
 398                 {
 399                 if (s->wbio == s->bbio)
 400                         {
 401                         s->wbio=s->wbio->next_bio;
 402                         s->bbio->next_bio=NULL;
 403                         }
 404                 }
 405         if ((s->rbio != NULL) && (s->rbio != rbio))
 406                 BIO_free_all(s->rbio);
 407         if ((s->wbio != NULL) && (s->wbio != wbio) && (s->rbio != s->wbio))
 408                 BIO_free_all(s->wbio);
 409         s->rbio=rbio;
 410         s->wbio=wbio;
 411         }
 412
 413 BIO *SSL_get_rbio(SSL *s)
 414         { return(s->rbio); }
 415
 416 BIO *SSL_get_wbio(SSL *s)
 417         { return(s->wbio); }
 418
 419 int SSL_get_fd(SSL *s)
 420         {
 421         int ret= -1;
 422         BIO *b,*r;
 423
 424         b=SSL_get_rbio(s);
 425         r=BIO_find_type(b,BIO_TYPE_DESCRIPTOR);
 426         if (r != NULL)
 427                 BIO_get_fd(r,&ret);
 428         return(ret);
 429         }
 430
 431 #ifndef NO_SOCK
 432 int SSL_set_fd(SSL *s,int fd)
 433         {
 434         int ret=0;
 435         BIO *bio=NULL;
 436
 437         bio=BIO_new(BIO_s_socket());
 438
 439         if (bio == NULL)
 440                 {
 441                 SSLerr(SSL_F_SSL_SET_FD,ERR_R_BUF_LIB);
 442                 goto err;
 443                 }
 444         BIO_set_fd(bio,fd,BIO_NOCLOSE);
 445         SSL_set_bio(s,bio,bio);
 446         ret=1;
 447 err:
 448         return(ret);
 449         }
 450
 451 int SSL_set_wfd(SSL *s,int fd)
 452         {
 453         int ret=0;
 454         BIO *bio=NULL;
 455
 456         if ((s->rbio == NULL) || (BIO_method_type(s->rbio) != BIO_TYPE_SOCKET)
 457                 || ((int)BIO_get_fd(s->rbio,NULL) != fd))
 458                 {
 459                 bio=BIO_new(BIO_s_socket());
 460
 461                 if (bio == NULL)
 462                         { SSLerr(SSL_F_SSL_SET_WFD,ERR_R_BUF_LIB); goto err; }
 463                 BIO_set_fd(bio,fd,BIO_NOCLOSE);
 464                 SSL_set_bio(s,SSL_get_rbio(s),bio);
 465                 }
 466         else
 467                 SSL_set_bio(s,SSL_get_rbio(s),SSL_get_rbio(s));
 468         ret=1;
 469 err:
 470         return(ret);
 471         }
 472
 473 int SSL_set_rfd(SSL *s,int fd)
 474         {
 475         int ret=0;
 476         BIO *bio=NULL;
 477
 478         if ((s->wbio == NULL) || (BIO_method_type(s->wbio) != BIO_TYPE_SOCKET)
 479                 || ((int)BIO_get_fd(s->wbio,NULL) != fd))
 480                 {
 481                 bio=BIO_new(BIO_s_socket());
 482
 483                 if (bio == NULL)
 484                         {
 485                         SSLerr(SSL_F_SSL_SET_RFD,ERR_R_BUF_LIB);
 486                         goto err;
 487                         }
 488                 BIO_set_fd(bio,fd,BIO_NOCLOSE);
 489                 SSL_set_bio(s,bio,SSL_get_wbio(s));
 490                 }
 491         else
 492                 SSL_set_bio(s,SSL_get_wbio(s),SSL_get_wbio(s));
 493         ret=1;
 494 err:
 495         return(ret);
 496         }
 497 #endif
 498
 499
 500 /* return length of latest Finished message we sent, copy to 'buf' */
 501 size_t SSL_get_finished(SSL *s, void *buf, size_t count)
 502         {
 503         size_t ret = 0;
 504
 505         if (s->s3 != NULL)
 506                 {
 507                 ret = s->s3->tmp.finish_md_len;
 508                 if (count > ret)
 509                         count = ret;
 510                 memcpy(buf, s->s3->tmp.finish_md, count);
 511                 }
 512         return ret;
 513         }
 514
 515 /* return length of latest Finished message we expected, copy to 'buf' */
 516 size_t SSL_get_peer_finished(SSL *s, void *buf, size_t count)
 517         {
 518         size_t ret = 0;
 519
 520         if (s->s3 != NULL)
 521                 {
 522                 ret = s->s3->tmp.peer_finish_md_len;
 523                 if (count > ret)
 524                         count = ret;
 525                 memcpy(buf, s->s3->tmp.peer_finish_md, count);
 526                 }
 527         return ret;
 528         }
 529
 530
 531 int SSL_get_verify_mode(SSL *s)
 532         {
 533         return(s->verify_mode);
 534         }
 535
 536 int SSL_get_verify_depth(SSL *s)
 537         {
 538         return(s->verify_depth);
 539         }
 540
 541 int (*SSL_get_verify_callback(SSL *s))(int,X509_STORE_CTX *)
 542         {
 543         return(s->verify_callback);
 544         }
 545
 546 int SSL_CTX_get_verify_mode(SSL_CTX *ctx)
 547         {
 548         return(ctx->verify_mode);
 549         }
 550
 551 int SSL_CTX_get_verify_depth(SSL_CTX *ctx)
 552         {
 553         return(ctx->verify_depth);
 554         }
 555
 556 int (*SSL_CTX_get_verify_callback(SSL_CTX *ctx))(int,X509_STORE_CTX *)
 557         {
 558         return(ctx->default_verify_callback);
 559         }
 560
 561 void SSL_set_verify(SSL *s,int mode,
 562                     int (*callback)(int ok,X509_STORE_CTX *ctx))
 563         {
 564         s->verify_mode=mode;
 565         if (callback != NULL)
 566                 s->verify_callback=callback;
 567         }
 568
 569 void SSL_set_verify_depth(SSL *s,int depth)
 570         {
 571         s->verify_depth=depth;
 572         }
 573
 574 void SSL_set_read_ahead(SSL *s,int yes)
 575         {
 576         s->read_ahead=yes;
 577         }
 578
 579 int SSL_get_read_ahead(SSL *s)
 580         {
 581         return(s->read_ahead);
 582         }
 583
 584 int SSL_pending(SSL *s)
 585         {
 586         return(s->method->ssl_pending(s));
 587         }
 588
 589 X509 *SSL_get_peer_certificate(SSL *s)
 590         {
 591         X509 *r;
 592
 593         if ((s == NULL) || (s->session == NULL))
 594                 r=NULL;
 595         else
 596                 r=s->session->peer;
 597
 598         if (r == NULL) return(r);
 599
 600         CRYPTO_add(&r->references,1,CRYPTO_LOCK_X509);
 601
 602         return(r);
 603         }
 604
 605 STACK_OF(X509) *SSL_get_peer_cert_chain(SSL *s)
 606         {
 607         STACK_OF(X509) *r;
 608
 609         if ((s == NULL) || (s->session == NULL) || (s->session->sess_cert == NULL))
 610                 r=NULL;
 611         else
 612                 r=s->session->sess_cert->cert_chain;
 613
 614         return(r);
 615         }
 616
 617 /* Now in theory, since the calling process own 't' it should be safe to
 618  * modify.  We need to be able to read f without being hassled */
 619 void SSL_copy_session_id(SSL *t,SSL *f)
 620         {
 621         CERT *tmp;
 622
 623         /* Do we need to to SSL locking? */
 624         SSL_set_session(t,SSL_get_session(f));
 625
 626         /* what if we are setup as SSLv2 but want to talk SSLv3 or
 627          * vice-versa */
 628         if (t->method != f->method)
 629                 {
 630                 t->method->ssl_free(t); /* cleanup current */
 631                 t->method=f->method;    /* change method */
 632                 t->method->ssl_new(t);  /* setup new */
 633                 }
 634
 635         tmp=t->cert;
 636         if (f->cert != NULL)
 637                 {
 638                 CRYPTO_add(&f->cert->references,1,CRYPTO_LOCK_SSL_CERT);
 639                 t->cert=f->cert;
 640                 }
 641         else
 642                 t->cert=NULL;
 643         if (tmp != NULL) ssl_cert_free(tmp);
 644         SSL_set_session_id_context(t,f->sid_ctx,f->sid_ctx_length);
 645         }
 646
 647 /* Fix this so it checks all the valid key/cert options */
 648 int SSL_CTX_check_private_key(SSL_CTX *ctx)
 649         {
 650         if (    (ctx == NULL) ||
 651                 (ctx->cert == NULL) ||
 652                 (ctx->cert->key->x509 == NULL))
 653                 {
 654                 SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
 655                 return(0);
 656                 }
 657         if      (ctx->cert->key->privatekey == NULL)
 658                 {
 659                 SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,SSL_R_NO_PRIVATE_KEY_ASSIGNED);
 660                 return(0);
 661                 }
 662         return(X509_check_private_key(ctx->cert->key->x509, ctx->cert->key->privatekey));
 663         }
 664
 665 /* Fix this function so that it takes an optional type parameter */
 666 int SSL_check_private_key(SSL *ssl)
 667         {
 668         if (ssl == NULL)
 669                 {
 670                 SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,ERR_R_PASSED_NULL_PARAMETER);
 671                 return(0);
 672                 }
 673         if (ssl->cert == NULL)
 674                 {
 675                 SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
 676                 return 0;
 677                 }
 678         if (ssl->cert->key->x509 == NULL)
 679                 {
 680                 SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
 681                 return(0);
 682                 }
 683         if (ssl->cert->key->privatekey == NULL)
 684                 {
 685                 SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_PRIVATE_KEY_ASSIGNED);
 686                 return(0);
 687                 }
 688         return(X509_check_private_key(ssl->cert->key->x509,
 689                 ssl->cert->key->privatekey));
 690         }
 691
 692 int SSL_accept(SSL *s)
 693         {
 694         if (s->handshake_func == 0)
 695                 /* Not properly initialized yet */
 696                 SSL_set_accept_state(s);
 697
 698         return(s->method->ssl_accept(s));
 699         }
 700
 701 int SSL_connect(SSL *s)
 702         {
 703         if (s->handshake_func == 0)
 704                 /* Not properly initialized yet */
 705                 SSL_set_connect_state(s);
 706
 707         return(s->method->ssl_connect(s));
 708         }
 709
 710 long SSL_get_default_timeout(SSL *s)
 711         {
 712         return(s->method->get_timeout());
 713         }
 714
 715 int SSL_read(SSL *s,char *buf,int num)
 716         {
 717         if (s->handshake_func == 0)
 718                 {
 719                 SSLerr(SSL_F_SSL_READ, SSL_R_UNINITIALIZED);
 720                 return -1;
 721                 }
 722
 723         if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
 724                 {
 725                 s->rwstate=SSL_NOTHING;
 726                 return(0);
 727                 }
 728         return(s->method->ssl_read(s,buf,num));
 729         }
 730
 731 int SSL_peek(SSL *s,char *buf,int num)
 732         {
 733         if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
 734                 {
 735                 return(0);
 736                 }
 737         return(s->method->ssl_peek(s,buf,num));
 738         }
 739
 740 int SSL_write(SSL *s,const char *buf,int num)
 741         {
 742         if (s->handshake_func == 0)
 743                 {
 744                 SSLerr(SSL_F_SSL_WRITE, SSL_R_UNINITIALIZED);
 745                 return -1;
 746                 }
 747
 748         if (s->shutdown & SSL_SENT_SHUTDOWN)
 749                 {
 750                 s->rwstate=SSL_NOTHING;
 751                 SSLerr(SSL_F_SSL_WRITE,SSL_R_PROTOCOL_IS_SHUTDOWN);
 752                 return(-1);
 753                 }
 754         return(s->method->ssl_write(s,buf,num));
 755         }
 756
 757 int SSL_shutdown(SSL *s)
 758         {
 759         /* Note that this function behaves differently from what one might
 760          * expect.  Return values are 0 for no success (yet),
 761          * 1 for success; but calling it once is usually not enough,
 762          * even if blocking I/O is used (see ssl3_shutdown).
 763          */
 764
 765         if (s->handshake_func == 0)
 766                 {
 767                 SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_UNINITIALIZED);
 768                 return -1;
 769                 }
 770
 771         if ((s != NULL) && !SSL_in_init(s))
 772                 return(s->method->ssl_shutdown(s));
 773         else
 774                 return(1);
 775         }
 776
 777 int SSL_renegotiate(SSL *s)
 778         {
 779         s->new_session=1;
 780         return(s->method->ssl_renegotiate(s));
 781         }
 782
 783 long SSL_ctrl(SSL *s,int cmd,long larg,char *parg)
 784         {
 785         long l;
 786
 787         switch (cmd)
 788                 {
 789         case SSL_CTRL_GET_READ_AHEAD:
 790                 return(s->read_ahead);
 791         case SSL_CTRL_SET_READ_AHEAD:
 792                 l=s->read_ahead;
 793                 s->read_ahead=larg;
 794                 return(l);
 795         case SSL_CTRL_OPTIONS:
 796                 return(s->options|=larg);
 797         case SSL_CTRL_MODE:
 798                 return(s->mode|=larg);
 799         default:
 800                 return(s->method->ssl_ctrl(s,cmd,larg,parg));
 801                 }
 802         }
 803
 804 long SSL_callback_ctrl(SSL *s, int cmd, void (*fp)())
 805         {
 806         switch(cmd)
 807                 {
 808         default:
 809                 return(s->method->ssl_callback_ctrl(s,cmd,fp));
 810                 }
 811         }
 812
 813 long SSL_CTX_ctrl(SSL_CTX *ctx,int cmd,long larg,char *parg)
 814         {
 815         long l;
 816
 817         switch (cmd)
 818                 {
 819         case SSL_CTRL_GET_READ_AHEAD:
 820                 return(ctx->read_ahead);
 821         case SSL_CTRL_SET_READ_AHEAD:
 822                 l=ctx->read_ahead;
 823                 ctx->read_ahead=larg;
 824                 return(l);
 825
 826         case SSL_CTRL_SET_SESS_CACHE_SIZE:
 827                 l=ctx->session_cache_size;
 828                 ctx->session_cache_size=larg;
 829                 return(l);
 830         case SSL_CTRL_GET_SESS_CACHE_SIZE:
 831                 return(ctx->session_cache_size);
 832         case SSL_CTRL_SET_SESS_CACHE_MODE:
 833                 l=ctx->session_cache_mode;
 834                 ctx->session_cache_mode=larg;
 835                 return(l);
 836         case SSL_CTRL_GET_SESS_CACHE_MODE:
 837                 return(ctx->session_cache_mode);
 838
 839         case SSL_CTRL_SESS_NUMBER:
 840                 return(ctx->sessions->num_items);
 841         case SSL_CTRL_SESS_CONNECT:
 842                 return(ctx->stats.sess_connect);
 843         case SSL_CTRL_SESS_CONNECT_GOOD:
 844                 return(ctx->stats.sess_connect_good);
 845         case SSL_CTRL_SESS_CONNECT_RENEGOTIATE:
 846                 return(ctx->stats.sess_connect_renegotiate);
 847         case SSL_CTRL_SESS_ACCEPT:
 848                 return(ctx->stats.sess_accept);
 849         case SSL_CTRL_SESS_ACCEPT_GOOD:
 850                 return(ctx->stats.sess_accept_good);
 851         case SSL_CTRL_SESS_ACCEPT_RENEGOTIATE:
 852                 return(ctx->stats.sess_accept_renegotiate);
 853         case SSL_CTRL_SESS_HIT:
 854                 return(ctx->stats.sess_hit);
 855         case SSL_CTRL_SESS_CB_HIT:
 856                 return(ctx->stats.sess_cb_hit);
 857         case SSL_CTRL_SESS_MISSES:
 858                 return(ctx->stats.sess_miss);
 859         case SSL_CTRL_SESS_TIMEOUTS:
 860                 return(ctx->stats.sess_timeout);
 861         case SSL_CTRL_SESS_CACHE_FULL:
 862                 return(ctx->stats.sess_cache_full);
 863         case SSL_CTRL_OPTIONS:
 864                 return(ctx->options|=larg);
 865         case SSL_CTRL_MODE:
 866                 return(ctx->mode|=larg);
 867         default:
 868                 return(ctx->method->ssl_ctx_ctrl(ctx,cmd,larg,parg));
 869                 }
 870         }
 871
 872 long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)())
 873         {
 874         switch(cmd)
 875                 {
 876         default:
 877                 return(ctx->method->ssl_ctx_callback_ctrl(ctx,cmd,fp));
 878                 }
 879         }
 880
 881 int ssl_cipher_id_cmp(SSL_CIPHER *a,SSL_CIPHER *b)
 882         {
 883         long l;
 884
 885         l=a->id-b->id;
 886         if (l == 0L)
 887                 return(0);
 888         else
 889                 return((l > 0)?1:-1);
 890         }
 891
 892 int ssl_cipher_ptr_id_cmp(SSL_CIPHER **ap,SSL_CIPHER **bp)
 893         {
 894         long l;
 895
 896         l=(*ap)->id-(*bp)->id;
 897         if (l == 0L)
 898                 return(0);
 899         else
 900                 return((l > 0)?1:-1);
 901         }
 902
 903 /** return a STACK of the ciphers available for the SSL and in order of
 904  * preference */
 905 STACK_OF(SSL_CIPHER) *SSL_get_ciphers(SSL *s)
 906         {
 907         if ((s != NULL) && (s->cipher_list != NULL))
 908                 {
 909                 return(s->cipher_list);
 910                 }
 911         else if ((s->ctx != NULL) &&
 912                 (s->ctx->cipher_list != NULL))
 913                 {
 914                 return(s->ctx->cipher_list);
 915                 }
 916         return(NULL);
 917         }
 918
 919 /** return a STACK of the ciphers available for the SSL and in order of
 920  * algorithm id */
 921 STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s)
 922         {
 923         if ((s != NULL) && (s->cipher_list_by_id != NULL))
 924                 {
 925                 return(s->cipher_list_by_id);
 926                 }
 927         else if ((s != NULL) && (s->ctx != NULL) &&
 928                 (s->ctx->cipher_list_by_id != NULL))
 929                 {
 930                 return(s->ctx->cipher_list_by_id);
 931                 }
 932         return(NULL);
 933         }
 934
 935 /** The old interface to get the same thing as SSL_get_ciphers() */
 936 const char *SSL_get_cipher_list(SSL *s,int n)
 937         {
 938         SSL_CIPHER *c;
 939         STACK_OF(SSL_CIPHER) *sk;
 940
 941         if (s == NULL) return(NULL);
 942         sk=SSL_get_ciphers(s);
 943         if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= n))
 944                 return(NULL);
 945         c=sk_SSL_CIPHER_value(sk,n);
 946         if (c == NULL) return(NULL);
 947         return(c->name);
 948         }
 949
 950 /** specify the ciphers to be used by default by the SSL_CTX */
 951 int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
 952         {
 953         STACK_OF(SSL_CIPHER) *sk;
 954
 955         sk=ssl_create_cipher_list(ctx->method,&ctx->cipher_list,
 956                 &ctx->cipher_list_by_id,str);
 957 /* XXXX */
 958         return((sk == NULL)?0:1);
 959         }
 960
 961 /** specify the ciphers to be used by the SSL */
 962 int SSL_set_cipher_list(SSL *s,const char *str)
 963         {
 964         STACK_OF(SSL_CIPHER) *sk;
 965
 966         sk=ssl_create_cipher_list(s->ctx->method,&s->cipher_list,
 967                 &s->cipher_list_by_id,str);
 968 /* XXXX */
 969         return((sk == NULL)?0:1);
 970         }
 971
 972 /* works well for SSLv2, not so good for SSLv3 */
 973 char *SSL_get_shared_ciphers(SSL *s,char *buf,int len)
 974         {
 975         char *p;
 976         const char *cp;
 977         STACK_OF(SSL_CIPHER) *sk;
 978         SSL_CIPHER *c;
 979         int i;
 980
 981         if ((s->session == NULL) || (s->session->ciphers == NULL) ||
 982                 (len < 2))
 983                 return(NULL);
 984
 985         p=buf;
 986         sk=s->session->ciphers;
 987         for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
 988                 {
 989                 /* Decrement for either the ':' or a '\0' */
 990                 len--;
 991                 c=sk_SSL_CIPHER_value(sk,i);
 992                 for (cp=c->name; *cp; )
 993                         {
 994                         if (len-- == 0)
 995                                 {
 996                                 *p='\0';
 997                                 return(buf);
 998                                 }
 999                         else
1000                                 *(p++)= *(cp++);
1001                         }
1002                 *(p++)=':';
1003                 }
1004         p[-1]='\0';
1005         return(buf);
1006         }
1007
1008 int ssl_cipher_list_to_bytes(SSL *s,STACK_OF(SSL_CIPHER) *sk,unsigned char *p)
1009         {
1010         int i,j=0;
1011         SSL_CIPHER *c;
1012         unsigned char *q;
1013
1014         if (sk == NULL) return(0);
1015         q=p;
1016
1017         for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
1018                 {
1019                 c=sk_SSL_CIPHER_value(sk,i);
1020                 j=ssl_put_cipher_by_char(s,c,p);
1021                 p+=j;
1022                 }
1023         return(p-q);
1024         }
1025
1026 STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,unsigned char *p,int num,
1027                                                STACK_OF(SSL_CIPHER) **skp)
1028         {
1029         SSL_CIPHER *c;
1030         STACK_OF(SSL_CIPHER) *sk;
1031         int i,n;
1032
1033         n=ssl_put_cipher_by_char(s,NULL,NULL);
1034         if ((num%n) != 0)
1035                 {
1036                 SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
1037                 return(NULL);
1038                 }
1039         if ((skp == NULL) || (*skp == NULL))
1040                 sk=sk_SSL_CIPHER_new(NULL); /* change perhaps later */
1041         else
1042                 {
1043                 sk= *skp;
1044                 sk_SSL_CIPHER_zero(sk);
1045                 }
1046
1047         for (i=0; i<num; i+=n)
1048                 {
1049                 c=ssl_get_cipher_by_char(s,p);
1050                 p+=n;
1051                 if (c != NULL)
1052                         {
1053                         if (!sk_SSL_CIPHER_push(sk,c))
1054                                 {
1055                                 SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,ERR_R_MALLOC_FAILURE);
1056                                 goto err;
1057                                 }
1058                         }
1059                 }
1060
1061         if (skp != NULL)
1062                 *skp=sk;
1063         return(sk);
1064 err:
1065         if ((skp == NULL) || (*skp == NULL))
1066                 sk_SSL_CIPHER_free(sk);
1067         return(NULL);
1068         }
1069
1070 unsigned long SSL_SESSION_hash(SSL_SESSION *a)
1071         {
1072         unsigned long l;
1073
1074         l=(unsigned long)
1075                 ((unsigned int) a->session_id[0]     )|
1076                 ((unsigned int) a->session_id[1]<< 8L)|
1077                 ((unsigned long)a->session_id[2]<<16L)|
1078                 ((unsigned long)a->session_id[3]<<24L);
1079         return(l);
1080         }
1081
1082 int SSL_SESSION_cmp(SSL_SESSION *a,SSL_SESSION *b)
1083         {
1084         if (a->ssl_version != b->ssl_version)
1085                 return(1);
1086         if (a->session_id_length != b->session_id_length)
1087                 return(1);
1088         return(memcmp(a->session_id,b->session_id,a->session_id_length));
1089         }
1090
1091 SSL_CTX *SSL_CTX_new(SSL_METHOD *meth)
1092         {
1093         SSL_CTX *ret=NULL;
1094
1095         if (meth == NULL)
1096                 {
1097                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_NULL_SSL_METHOD_PASSED);
1098                 return(NULL);
1099                 }
1100
1101         if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0)
1102                 {
1103                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
1104                 goto err;
1105                 }
1106         ret=(SSL_CTX *)Malloc(sizeof(SSL_CTX));
1107         if (ret == NULL)
1108                 goto err;
1109
1110         memset(ret,0,sizeof(SSL_CTX));
1111
1112         ret->method=meth;
1113
1114         ret->cert_store=NULL;
1115         ret->session_cache_mode=SSL_SESS_CACHE_SERVER;
1116         ret->session_cache_size=SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
1117         ret->session_cache_head=NULL;
1118         ret->session_cache_tail=NULL;
1119
1120         /* We take the system default */
1121         ret->session_timeout=meth->get_timeout();
1122
1123         ret->new_session_cb=NULL;
1124         ret->remove_session_cb=NULL;
1125         ret->get_session_cb=NULL;
1126
1127         memset((char *)&ret->stats,0,sizeof(ret->stats));
1128
1129         ret->references=1;
1130         ret->quiet_shutdown=0;
1131
1132 /*      ret->cipher=NULL;*/
1133 /*      ret->s2->challenge=NULL;
1134         ret->master_key=NULL;
1135         ret->key_arg=NULL;
1136         ret->s2->conn_id=NULL; */
1137
1138         ret->info_callback=NULL;
1139
1140         ret->app_verify_callback=NULL;
1141         ret->app_verify_arg=NULL;
1142
1143         ret->read_ahead=0;
1144         ret->verify_mode=SSL_VERIFY_NONE;
1145         ret->verify_depth=-1; /* Don't impose a limit (but x509_lu.c does) */
1146         ret->default_verify_callback=NULL;
1147         if ((ret->cert=ssl_cert_new()) == NULL)
1148                 goto err;
1149
1150         ret->default_passwd_callback=NULL;
1151         ret->default_passwd_callback_userdata=NULL;
1152         ret->client_cert_cb=NULL;
1153
1154         ret->sessions=lh_new(SSL_SESSION_hash,SSL_SESSION_cmp);
1155         if (ret->sessions == NULL) goto err;
1156         ret->cert_store=X509_STORE_new();
1157         if (ret->cert_store == NULL) goto err;
1158
1159         ssl_create_cipher_list(ret->method,
1160                 &ret->cipher_list,&ret->cipher_list_by_id,
1161                 SSL_DEFAULT_CIPHER_LIST);
1162         if (ret->cipher_list == NULL
1163             || sk_SSL_CIPHER_num(ret->cipher_list) <= 0)
1164                 {
1165                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_LIBRARY_HAS_NO_CIPHERS);
1166                 goto err2;
1167                 }
1168
1169         if ((ret->rsa_md5=EVP_get_digestbyname("ssl2-md5")) == NULL)
1170                 {
1171                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL2_MD5_ROUTINES);
1172                 goto err2;
1173                 }
1174         if ((ret->md5=EVP_get_digestbyname("ssl3-md5")) == NULL)
1175                 {
1176                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES);
1177                 goto err2;
1178                 }
1179         if ((ret->sha1=EVP_get_digestbyname("ssl3-sha1")) == NULL)
1180                 {
1181                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES);
1182                 goto err2;
1183                 }
1184
1185         if ((ret->client_CA=sk_X509_NAME_new_null()) == NULL)
1186                 goto err;
1187
1188         CRYPTO_new_ex_data(ssl_ctx_meth,(char *)ret,&ret->ex_data);
1189
1190         ret->extra_certs=NULL;
1191         ret->comp_methods=SSL_COMP_get_compression_methods();
1192
1193         return(ret);
1194 err:
1195         SSLerr(SSL_F_SSL_CTX_NEW,ERR_R_MALLOC_FAILURE);
1196 err2:
1197         if (ret != NULL) SSL_CTX_free(ret);
1198         return(NULL);
1199         }
1200
1201 static void SSL_COMP_free(SSL_COMP *comp)
1202     { Free(comp); }
1203
1204 void SSL_CTX_free(SSL_CTX *a)
1205         {
1206         int i;
1207
1208         if (a == NULL) return;
1209
1210         i=CRYPTO_add(&a->references,-1,CRYPTO_LOCK_SSL_CTX);
1211 #ifdef REF_PRINT
1212         REF_PRINT("SSL_CTX",a);
1213 #endif
1214         if (i > 0) return;
1215 #ifdef REF_CHECK
1216         if (i < 0)
1217                 {
1218                 fprintf(stderr,"SSL_CTX_free, bad reference count\n");
1219                 abort(); /* ok */
1220                 }
1221 #endif
1222         CRYPTO_free_ex_data(ssl_ctx_meth,(char *)a,&a->ex_data);
1223
1224         if (a->sessions != NULL)
1225                 {
1226                 SSL_CTX_flush_sessions(a,0);
1227                 lh_free(a->sessions);
1228                 }
1229         if (a->cert_store != NULL)
1230                 X509_STORE_free(a->cert_store);
1231         if (a->cipher_list != NULL)
1232                 sk_SSL_CIPHER_free(a->cipher_list);
1233         if (a->cipher_list_by_id != NULL)
1234                 sk_SSL_CIPHER_free(a->cipher_list_by_id);
1235         if (a->cert != NULL)
1236                 ssl_cert_free(a->cert);
1237         if (a->client_CA != NULL)
1238                 sk_X509_NAME_pop_free(a->client_CA,X509_NAME_free);
1239         if (a->extra_certs != NULL)
1240                 sk_X509_pop_free(a->extra_certs,X509_free);
1241         if (a->comp_methods != NULL)
1242                 sk_SSL_COMP_pop_free(a->comp_methods,SSL_COMP_free);
1243         Free(a);
1244         }
1245
1246 void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
1247         {
1248         ctx->default_passwd_callback=cb;
1249         }
1250
1251 void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx,void *u)
1252         {
1253         ctx->default_passwd_callback_userdata=u;
1254         }
1255
1256 void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,int (*cb)(),char *arg)
1257         {
1258         /* now
1259          *     int (*cb)(X509_STORE_CTX *),
1260          * but should be
1261          *     int (*cb)(X509_STORE_CTX *, void *arg)
1262          */
1263         ctx->app_verify_callback=cb;
1264         ctx->app_verify_arg=arg; /* never used */
1265         }
1266
1267 void SSL_CTX_set_verify(SSL_CTX *ctx,int mode,int (*cb)(int, X509_STORE_CTX *))
1268         {
1269         ctx->verify_mode=mode;
1270         ctx->default_verify_callback=cb;
1271         /* This needs cleaning up EAY EAY EAY */
1272         X509_STORE_set_verify_cb_func(ctx->cert_store,cb);
1273         }
1274
1275 void SSL_CTX_set_verify_depth(SSL_CTX *ctx,int depth)
1276         {
1277         ctx->verify_depth=depth;
1278         }
1279
1280 void ssl_set_cert_masks(CERT *c, SSL_CIPHER *cipher)
1281         {
1282         CERT_PKEY *cpk;
1283         int rsa_enc,rsa_tmp,rsa_sign,dh_tmp,dh_rsa,dh_dsa,dsa_sign;
1284         int rsa_enc_export,dh_rsa_export,dh_dsa_export;
1285         int rsa_tmp_export,dh_tmp_export,kl;
1286         unsigned long mask,emask;
1287
1288         if (c == NULL) return;
1289
1290         kl=SSL_C_EXPORT_PKEYLENGTH(cipher);
1291
1292 #ifndef NO_RSA
1293         rsa_tmp=(c->rsa_tmp != NULL || c->rsa_tmp_cb != NULL);
1294         rsa_tmp_export=(c->rsa_tmp_cb != NULL ||
1295                 (rsa_tmp && RSA_size(c->rsa_tmp)*8 <= kl));
1296 #else
1297         rsa_tmp=rsa_tmp_export=0;
1298 #endif
1299 #ifndef NO_DH
1300         dh_tmp=(c->dh_tmp != NULL || c->dh_tmp_cb != NULL);
1301         dh_tmp_export=(c->dh_tmp_cb != NULL ||
1302                 (dh_tmp && DH_size(c->dh_tmp)*8 <= kl));
1303 #else
1304         dh_tmp=dh_tmp_export=0;
1305 #endif
1306
1307         cpk= &(c->pkeys[SSL_PKEY_RSA_ENC]);
1308         rsa_enc= (cpk->x509 != NULL && cpk->privatekey != NULL);
1309         rsa_enc_export=(rsa_enc && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
1310         cpk= &(c->pkeys[SSL_PKEY_RSA_SIGN]);
1311         rsa_sign=(cpk->x509 != NULL && cpk->privatekey != NULL);
1312         cpk= &(c->pkeys[SSL_PKEY_DSA_SIGN]);
1313         dsa_sign=(cpk->x509 != NULL && cpk->privatekey != NULL);
1314         cpk= &(c->pkeys[SSL_PKEY_DH_RSA]);
1315         dh_rsa=  (cpk->x509 != NULL && cpk->privatekey != NULL);
1316         dh_rsa_export=(dh_rsa && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
1317         cpk= &(c->pkeys[SSL_PKEY_DH_DSA]);
1318 /* FIX THIS EAY EAY EAY */
1319         dh_dsa=  (cpk->x509 != NULL && cpk->privatekey != NULL);
1320         dh_dsa_export=(dh_dsa && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
1321
1322         mask=0;
1323         emask=0;
1324
1325 #ifdef CIPHER_DEBUG
1326         printf("rt=%d rte=%d dht=%d re=%d ree=%d rs=%d ds=%d dhr=%d dhd=%d\n",
1327                 rsa_tmp,rsa_tmp_export,dh_tmp,
1328                 rsa_enc,rsa_enc_export,rsa_sign,dsa_sign,dh_rsa,dh_dsa);
1329 #endif
1330
1331         if (rsa_enc || (rsa_tmp && rsa_sign))
1332                 mask|=SSL_kRSA;
1333         if (rsa_enc_export || (rsa_tmp_export && (rsa_sign || rsa_enc)))
1334                 emask|=SSL_kRSA;
1335
1336 #if 0
1337         /* The match needs to be both kEDH and aRSA or aDSA, so don't worry */
1338         if (    (dh_tmp || dh_rsa || dh_dsa) &&
1339                 (rsa_enc || rsa_sign || dsa_sign))
1340                 mask|=SSL_kEDH;
1341         if ((dh_tmp_export || dh_rsa_export || dh_dsa_export) &&
1342                 (rsa_enc || rsa_sign || dsa_sign))
1343                 emask|=SSL_kEDH;
1344 #endif
1345
1346         if (dh_tmp_export)
1347                 emask|=SSL_kEDH;
1348
1349         if (dh_tmp)
1350                 mask|=SSL_kEDH;
1351
1352         if (dh_rsa) mask|=SSL_kDHr;
1353         if (dh_rsa_export) emask|=SSL_kDHr;
1354
1355         if (dh_dsa) mask|=SSL_kDHd;
1356         if (dh_dsa_export) emask|=SSL_kDHd;
1357
1358         if (rsa_enc || rsa_sign)
1359                 {
1360                 mask|=SSL_aRSA;
1361                 emask|=SSL_aRSA;
1362                 }
1363
1364         if (dsa_sign)
1365                 {
1366                 mask|=SSL_aDSS;
1367                 emask|=SSL_aDSS;
1368                 }
1369
1370         mask|=SSL_aNULL;
1371         emask|=SSL_aNULL;
1372
1373         c->mask=mask;
1374         c->export_mask=emask;
1375         c->valid=1;
1376         }
1377
1378 /* THIS NEEDS CLEANING UP */
1379 X509 *ssl_get_server_send_cert(SSL *s)
1380         {
1381         unsigned long alg,mask,kalg;
1382         CERT *c;
1383         int i,is_export;
1384
1385         c=s->cert;
1386         ssl_set_cert_masks(c, s->s3->tmp.new_cipher);
1387         alg=s->s3->tmp.new_cipher->algorithms;
1388         is_export=SSL_C_IS_EXPORT(s->s3->tmp.new_cipher);
1389         mask=is_export?c->export_mask:c->mask;
1390         kalg=alg&(SSL_MKEY_MASK|SSL_AUTH_MASK);
1391
1392         if      (kalg & SSL_kDHr)
1393                 i=SSL_PKEY_DH_RSA;
1394         else if (kalg & SSL_kDHd)
1395                 i=SSL_PKEY_DH_DSA;
1396         else if (kalg & SSL_aDSS)
1397                 i=SSL_PKEY_DSA_SIGN;
1398         else if (kalg & SSL_aRSA)
1399                 {
1400                 if (c->pkeys[SSL_PKEY_RSA_ENC].x509 == NULL)
1401                         i=SSL_PKEY_RSA_SIGN;
1402                 else
1403                         i=SSL_PKEY_RSA_ENC;
1404                 }
1405         else /* if (kalg & SSL_aNULL) */
1406                 {
1407                 SSLerr(SSL_F_SSL_GET_SERVER_SEND_CERT,SSL_R_INTERNAL_ERROR);
1408                 return(NULL);
1409                 }
1410         if (c->pkeys[i].x509 == NULL) return(NULL);
1411         return(c->pkeys[i].x509);
1412         }
1413
1414 EVP_PKEY *ssl_get_sign_pkey(SSL *s,SSL_CIPHER *cipher)
1415         {
1416         unsigned long alg;
1417         CERT *c;
1418
1419         alg=cipher->algorithms;
1420         c=s->cert;
1421
1422         if ((alg & SSL_aDSS) &&
1423                 (c->pkeys[SSL_PKEY_DSA_SIGN].privatekey != NULL))
1424                 return(c->pkeys[SSL_PKEY_DSA_SIGN].privatekey);
1425         else if (alg & SSL_aRSA)
1426                 {
1427                 if (c->pkeys[SSL_PKEY_RSA_SIGN].privatekey != NULL)
1428                         return(c->pkeys[SSL_PKEY_RSA_SIGN].privatekey);
1429                 else if (c->pkeys[SSL_PKEY_RSA_ENC].privatekey != NULL)
1430                         return(c->pkeys[SSL_PKEY_RSA_ENC].privatekey);
1431                 else
1432                         return(NULL);
1433                 }
1434         else /* if (alg & SSL_aNULL) */
1435                 {
1436                 SSLerr(SSL_F_SSL_GET_SIGN_PKEY,SSL_R_INTERNAL_ERROR);
1437                 return(NULL);
1438                 }
1439         }
1440
1441 void ssl_update_cache(SSL *s,int mode)
1442         {
1443         int i;
1444
1445         /* If the session_id_length is 0, we are not supposed to cache it,
1446          * and it would be rather hard to do anyway :-) */
1447         if (s->session->session_id_length == 0) return;
1448
1449         if ((s->ctx->session_cache_mode & mode)
1450                 && (!s->hit)
1451                 && SSL_CTX_add_session(s->ctx,s->session)
1452                 && (s->ctx->new_session_cb != NULL))
1453                 {
1454                 CRYPTO_add(&s->session->references,1,CRYPTO_LOCK_SSL_SESSION);
1455                 if (!s->ctx->new_session_cb(s,s->session))
1456                         SSL_SESSION_free(s->session);
1457                 }
1458
1459         /* auto flush every 255 connections */
1460         i=s->ctx->session_cache_mode;
1461         if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) &&
1462                 ((i & mode) == mode))
1463                 {
1464                 if (  (((mode & SSL_SESS_CACHE_CLIENT)
1465                         ?s->ctx->stats.sess_connect_good
1466                         :s->ctx->stats.sess_accept_good) & 0xff) == 0xff)
1467                         {
1468                         SSL_CTX_flush_sessions(s->ctx,time(NULL));
1469                         }
1470                 }
1471         }
1472
1473 SSL_METHOD *SSL_get_ssl_method(SSL *s)
1474         {
1475         return(s->method);
1476         }
1477
1478 int SSL_set_ssl_method(SSL *s,SSL_METHOD *meth)
1479         {
1480         int conn= -1;
1481         int ret=1;
1482
1483         if (s->method != meth)
1484                 {
1485                 if (s->handshake_func != NULL)
1486                         conn=(s->handshake_func == s->method->ssl_connect);
1487
1488                 if (s->method->version == meth->version)
1489                         s->method=meth;
1490                 else
1491                         {
1492                         s->method->ssl_free(s);
1493                         s->method=meth;
1494                         ret=s->method->ssl_new(s);
1495                         }
1496
1497                 if (conn == 1)
1498                         s->handshake_func=meth->ssl_connect;
1499                 else if (conn == 0)
1500                         s->handshake_func=meth->ssl_accept;
1501                 }
1502         return(ret);
1503         }
1504
1505 int SSL_get_error(SSL *s,int i)
1506         {
1507         int reason;
1508         unsigned long l;
1509         BIO *bio;
1510
1511         if (i > 0) return(SSL_ERROR_NONE);
1512
1513         /* Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake
1514          * etc, where we do encode the error */
1515         if ((l=ERR_peek_error()) != 0)
1516                 {
1517                 if (ERR_GET_LIB(l) == ERR_LIB_SYS)
1518                         return(SSL_ERROR_SYSCALL);
1519                 else
1520                         return(SSL_ERROR_SSL);
1521                 }
1522
1523         if ((i < 0) && SSL_want_read(s))
1524                 {
1525                 bio=SSL_get_rbio(s);
1526                 if (BIO_should_read(bio))
1527                         return(SSL_ERROR_WANT_READ);
1528                 else if (BIO_should_write(bio))
1529                         /* This one doesn't make too much sense ... We never try
1530                          * to write to the rbio, and an application program where
1531                          * rbio and wbio are separate couldn't even know what it
1532                          * should wait for.
1533                          * However if we ever set s->rwstate incorrectly
1534                          * (so that we have SSL_want_read(s) instead of
1535                          * SSL_want_write(s)) and rbio and wbio *are* the same,
1536                          * this test works around that bug; so it might be safer
1537                          * to keep it. */
1538                         return(SSL_ERROR_WANT_WRITE);
1539                 else if (BIO_should_io_special(bio))
1540                         {
1541                         reason=BIO_get_retry_reason(bio);
1542                         if (reason == BIO_RR_CONNECT)
1543                                 return(SSL_ERROR_WANT_CONNECT);
1544                         else
1545                                 return(SSL_ERROR_SYSCALL); /* unknown */
1546                         }
1547                 }
1548
1549         if ((i < 0) && SSL_want_write(s))
1550                 {
1551                 bio=SSL_get_wbio(s);
1552                 if (BIO_should_write(bio))
1553                         return(SSL_ERROR_WANT_WRITE);
1554                 else if (BIO_should_read(bio))
1555                         /* See above (SSL_want_read(s) with BIO_should_write(bio)) */
1556                         return(SSL_ERROR_WANT_READ);
1557                 else if (BIO_should_io_special(bio))
1558                         {
1559                         reason=BIO_get_retry_reason(bio);
1560                         if (reason == BIO_RR_CONNECT)
1561                                 return(SSL_ERROR_WANT_CONNECT);
1562                         else
1563                                 return(SSL_ERROR_SYSCALL);
1564                         }
1565                 }
1566         if ((i < 0) && SSL_want_x509_lookup(s))
1567                 {
1568                 return(SSL_ERROR_WANT_X509_LOOKUP);
1569                 }
1570
1571         if (i == 0)
1572                 {
1573                 if (s->version == SSL2_VERSION)
1574                         {
1575                         /* assume it is the socket being closed */
1576                         return(SSL_ERROR_ZERO_RETURN);
1577                         }
1578                 else
1579                         {
1580                         if ((s->shutdown & SSL_RECEIVED_SHUTDOWN) &&
1581                                 (s->s3->warn_alert == SSL_AD_CLOSE_NOTIFY))
1582                                 return(SSL_ERROR_ZERO_RETURN);
1583                         }
1584                 }
1585         return(SSL_ERROR_SYSCALL);
1586         }
1587
1588 int SSL_do_handshake(SSL *s)
1589         {
1590         int ret=1;
1591
1592         if (s->handshake_func == NULL)
1593                 {
1594                 SSLerr(SSL_F_SSL_DO_HANDSHAKE,SSL_R_CONNECTION_TYPE_NOT_SET);
1595                 return(-1);
1596                 }
1597
1598         s->method->ssl_renegotiate_check(s);
1599
1600         if (SSL_in_init(s) || SSL_in_before(s))
1601                 {
1602                 ret=s->handshake_func(s);
1603                 }
1604         return(ret);
1605         }
1606
1607 /* For the next 2 functions, SSL_clear() sets shutdown and so
1608  * one of these calls will reset it */
1609 void SSL_set_accept_state(SSL *s)
1610         {
1611         s->server=1;
1612         s->shutdown=0;
1613         s->state=SSL_ST_ACCEPT|SSL_ST_BEFORE;
1614         s->handshake_func=s->method->ssl_accept;
1615         /* clear the current cipher */
1616         ssl_clear_cipher_ctx(s);
1617         }
1618
1619 void SSL_set_connect_state(SSL *s)
1620         {
1621         s->server=0;
1622         s->shutdown=0;
1623         s->state=SSL_ST_CONNECT|SSL_ST_BEFORE;
1624         s->handshake_func=s->method->ssl_connect;
1625         /* clear the current cipher */
1626         ssl_clear_cipher_ctx(s);
1627         }
1628
1629 int ssl_undefined_function(SSL *s)
1630         {
1631         SSLerr(SSL_F_SSL_UNDEFINED_FUNCTION,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
1632         return(0);
1633         }
1634
1635 SSL_METHOD *ssl_bad_method(int ver)
1636         {
1637         SSLerr(SSL_F_SSL_BAD_METHOD,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
1638         return(NULL);
1639         }
1640
1641 const char *SSL_get_version(SSL *s)
1642         {
1643         if (s->version == TLS1_VERSION)
1644                 return("TLSv1");
1645         else if (s->version == SSL3_VERSION)
1646                 return("SSLv3");
1647         else if (s->version == SSL2_VERSION)
1648                 return("SSLv2");
1649         else
1650                 return("unknown");
1651         }
1652
1653 SSL *SSL_dup(SSL *s)
1654         {
1655         STACK_OF(X509_NAME) *sk;
1656         X509_NAME *xn;
1657         SSL *ret;
1658         int i;
1659
1660         if ((ret=SSL_new(SSL_get_SSL_CTX(s))) == NULL)
1661             return(NULL);
1662
1663         if (s->session != NULL)
1664                 {
1665                 /* This copies session-id, SSL_METHOD, sid_ctx, and 'cert' */
1666                 SSL_copy_session_id(ret,s);
1667                 }
1668         else
1669                 {
1670                 /* No session has been established yet, so we have to expect
1671                  * that s->cert or ret->cert will be changed later --
1672                  * they should not both point to the same object,
1673                  * and thus we can't use SSL_copy_session_id. */
1674
1675                 ret->method = s->method;
1676                 ret->method->ssl_new(ret);
1677
1678                 if (s->cert != NULL)
1679                         {
1680                         ret->cert = ssl_cert_dup(s->cert);
1681                         if (ret->cert == NULL)
1682                                 goto err;
1683                         }
1684
1685                 SSL_set_session_id_context(ret,
1686                         s->sid_ctx, s->sid_ctx_length);
1687                 }
1688
1689         SSL_set_read_ahead(ret,SSL_get_read_ahead(s));
1690         SSL_set_verify(ret,SSL_get_verify_mode(s),
1691                 SSL_get_verify_callback(s));
1692         SSL_set_verify_depth(ret,SSL_get_verify_depth(s));
1693
1694         SSL_set_info_callback(ret,SSL_get_info_callback(s));
1695
1696         ret->debug=s->debug;
1697         ret->options=s->options;
1698
1699         /* copy app data, a little dangerous perhaps */
1700         if (!CRYPTO_dup_ex_data(ssl_meth,&ret->ex_data,&s->ex_data))
1701                 goto err;
1702
1703         /* setup rbio, and wbio */
1704         if (s->rbio != NULL)
1705                 {
1706                 if (!BIO_dup_state(s->rbio,(char *)&ret->rbio))
1707                         goto err;
1708                 }
1709         if (s->wbio != NULL)
1710                 {
1711                 if (s->wbio != s->rbio)
1712                         {
1713                         if (!BIO_dup_state(s->wbio,(char *)&ret->wbio))
1714                                 goto err;
1715                         }
1716                 else
1717                         ret->wbio=ret->rbio;
1718                 }
1719
1720         /* dup the cipher_list and cipher_list_by_id stacks */
1721         if (s->cipher_list != NULL)
1722                 {
1723                 if ((ret->cipher_list=sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
1724                         goto err;
1725                 }
1726         if (s->cipher_list_by_id != NULL)
1727                 if ((ret->cipher_list_by_id=sk_SSL_CIPHER_dup(s->cipher_list_by_id))
1728                         == NULL)
1729                         goto err;
1730
1731         /* Dup the client_CA list */
1732         if (s->client_CA != NULL)
1733                 {
1734                 if ((sk=sk_X509_NAME_dup(s->client_CA)) == NULL) goto err;
1735                 ret->client_CA=sk;
1736                 for (i=0; i<sk_X509_NAME_num(sk); i++)
1737                         {
1738                         xn=sk_X509_NAME_value(sk,i);
1739                         if (sk_X509_NAME_set(sk,i,X509_NAME_dup(xn)) == NULL)
1740                                 {
1741                                 X509_NAME_free(xn);
1742                                 goto err;
1743                                 }
1744                         }
1745                 }
1746
1747         ret->shutdown=s->shutdown;
1748         ret->state=s->state;
1749         ret->handshake_func=s->handshake_func;
1750         ret->server=s->server;
1751
1752         if (0)
1753                 {
1754 err:
1755                 if (ret != NULL) SSL_free(ret);
1756                 ret=NULL;
1757                 }
1758         return(ret);
1759         }
1760
1761 void ssl_clear_cipher_ctx(SSL *s)
1762         {
1763         if (s->enc_read_ctx != NULL)
1764                 {
1765                 EVP_CIPHER_CTX_cleanup(s->enc_read_ctx);
1766                 Free(s->enc_read_ctx);
1767                 s->enc_read_ctx=NULL;
1768                 }
1769         if (s->enc_write_ctx != NULL)
1770                 {
1771                 EVP_CIPHER_CTX_cleanup(s->enc_write_ctx);
1772                 Free(s->enc_write_ctx);
1773                 s->enc_write_ctx=NULL;
1774                 }
1775         if (s->expand != NULL)
1776                 {
1777                 COMP_CTX_free(s->expand);
1778                 s->expand=NULL;
1779                 }
1780         if (s->compress != NULL)
1781                 {
1782                 COMP_CTX_free(s->compress);
1783                 s->compress=NULL;
1784                 }
1785         }
1786
1787 /* Fix this function so that it takes an optional type parameter */
1788 X509 *SSL_get_certificate(SSL *s)
1789         {
1790         if (s->cert != NULL)
1791                 return(s->cert->key->x509);
1792         else
1793                 return(NULL);
1794         }
1795
1796 /* Fix this function so that it takes an optional type parameter */
1797 EVP_PKEY *SSL_get_privatekey(SSL *s)
1798         {
1799         if (s->cert != NULL)
1800                 return(s->cert->key->privatekey);
1801         else
1802                 return(NULL);
1803         }
1804
1805 SSL_CIPHER *SSL_get_current_cipher(SSL *s)
1806         {
1807         if ((s->session != NULL) && (s->session->cipher != NULL))
1808                 return(s->session->cipher);
1809         return(NULL);
1810         }
1811
1812 int ssl_init_wbio_buffer(SSL *s,int push)
1813         {
1814         BIO *bbio;
1815
1816         if (s->bbio == NULL)
1817                 {
1818                 bbio=BIO_new(BIO_f_buffer());
1819                 if (bbio == NULL) return(0);
1820                 s->bbio=bbio;
1821                 }
1822         else
1823                 {
1824                 bbio=s->bbio;
1825                 if (s->bbio == s->wbio)
1826                         s->wbio=BIO_pop(s->wbio);
1827                 }
1828         (void)BIO_reset(bbio);
1829 /*      if (!BIO_set_write_buffer_size(bbio,16*1024)) */
1830         if (!BIO_set_read_buffer_size(bbio,1))
1831                 {
1832                 SSLerr(SSL_F_SSL_INIT_WBIO_BUFFER,ERR_R_BUF_LIB);
1833                 return(0);
1834                 }
1835         if (push)
1836                 {
1837                 if (s->wbio != bbio)
1838                         s->wbio=BIO_push(bbio,s->wbio);
1839                 }
1840         else
1841                 {
1842                 if (s->wbio == bbio)
1843                         s->wbio=BIO_pop(bbio);
1844                 }
1845         return(1);
1846         }
1847
1848 void ssl_free_wbio_buffer(SSL *s)
1849         {
1850         BIO *under;
1851
1852         if (s->bbio == NULL) return;
1853
1854         if (s->bbio == s->wbio)
1855                 {
1856                 /* remove buffering */
1857                 under=BIO_pop(s->wbio);
1858                 if (under != NULL)
1859                         s->wbio=under;
1860                 else
1861                         abort(); /* ok */
1862                 }
1863         BIO_free(s->bbio);
1864         s->bbio=NULL;
1865         }
1866
1867 void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx,int mode)
1868         {
1869         ctx->quiet_shutdown=mode;
1870         }
1871
1872 int SSL_CTX_get_quiet_shutdown(SSL_CTX *ctx)
1873         {
1874         return(ctx->quiet_shutdown);
1875         }
1876
1877 void SSL_set_quiet_shutdown(SSL *s,int mode)
1878         {
1879         s->quiet_shutdown=mode;
1880         }
1881
1882 int SSL_get_quiet_shutdown(SSL *s)
1883         {
1884         return(s->quiet_shutdown);
1885         }
1886
1887 void SSL_set_shutdown(SSL *s,int mode)
1888         {
1889         s->shutdown=mode;
1890         }
1891
1892 int SSL_get_shutdown(SSL *s)
1893         {
1894         return(s->shutdown);
1895         }
1896
1897 int SSL_version(SSL *s)
1898         {
1899         return(s->version);
1900         }
1901
1902 SSL_CTX *SSL_get_SSL_CTX(SSL *ssl)
1903         {
1904         return(ssl->ctx);
1905         }
1906
1907 #ifndef NO_STDIO
1908 int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
1909         {
1910         return(X509_STORE_set_default_paths(ctx->cert_store));
1911         }
1912
1913 int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
1914                 const char *CApath)
1915         {
1916         return(X509_STORE_load_locations(ctx->cert_store,CAfile,CApath));
1917         }
1918 #endif
1919
1920 void SSL_set_info_callback(SSL *ssl,void (*cb)())
1921         {
1922         ssl->info_callback=cb;
1923         }
1924
1925 void (*SSL_get_info_callback(SSL *ssl))(void)
1926         {
1927         return((void (*)())ssl->info_callback);
1928         }
1929
1930 int SSL_state(SSL *ssl)
1931         {
1932         return(ssl->state);
1933         }
1934
1935 void SSL_set_verify_result(SSL *ssl,long arg)
1936         {
1937         ssl->verify_result=arg;
1938         }
1939
1940 long SSL_get_verify_result(SSL *ssl)
1941         {
1942         return(ssl->verify_result);
1943         }
1944
1945 int SSL_get_ex_new_index(long argl,void *argp,CRYPTO_EX_new *new_func,
1946                          CRYPTO_EX_dup *dup_func,CRYPTO_EX_free *free_func)
1947         {
1948         ssl_meth_num++;
1949         return(CRYPTO_get_ex_new_index(ssl_meth_num-1,
1950                 &ssl_meth,argl,argp,new_func,dup_func,free_func));
1951         }
1952
1953 int SSL_set_ex_data(SSL *s,int idx,void *arg)
1954         {
1955         return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
1956         }
1957
1958 void *SSL_get_ex_data(SSL *s,int idx)
1959         {
1960         return(CRYPTO_get_ex_data(&s->ex_data,idx));
1961         }
1962
1963 int SSL_CTX_get_ex_new_index(long argl,void *argp,CRYPTO_EX_new *new_func,
1964                              CRYPTO_EX_dup *dup_func,CRYPTO_EX_free *free_func)
1965         {
1966         ssl_ctx_meth_num++;
1967         return(CRYPTO_get_ex_new_index(ssl_ctx_meth_num-1,
1968                 &ssl_ctx_meth,argl,argp,new_func,dup_func,free_func));
1969         }
1970
1971 int SSL_CTX_set_ex_data(SSL_CTX *s,int idx,void *arg)
1972         {
1973         return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
1974         }
1975
1976 void *SSL_CTX_get_ex_data(SSL_CTX *s,int idx)
1977         {
1978         return(CRYPTO_get_ex_data(&s->ex_data,idx));
1979         }
1980
1981 int ssl_ok(SSL *s)
1982         {
1983         return(1);
1984         }
1985
1986 X509_STORE *SSL_CTX_get_cert_store(SSL_CTX *ctx)
1987         {
1988         return(ctx->cert_store);
1989         }
1990
1991 void SSL_CTX_set_cert_store(SSL_CTX *ctx,X509_STORE *store)
1992         {
1993         if (ctx->cert_store != NULL)
1994                 X509_STORE_free(ctx->cert_store);
1995         ctx->cert_store=store;
1996         }
1997
1998 int SSL_want(SSL *s)
1999         {
2000         return(s->rwstate);
2001         }
2002
2003 /*!
2004  * \brief Set the callback for generating temporary RSA keys.
2005  * \param ctx the SSL context.
2006  * \param cb the callback
2007  */
2008
2009 #ifndef NO_RSA
2010 void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx,RSA *(*cb)(SSL *ssl,
2011                                                           int is_export,
2012                                                           int keylength))
2013     {
2014     SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_RSA_CB,(void (*)())cb);
2015     }
2016
2017 void SSL_set_tmp_rsa_callback(SSL *ssl,RSA *(*cb)(SSL *ssl,
2018                                                   int is_export,
2019                                                   int keylength))
2020     {
2021     SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_RSA_CB,(void (*)())cb);
2022     }
2023 #endif
2024
2025 #ifdef DOXYGEN
2026 /*!
2027  * \brief The RSA temporary key callback function.
2028  * \param ssl the SSL session.
2029  * \param is_export \c TRUE if the temp RSA key is for an export ciphersuite.
2030  * \param keylength if \c is_export is \c TRUE, then \c keylength is the size
2031  * of the required key in bits.
2032  * \return the temporary RSA key.
2033  * \sa SSL_CTX_set_tmp_rsa_callback, SSL_set_tmp_rsa_callback
2034  */
2035
2036 RSA *cb(SSL *ssl,int is_export,int keylength)
2037     {}
2038 #endif
2039
2040 /*!
2041  * \brief Set the callback for generating temporary DH keys.
2042  * \param ctx the SSL context.
2043  * \param dh the callback
2044  */
2045
2046 #ifndef NO_DH
2047 void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,DH *(*dh)(SSL *ssl,int is_export,
2048                                                         int keylength))
2049     {
2050     SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_DH_CB,(void (*)())dh);
2051     }
2052
2053 void SSL_set_tmp_dh_callback(SSL *ssl,DH *(*dh)(SSL *ssl,int is_export,
2054                                                 int keylength))
2055     {
2056     SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_DH_CB,(void (*)())dh);
2057     }
2058 #endif
2059
2060 #if defined(_WINDLL) && defined(WIN16)
2061 #include "../crypto/bio/bss_file.c"
2062 #endif
2063
2064 IMPLEMENT_STACK_OF(SSL_CIPHER)
2065 IMPLEMENT_STACK_OF(SSL_COMP)