50 files changed, 8774 insertions, 4159 deletions

diff --git a/src/lib/libssl/LICENSE b/src/lib/libssl/LICENSE
index b9e18d5e7b..7b93e0dbce 100644
--- a/src/lib/libssl/LICENSE
+++ b/src/lib/libssl/LICENSE
@@ -12,7 +12,7 @@
   ---------------
 
 /* ====================================================================
- * Copyright (c) 1998-1999 The OpenSSL Project.  All rights reserved.
+ * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
diff --git a/src/lib/libssl/bio_ssl.c b/src/lib/libssl/bio_ssl.c
index 58a6d69b9b..467e149947 100644
--- a/src/lib/libssl/bio_ssl.c
+++ b/src/lib/libssl/bio_ssl.c
@@ -60,27 +60,18 @@
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
-#include "crypto.h"
-#include "bio.h"
-#include "err.h"
-#include "ssl.h"
-
-#ifndef NOPROTO
-static int ssl_write(BIO *h,char *buf,int num);
-static int ssl_read(BIO *h,char *buf,int size);
-static int ssl_puts(BIO *h,char *str);
-static long ssl_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+#include <openssl/crypto.h>
+#include <openssl/bio.h>
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+
+static int ssl_write(BIO *h, const char *buf, int num);
+static int ssl_read(BIO *h, char *buf, int size);
+static int ssl_puts(BIO *h, const char *str);
+static long ssl_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 static int ssl_new(BIO *h);
 static int ssl_free(BIO *data);
-#else
-static int ssl_write();
-static int ssl_read();
-static int ssl_puts();
-static long ssl_ctrl();
-static int ssl_new();
-static int ssl_free();
-#endif
-
+static long ssl_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp);
 typedef struct bio_ssl_st
         {
         SSL *ssl; /* The ssl handle :-) */
@@ -102,19 +93,19 @@ static BIO_METHOD methods_sslp=
         ssl_ctrl,
         ssl_new,
         ssl_free,
+        ssl_callback_ctrl,
         };
 
-BIO_METHOD *BIO_f_ssl()
+BIO_METHOD *BIO_f_ssl(void)
         {
         return(&methods_sslp);
         }
 
-static int ssl_new(bi)
-BIO *bi;
+static int ssl_new(BIO *bi)
         {
         BIO_SSL *bs;
 
-        bs=(BIO_SSL *)Malloc(sizeof(BIO_SSL));
+        bs=(BIO_SSL *)OPENSSL_malloc(sizeof(BIO_SSL));
         if (bs == NULL)
                 {
                 BIOerr(BIO_F_SSL_NEW,ERR_R_MALLOC_FAILURE);
@@ -127,8 +118,7 @@ BIO *bi;
         return(1);
         }
 
-static int ssl_free(a)
-BIO *a;
+static int ssl_free(BIO *a)
         {
         BIO_SSL *bs;
 
@@ -143,14 +133,11 @@ BIO *a;
                 a->flags=0;
                 }
         if (a->ptr != NULL)
-                Free(a->ptr);
+                OPENSSL_free(a->ptr);
         return(1);
         }
         
-static int ssl_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int ssl_read(BIO *b, char *out, int outl)
         {
         int ret=1;
         BIO_SSL *sb;
@@ -219,6 +206,10 @@ int outl;
                 BIO_set_retry_special(b);
                 retry_reason=BIO_RR_SSL_X509_LOOKUP;
                 break;
+        case SSL_ERROR_WANT_ACCEPT:
+                BIO_set_retry_special(b);
+                retry_reason=BIO_RR_ACCEPT;
+                break;
         case SSL_ERROR_WANT_CONNECT:
                 BIO_set_retry_special(b);
                 retry_reason=BIO_RR_CONNECT;
@@ -234,10 +225,7 @@ int outl;
         return(ret);
         }
 
-static int ssl_write(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int ssl_write(BIO *b, const char *out, int outl)
         {
         int ret,r=0;
         int retry_reason=0;
@@ -305,11 +293,7 @@ int outl;
         return(ret);
         }
 
-static long ssl_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long ssl_ctrl(BIO *b, int cmd, long num, void *ptr)
         {
         SSL **sslp,*ssl;
         BIO_SSL *bs;
@@ -466,7 +450,14 @@ char *ptr;
                 ret=BIO_ctrl(ssl->rbio,cmd,num,ptr);
                 break;
         case BIO_CTRL_SET_CALLBACK:
-                SSL_set_info_callback(ssl,(void (*)())ptr);
+                {
+#if 0 /* FIXME: Should this be used?  -- Richard Levitte */
+                BIOerr(SSL_F_SSL_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+                ret = -1;
+#else
+                ret=0;
+#endif
+                }
                 break;
         case BIO_CTRL_GET_CALLBACK:
                 {
@@ -483,9 +474,31 @@ char *ptr;
         return(ret);
         }
 
-static int ssl_puts(bp,str)
-BIO *bp;
-char *str;
+static long ssl_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
+        {
+        SSL *ssl;
+        BIO_SSL *bs;
+        long ret=1;
+
+        bs=(BIO_SSL *)b->ptr;
+        ssl=bs->ssl;
+        switch (cmd)
+                {
+        case BIO_CTRL_SET_CALLBACK:
+                {
+                /* FIXME: setting this via a completely different prototype
+                   seems like a crap idea */
+                SSL_set_info_callback(ssl,(void (*)(const SSL *,int,int))fp);
+                }
+                break;
+        default:
+                ret=BIO_callback_ctrl(ssl->rbio,cmd,fp);
+                break;
+                }
+        return(ret);
+        }
+
+static int ssl_puts(BIO *bp, const char *str)
         {
         int n,ret;
 
@@ -494,8 +507,7 @@ char *str;
         return(ret);
         }
 
-BIO *BIO_new_buffer_ssl_connect(ctx)
-SSL_CTX *ctx;
+BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx)
         {
         BIO *ret=NULL,*buf=NULL,*ssl=NULL;
 
@@ -512,8 +524,7 @@ err:
         return(NULL);
         }
 
-BIO *BIO_new_ssl_connect(ctx)
-SSL_CTX *ctx;
+BIO *BIO_new_ssl_connect(SSL_CTX *ctx)
         {
         BIO *ret=NULL,*con=NULL,*ssl=NULL;
 
@@ -530,9 +541,7 @@ err:
         return(NULL);
         }
 
-BIO *BIO_new_ssl(ctx,client)
-SSL_CTX *ctx;
-int client;
+BIO *BIO_new_ssl(SSL_CTX *ctx, int client)
         {
         BIO *ret;
         SSL *ssl;
@@ -553,8 +562,7 @@ int client;
         return(ret);
         }
 
-int BIO_ssl_copy_session_id(t,f)
-BIO *t,*f;
+int BIO_ssl_copy_session_id(BIO *t, BIO *f)
         {
         t=BIO_find_type(t,BIO_TYPE_SSL);
         f=BIO_find_type(f,BIO_TYPE_SSL);
@@ -567,8 +575,7 @@ BIO *t,*f;
         return(1);
         }
 
-void BIO_ssl_shutdown(b)
-BIO *b;
+void BIO_ssl_shutdown(BIO *b)
         {
         SSL *s;
 
diff --git a/src/lib/libssl/doc/openssl.cnf b/src/lib/libssl/doc/openssl.cnf
index d70dd25622..eca51c3322 100644
--- a/src/lib/libssl/doc/openssl.cnf
+++ b/src/lib/libssl/doc/openssl.cnf
@@ -3,8 +3,13 @@
 # This is mostly being used for generation of certificate requests.
 #
 
+# This definition stops the following lines choking if HOME isn't
+# defined.
+HOME                    = .
 RANDFILE                = $ENV::HOME/.rnd
-oid_file                = $ENV::HOME/.oid
+
+# Extra OBJECT IDENTIFIER info:
+#oid_file               = $ENV::HOME/.oid
 oid_section             = new_oids
 
 # To use this configuration file with the "-extfile" option of the
@@ -43,6 +48,14 @@ RANDFILE	= $dir/private/.rand	# private random number file
 
 x509_extensions = usr_cert              # The extentions to add to the cert
 
+# Comment out the following two lines for the "traditional"
+# (and highly broken) format.
+name_opt        = ca_default            # Subject Name options
+cert_opt        = ca_default            # Certificate field options
+
+# Extension copying option: use with caution.
+# copy_extensions = copy
+
 # Extensions to add to a CRL. Note: Netscape communicator chokes on V2 CRLs
 # so this is commented out by default to leave a V1 CRL.
 # crl_extensions        = crl_ext
@@ -86,6 +99,22 @@ distinguished_name	= req_distinguished_name
 attributes              = req_attributes
 x509_extensions = v3_ca # The extentions to add to the self signed cert
 
+# Passwords for private keys if not present they will be prompted for
+# input_password = secret
+# output_password = secret
+
+# This sets a mask for permitted string types. There are several options. 
+# default: PrintableString, T61String, BMPString.
+# pkix   : PrintableString, BMPString.
+# utf8only: only UTF8Strings.
+# nombstr : PrintableString, T61String (no BMPStrings or UTF8Strings).
+# MASK:XXXX a literal mask value.
+# WARNING: current versions of Netscape crash on BMPStrings or UTF8Strings
+# so use this option with caution!
+string_mask = nombstr
+
+# req_extensions = v3_req # The extensions to add to a certificate request
+
 [ req_distinguished_name ]
 countryName                     = Country Name (2 letter code)
 countryName_default             = AU
@@ -111,7 +140,7 @@ commonName			= Common Name (eg, YOUR name)
 commonName_max                  = 64
 
 emailAddress                    = Email Address
-emailAddress_max                = 40
+emailAddress_max                = 64
 
 # SET-ex3                       = SET extension number 3
 
@@ -159,6 +188,9 @@ authorityKeyIdentifier=keyid,issuer:always
 # This stuff is for subjectAltName and issuerAltname.
 # Import the email address.
 # subjectAltName=email:copy
+# An alternative to produce certificates that aren't
+# deprecated according to PKIX.
+# subjectAltName=email:move
 
 # Copy subject details
 # issuerAltName=issuer:copy
@@ -170,8 +202,16 @@ authorityKeyIdentifier=keyid,issuer:always
 #nsCaPolicyUrl
 #nsSslServerName
 
+[ v3_req ]
+
+# Extensions to add to a certificate request
+
+basicConstraints = CA:FALSE
+keyUsage = nonRepudiation, digitalSignature, keyEncipherment
+
 [ v3_ca ]
 
+
 # Extensions for a typical CA
 
 
@@ -200,10 +240,11 @@ basicConstraints = CA:true
 # Copy issuer details
 # issuerAltName=issuer:copy
 
-# RAW DER hex encoding of an extension: beware experts only!
-# 1.2.3.5=RAW:02:03
+# DER hex encoding of an extension: beware experts only!
+# obj=DER:02:03
+# Where 'obj' is a standard or added object
 # You can even override a supported extension:
-# basicConstraints= critical, RAW:30:03:01:01:FF
+# basicConstraints= critical, DER:30:03:01:01:FF
 
 [ crl_ext ]
 
diff --git a/src/lib/libssl/doc/openssl.txt b/src/lib/libssl/doc/openssl.txt
index 91b85e5f14..5da519e7e4 100644
--- a/src/lib/libssl/doc/openssl.txt
+++ b/src/lib/libssl/doc/openssl.txt
@@ -1,53 +1,12 @@
 
 This is some preliminary documentation for OpenSSL.
 
-==============================================================================
-                            BUFFER Library
-==============================================================================
-
-The buffer library handles simple character arrays. Buffers are used for
-various purposes in the library, most notably memory BIOs.
-
-The library uses the BUF_MEM structure defined in buffer.h:
-
-typedef struct buf_mem_st
-{
-        int length;     /* current number of bytes */
-        char *data;
-        int max;        /* size of buffer */
-} BUF_MEM;
-
-'length' is the current size of the buffer in bytes, 'max' is the amount of
-memory allocated to the buffer. There are three functions which handle these
-and one "miscellaneous" function.
-
-BUF_MEM *BUF_MEM_new()
-
-This allocates a new buffer of zero size. Returns the buffer or NULL on error.
-
-void BUF_MEM_free(BUF_MEM *a)
-
-This frees up an already existing buffer. The data is zeroed before freeing
-up in case the buffer contains sensitive data.
-
-int BUF_MEM_grow(BUF_MEM *str, int len)
+Contents:
 
-This changes the size of an already existing buffer. It returns zero on error
-or the new size (i.e. 'len'). Any data already in the buffer is preserved if
-it increases in size.
+ OpenSSL X509V3 extension configuration
+ X509V3 Extension code: programmers guide
+ PKCS#12 Library
 
-char * BUF_strdup(char *str)
-
-This is the previously mentioned strdup function: like the standard library
-strdup() it copies a null terminated string into a block of allocated memory
-and returns a pointer to the allocated block.
-
-Unlike the standard C library strdup() this function uses Malloc() and so
-should be used in preference to the standard library strdup() because it can
-be used for memory leak checking or replacing the malloc() function.
-
-The memory allocated from BUF_strdup() should be freed up using the Free()
-function.
 
 ==============================================================================
                OpenSSL X509V3 extension configuration
@@ -188,7 +147,7 @@ email.1=steve@here
 email.2=steve@there
 
 This is because the configuration file code cannot handle the same name
-occurring twice in the same extension.
+occurring twice in the same section.
 
 The syntax of raw extensions is governed by the extension code: it can
 for example contain data in multiple sections. The correct syntax to
@@ -315,6 +274,41 @@ TRUE. An end user certificate MUST NOT have the CA value set to true.
 According to PKIX recommendations it should exclude the extension entirely,
 however some software may require CA set to FALSE for end entity certificates.
 
+Extended Key Usage.
+
+This extensions consists of a list of usages.
+
+These can either be object short names of the dotted numerical form of OIDs.
+While any OID can be used only certain values make sense. In particular the
+following PKIX, NS and MS values are meaningful:
+
+Value                   Meaning
+-----                   -------
+serverAuth              SSL/TLS Web Server Authentication.
+clientAuth              SSL/TLS Web Client Authentication.
+codeSigning             Code signing.
+emailProtection         E-mail Protection (S/MIME).
+timeStamping            Trusted Timestamping
+msCodeInd               Microsoft Individual Code Signing (authenticode)
+msCodeCom               Microsoft Commercial Code Signing (authenticode)
+msCTLSign               Microsoft Trust List Signing
+msSGC                   Microsoft Server Gated Crypto
+msEFS                   Microsoft Encrypted File System
+nsSGC                   Netscape Server Gated Crypto
+
+For example, under IE5 a CA can be used for any purpose: by including a list
+of the above usages the CA can be restricted to only authorised uses.
+
+Note: software packages may place additional interpretations on certificate 
+use, in particular some usages may only work for selected CAs. Don't for example
+expect just including msSGC or nsSGC will automatically mean that a certificate
+can be used for SGC ("step up" encryption) otherwise anyone could use it.
+
+Examples:
+
+extendedKeyUsage=critical,codeSigning,1.2.3.4
+extendedKeyUsage=nsSGC,msSGC
+
 Subject Key Identifier.
 
 This is really a string extension and can take two possible values. Either
@@ -361,6 +355,24 @@ that would not make sense. It does support an additional issuer:copy option
 that will copy all the subject alternative name values from the issuer 
 certificate (if possible).
 
+Example:
+
+issuserAltName = issuer:copy
+
+Authority Info Access.
+
+The authority information access extension gives details about how to access
+certain information relating to the CA. Its syntax is accessOID;location
+where 'location' has the same syntax as subject alternative name (except
+that email:copy is not supported). accessOID can be any valid OID but only
+certain values are meaningful for example OCSP and caIssuers. OCSP gives the
+location of an OCSP responder: this is used by Netscape PSM and other software.
+
+Example:
+
+authorityInfoAccess = OCSP;URI:http://ocsp.my.host/
+authorityInfoAccess = caIssuers;URI:http://my.ca/ca.html
+
 CRL distribution points.
 
 This is a multi-valued extension that supports all the literal options of
@@ -459,16 +471,16 @@ extension in a human or machine readable form.
 
 1. Initialisation and cleanup.
 
-X509V3_add_standard_extensions();
-
-This function should be called before any other extension code. It adds support
-for some common PKIX and Netscape extensions. Additional custom extensions can
-be added as well (see later).
+No special initialisation is needed before calling the extension functions.
+You used to have to call X509V3_add_standard_extensions(); but this is no longer
+required and this function no longer does anything.
 
 void X509V3_EXT_cleanup(void);
 
-This function should be called last to cleanup the extension code. After this
-call no other extension calls should be made.
+This function should be called to cleanup the extension code if any custom
+extensions have been added. If no custom extensions have been added then this
+call does nothing. After this call all custom extension code is freed up but
+you can still use the standard extensions.
 
 2. Printing and parsing extensions.
 
@@ -495,6 +507,47 @@ details about the structures returned. The returned structure should be freed
 after use using the relevant free function, BASIC_CONSTRAINTS_free() for 
 example.
 
+void    *       X509_get_ext_d2i(X509 *x, int nid, int *crit, int *idx);
+void    *       X509_CRL_get_ext_d2i(X509_CRL *x, int nid, int *crit, int *idx);
+void    *       X509_REVOKED_get_ext_d2i(X509_REVOKED *x, int nid, int *crit, int *idx);
+void    *       X509V3_get_d2i(STACK_OF(X509_EXTENSION) *x, int nid, int *crit, int *idx);
+
+These functions combine the operations of searching for extensions and
+parsing them. They search a certificate, a CRL a CRL entry or a stack
+of extensions respectively for extension whose NID is 'nid' and return
+the parsed result of NULL if an error occurred. For example:
+
+BASIC_CONSTRAINTS *bs;
+bs = X509_get_ext_d2i(cert, NID_basic_constraints, NULL, NULL);
+
+This will search for the basicConstraints extension and either return
+it value or NULL. NULL can mean either the extension was not found, it
+occurred more than once or it could not be parsed.
+
+If 'idx' is NULL then an extension is only parsed if it occurs precisely
+once. This is standard behaviour because extensions normally cannot occur
+more than once. If however more than one extension of the same type can
+occur it can be used to parse successive extensions for example:
+
+int i;
+void *ext;
+
+i = -1;
+for(;;) {
+        ext = X509_get_ext_d2i(x, nid, crit, &idx);
+        if(ext == NULL) break;
+         /* Do something with ext */
+}
+
+If 'crit' is not NULL and the extension was found then the int it points to
+is set to 1 for critical extensions and 0 for non critical. Therefore if the
+function returns NULL but 'crit' is set to 0 or 1 then the extension was
+found but it could not be parsed.
+
+The int pointed to by crit will be set to -1 if the extension was not found
+and -2 if the extension occurred more than once (this will only happen if
+idx is NULL). In both cases the function will return NULL.
+
 3. Generating extensions.
 
 An extension will typically be generated from a configuration file, or some
@@ -512,7 +565,7 @@ or CRL is due to be signed. Both return 0 on error on non zero for success.
 In each case 'conf' is the LHASH pointer of the configuration file to use
 and 'section' is the section containing the extension details.
 
-See the 'context functions' section for a description of the ctx paramater.
+See the 'context functions' section for a description of the ctx parameter.
 
 
 X509_EXTENSION *X509V3_EXT_conf(LHASH *conf, X509V3_CTX *ctx, char *name,
@@ -531,7 +584,7 @@ takes the NID of the extension rather than its name.
 For example to produce basicConstraints with the CA flag and a path length of
 10:
 
-x = X509V3_EXT_conf_nid(NULL, NULL, NID_basicConstraints, "CA:TRUE,pathlen:10");
+x = X509V3_EXT_conf_nid(NULL, NULL, NID_basic_constraints,"CA:TRUE,pathlen:10");
 
 
 X509_EXTENSION *X509V3_EXT_i2d(int ext_nid, int crit, void *ext_struc);
@@ -659,7 +712,7 @@ The same as above but for an unsigned character value.
 int X509V3_add_value_bool(const char *name, int asn1_bool,
                                                 STACK_OF(CONF_VALUE) **extlist);
 
-This adds either "TRUE" or "FALSE" depending on the value of 'ans1_bool'
+This adds either "TRUE" or "FALSE" depending on the value of 'asn1_bool'
 
 int X509V3_add_value_bool_nf(char *name, int asn1_bool,
                                                 STACK_OF(CONF_VALUE) **extlist);
@@ -686,7 +739,7 @@ Multi value extensions are passed a STACK_OF(CONF_VALUE) name and value pairs
 or return a STACK_OF(CONF_VALUE).
 
 Raw extensions are just passed a BIO or a value and it is the extensions
-responsiblity to handle all the necessary printing.
+responsibility to handle all the necessary printing.
 
 There are two ways to add an extension. One is simply as an alias to an already
 existing extension. An alias is an extension that is identical in ASN1 structure
@@ -811,7 +864,7 @@ int i2r(struct v3_ext_method *method, void *ext, BIO *out, int indent);
 
 This function is passed the internal extension structure in the ext parameter
 and sends out a human readable version of the extension to out. The 'indent'
-paremeter should be noted to determine the necessary amount of indentation
+parameter should be noted to determine the necessary amount of indentation
 needed on the output.
 
 void * r2i(struct v3_ext_method *method, struct v3_ext_ctx *ctx, char *str);
@@ -882,7 +935,7 @@ d2i_PKCS12_fp(fp, p12)
 
 This is the same but for a FILE pointer.
 
-3. Parsing and creation functions.
+3. High level functions.
 
 3.1 Parsing with PKCS12_parse().
 
@@ -920,6 +973,14 @@ p12 = PKCS12_create(pass, "My Certificate", pkey, cert, NULL, 0,0,0,0,0);
 i2d_PKCS12_fp(fp, p12);
 PKCS12_free(p12);
 
+3.3 Changing a PKCS#12 structure password.
+
+int PKCS12_newpass(PKCS12 *p12, char *oldpass, char *newpass);
+
+This changes the password of an already existing PKCS#12 structure. oldpass
+is the old password and newpass is the new one. An error occurs if the old
+password is incorrect.
+
 LOW LEVEL FUNCTIONS.
 
 In some cases the high level functions do not provide the necessary
diff --git a/src/lib/libssl/doc/standards.txt b/src/lib/libssl/doc/standards.txt
index 61ccc5d7e0..596d9001e6 100644
--- a/src/lib/libssl/doc/standards.txt
+++ b/src/lib/libssl/doc/standards.txt
@@ -24,7 +24,8 @@ http://www.rsasecurity.com/rsalabs/pkcs/.
 Implemented:
 ------------
 
-These are documents that describe things that are implemented in OpenSSL.
+These are documents that describe things that are implemented (in
+whole or at least great parts) in OpenSSL.
 
 1319 The MD2 Message-Digest Algorithm. B. Kaliski. April 1992.
      (Format: TXT=25661 bytes) (Status: INFORMATIONAL)
@@ -59,6 +60,11 @@ PKCS#8: Private-Key Information Syntax Standard
 
 PKCS#12: Personal Information Exchange Syntax Standard, version 1.0.
 
+2560 X.509 Internet Public Key Infrastructure Online Certificate
+     Status Protocol - OCSP. M. Myers, R. Ankney, A. Malpani, S. Galperin,
+     C. Adams. June 1999. (Format: TXT=43243 bytes) (Status: PROPOSED
+     STANDARD)
+
 
 Related:
 --------
@@ -84,6 +90,10 @@ STARTTLS documents.
      Certification and Related Services. B. Kaliski. February 1993.
      (Format: TXT=17537 bytes) (Status: PROPOSED STANDARD)
 
+2256 A Summary of the X.500(96) User Schema for use with LDAPv3. M.
+     Wahl. December 1997. (Format: TXT=32377 bytes) (Status: PROPOSED
+     STANDARD)
+
 2487 SMTP Service Extension for Secure SMTP over TLS. P. Hoffman.
      January 1999. (Format: TXT=15120 bytes) (Status: PROPOSED STANDARD)
 
@@ -114,8 +124,7 @@ To be implemented:
 These are documents that describe things that are planed to be
 implemented in the hopefully short future.
 
-2560 X.509 Internet Public Key Infrastructure Online Certificate
-     Status Protocol - OCSP. M. Myers, R. Ankney, A. Malpani, S. Galperin,
-     C. Adams. June 1999. (Format: TXT=43243 bytes) (Status: PROPOSED
-     STANDARD)
+2712 Addition of Kerberos Cipher Suites to Transport Layer Security
+     (TLS). A. Medvinsky, M. Hur. October 1999. (Format: TXT=13763 bytes)
+     (Status: PROPOSED STANDARD)
 
diff --git a/src/lib/libssl/s23_clnt.c b/src/lib/libssl/s23_clnt.c
index a4661ebb68..b2be8340fb 100644
--- a/src/lib/libssl/s23_clnt.c
+++ b/src/lib/libssl/s23_clnt.c
@@ -57,28 +57,22 @@
  */
 
 #include <stdio.h>
-#include "buffer.h"
-#include "rand.h"
-#include "objects.h"
-#include "evp.h"
+#include <openssl/buffer.h>
+#include <openssl/rand.h>
+#include <openssl/objects.h>
+#include <openssl/evp.h>
 #include "ssl_locl.h"
 
-#define BREAK break
-
-#ifndef NOPROTO
+static SSL_METHOD *ssl23_get_client_method(int ver);
 static int ssl23_client_hello(SSL *s);
 static int ssl23_get_server_hello(SSL *s);
-#else
-static int ssl23_client_hello();
-static int ssl23_get_server_hello();
-#endif
-
-static SSL_METHOD *ssl23_get_client_method(ver)
-int ver;
+static SSL_METHOD *ssl23_get_client_method(int ver)
         {
+#ifndef OPENSSL_NO_SSL2
         if (ver == SSL2_VERSION)
                 return(SSLv2_client_method());
-        else if (ver == SSL3_VERSION)
+#endif
+        if (ver == SSL3_VERSION)
                 return(SSLv3_client_method());
         else if (ver == TLS1_VERSION)
                 return(TLSv1_client_method());
@@ -86,32 +80,31 @@ int ver;
                 return(NULL);
         }
 
-SSL_METHOD *SSLv23_client_method()
+SSL_METHOD *SSLv23_client_method(void)
         {
         static int init=1;
         static SSL_METHOD SSLv23_client_data;
 
         if (init)
                 {
-                init=0;
                 memcpy((char *)&SSLv23_client_data,
                         (char *)sslv23_base_method(),sizeof(SSL_METHOD));
                 SSLv23_client_data.ssl_connect=ssl23_connect;
                 SSLv23_client_data.get_ssl_method=ssl23_get_client_method;
+                init=0;
                 }
         return(&SSLv23_client_data);
         }
 
-int ssl23_connect(s)
-SSL *s;
+int ssl23_connect(SSL *s)
         {
         BUF_MEM *buf;
         unsigned long Time=time(NULL);
-        void (*cb)()=NULL;
+        void (*cb)(const SSL *ssl,int type,int val)=NULL;
         int ret= -1;
         int new_state,state;
 
-        RAND_seed((unsigned char *)&Time,sizeof(Time));
+        RAND_add(&Time,sizeof(Time),0);
         ERR_clear_error();
         clear_sys_error();
 
@@ -120,8 +113,8 @@ SSL *s;
         else if (s->ctx->info_callback != NULL)
                 cb=s->ctx->info_callback;
         
-        if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s); 
         s->in_handshake++;
+        if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s); 
 
         for (;;)
                 {
@@ -134,6 +127,13 @@ SSL *s;
                 case SSL_ST_BEFORE|SSL_ST_CONNECT:
                 case SSL_ST_OK|SSL_ST_CONNECT:
 
+                        if (s->session != NULL)
+                                {
+                                SSLerr(SSL_F_SSL23_CONNECT,SSL_R_SSL23_DOING_SESSION_ID_REUSE);
+                                ret= -1;
+                                goto end;
+                                }
+                        s->server=0;
                         if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
 
                         /* s->version=TLS1_VERSION; */
@@ -159,7 +159,7 @@ SSL *s;
                         ssl3_init_finished_mac(s);
 
                         s->state=SSL23_ST_CW_CLNT_HELLO_A;
-                        s->ctx->sess_connect++;
+                        s->ctx->stats.sess_connect++;
                         s->init_num=0;
                         break;
 
@@ -179,7 +179,7 @@ SSL *s;
                         ret=ssl23_get_server_hello(s);
                         if (ret >= 0) cb=NULL;
                         goto end;
-                        break;
+                        /* break; */
 
                 default:
                         SSLerr(SSL_F_SSL23_CONNECT,SSL_R_UNKNOWN_STATE);
@@ -188,7 +188,7 @@ SSL *s;
                         /* break; */
                         }
 
-                if (s->debug) BIO_flush(s->wbio);
+                if (s->debug) { (void)BIO_flush(s->wbio); }
 
                 if ((cb != NULL) && (s->state != state))
                         {
@@ -206,12 +206,12 @@ end:
         }
 
 
-static int ssl23_client_hello(s)
-SSL *s;
+static int ssl23_client_hello(SSL *s)
         {
         unsigned char *buf;
         unsigned char *p,*d;
         int i,ch_len;
+        int ret;
 
         buf=(unsigned char *)s->init_buf->data;
         if (s->state == SSL23_ST_CW_CLNT_HELLO_A)
@@ -225,7 +225,7 @@ SSL *s;
 #endif
 
                 p=s->s3->client_random;
-                RAND_bytes(p,SSL3_RANDOM_SIZE);
+                RAND_pseudo_bytes(p,SSL3_RANDOM_SIZE);
 
                 /* Do the message type and length last */
                 d= &(buf[2]);
@@ -236,16 +236,19 @@ SSL *s;
                         {
                         *(d++)=TLS1_VERSION_MAJOR;
                         *(d++)=TLS1_VERSION_MINOR;
+                        s->client_version=TLS1_VERSION;
                         }
                 else if (!(s->options & SSL_OP_NO_SSLv3))
                         {
                         *(d++)=SSL3_VERSION_MAJOR;
                         *(d++)=SSL3_VERSION_MINOR;
+                        s->client_version=SSL3_VERSION;
                         }
                 else if (!(s->options & SSL_OP_NO_SSLv2))
                         {
                         *(d++)=SSL2_VERSION_MAJOR;
                         *(d++)=SSL2_VERSION_MINOR;
+                        s->client_version=SSL2_VERSION;
                         }
                 else
                         {
@@ -283,7 +286,7 @@ SSL *s;
                         i=ch_len;
                 s2n(i,d);
                 memset(&(s->s3->client_random[0]),0,SSL3_RANDOM_SIZE);
-                RAND_bytes(&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i);
+                RAND_pseudo_bytes(&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i);
                 memcpy(p,&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i);
                 p+=i;
 
@@ -300,15 +303,18 @@ SSL *s;
                 }
 
         /* SSL3_ST_CW_CLNT_HELLO_B */
-        return(ssl23_write_bytes(s));
+        ret = ssl23_write_bytes(s);
+        if (ret >= 2)
+                if (s->msg_callback)
+                        s->msg_callback(1, SSL2_VERSION, 0, s->init_buf->data+2, ret-2, s, s->msg_callback_arg); /* CLIENT-HELLO */
+        return ret;
         }
 
-static int ssl23_get_server_hello(s)
-SSL *s;
+static int ssl23_get_server_hello(SSL *s)
         {
         char buf[8];
         unsigned char *p;
-        int i,ch_len;
+        int i;
         int n;
 
         n=ssl23_read_bytes(s,7);
@@ -321,9 +327,14 @@ SSL *s;
         if ((p[0] & 0x80) && (p[2] == SSL2_MT_SERVER_HELLO) &&
                 (p[5] == 0x00) && (p[6] == 0x02))
                 {
+#ifdef OPENSSL_NO_SSL2
+                SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
+                goto err;
+#else
                 /* we are talking sslv2 */
                 /* we need to clean up the SSLv3 setup and put in the
                  * sslv2 stuff. */
+                int ch_len;
 
                 if (s->options & SSL_OP_NO_SSLv2)
                         {
@@ -360,7 +371,9 @@ SSL *s;
                         }
 
                 s->state=SSL2_ST_GET_SERVER_HELLO_A;
-                s->s2->ssl2_rollback=1;
+                if (!(s->client_version == SSL2_VERSION))
+                        /* use special padding (SSL 3.0 draft/RFC 2246, App. E.2) */
+                        s->s2->ssl2_rollback=1;
 
                 /* setup the 5 bytes we have read so we get them from
                  * the sslv2 buffer */
@@ -376,6 +389,7 @@ SSL *s;
 
                 s->method=SSLv2_client_method();
                 s->handshake_func=s->method->ssl_connect;
+#endif
                 }
         else if ((p[0] == SSL3_RT_HANDSHAKE) &&
                  (p[1] == SSL3_VERSION_MAJOR) &&
@@ -426,7 +440,7 @@ SSL *s;
                  (p[3] == 0) &&
                  (p[4] == 2))
                 {
-                void (*cb)()=NULL;
+                void (*cb)(const SSL *ssl,int type,int val)=NULL;
                 int j;
 
                 /* An alert */
@@ -443,7 +457,7 @@ SSL *s;
                         }
 
                 s->rwstate=SSL_NOTHING;
-                SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,1000+p[6]);
+                SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_AD_REASON_OFFSET+p[6]);
                 goto err;
                 }
         else
diff --git a/src/lib/libssl/s23_lib.c b/src/lib/libssl/s23_lib.c
index e16f641101..b70002a647 100644
--- a/src/lib/libssl/s23_lib.c
+++ b/src/lib/libssl/s23_lib.c
@@ -57,28 +57,18 @@
  */
 
 #include <stdio.h>
-#include "objects.h"
+#include <openssl/objects.h>
 #include "ssl_locl.h"
 
-#ifndef NOPROTO
 static int ssl23_num_ciphers(void );
 static SSL_CIPHER *ssl23_get_cipher(unsigned int u);
-static int ssl23_read(SSL *s, char *buf, int len);
-static int ssl23_write(SSL *s, char *buf, int len);
+static int ssl23_read(SSL *s, void *buf, int len);
+static int ssl23_peek(SSL *s, void *buf, int len);
+static int ssl23_write(SSL *s, const void *buf, int len);
 static long ssl23_default_timeout(void );
-static int ssl23_put_cipher_by_char(SSL_CIPHER *c, unsigned char *p);
-static SSL_CIPHER *ssl23_get_cipher_by_char(unsigned char *p);
-#else
-static int ssl23_num_ciphers();
-static SSL_CIPHER *ssl23_get_cipher();
-static int ssl23_read();
-static int ssl23_write();
-static long ssl23_default_timeout();
-static int ssl23_put_cipher_by_char();
-static SSL_CIPHER *ssl23_get_cipher_by_char();
-#endif
-
-char *SSL23_version_str="SSLv2/3 compatablity part of SSLeay 0.7.0 30-Jan-1997";
+static int ssl23_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p);
+static SSL_CIPHER *ssl23_get_cipher_by_char(const unsigned char *p);
+const char *SSL23_version_str="SSLv2/3 compatibility" OPENSSL_VERSION_PTEXT;
 
 static SSL_METHOD SSLv23_data= {
         TLS1_VERSION,
@@ -88,10 +78,11 @@ static SSL_METHOD SSLv23_data= {
         ssl_undefined_function,
         ssl_undefined_function,
         ssl23_read,
-        ssl_undefined_function,
+        ssl23_peek,
         ssl23_write,
         ssl_undefined_function,
         ssl_undefined_function,
+        ssl_ok,
         ssl3_ctrl,
         ssl3_ctx_ctrl,
         ssl23_get_cipher_by_char,
@@ -102,38 +93,47 @@ static SSL_METHOD SSLv23_data= {
         ssl_bad_method,
         ssl23_default_timeout,
         &ssl3_undef_enc_method,
+        ssl_undefined_function,
+        ssl3_callback_ctrl,
+        ssl3_ctx_callback_ctrl,
         };
 
-static long ssl23_default_timeout()
+static long ssl23_default_timeout(void)
         {
         return(300);
         }
 
-SSL_METHOD *sslv23_base_method()
+SSL_METHOD *sslv23_base_method(void)
         {
         return(&SSLv23_data);
         }
 
-static int ssl23_num_ciphers()
+static int ssl23_num_ciphers(void)
         {
-        return(ssl3_num_ciphers()+ssl2_num_ciphers());
+        return(ssl3_num_ciphers()
+#ifndef OPENSSL_NO_SSL2
+               + ssl2_num_ciphers()
+#endif
+            );
         }
 
-static SSL_CIPHER *ssl23_get_cipher(u)
-unsigned int u;
+static SSL_CIPHER *ssl23_get_cipher(unsigned int u)
         {
         unsigned int uu=ssl3_num_ciphers();
 
         if (u < uu)
                 return(ssl3_get_cipher(u));
         else
+#ifndef OPENSSL_NO_SSL2
                 return(ssl2_get_cipher(u-uu));
+#else
+                return(NULL);
+#endif
         }
 
 /* This function needs to check if the ciphers required are actually
  * available */
-static SSL_CIPHER *ssl23_get_cipher_by_char(p)
-unsigned char *p;
+static SSL_CIPHER *ssl23_get_cipher_by_char(const unsigned char *p)
         {
         SSL_CIPHER c,*cp;
         unsigned long id;
@@ -144,14 +144,14 @@ unsigned char *p;
                 ((unsigned long)p[1]<<8L)|(unsigned long)p[2];
         c.id=id;
         cp=ssl3_get_cipher_by_char(p);
+#ifndef OPENSSL_NO_SSL2
         if (cp == NULL)
                 cp=ssl2_get_cipher_by_char(p);
+#endif
         return(cp);
         }
 
-static int ssl23_put_cipher_by_char(c,p)
-SSL_CIPHER *c;
-unsigned char *p;
+static int ssl23_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p)
         {
         long l;
 
@@ -166,20 +166,10 @@ unsigned char *p;
         return(3);
         }
 
-static int ssl23_read(s,buf,len)
-SSL *s;
-char *buf;
-int len;
+static int ssl23_read(SSL *s, void *buf, int len)
         {
         int n;
 
-#if 0
-        if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
-                {
-                s->rwstate=SSL_NOTHING;
-                return(0);
-                }
-#endif
         clear_sys_error();
         if (SSL_in_init(s) && (!s->in_handshake))
                 {
@@ -199,20 +189,33 @@ int len;
                 }
         }
 
-static int ssl23_write(s,buf,len)
-SSL *s;
-char *buf;
-int len;
+static int ssl23_peek(SSL *s, void *buf, int len)
         {
         int n;
 
-#if 0
-        if (s->shutdown & SSL_SENT_SHUTDOWN)
+        clear_sys_error();
+        if (SSL_in_init(s) && (!s->in_handshake))
                 {
-                s->rwstate=SSL_NOTHING;
-                return(0);
+                n=s->handshake_func(s);
+                if (n < 0) return(n);
+                if (n == 0)
+                        {
+                        SSLerr(SSL_F_SSL23_PEEK,SSL_R_SSL_HANDSHAKE_FAILURE);
+                        return(-1);
+                        }
+                return(SSL_peek(s,buf,len));
                 }
-#endif
+        else
+                {
+                ssl_undefined_function(s);
+                return(-1);
+                }
+        }
+
+static int ssl23_write(SSL *s, const void *buf, int len)
+        {
+        int n;
+
         clear_sys_error();
         if (SSL_in_init(s) && (!s->in_handshake))
                 {
diff --git a/src/lib/libssl/s23_pkt.c b/src/lib/libssl/s23_pkt.c
index c25c312772..f45e1ce3d8 100644
--- a/src/lib/libssl/s23_pkt.c
+++ b/src/lib/libssl/s23_pkt.c
@@ -59,12 +59,11 @@
 #include <stdio.h>
 #include <errno.h>
 #define USE_SOCKETS
-#include "evp.h"
-#include "buffer.h"
+#include <openssl/evp.h>
+#include <openssl/buffer.h>
 #include "ssl_locl.h"
 
-int ssl23_write_bytes(s)
-SSL *s;
+int ssl23_write_bytes(SSL *s)
         {
         int i,num,tot;
         char *buf;
@@ -76,7 +75,7 @@ SSL *s;
                 {
                 s->rwstate=SSL_WRITING;
                 i=BIO_write(s->wbio,&(buf[tot]),num);
-                if (i < 0)
+                if (i <= 0)
                         {
                         s->init_off=tot;
                         s->init_num=num;
@@ -90,10 +89,8 @@ SSL *s;
                 }
         }
 
-/* only return when we have read 'n' bytes */
-int ssl23_read_bytes(s,n)
-SSL *s;
-int n;
+/* return regularly only when we have read (at least) 'n' bytes */
+int ssl23_read_bytes(SSL *s, int n)
         {
         unsigned char *p;
         int j;
diff --git a/src/lib/libssl/s23_srvr.c b/src/lib/libssl/s23_srvr.c
index c7b9ecbcf2..9e89cc7f9a 100644
--- a/src/lib/libssl/s23_srvr.c
+++ b/src/lib/libssl/s23_srvr.c
@@ -55,28 +55,76 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
+/* ====================================================================
+ * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
 
 #include <stdio.h>
-#include "buffer.h"
-#include "rand.h"
-#include "objects.h"
-#include "evp.h"
+#include <openssl/buffer.h>
+#include <openssl/rand.h>
+#include <openssl/objects.h>
+#include <openssl/evp.h>
 #include "ssl_locl.h"
 
-#define BREAK break
-
-#ifndef NOPROTO
+static SSL_METHOD *ssl23_get_server_method(int ver);
 int ssl23_get_client_hello(SSL *s);
-#else
-int ssl23_get_client_hello();
-#endif
-
-static SSL_METHOD *ssl23_get_server_method(ver)
-int ver;
+static SSL_METHOD *ssl23_get_server_method(int ver)
         {
+#ifndef OPENSSL_NO_SSL2
         if (ver == SSL2_VERSION)
                 return(SSLv2_server_method());
-        else if (ver == SSL3_VERSION)
+#endif
+        if (ver == SSL3_VERSION)
                 return(SSLv3_server_method());
         else if (ver == TLS1_VERSION)
                 return(TLSv1_server_method());
@@ -84,32 +132,31 @@ int ver;
                 return(NULL);
         }
 
-SSL_METHOD *SSLv23_server_method()
+SSL_METHOD *SSLv23_server_method(void)
         {
         static int init=1;
         static SSL_METHOD SSLv23_server_data;
 
         if (init)
                 {
-                init=0;
                 memcpy((char *)&SSLv23_server_data,
                         (char *)sslv23_base_method(),sizeof(SSL_METHOD));
                 SSLv23_server_data.ssl_accept=ssl23_accept;
                 SSLv23_server_data.get_ssl_method=ssl23_get_server_method;
+                init=0;
                 }
         return(&SSLv23_server_data);
         }
 
-int ssl23_accept(s)
-SSL *s;
+int ssl23_accept(SSL *s)
         {
         BUF_MEM *buf;
         unsigned long Time=time(NULL);
-        void (*cb)()=NULL;
+        void (*cb)(const SSL *ssl,int type,int val)=NULL;
         int ret= -1;
         int new_state,state;
 
-        RAND_seed((unsigned char *)&Time,sizeof(Time));
+        RAND_add(&Time,sizeof(Time),0);
         ERR_clear_error();
         clear_sys_error();
 
@@ -118,8 +165,8 @@ SSL *s;
         else if (s->ctx->info_callback != NULL)
                 cb=s->ctx->info_callback;
         
-        if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s); 
         s->in_handshake++;
+        if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s); 
 
         for (;;)
                 {
@@ -132,6 +179,7 @@ SSL *s;
                 case SSL_ST_BEFORE|SSL_ST_ACCEPT:
                 case SSL_ST_OK|SSL_ST_ACCEPT:
 
+                        s->server=1;
                         if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
 
                         /* s->version=SSL3_VERSION; */
@@ -155,7 +203,7 @@ SSL *s;
                         ssl3_init_finished_mac(s);
 
                         s->state=SSL23_ST_SR_CLNT_HELLO_A;
-                        s->ctx->sess_accept++;
+                        s->ctx->stats.sess_accept++;
                         s->init_num=0;
                         break;
 
@@ -166,7 +214,7 @@ SSL *s;
                         ret=ssl23_get_client_hello(s);
                         if (ret >= 0) cb=NULL;
                         goto end;
-                        break;
+                        /* break; */
 
                 default:
                         SSLerr(SSL_F_SSL23_ACCEPT,SSL_R_UNKNOWN_STATE);
@@ -184,31 +232,48 @@ SSL *s;
                         }
                 }
 end:
+        s->in_handshake--;
         if (cb != NULL)
                 cb(s,SSL_CB_ACCEPT_EXIT,ret);
-        s->in_handshake--;
         return(ret);
         }
 
 
-int ssl23_get_client_hello(s)
-SSL *s;
+int ssl23_get_client_hello(SSL *s)
         {
-        char buf_space[8];
+        char buf_space[11]; /* Request this many bytes in initial read.
+                             * We can detect SSL 3.0/TLS 1.0 Client Hellos
+                             * ('type == 3') correctly only when the following
+                             * is in a single record, which is not guaranteed by
+                             * the protocol specification:
+                             * Byte  Content
+                             *  0     type            \
+                             *  1/2   version          > record header
+                             *  3/4   length          /
+                             *  5     msg_type        \
+                             *  6-8   length           > Client Hello message
+                             *  9/10  client_version  /
+                             */
         char *buf= &(buf_space[0]);
-        unsigned char *p,*d,*dd;
+        unsigned char *p,*d,*d_len,*dd;
         unsigned int i;
         unsigned int csl,sil,cl;
-        int n=0,j,tls1=0;
-        int type=0,use_sslv2_strong=0;
+        int n=0,j;
+        int type=0;
+        int v[2];
+#ifndef OPENSSL_NO_RSA
+        int use_sslv2_strong=0;
+#endif
 
-        /* read the initial header */
         if (s->state == SSL23_ST_SR_CLNT_HELLO_A)
                 {
+                /* read the initial header */
+                v[0]=v[1]=0;
+
                 if (!ssl3_setup_buffers(s)) goto err;
 
-                n=ssl23_read_bytes(s,7);
-                if (n != 7) return(n);
+                n=ssl23_read_bytes(s, sizeof buf_space);
+                if (n != sizeof buf_space) return(n); /* n == -1 || n == 0 */
 
                 p=s->packet;
 
@@ -216,124 +281,135 @@ SSL *s;
 
                 if ((p[0] & 0x80) && (p[2] == SSL2_MT_CLIENT_HELLO))
                         {
-                        /* SSLv2 header */
+                        /*
+                         * SSLv2 header
+                         */
                         if ((p[3] == 0x00) && (p[4] == 0x02))
                                 {
+                                v[0]=p[3]; v[1]=p[4];
                                 /* SSLv2 */
                                 if (!(s->options & SSL_OP_NO_SSLv2))
                                         type=1;
                                 }
                         else if (p[3] == SSL3_VERSION_MAJOR)
                                 {
+                                v[0]=p[3]; v[1]=p[4];
                                 /* SSLv3/TLSv1 */
                                 if (p[4] >= TLS1_VERSION_MINOR)
                                         {
                                         if (!(s->options & SSL_OP_NO_TLSv1))
                                                 {
-                                                tls1=1;
+                                                s->version=TLS1_VERSION;
+                                                /* type=2; */ /* done later to survive restarts */
                                                 s->state=SSL23_ST_SR_CLNT_HELLO_B;
                                                 }
                                         else if (!(s->options & SSL_OP_NO_SSLv3))
                                                 {
+                                                s->version=SSL3_VERSION;
+                                                /* type=2; */
                                                 s->state=SSL23_ST_SR_CLNT_HELLO_B;
                                                 }
+                                        else if (!(s->options & SSL_OP_NO_SSLv2))
+                                                {
+                                                type=1;
+                                                }
                                         }
                                 else if (!(s->options & SSL_OP_NO_SSLv3))
-                                        s->state=SSL23_ST_SR_CLNT_HELLO_B;
-
-                                if (s->options & SSL_OP_NON_EXPORT_FIRST)
                                         {
-                                        STACK *sk;
-                                        SSL_CIPHER *c;
-                                        int ne2,ne3;
-
-                                        j=((p[0]&0x7f)<<8)|p[1];
-                                        if (j > (1024*4))
-                                                {
-                                                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_LARGE);
-                                                goto err;
-                                                }
-
-                                        n=ssl23_read_bytes(s,j+2);
-                                        if (n <= 0) return(n);
-                                        p=s->packet;
-
-                                        if ((buf=Malloc(n)) == NULL)
-                                                {
-                                                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,ERR_R_MALLOC_FAILURE);
-                                                goto err;
-                                                }
-                                        memcpy(buf,p,n);
-
-                                        p+=5;
-                                        n2s(p,csl);
-                                        p+=4;
-
-                                        sk=ssl_bytes_to_cipher_list(
-                                                s,p,csl,NULL);
-                                        if (sk != NULL)
-                                                {
-                                                ne2=ne3=0;
-                                                for (j=0; j<sk_num(sk); j++)
-                                                        {
-                                                        c=(SSL_CIPHER *)sk_value(sk,j);
-                                                        if (!(c->algorithms & SSL_EXP))
-                                                                {
-                                                                if ((c->id>>24L) == 2L)
-                                                                        ne2=1;
-                                                                else
-                                                                        ne3=1;
-                                                                }
-                                                        }
-                                                if (ne2 && !ne3)
-                                                        {
-                                                        type=1;
-                                                        use_sslv2_strong=1;
-                                                        goto next_bit;
-                                                        }
-                                                }
+                                        s->version=SSL3_VERSION;
+                                        /* type=2; */
+                                        s->state=SSL23_ST_SR_CLNT_HELLO_B;
                                         }
+                                else if (!(s->options & SSL_OP_NO_SSLv2))
+                                        type=1;
+
                                 }
                         }
                 else if ((p[0] == SSL3_RT_HANDSHAKE) &&
                          (p[1] == SSL3_VERSION_MAJOR) &&
-                         (p[5] == SSL3_MT_CLIENT_HELLO))
+                         (p[5] == SSL3_MT_CLIENT_HELLO) &&
+                         ((p[3] == 0 && p[4] < 5 /* silly record length? */)
+                                || (p[9] == p[1])))
                         {
-                        /* true SSLv3 or tls1 */
-                        if (p[2] >= TLS1_VERSION_MINOR)
+                        /*
+                         * SSLv3 or tls1 header
+                         */
+                        
+                        v[0]=p[1]; /* major version (= SSL3_VERSION_MAJOR) */
+                        /* We must look at client_version inside the Client Hello message
+                         * to get the correct minor version.
+                         * However if we have only a pathologically small fragment of the
+                         * Client Hello message, this would be difficult, and we'd have
+                         * to read more records to find out.
+                         * No known SSL 3.0 client fragments ClientHello like this,
+                         * so we simply assume TLS 1.0 to avoid protocol version downgrade
+                         * attacks. */
+                        if (p[3] == 0 && p[4] < 6)
+                                {
+#if 0
+                                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_SMALL);
+                                goto err;
+#else
+                                v[1] = TLS1_VERSION_MINOR;
+#endif
+                                }
+                        else
+                                v[1]=p[10]; /* minor version according to client_version */
+                        if (v[1] >= TLS1_VERSION_MINOR)
                                 {
                                 if (!(s->options & SSL_OP_NO_TLSv1))
                                         {
+                                        s->version=TLS1_VERSION;
                                         type=3;
-                                        tls1=1;
                                         }
                                 else if (!(s->options & SSL_OP_NO_SSLv3))
+                                        {
+                                        s->version=SSL3_VERSION;
+                                        type=3;
+                                        }
+                                }
+                        else
+                                {
+                                /* client requests SSL 3.0 */
+                                if (!(s->options & SSL_OP_NO_SSLv3))
+                                        {
+                                        s->version=SSL3_VERSION;
                                         type=3;
+                                        }
+                                else if (!(s->options & SSL_OP_NO_TLSv1))
+                                        {
+                                        /* we won't be able to use TLS of course,
+                                         * but this will send an appropriate alert */
+                                        s->version=TLS1_VERSION;
+                                        type=3;
+                                        }
                                 }
-                        else if (!(s->options & SSL_OP_NO_SSLv3))
-                                type=3;
                         }
-                else if ((strncmp("GET ", p,4) == 0) ||
-                         (strncmp("POST ",p,5) == 0) ||
-                         (strncmp("HEAD ",p,5) == 0) ||
-                         (strncmp("PUT ", p,4) == 0))
+                else if ((strncmp("GET ", (char *)p,4) == 0) ||
+                         (strncmp("POST ",(char *)p,5) == 0) ||
+                         (strncmp("HEAD ",(char *)p,5) == 0) ||
+                         (strncmp("PUT ", (char *)p,4) == 0))
                         {
                         SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTP_REQUEST);
                         goto err;
                         }
-                else if (strncmp("CONNECT",p,7) == 0)
+                else if (strncmp("CONNECT",(char *)p,7) == 0)
                         {
                         SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTPS_PROXY_REQUEST);
                         goto err;
                         }
                 }
 
-next_bit:
         if (s->state == SSL23_ST_SR_CLNT_HELLO_B)
                 {
-                /* we have a SSLv3/TLSv1 in a SSLv2 header */
+                /* we have SSLv3/TLSv1 in an SSLv2 header
+                 * (other cases skip this state) */
+
                 type=2;
                 p=s->packet;
+                v[0] = p[3]; /* == SSL3_VERSION_MAJOR */
+                v[1] = p[4];
+
                 n=((p[0]&0x7f)<<8)|p[1];
                 if (n > (1024*4))
                         {
@@ -344,7 +420,9 @@ next_bit:
                 j=ssl23_read_bytes(s,n+2);
                 if (j <= 0) return(j);
 
-                ssl3_finish_mac(s,&(s->packet[2]),s->packet_length-2);
+                ssl3_finish_mac(s, s->packet+2, s->packet_length-2);
+                if (s->msg_callback)
+                        s->msg_callback(0, SSL2_VERSION, 0, s->packet+2, s->packet_length-2, s, s->msg_callback_arg); /* CLIENT-HELLO */
 
                 p=s->packet;
                 p+=5;
@@ -358,14 +436,18 @@ next_bit:
                         goto err;
                         }
 
-                *(d++)=SSL3_VERSION_MAJOR;
-                if (tls1)
-                        *(d++)=TLS1_VERSION_MINOR;
-                else
-                        *(d++)=SSL3_VERSION_MINOR;
+                /* record header: msg_type ... */
+                *(d++) = SSL3_MT_CLIENT_HELLO;
+                /* ... and length (actual value will be written later) */
+                d_len = d;
+                d += 3;
+
+                /* client_version */
+                *(d++) = SSL3_VERSION_MAJOR; /* == v[0] */
+                *(d++) = v[1];
 
                 /* lets populate the random area */
-                /* get the chalenge_length */
+                /* get the challenge_length */
                 i=(cl > SSL3_RANDOM_SIZE)?SSL3_RANDOM_SIZE:cl;
                 memset(d,0,SSL3_RANDOM_SIZE);
                 memcpy(&(d[SSL3_RANDOM_SIZE-i]),&(p[csl+sil]),i);
@@ -387,11 +469,12 @@ next_bit:
                         }
                 s2n(j,dd);
 
-                /* compression */
+                /* COMPRESSION */
                 *(d++)=1;
                 *(d++)=0;
                 
-                i=(d-(unsigned char *)s->init_buf->data);
+                i = (d-(unsigned char *)s->init_buf->data) - 4;
+                l2n3((long)i, d_len);
 
                 /* get the data reused from the init_buf */
                 s->s3->tmp.reuse_message=1;
@@ -399,8 +482,15 @@ next_bit:
                 s->s3->tmp.message_size=i;
                 }
 
+        /* imaginary new state (for program structure): */
+        /* s->state = SSL23_SR_CLNT_HELLO_C */
+
         if (type == 1)
                 {
+#ifdef OPENSSL_NO_SSL2
+                SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
+                goto err;
+#else
                 /* we are talking sslv2 */
                 /* we need to clean up the SSLv3/TLSv1 setup and put in the
                  * sslv2 stuff. */
@@ -423,12 +513,15 @@ next_bit:
 
                 s->state=SSL2_ST_GET_CLIENT_HELLO_A;
                 if ((s->options & SSL_OP_MSIE_SSLV2_RSA_PADDING) ||
-                        use_sslv2_strong)
+                        use_sslv2_strong ||
+                        (s->options & SSL_OP_NO_TLSv1 && s->options & SSL_OP_NO_SSLv3))
                         s->s2->ssl2_rollback=0;
                 else
+                        /* reject SSL 2.0 session if client supports SSL 3.0 or TLS 1.0
+                         * (SSL 3.0 draft/RFC 2246, App. E.2) */
                         s->s2->ssl2_rollback=1;
 
-                /* setup the 5 bytes we have read so we get them from
+                /* setup the n bytes we have read so we get them from
                  * the sslv2 buffer */
                 s->rstate=SSL_ST_READ_HEADER;
                 s->packet_length=n;
@@ -439,11 +532,12 @@ next_bit:
 
                 s->method=SSLv2_server_method();
                 s->handshake_func=s->method->ssl_accept;
+#endif
                 }
 
         if ((type == 2) || (type == 3))
                 {
-                /* we have SSLv3/TLSv1 */
+                /* we have SSLv3/TLSv1 (type 2: SSL2 style, type 3: SSL3/TLS style) */
 
                 if (!ssl_init_wbio_buffer(s,1)) goto err;
 
@@ -468,16 +562,13 @@ next_bit:
                         s->s3->rbuf.offset=0;
                         }
 
-                if (tls1)
-                        {
-                        s->version=TLS1_VERSION;
-                        s->method=TLSv1_server_method();
-                        }
+                if (s->version == TLS1_VERSION)
+                        s->method = TLSv1_server_method();
                 else
-                        {
-                        s->version=SSL3_VERSION;
-                        s->method=SSLv3_server_method();
-                        }
+                        s->method = SSLv3_server_method();
+#if 0 /* ssl3_get_client_hello does this */
+                s->client_version=(v[0]<<8)|v[1];
+#endif
                 s->handshake_func=s->method->ssl_accept;
                 }
         
@@ -489,11 +580,10 @@ next_bit:
                 }
         s->init_num=0;
 
-        if (buf != buf_space) Free(buf);
+        if (buf != buf_space) OPENSSL_free(buf);
         s->first_packet=1;
         return(SSL_accept(s));
 err:
-        if (buf != buf_space) Free(buf);
+        if (buf != buf_space) OPENSSL_free(buf);
         return(-1);
         }
-
diff --git a/src/lib/libssl/s3_both.c b/src/lib/libssl/s3_both.c
index 6de62e1591..58a24cd883 100644
--- a/src/lib/libssl/s3_both.c
+++ b/src/lib/libssl/s3_both.c
@@ -55,26 +55,95 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
+/* ====================================================================
+ * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
 
+#include <limits.h>
+#include <string.h>
 #include <stdio.h>
-#include "buffer.h"
-#include "rand.h"
-#include "objects.h"
-#include "evp.h"
-#include "x509.h"
+#include <openssl/buffer.h>
+#include <openssl/rand.h>
+#include <openssl/objects.h>
+#include <openssl/evp.h>
+#include <openssl/x509.h>
 #include "ssl_locl.h"
 
-#define BREAK   break
-
-/* SSL3err(SSL_F_SSL3_GET_FINISHED,SSL_R_EXCESSIVE_MESSAGE_SIZE);
- */
+/* send s->init_buf in records of type 'type' (SSL3_RT_HANDSHAKE or SSL3_RT_CHANGE_CIPHER_SPEC) */
+int ssl3_do_write(SSL *s, int type)
+        {
+        int ret;
+
+        ret=ssl3_write_bytes(s,type,&s->init_buf->data[s->init_off],
+                             s->init_num);
+        if (ret < 0) return(-1);
+        if (type == SSL3_RT_HANDSHAKE)
+                /* should not be done for 'Hello Request's, but in that case
+                 * we'll ignore the result anyway */
+                ssl3_finish_mac(s,(unsigned char *)&s->init_buf->data[s->init_off],ret);
+        
+        if (ret == s->init_num)
+                {
+                if (s->msg_callback)
+                        s->msg_callback(1, s->version, type, s->init_buf->data, (size_t)(s->init_off + s->init_num), s, s->msg_callback_arg);
+                return(1);
+                }
+        s->init_off+=ret;
+        s->init_num-=ret;
+        return(0);
+        }
 
-int ssl3_send_finished(s,a,b,sender,slen)
-SSL *s;
-int a;
-int b;
-unsigned char *sender;
-int slen;
+int ssl3_send_finished(SSL *s, int a, int b, const char *sender, int slen)
         {
         unsigned char *p,*d;
         int i;
@@ -88,10 +157,19 @@ int slen;
                 i=s->method->ssl3_enc->final_finish_mac(s,
                         &(s->s3->finish_dgst1),
                         &(s->s3->finish_dgst2),
-                        sender,slen,p);
+                        sender,slen,s->s3->tmp.finish_md);
+                s->s3->tmp.finish_md_len = i;
+                memcpy(p, s->s3->tmp.finish_md, i);
                 p+=i;
                 l=i;
 
+#ifdef OPENSSL_SYS_WIN16
+                /* MSVC 1.5 does not clear the top bytes of the word unless
+                 * I do this.
+                 */
+                l&=0xffff;
+#endif
+
                 *(d++)=SSL3_MT_FINISHED;
                 l2n3(l,d);
                 s->init_num=(int)l+4;
@@ -104,17 +182,14 @@ int slen;
         return(ssl3_do_write(s,SSL3_RT_HANDSHAKE));
         }
 
-int ssl3_get_finished(s,a,b)
-SSL *s;
-int a;
-int b;
+int ssl3_get_finished(SSL *s, int a, int b)
         {
         int al,i,ok;
         long n;
         unsigned char *p;
 
         /* the mac has already been generated when we received the
-         * change cipher spec message and is in s->s3->tmp.in_dgst[12]
+         * change cipher spec message and is in s->s3->tmp.peer_finish_md
          */ 
 
         n=ssl3_get_message(s,
@@ -126,7 +201,7 @@ int b;
 
         if (!ok) return((int)n);
 
-        /* If this occurs if we has missed a message */
+        /* If this occurs, we have missed a message */
         if (!s->s3->change_cipher_spec)
                 {
                 al=SSL_AD_UNEXPECTED_MESSAGE;
@@ -135,9 +210,8 @@ int b;
                 }
         s->s3->change_cipher_spec=0;
 
-        p=(unsigned char *)s->init_buf->data;
-
-        i=s->method->ssl3_enc->finish_mac_length;
+        p = (unsigned char *)s->init_msg;
+        i = s->s3->tmp.peer_finish_md_len;
 
         if (i != n)
                 {
@@ -146,7 +220,7 @@ int b;
                 goto f_err;
                 }
 
-        if (memcmp(  p,    (char *)&(s->s3->tmp.finish_md[0]),i) != 0)
+        if (memcmp(p, s->s3->tmp.peer_finish_md, i) != 0)
                 {
                 al=SSL_AD_DECRYPT_ERROR;
                 SSLerr(SSL_F_SSL3_GET_FINISHED,SSL_R_DIGEST_CHECK_FAILED);
@@ -167,9 +241,7 @@ f_err:
  * ssl->session->read_compression       assign
  * ssl->session->read_hash              assign
  */
-int ssl3_send_change_cipher_spec(s,a,b)
-SSL *s;
-int a,b;
+int ssl3_send_change_cipher_spec(SSL *s, int a, int b)
         { 
         unsigned char *p;
 
@@ -187,9 +259,7 @@ int a,b;
         return(ssl3_do_write(s,SSL3_RT_CHANGE_CIPHER_SPEC));
         }
 
-unsigned long ssl3_output_cert_chain(s,x)
-SSL *s;
-X509 *x;
+unsigned long ssl3_output_cert_chain(SSL *s, X509 *x)
         {
         unsigned char *p;
         int n,i;
@@ -207,7 +277,11 @@ X509 *x;
                 }
         if (x != NULL)
                 {
-                X509_STORE_CTX_init(&xs_ctx,s->ctx->cert_store,NULL,NULL);
+                if(!X509_STORE_CTX_init(&xs_ctx,s->ctx->cert_store,NULL,NULL))
+                        {
+                        SSLerr(SSL_F_SSL3_OUTPUT_CERT_CHAIN,ERR_R_X509_LIB);
+                        return(0);
+                        }
 
                 for (;;)
                         {
@@ -236,6 +310,23 @@ X509 *x;
                 X509_STORE_CTX_cleanup(&xs_ctx);
                 }
 
+        /* Thawte special :-) */
+        if (s->ctx->extra_certs != NULL)
+        for (i=0; i<sk_X509_num(s->ctx->extra_certs); i++)
+                {
+                x=sk_X509_value(s->ctx->extra_certs,i);
+                n=i2d_X509(x,NULL);
+                if (!BUF_MEM_grow(buf,(int)(n+l+3)))
+                        {
+                        SSLerr(SSL_F_SSL3_OUTPUT_CERT_CHAIN,ERR_R_BUF_LIB);
+                        return(0);
+                        }
+                p=(unsigned char *)&(buf->data[l]);
+                l2n3(n,p);
+                i2d_X509(x,&p);
+                l+=n+3;
+                }
+
         l-=7;
         p=(unsigned char *)&(buf->data[4]);
         l2n3(l,p);
@@ -247,11 +338,12 @@ X509 *x;
         return(l);
         }
 
-long ssl3_get_message(s,st1,stn,mt,max,ok)
-SSL *s;
-int st1,stn,mt;
-long max;
-int *ok;
+/* Obtain handshake message of message type 'mt' (any if mt == -1),
+ * maximum acceptable body length 'max'.
+ * The first four bytes (msg_type and length) are read in state 'st1',
+ * the body is read in state 'stn'.
+ */
+long ssl3_get_message(SSL *s, int st1, int stn, int mt, long max, int *ok)
         {
         unsigned char *p;
         unsigned long l;
@@ -268,21 +360,51 @@ int *ok;
                         goto f_err;
                         }
                 *ok=1;
-                return((int)s->s3->tmp.message_size);
+                s->init_msg = s->init_buf->data + 4;
+                s->init_num = (int)s->s3->tmp.message_size;
+                return s->init_num;
                 }
 
         p=(unsigned char *)s->init_buf->data;
 
-        if (s->state == st1)
+        if (s->state == st1) /* s->init_num < 4 */
                 {
-                i=ssl3_read_bytes(s,SSL3_RT_HANDSHAKE,
-                        (char *)&(p[s->init_num]),
-                        4-s->init_num);
-                if (i < (4-s->init_num))
+                int skip_message;
+
+                do
                         {
-                        *ok=0;
-                        return(ssl3_part_read(s,i));
+                        while (s->init_num < 4)
+                                {
+                                i=ssl3_read_bytes(s,SSL3_RT_HANDSHAKE,&p[s->init_num],
+                                        4 - s->init_num, 0);
+                                if (i <= 0)
+                                        {
+                                        s->rwstate=SSL_READING;
+                                        *ok = 0;
+                                        return i;
+                                        }
+                                s->init_num+=i;
+                                }
+                        
+                        skip_message = 0;
+                        if (!s->server)
+                                if (p[0] == SSL3_MT_HELLO_REQUEST)
+                                        /* The server may always send 'Hello Request' messages --
+                                         * we are doing a handshake anyway now, so ignore them
+                                         * if their format is correct. Does not count for
+                                         * 'Finished' MAC. */
+                                        if (p[1] == 0 && p[2] == 0 &&p[3] == 0)
+                                                {
+                                                s->init_num = 0;
+                                                skip_message = 1;
+
+                                                if (s->msg_callback)
+                                                        s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, p, 4, s, s->msg_callback_arg);
+                                                }
                         }
+                while (skip_message);
+
+                /* s->init_num == 4 */
 
                 if ((mt >= 0) && (*p != mt))
                         {
@@ -290,6 +412,18 @@ int *ok;
                         SSLerr(SSL_F_SSL3_GET_MESSAGE,SSL_R_UNEXPECTED_MESSAGE);
                         goto f_err;
                         }
+                if ((mt < 0) && (*p == SSL3_MT_CLIENT_HELLO) &&
+                                        (st1 == SSL3_ST_SR_CERT_A) &&
+                                        (stn == SSL3_ST_SR_CERT_B))
+                        {
+                        /* At this point we have got an MS SGC second client
+                         * hello (maybe we should always allow the client to
+                         * start a new handshake?). We need to restart the mac.
+                         * Don't increment {num,total}_renegotiations because
+                         * we have not completed the handshake. */
+                        ssl3_init_finished_mac(s);
+                        }
+
                 s->s3->tmp.message_type= *(p++);
 
                 n2l3(p,l);
@@ -299,7 +433,13 @@ int *ok;
                         SSLerr(SSL_F_SSL3_GET_MESSAGE,SSL_R_EXCESSIVE_MESSAGE_SIZE);
                         goto f_err;
                         }
-                if (l && !BUF_MEM_grow(s->init_buf,(int)l))
+                if (l > (INT_MAX-4)) /* BUF_MEM_grow takes an 'int' parameter */
+                        {
+                        al=SSL_AD_ILLEGAL_PARAMETER;
+                        SSLerr(SSL_F_SSL3_GET_MESSAGE,SSL_R_EXCESSIVE_MESSAGE_SIZE);
+                        goto f_err;
+                        }
+                if (l && !BUF_MEM_grow(s->init_buf,(int)l+4))
                         {
                         SSLerr(SSL_F_SSL3_GET_MESSAGE,ERR_R_BUF_LIB);
                         goto err;
@@ -307,24 +447,30 @@ int *ok;
                 s->s3->tmp.message_size=l;
                 s->state=stn;
 
-                s->init_num=0;
+                s->init_msg = s->init_buf->data + 4;
+                s->init_num = 0;
                 }
 
         /* next state (stn) */
-        p=(unsigned char *)s->init_buf->data;
-        n=s->s3->tmp.message_size;
-        if (n > 0)
+        p = s->init_msg;
+        n = s->s3->tmp.message_size - s->init_num;
+        while (n > 0)
                 {
-                i=ssl3_read_bytes(s,SSL3_RT_HANDSHAKE,
-                        (char *)&(p[s->init_num]),(int)n);
-                if (i != (int)n)
+                i=ssl3_read_bytes(s,SSL3_RT_HANDSHAKE,&p[s->init_num],n,0);
+                if (i <= 0)
                         {
-                        *ok=0;
-                        return(ssl3_part_read(s,i));
+                        s->rwstate=SSL_READING;
+                        *ok = 0;
+                        return i;
                         }
+                s->init_num += i;
+                n -= i;
                 }
+        ssl3_finish_mac(s, (unsigned char *)s->init_buf->data, s->init_num + 4);
+        if (s->msg_callback)
+                s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, s->init_buf->data, (size_t)s->init_num + 4, s, s->msg_callback_arg);
         *ok=1;
-        return(n);
+        return s->init_num;
 f_err:
         ssl3_send_alert(s,SSL3_AL_FATAL,al);
 err:
@@ -332,9 +478,7 @@ err:
         return(-1);
         }
 
-int ssl_cert_type(x,pkey)
-X509 *x;
-EVP_PKEY *pkey;
+int ssl_cert_type(X509 *x, EVP_PKEY *pkey)
         {
         EVP_PKEY *pk;
         int ret= -1,i,j;
@@ -380,11 +524,11 @@ EVP_PKEY *pkey;
                 ret= -1;
 
 err:
+        if(!pkey) EVP_PKEY_free(pk);
         return(ret);
         }
 
-int ssl_verify_alarm_type(type)
-long type;
+int ssl_verify_alarm_type(long type)
         {
         int al;
 
@@ -392,6 +536,7 @@ long type;
                 {
         case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
         case X509_V_ERR_UNABLE_TO_GET_CRL:
+        case X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER:
                 al=SSL_AD_UNKNOWN_CA;
                 break;
         case X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE:
@@ -403,6 +548,8 @@ long type;
         case X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD:
         case X509_V_ERR_CERT_NOT_YET_VALID:
         case X509_V_ERR_CRL_NOT_YET_VALID:
+        case X509_V_ERR_CERT_UNTRUSTED:
+        case X509_V_ERR_CERT_REJECTED:
                 al=SSL_AD_BAD_CERTIFICATE;
                 break;
         case X509_V_ERR_CERT_SIGNATURE_FAILURE:
@@ -424,11 +571,16 @@ long type;
         case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
         case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
         case X509_V_ERR_CERT_CHAIN_TOO_LONG:
+        case X509_V_ERR_PATH_LENGTH_EXCEEDED:
+        case X509_V_ERR_INVALID_CA:
                 al=SSL_AD_UNKNOWN_CA;
                 break;
         case X509_V_ERR_APPLICATION_VERIFICATION:
                 al=SSL_AD_HANDSHAKE_FAILURE;
                 break;
+        case X509_V_ERR_INVALID_PURPOSE:
+                al=SSL_AD_UNSUPPORTED_CERTIFICATE;
+                break;
         default:
                 al=SSL_AD_CERTIFICATE_UNKNOWN;
                 break;
@@ -436,11 +588,11 @@ long type;
         return(al);
         }
 
-int ssl3_setup_buffers(s)
-SSL *s;
+int ssl3_setup_buffers(SSL *s)
         {
         unsigned char *p;
         unsigned int extra;
+        size_t len;
 
         if (s->s3->rbuf.buf == NULL)
                 {
@@ -448,18 +600,21 @@ SSL *s;
                         extra=SSL3_RT_MAX_EXTRA;
                 else
                         extra=0;
-                if ((p=(unsigned char *)Malloc(SSL3_RT_MAX_PACKET_SIZE+extra))
-                        == NULL)
+                len = SSL3_RT_MAX_PACKET_SIZE + extra;
+                if ((p=OPENSSL_malloc(len)) == NULL)
                         goto err;
-                s->s3->rbuf.buf=p;
+                s->s3->rbuf.buf = p;
+                s->s3->rbuf.len = len;
                 }
 
         if (s->s3->wbuf.buf == NULL)
                 {
-                if ((p=(unsigned char *)Malloc(SSL3_RT_MAX_PACKET_SIZE))
-                        == NULL)
+                len = SSL3_RT_MAX_PACKET_SIZE;
+                len += SSL3_RT_HEADER_LENGTH + 256; /* extra space for empty fragment */
+                if ((p=OPENSSL_malloc(len)) == NULL)
                         goto err;
-                s->s3->wbuf.buf=p;
+                s->s3->wbuf.buf = p;
+                s->s3->wbuf.len = len;
                 }
         s->packet= &(s->s3->rbuf.buf[0]);
         return(1);
diff --git a/src/lib/libssl/s3_clnt.c b/src/lib/libssl/s3_clnt.c
index 940c6a458f..e5853ede95 100644
--- a/src/lib/libssl/s3_clnt.c
+++ b/src/lib/libssl/s3_clnt.c
@@ -55,29 +55,74 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
+/* ====================================================================
+ * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
 
 #include <stdio.h>
-#include "buffer.h"
-#include "rand.h"
-#include "objects.h"
-#include "evp.h"
+#include <openssl/buffer.h>
+#include <openssl/rand.h>
+#include <openssl/objects.h>
+#include <openssl/evp.h>
 #include "ssl_locl.h"
+#include "kssl_lcl.h"
+#include <openssl/md5.h>
 
-#define BREAK break
-/* SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,ERR_R_MALLOC_FAILURE);
- * SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,ERR_R_MALLOC_FAILURE);
- * SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,ERR_R_MALLOC_FAILURE);
- * SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_MALLOC_FAILURE);
- * SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,ERR_R_MALLOC_FAILURE);
- * SSLerr(SSL_F_SSL3_GET_SERVER_DONE,ERR_R_MALLOC_FAILURE);
-SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_SSL3_SESSION_ID_TOO_SHORT);
- */
-
-#ifndef NOPROTO
+static SSL_METHOD *ssl3_get_client_method(int ver);
 static int ssl3_client_hello(SSL *s);
 static int ssl3_get_server_hello(SSL *s);
 static int ssl3_get_certificate_request(SSL *s);
-static int ca_dn_cmp(X509_NAME **a,X509_NAME **b);
+static int ca_dn_cmp(const X509_NAME * const *a,const X509_NAME * const *b);
 static int ssl3_get_server_done(SSL *s);
 static int ssl3_send_client_verify(SSL *s);
 static int ssl3_send_client_certificate(SSL *s);
@@ -85,22 +130,7 @@ static int ssl3_send_client_key_exchange(SSL *s);
 static int ssl3_get_key_exchange(SSL *s);
 static int ssl3_get_server_certificate(SSL *s);
 static int ssl3_check_cert_and_algorithm(SSL *s);
-#else
-static int ssl3_client_hello();
-static int ssl3_get_server_hello();
-static int ssl3_get_certificate_request();
-static int ca_dn_cmp();
-static int ssl3_get_server_done();
-static int ssl3_send_client_verify();
-static int ssl3_send_client_certificate();
-static int ssl3_send_client_key_exchange();
-static int ssl3_get_key_exchange();
-static int ssl3_get_server_certificate();
-static int ssl3_check_cert_and_algorithm();
-#endif
-
-static SSL_METHOD *ssl3_get_client_method(ver)
-int ver;
+static SSL_METHOD *ssl3_get_client_method(int ver)
         {
         if (ver == SSL3_VERSION)
                 return(SSLv3_client_method());
@@ -108,7 +138,7 @@ int ver;
                 return(NULL);
         }
 
-SSL_METHOD *SSLv3_client_method()
+SSL_METHOD *SSLv3_client_method(void)
         {
         static int init=1;
         static SSL_METHOD SSLv3_client_data;
@@ -124,18 +154,16 @@ SSL_METHOD *SSLv3_client_method()
         return(&SSLv3_client_data);
         }
 
-int ssl3_connect(s)
-SSL *s;
+int ssl3_connect(SSL *s)
         {
         BUF_MEM *buf;
         unsigned long Time=time(NULL),l;
         long num1;
-        void (*cb)()=NULL;
+        void (*cb)(const SSL *ssl,int type,int val)=NULL;
         int ret= -1;
-        BIO *under;
         int new_state,state,skip=0;;
 
-        RAND_seed((unsigned char *)&Time,sizeof(Time));
+        RAND_add(&Time,sizeof(Time),0);
         ERR_clear_error();
         clear_sys_error();
 
@@ -144,8 +172,8 @@ SSL *s;
         else if (s->ctx->info_callback != NULL)
                 cb=s->ctx->info_callback;
         
-        if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s); 
         s->in_handshake++;
+        if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s); 
 
         for (;;)
                 {
@@ -156,17 +184,23 @@ SSL *s;
                 case SSL_ST_RENEGOTIATE:
                         s->new_session=1;
                         s->state=SSL_ST_CONNECT;
-                        s->ctx->sess_connect_renegotiate++;
+                        s->ctx->stats.sess_connect_renegotiate++;
                         /* break */
                 case SSL_ST_BEFORE:
                 case SSL_ST_CONNECT:
                 case SSL_ST_BEFORE|SSL_ST_CONNECT:
                 case SSL_ST_OK|SSL_ST_CONNECT:
 
+                        s->server=0;
                         if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
 
                         if ((s->version & 0xff00 ) != 0x0300)
-                                abort();
+                                {
+                                SSLerr(SSL_F_SSL3_CONNECT, ERR_R_INTERNAL_ERROR);
+                                ret = -1;
+                                goto end;
+                                }
+                                
                         /* s->version=SSL3_VERSION; */
                         s->type=SSL_ST_CONNECT;
 
@@ -195,7 +229,7 @@ SSL *s;
                         ssl3_init_finished_mac(s);
 
                         s->state=SSL3_ST_CW_CLNT_HELLO_A;
-                        s->ctx->sess_connect++;
+                        s->ctx->stats.sess_connect++;
                         s->init_num=0;
                         break;
 
@@ -278,6 +312,7 @@ SSL *s;
                 case SSL3_ST_CW_CERT_A:
                 case SSL3_ST_CW_CERT_B:
                 case SSL3_ST_CW_CERT_C:
+                case SSL3_ST_CW_CERT_D:
                         ret=ssl3_send_client_certificate(s);
                         if (ret <= 0) goto end;
                         s->state=SSL3_ST_CW_KEY_EXCH_A;
@@ -324,6 +359,11 @@ SSL *s;
                         s->init_num=0;
 
                         s->session->cipher=s->s3->tmp.new_cipher;
+                        if (s->s3->tmp.new_compression == NULL)
+                                s->session->compress_meth=0;
+                        else
+                                s->session->compress_meth=
+                                        s->s3->tmp.new_compression->id;
                         if (!s->method->ssl3_enc->setup_key_block(s))
                                 {
                                 ret= -1;
@@ -343,8 +383,8 @@ SSL *s;
                 case SSL3_ST_CW_FINISHED_B:
                         ret=ssl3_send_finished(s,
                                 SSL3_ST_CW_FINISHED_A,SSL3_ST_CW_FINISHED_B,
-                                s->method->ssl3_enc->client_finished,
-                                s->method->ssl3_enc->client_finished_len);
+                                s->method->ssl3_enc->client_finished_label,
+                                s->method->ssl3_enc->client_finished_label_len);
                         if (ret <= 0) goto end;
                         s->state=SSL3_ST_CW_FLUSH;
 
@@ -399,38 +439,33 @@ SSL *s;
                         /* clean a few things up */
                         ssl3_cleanup_key_block(s);
 
-                        BUF_MEM_free(s->init_buf);
-                        s->init_buf=NULL;
-
-                        if (!(s->s3->flags & SSL3_FLAGS_POP_BUFFER))
+                        if (s->init_buf != NULL)
                                 {
-                                /* remove buffering */
-                                under=BIO_pop(s->wbio);
-                                if (under != NULL)
-                                        s->wbio=under;
-                                else
-                                        abort(); /* ok */
-
-                                BIO_free(s->bbio);
-                                s->bbio=NULL;
+                                BUF_MEM_free(s->init_buf);
+                                s->init_buf=NULL;
                                 }
-                        /* else do it later */
+
+                        /* If we are not 'joining' the last two packets,
+                         * remove the buffering now */
+                        if (!(s->s3->flags & SSL3_FLAGS_POP_BUFFER))
+                                ssl_free_wbio_buffer(s);
+                        /* else do it later in ssl3_write */
 
                         s->init_num=0;
                         s->new_session=0;
 
                         ssl_update_cache(s,SSL_SESS_CACHE_CLIENT);
-                        if (s->hit) s->ctx->sess_hit++;
+                        if (s->hit) s->ctx->stats.sess_hit++;
 
                         ret=1;
                         /* s->server=0; */
                         s->handshake_func=ssl3_connect;
-                        s->ctx->sess_connect_good++;
+                        s->ctx->stats.sess_connect_good++;
 
                         if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_DONE,1);
 
                         goto end;
-                        break;
+                        /* break; */
                         
                 default:
                         SSLerr(SSL_F_SSL3_CONNECT,SSL_R_UNKNOWN_STATE);
@@ -459,26 +494,27 @@ SSL *s;
                 skip=0;
                 }
 end:
+        s->in_handshake--;
         if (cb != NULL)
                 cb(s,SSL_CB_CONNECT_EXIT,ret);
-        s->in_handshake--;
         return(ret);
         }
 
 
-static int ssl3_client_hello(s)
-SSL *s;
+static int ssl3_client_hello(SSL *s)
         {
         unsigned char *buf;
         unsigned char *p,*d;
-        int i;
+        int i,j;
         unsigned long Time,l;
+        SSL_COMP *comp;
 
         buf=(unsigned char *)s->init_buf->data;
         if (s->state == SSL3_ST_CW_CLNT_HELLO_A)
                 {
                 if ((s->session == NULL) ||
-                        (s->session->ssl_version != s->version))
+                        (s->session->ssl_version != s->version) ||
+                        (s->session->not_resumable))
                         {
                         if (!ssl_get_new_session(s,0))
                                 goto err;
@@ -488,13 +524,14 @@ SSL *s;
                 p=s->s3->client_random;
                 Time=time(NULL);                        /* Time */
                 l2n(Time,p);
-                RAND_bytes(&(p[4]),SSL3_RANDOM_SIZE-sizeof(Time));
+                RAND_pseudo_bytes(p,SSL3_RANDOM_SIZE-sizeof(Time));
 
                 /* Do the message type and length last */
                 d=p= &(buf[4]);
 
                 *(p++)=s->version>>8;
                 *(p++)=s->version&0xff;
+                s->client_version=s->version;
 
                 /* Random stuff */
                 memcpy(p,s->s3->client_random,SSL3_RANDOM_SIZE);
@@ -522,9 +559,18 @@ SSL *s;
                 s2n(i,p);
                 p+=i;
 
-                /* hardwire in the NULL compression algorithm. */
-                *(p++)=1;
-                *(p++)=0;
+                /* COMPRESSION */
+                if (s->ctx->comp_methods == NULL)
+                        j=0;
+                else
+                        j=sk_SSL_COMP_num(s->ctx->comp_methods);
+                *(p++)=1+j;
+                for (i=0; i<j; i++)
+                        {
+                        comp=sk_SSL_COMP_value(s->ctx->comp_methods,i);
+                        *(p++)=comp->id;
+                        }
+                *(p++)=0; /* Add the NULL method */
                 
                 l=(p-d);
                 d=buf;
@@ -543,15 +589,15 @@ err:
         return(-1);
         }
 
-static int ssl3_get_server_hello(s)
-SSL *s;
+static int ssl3_get_server_hello(SSL *s)
         {
-        STACK *sk;
+        STACK_OF(SSL_CIPHER) *sk;
         SSL_CIPHER *c;
         unsigned char *p,*d;
         int i,al,ok;
         unsigned int j;
         long n;
+        SSL_COMP *comp;
 
         n=ssl3_get_message(s,
                 SSL3_ST_CR_SRVR_HELLO_A,
@@ -561,7 +607,7 @@ SSL *s;
                 &ok);
 
         if (!ok) return((int)n);
-        d=p=(unsigned char *)s->init_buf->data;
+        d=p=(unsigned char *)s->init_msg;
 
         if ((p[0] != (s->version>>8)) || (p[1] != (s->version&0xff)))
                 {
@@ -590,9 +636,18 @@ SSL *s;
                         goto f_err;
                         }
                 }
-        if ((j != 0) && (j == s->session->session_id_length) &&
-                (memcmp(p,s->session->session_id,j) == 0))
-                s->hit=1;
+        if (j != 0 && j == s->session->session_id_length
+            && memcmp(p,s->session->session_id,j) == 0)
+            {
+            if(s->sid_ctx_length != s->session->sid_ctx_length
+               || memcmp(s->session->sid_ctx,s->sid_ctx,s->sid_ctx_length))
+                {
+                al=SSL_AD_ILLEGAL_PARAMETER;
+                SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT);
+                goto f_err;
+                }
+            s->hit=1;
+            }
         else    /* a miss or crap from the other end */
                 {
                 /* If we were trying for session-id reuse, make a new
@@ -621,7 +676,7 @@ SSL *s;
         p+=ssl_put_cipher_by_char(s,NULL,NULL);
 
         sk=ssl_get_ciphers_by_id(s);
-        i=sk_find(sk,(char *)c);
+        i=sk_SSL_CIPHER_find(sk,c);
         if (i < 0)
                 {
                 /* we did not say we would use this cipher */
@@ -643,13 +698,23 @@ SSL *s;
         s->s3->tmp.new_cipher=c;
 
         /* lets get the compression algorithm */
+        /* COMPRESSION */
         j= *(p++);
-        if (j != 0)
+        if (j == 0)
+                comp=NULL;
+        else
+                comp=ssl3_comp_find(s->ctx->comp_methods,j);
+        
+        if ((j != 0) && (comp == NULL))
                 {
                 al=SSL_AD_ILLEGAL_PARAMETER;
                 SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM);
                 goto f_err;
                 }
+        else
+                {
+                s->s3->tmp.new_compression=comp;
+                }
 
         if (p != (d+n))
                 {
@@ -666,26 +731,22 @@ err:
         return(-1);
         }
 
-static int ssl3_get_server_certificate(s)
-SSL *s;
+static int ssl3_get_server_certificate(SSL *s)
         {
         int al,i,ok,ret= -1;
         unsigned long n,nc,llen,l;
         X509 *x=NULL;
         unsigned char *p,*d,*q;
-        STACK *sk=NULL;
-        CERT *c;
+        STACK_OF(X509) *sk=NULL;
+        SESS_CERT *sc;
         EVP_PKEY *pkey=NULL;
+        int need_cert = 1; /* VRS: 0=> will allow null cert if auth == KRB5 */
 
         n=ssl3_get_message(s,
                 SSL3_ST_CR_CERT_A,
                 SSL3_ST_CR_CERT_B,
                 -1,
-#if defined(MSDOS) && !defined(WIN32)
-                1024*30, /* 30k max cert list :-) */
-#else
-                1024*100, /* 100k max cert list :-) */
-#endif
+                s->max_cert_list,
                 &ok);
 
         if (!ok) return((int)n);
@@ -702,9 +763,9 @@ SSL *s;
                 SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,SSL_R_BAD_MESSAGE_TYPE);
                 goto f_err;
                 }
-        d=p=(unsigned char *)s->init_buf->data;
+        d=p=(unsigned char *)s->init_msg;
 
-        if ((sk=sk_new_null()) == NULL)
+        if ((sk=sk_X509_new_null()) == NULL)
                 {
                 SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,ERR_R_MALLOC_FAILURE);
                 goto err;
@@ -741,7 +802,7 @@ SSL *s;
                         SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,SSL_R_CERT_LENGTH_MISMATCH);
                         goto f_err;
                         }
-                if (!sk_push(sk,(char *)x))
+                if (!sk_X509_push(sk,x))
                         {
                         SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,ERR_R_MALLOC_FAILURE);
                         goto err;
@@ -752,53 +813,91 @@ SSL *s;
                 }
 
         i=ssl_verify_cert_chain(s,sk);
-        if ((s->verify_mode != SSL_VERIFY_NONE) && (!i))
+        if ((s->verify_mode != SSL_VERIFY_NONE) && (!i)
+#ifndef OPENSSL_NO_KRB5
+                && (s->s3->tmp.new_cipher->algorithms & (SSL_MKEY_MASK|SSL_AUTH_MASK))
+                != (SSL_aKRB5|SSL_kKRB5)
+#endif /* OPENSSL_NO_KRB5 */
+                )
                 {
                 al=ssl_verify_alarm_type(s->verify_result);
                 SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,SSL_R_CERTIFICATE_VERIFY_FAILED);
                 goto f_err; 
                 }
+        ERR_clear_error(); /* but we keep s->verify_result */
 
-        c=ssl_cert_new();
-        if (c == NULL) goto err;
+        sc=ssl_sess_cert_new();
+        if (sc == NULL) goto err;
 
-        if (s->session->cert) ssl_cert_free(s->session->cert);
-        s->session->cert=c;
+        if (s->session->sess_cert) ssl_sess_cert_free(s->session->sess_cert);
+        s->session->sess_cert=sc;
 
-        c->cert_chain=sk;
-        x=(X509 *)sk_value(sk,0);
+        sc->cert_chain=sk;
+        /* Inconsistency alert: cert_chain does include the peer's
+         * certificate, which we don't include in s3_srvr.c */
+        x=sk_X509_value(sk,0);
         sk=NULL;
+        /* VRS 19990621: possible memory leak; sk=null ==> !sk_pop_free() @end*/
 
         pkey=X509_get_pubkey(x);
 
-        if (EVP_PKEY_missing_parameters(pkey))
+        /* VRS: allow null cert if auth == KRB5 */
+        need_cert =     ((s->s3->tmp.new_cipher->algorithms
+                        & (SSL_MKEY_MASK|SSL_AUTH_MASK))
+                        == (SSL_aKRB5|SSL_kKRB5))? 0: 1;
+
+#ifdef KSSL_DEBUG
+        printf("pkey,x = %p, %p\n", pkey,x);
+        printf("ssl_cert_type(x,pkey) = %d\n", ssl_cert_type(x,pkey));
+        printf("cipher, alg, nc = %s, %lx, %d\n", s->s3->tmp.new_cipher->name,
+                s->s3->tmp.new_cipher->algorithms, need_cert);
+#endif    /* KSSL_DEBUG */
+
+        if (need_cert && ((pkey == NULL) || EVP_PKEY_missing_parameters(pkey)))
                 {
                 x=NULL;
                 al=SSL3_AL_FATAL;
-                SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS);
+                SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,
+                        SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS);
                 goto f_err;
                 }
 
         i=ssl_cert_type(x,pkey);
-        if (i < 0)
+        if (need_cert && i < 0)
                 {
                 x=NULL;
                 al=SSL3_AL_FATAL;
-                SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,SSL_R_UNKNOWN_CERTIFICATE_TYPE);
+                SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,
+                        SSL_R_UNKNOWN_CERTIFICATE_TYPE);
                 goto f_err;
                 }
 
-        c->cert_type=i;
-        CRYPTO_add(&x->references,1,CRYPTO_LOCK_X509);
-        if (c->pkeys[i].x509 != NULL)
-                X509_free(c->pkeys[i].x509);
-        c->pkeys[i].x509=x;
-        c->key= &(c->pkeys[i]);
-
-        if ((s->session != NULL) && (s->session->peer != NULL)) 
-                X509_free(s->session->peer);
-        CRYPTO_add(&x->references,1,CRYPTO_LOCK_X509);
-        s->session->peer=x;
+        if (need_cert)
+                {
+                sc->peer_cert_type=i;
+                CRYPTO_add(&x->references,1,CRYPTO_LOCK_X509);
+                /* Why would the following ever happen?
+                 * We just created sc a couple of lines ago. */
+                if (sc->peer_pkeys[i].x509 != NULL)
+                        X509_free(sc->peer_pkeys[i].x509);
+                sc->peer_pkeys[i].x509=x;
+                sc->peer_key= &(sc->peer_pkeys[i]);
+
+                if (s->session->peer != NULL)
+                        X509_free(s->session->peer);
+                CRYPTO_add(&x->references,1,CRYPTO_LOCK_X509);
+                s->session->peer=x;
+                }
+        else
+                {
+                sc->peer_cert_type=i;
+                sc->peer_key= NULL;
+
+                if (s->session->peer != NULL)
+                        X509_free(s->session->peer);
+                s->session->peer=NULL;
+                }
+        s->session->verify_result = s->verify_result;
 
         x=NULL;
         ret=1;
@@ -809,15 +908,15 @@ f_err:
                 ssl3_send_alert(s,SSL3_AL_FATAL,al);
                 }
 err:
-        if (x != NULL) X509_free(x);
-        if (sk != NULL) sk_pop_free(sk,X509_free);
+        EVP_PKEY_free(pkey);
+        X509_free(x);
+        sk_X509_pop_free(sk,X509_free);
         return(ret);
         }
 
-static int ssl3_get_key_exchange(s)
-SSL *s;
+static int ssl3_get_key_exchange(SSL *s)
         {
-#ifndef NO_RSA
+#ifndef OPENSSL_NO_RSA
         unsigned char *q,md_buf[EVP_MAX_MD_SIZE*2];
 #endif
         EVP_MD_CTX md_ctx;
@@ -825,16 +924,20 @@ SSL *s;
         int al,i,j,param_len,ok;
         long n,alg;
         EVP_PKEY *pkey=NULL;
+#ifndef OPENSSL_NO_RSA
         RSA *rsa=NULL;
-#ifndef NO_DH
+#endif
+#ifndef OPENSSL_NO_DH
         DH *dh=NULL;
 #endif
 
+        /* use same message size as in ssl3_get_certificate_request()
+         * as ServerKeyExchange message may be skipped */
         n=ssl3_get_message(s,
                 SSL3_ST_CR_KEY_EXCH_A,
                 SSL3_ST_CR_KEY_EXCH_B,
                 -1,
-                1024*8, /* ?? */
+                s->max_cert_list,
                 &ok);
 
         if (!ok) return((int)n);
@@ -845,34 +948,35 @@ SSL *s;
                 return(1);
                 }
 
-        param=p=(unsigned char *)s->init_buf->data;
+        param=p=(unsigned char *)s->init_msg;
 
-        if (s->session->cert != NULL)
+        if (s->session->sess_cert != NULL)
                 {
-#ifndef NO_RSA
-                if (s->session->cert->rsa_tmp != NULL)
+#ifndef OPENSSL_NO_RSA
+                if (s->session->sess_cert->peer_rsa_tmp != NULL)
                         {
-                        RSA_free(s->session->cert->rsa_tmp);
-                        s->session->cert->rsa_tmp=NULL;
+                        RSA_free(s->session->sess_cert->peer_rsa_tmp);
+                        s->session->sess_cert->peer_rsa_tmp=NULL;
                         }
 #endif
-#ifndef NO_DH
-                if (s->session->cert->dh_tmp)
+#ifndef OPENSSL_NO_DH
+                if (s->session->sess_cert->peer_dh_tmp)
                         {
-                        DH_free(s->session->cert->dh_tmp);
-                        s->session->cert->dh_tmp=NULL;
+                        DH_free(s->session->sess_cert->peer_dh_tmp);
+                        s->session->sess_cert->peer_dh_tmp=NULL;
                         }
 #endif
                 }
         else
                 {
-                s->session->cert=ssl_cert_new();
+                s->session->sess_cert=ssl_sess_cert_new();
                 }
 
         param_len=0;
         alg=s->s3->tmp.new_cipher->algorithms;
+        EVP_MD_CTX_init(&md_ctx);
 
-#ifndef NO_RSA
+#ifndef OPENSSL_NO_RSA
         if (alg & SSL_kRSA)
                 {
                 if ((rsa=RSA_new()) == NULL)
@@ -911,21 +1015,23 @@ SSL *s;
                 p+=i;
                 n-=param_len;
 
-/*              s->session->cert->rsa_tmp=rsa;*/
                 /* this should be because we are using an export cipher */
                 if (alg & SSL_aRSA)
-                        pkey=X509_get_pubkey(s->session->cert->pkeys[SSL_PKEY_RSA_ENC].x509);
+                        pkey=X509_get_pubkey(s->session->sess_cert->peer_pkeys[SSL_PKEY_RSA_ENC].x509);
                 else
                         {
-                        SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_INTERNAL_ERROR);
+                        SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
                         goto err;
                         }
-                s->session->cert->rsa_tmp=rsa;
+                s->session->sess_cert->peer_rsa_tmp=rsa;
+                rsa=NULL;
                 }
-        else
+#else /* OPENSSL_NO_RSA */
+        if (0)
+                ;
 #endif
-#ifndef NO_DH
-                if (alg & SSL_kEDH)
+#ifndef OPENSSL_NO_DH
+        else if (alg & SSL_kEDH)
                 {
                 if ((dh=DH_new()) == NULL)
                         {
@@ -978,18 +1084,21 @@ SSL *s;
                 p+=i;
                 n-=param_len;
 
-#ifndef NO_RSA
+#ifndef OPENSSL_NO_RSA
                 if (alg & SSL_aRSA)
-                        pkey=X509_get_pubkey(s->session->cert->pkeys[SSL_PKEY_RSA_ENC].x509);
-                else
+                        pkey=X509_get_pubkey(s->session->sess_cert->peer_pkeys[SSL_PKEY_RSA_ENC].x509);
+#else
+                if (0)
+                        ;
 #endif
-#ifndef NO_DSA
-                if (alg & SSL_aDSS)
-                        pkey=X509_get_pubkey(s->session->cert->pkeys[SSL_PKEY_DSA_SIGN].x509);
+#ifndef OPENSSL_NO_DSA
+                else if (alg & SSL_aDSS)
+                        pkey=X509_get_pubkey(s->session->sess_cert->peer_pkeys[SSL_PKEY_DSA_SIGN].x509);
 #endif
                 /* else anonymous DH, so no certificate or pkey. */
 
-                s->session->cert->dh_tmp=dh;
+                s->session->sess_cert->peer_dh_tmp=dh;
+                dh=NULL;
                 }
         else if ((alg & SSL_kDHr) || (alg & SSL_kDHd))
                 {
@@ -997,7 +1106,14 @@ SSL *s;
                 SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_TRIED_TO_USE_UNSUPPORTED_CIPHER);
                 goto f_err;
                 }
-#endif
+#endif /* !OPENSSL_NO_DH */
+        if (alg & SSL_aFZA)
+                {
+                al=SSL_AD_HANDSHAKE_FAILURE;
+                SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_TRIED_TO_USE_UNSUPPORTED_CIPHER);
+                goto f_err;
+                }
+
 
         /* p points to the next byte, there are 'n' bytes left */
 
@@ -1014,10 +1130,10 @@ SSL *s;
                         /* wrong packet length */
                         al=SSL_AD_DECODE_ERROR;
                         SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_WRONG_SIGNATURE_LENGTH);
-                        goto err;
+                        goto f_err;
                         }
 
-#ifndef NO_RSA
+#ifndef OPENSSL_NO_RSA
                 if (pkey->type == EVP_PKEY_RSA)
                         {
                         int num;
@@ -1026,24 +1142,24 @@ SSL *s;
                         q=md_buf;
                         for (num=2; num > 0; num--)
                                 {
-                                EVP_DigestInit(&md_ctx,(num == 2)
-                                        ?s->ctx->md5:s->ctx->sha1);
+                                EVP_DigestInit_ex(&md_ctx,(num == 2)
+                                        ?s->ctx->md5:s->ctx->sha1, NULL);
                                 EVP_DigestUpdate(&md_ctx,&(s->s3->client_random[0]),SSL3_RANDOM_SIZE);
                                 EVP_DigestUpdate(&md_ctx,&(s->s3->server_random[0]),SSL3_RANDOM_SIZE);
                                 EVP_DigestUpdate(&md_ctx,param,param_len);
-                                EVP_DigestFinal(&md_ctx,q,(unsigned int *)&i);
+                                EVP_DigestFinal_ex(&md_ctx,q,(unsigned int *)&i);
                                 q+=i;
                                 j+=i;
                                 }
-                        i=RSA_public_decrypt((int)n,p,p,pkey->pkey.rsa,
-                                RSA_PKCS1_PADDING);
-                        if (i <= 0)
+                        i=RSA_verify(NID_md5_sha1, md_buf, j, p, n,
+                                                                pkey->pkey.rsa);
+                        if (i < 0)
                                 {
                                 al=SSL_AD_DECRYPT_ERROR;
                                 SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_BAD_RSA_DECRYPT);
                                 goto f_err;
                                 }
-                        if ((j != i) || (memcmp(p,md_buf,i) != 0))
+                        if (i == 0)
                                 {
                                 /* bad signature */
                                 al=SSL_AD_DECRYPT_ERROR;
@@ -1053,11 +1169,11 @@ SSL *s;
                         }
                 else
 #endif
-#ifndef NO_DSA
+#ifndef OPENSSL_NO_DSA
                         if (pkey->type == EVP_PKEY_DSA)
                         {
                         /* lets do DSS */
-                        EVP_VerifyInit(&md_ctx,EVP_dss1());
+                        EVP_VerifyInit_ex(&md_ctx,EVP_dss1(), NULL);
                         EVP_VerifyUpdate(&md_ctx,&(s->s3->client_random[0]),SSL3_RANDOM_SIZE);
                         EVP_VerifyUpdate(&md_ctx,&(s->s3->server_random[0]),SSL3_RANDOM_SIZE);
                         EVP_VerifyUpdate(&md_ctx,param,param_len);
@@ -1072,7 +1188,7 @@ SSL *s;
                 else
 #endif
                         {
-                        SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_INTERNAL_ERROR);
+                        SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
                         goto err;
                         }
                 }
@@ -1081,7 +1197,7 @@ SSL *s;
                 /* still data left over */
                 if (!(alg & SSL_aNULL))
                         {
-                        SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_INTERNAL_ERROR);
+                        SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
                         goto err;
                         }
                 if (n != 0)
@@ -1091,33 +1207,39 @@ SSL *s;
                         goto f_err;
                         }
                 }
-
+        EVP_PKEY_free(pkey);
+        EVP_MD_CTX_cleanup(&md_ctx);
         return(1);
 f_err:
         ssl3_send_alert(s,SSL3_AL_FATAL,al);
 err:
+        EVP_PKEY_free(pkey);
+#ifndef OPENSSL_NO_RSA
+        if (rsa != NULL)
+                RSA_free(rsa);
+#endif
+#ifndef OPENSSL_NO_DH
+        if (dh != NULL)
+                DH_free(dh);
+#endif
+        EVP_MD_CTX_cleanup(&md_ctx);
         return(-1);
         }
 
-static int ssl3_get_certificate_request(s)
-SSL *s;
+static int ssl3_get_certificate_request(SSL *s)
         {
         int ok,ret=0;
         unsigned long n,nc,l;
         unsigned int llen,ctype_num,i;
         X509_NAME *xn=NULL;
         unsigned char *p,*d,*q;
-        STACK *ca_sk=NULL;
+        STACK_OF(X509_NAME) *ca_sk=NULL;
 
         n=ssl3_get_message(s,
                 SSL3_ST_CR_CERT_REQ_A,
                 SSL3_ST_CR_CERT_REQ_B,
                 -1,
-#if defined(MSDOS) && !defined(WIN32)
-                1024*30,  /* 30k max cert list :-) */
-#else
-                1024*100, /* 100k max cert list :-) */
-#endif
+                s->max_cert_list,
                 &ok);
 
         if (!ok) return((int)n);
@@ -1149,9 +1271,9 @@ SSL *s;
                         }
                 }
 
-        d=p=(unsigned char *)s->init_buf->data;
+        d=p=(unsigned char *)s->init_msg;
 
-        if ((ca_sk=sk_new(ca_dn_cmp)) == NULL)
+        if ((ca_sk=sk_X509_NAME_new(ca_dn_cmp)) == NULL)
                 {
                 SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,ERR_R_MALLOC_FAILURE);
                 goto err;
@@ -1167,6 +1289,15 @@ SSL *s;
 
         /* get the CA RDNs */
         n2s(p,llen);
+#if 0
+{
+FILE *out;
+out=fopen("/tmp/vsign.der","w");
+fwrite(p,1,llen,out);
+fclose(out);
+}
+#endif
+
         if ((llen+ctype_num+2+1) != n)
                 {
                 ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_DECODE_ERROR);
@@ -1190,7 +1321,7 @@ SSL *s;
 
                 if ((xn=d2i_X509_NAME(NULL,&q,l)) == NULL)
                         {
-                        /* If netscape tollerance is on, ignore errors */
+                        /* If netscape tolerance is on, ignore errors */
                         if (s->options & SSL_OP_NETSCAPE_CA_DN_BUG)
                                 goto cont;
                         else
@@ -1207,7 +1338,7 @@ SSL *s;
                         SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,SSL_R_CA_DN_LENGTH_MISMATCH);
                         goto err;
                         }
-                if (!sk_push(ca_sk,(char *)xn))
+                if (!sk_X509_NAME_push(ca_sk,xn))
                         {
                         SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,ERR_R_MALLOC_FAILURE);
                         goto err;
@@ -1223,28 +1354,26 @@ cont:
                 ERR_clear_error();
                 }
 
-        /* we should setup a certficate to return.... */
+        /* we should setup a certificate to return.... */
         s->s3->tmp.cert_req=1;
         s->s3->tmp.ctype_num=ctype_num;
         if (s->s3->tmp.ca_names != NULL)
-                sk_pop_free(s->s3->tmp.ca_names,X509_NAME_free);
+                sk_X509_NAME_pop_free(s->s3->tmp.ca_names,X509_NAME_free);
         s->s3->tmp.ca_names=ca_sk;
         ca_sk=NULL;
 
         ret=1;
 err:
-        if (ca_sk != NULL) sk_pop_free(ca_sk,X509_NAME_free);
+        if (ca_sk != NULL) sk_X509_NAME_pop_free(ca_sk,X509_NAME_free);
         return(ret);
         }
 
-static int ca_dn_cmp(a,b)
-X509_NAME **a,**b;
+static int ca_dn_cmp(const X509_NAME * const *a, const X509_NAME * const *b)
         {
         return(X509_NAME_cmp(*a,*b));
         }
 
-static int ssl3_get_server_done(s)
-SSL *s;
+static int ssl3_get_server_done(SSL *s)
         {
         int ok,ret=0;
         long n;
@@ -1262,18 +1391,24 @@ SSL *s;
                 /* should contain no data */
                 ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_DECODE_ERROR);
                 SSLerr(SSL_F_SSL3_GET_SERVER_DONE,SSL_R_LENGTH_MISMATCH);
+                return -1;
                 }
         ret=1;
         return(ret);
         }
 
-static int ssl3_send_client_key_exchange(s)
-SSL *s;
+static int ssl3_send_client_key_exchange(SSL *s)
         {
-        unsigned char *p,*q,*d;
+        unsigned char *p,*d;
         int n;
         unsigned long l;
+#ifndef OPENSSL_NO_RSA
+        unsigned char *q;
         EVP_PKEY *pkey=NULL;
+#endif
+#ifndef OPENSSL_NO_KRB5
+        KSSL_ERR kssl_err;
+#endif /* OPENSSL_NO_KRB5 */
 
         if (s->state == SSL3_ST_CW_KEY_EXCH_A)
                 {
@@ -1282,30 +1417,34 @@ SSL *s;
 
                 l=s->s3->tmp.new_cipher->algorithms;
 
-#ifndef NO_RSA
-                if (l & SSL_kRSA)
+                /* Fool emacs indentation */
+                if (0) {}
+#ifndef OPENSSL_NO_RSA
+                else if (l & SSL_kRSA)
                         {
                         RSA *rsa;
-                        unsigned char tmp_buf[48];
+                        unsigned char tmp_buf[SSL_MAX_MASTER_KEY_LENGTH];
 
-                        if (s->session->cert->rsa_tmp != NULL)
-                                rsa=s->session->cert->rsa_tmp;
+                        if (s->session->sess_cert->peer_rsa_tmp != NULL)
+                                rsa=s->session->sess_cert->peer_rsa_tmp;
                         else
                                 {
-                                pkey=X509_get_pubkey(s->session->cert->pkeys[SSL_PKEY_RSA_ENC].x509);
+                                pkey=X509_get_pubkey(s->session->sess_cert->peer_pkeys[SSL_PKEY_RSA_ENC].x509);
                                 if ((pkey == NULL) ||
                                         (pkey->type != EVP_PKEY_RSA) ||
                                         (pkey->pkey.rsa == NULL))
                                         {
-                                        SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,SSL_R_INTERNAL_ERROR);
+                                        SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
                                         goto err;
                                         }
                                 rsa=pkey->pkey.rsa;
+                                EVP_PKEY_free(pkey);
                                 }
                                 
-                        tmp_buf[0]=s->version>>8;
-                        tmp_buf[1]=s->version&0xff;
-                        RAND_bytes(&(tmp_buf[2]),SSL_MAX_MASTER_KEY_LENGTH-2);
+                        tmp_buf[0]=s->client_version>>8;
+                        tmp_buf[1]=s->client_version&0xff;
+                        if (RAND_bytes(&(tmp_buf[2]),SSL_MAX_MASTER_KEY_LENGTH-2) <= 0)
+                                        goto err;
 
                         s->session->master_key_length=SSL_MAX_MASTER_KEY_LENGTH;
 
@@ -1315,6 +1454,10 @@ SSL *s;
                                 p+=2;
                         n=RSA_public_encrypt(SSL_MAX_MASTER_KEY_LENGTH,
                                 tmp_buf,p,rsa,RSA_PKCS1_PADDING);
+#ifdef PKCS1_CHECK
+                        if (s->options & SSL_OP_PKCS1_CHECK_1) p[1]++;
+                        if (s->options & SSL_OP_PKCS1_CHECK_2) tmp_buf[0]=0x70;
+#endif
                         if (n <= 0)
                                 {
                                 SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,SSL_R_BAD_RSA_ENCRYPT);
@@ -1331,18 +1474,144 @@ SSL *s;
                         s->session->master_key_length=
                                 s->method->ssl3_enc->generate_master_secret(s,
                                         s->session->master_key,
-                                        tmp_buf,48);
-                        memset(tmp_buf,0,48);
+                                        tmp_buf,SSL_MAX_MASTER_KEY_LENGTH);
+                        memset(tmp_buf,0,SSL_MAX_MASTER_KEY_LENGTH);
                         }
-                else
 #endif
-#ifndef NO_DH
-                if (l & (SSL_kEDH|SSL_kDHr|SSL_kDHd))
+#ifndef OPENSSL_NO_KRB5
+                else if (l & SSL_kKRB5)
+                        {
+                        krb5_error_code krb5rc;
+                        KSSL_CTX        *kssl_ctx = s->kssl_ctx;
+                        /*  krb5_data   krb5_ap_req;  */
+                        krb5_data       *enc_ticket;
+                        krb5_data       authenticator, *authp = NULL;
+                        EVP_CIPHER_CTX  ciph_ctx;
+                        EVP_CIPHER      *enc = NULL;
+                        unsigned char   iv[EVP_MAX_IV_LENGTH];
+                        unsigned char   tmp_buf[SSL_MAX_MASTER_KEY_LENGTH];
+                        unsigned char   epms[SSL_MAX_MASTER_KEY_LENGTH 
+                                                + EVP_MAX_IV_LENGTH];
+                        int             padl, outl = sizeof(epms);
+
+                        EVP_CIPHER_CTX_init(&ciph_ctx);
+
+#ifdef KSSL_DEBUG
+                        printf("ssl3_send_client_key_exchange(%lx & %lx)\n",
+                                l, SSL_kKRB5);
+#endif  /* KSSL_DEBUG */
+
+                        authp = NULL;
+#ifdef KRB5SENDAUTH
+                        if (KRB5SENDAUTH)  authp = &authenticator;
+#endif  /* KRB5SENDAUTH */
+
+                        krb5rc = kssl_cget_tkt(kssl_ctx, &enc_ticket, authp,
+                                &kssl_err);
+                        enc = kssl_map_enc(kssl_ctx->enctype);
+                        if (enc == NULL)
+                            goto err;
+#ifdef KSSL_DEBUG
+                        {
+                        printf("kssl_cget_tkt rtn %d\n", krb5rc);
+                        if (krb5rc && kssl_err.text)
+                          printf("kssl_cget_tkt kssl_err=%s\n", kssl_err.text);
+                        }
+#endif  /* KSSL_DEBUG */
+
+                        if (krb5rc)
+                                {
+                                ssl3_send_alert(s,SSL3_AL_FATAL,
+                                                SSL_AD_HANDSHAKE_FAILURE);
+                                SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
+                                                kssl_err.reason);
+                                goto err;
+                                }
+
+                        /*  20010406 VRS - Earlier versions used KRB5 AP_REQ
+                        **  in place of RFC 2712 KerberosWrapper, as in:
+                        **
+                        **  Send ticket (copy to *p, set n = length)
+                        **  n = krb5_ap_req.length;
+                        **  memcpy(p, krb5_ap_req.data, krb5_ap_req.length);
+                        **  if (krb5_ap_req.data)  
+                        **    kssl_krb5_free_data_contents(NULL,&krb5_ap_req);
+                        **
+                        **  Now using real RFC 2712 KerberosWrapper
+                        **  (Thanks to Simon Wilkinson <sxw@sxw.org.uk>)
+                        **  Note: 2712 "opaque" types are here replaced
+                        **  with a 2-byte length followed by the value.
+                        **  Example:
+                        **  KerberosWrapper= xx xx asn1ticket 0 0 xx xx encpms
+                        **  Where "xx xx" = length bytes.  Shown here with
+                        **  optional authenticator omitted.
+                        */
+
+                        /*  KerberosWrapper.Ticket              */
+                        s2n(enc_ticket->length,p);
+                        memcpy(p, enc_ticket->data, enc_ticket->length);
+                        p+= enc_ticket->length;
+                        n = enc_ticket->length + 2;
+
+                        /*  KerberosWrapper.Authenticator       */
+                        if (authp  &&  authp->length)  
+                                {
+                                s2n(authp->length,p);
+                                memcpy(p, authp->data, authp->length);
+                                p+= authp->length;
+                                n+= authp->length + 2;
+                                
+                                free(authp->data);
+                                authp->data = NULL;
+                                authp->length = 0;
+                                }
+                        else
+                                {
+                                s2n(0,p);/*  null authenticator length  */
+                                n+=2;
+                                }
+ 
+                        if (RAND_bytes(tmp_buf,SSL_MAX_MASTER_KEY_LENGTH) <= 0)
+                            goto err;
+
+                        /*  20010420 VRS.  Tried it this way; failed.
+                        **      EVP_EncryptInit_ex(&ciph_ctx,enc, NULL,NULL);
+                        **      EVP_CIPHER_CTX_set_key_length(&ciph_ctx,
+                        **                              kssl_ctx->length);
+                        **      EVP_EncryptInit_ex(&ciph_ctx,NULL, key,iv);
+                        */
+
+                        memset(iv, 0, EVP_MAX_IV_LENGTH);  /* per RFC 1510 */
+                        EVP_EncryptInit_ex(&ciph_ctx,enc, NULL,
+                                kssl_ctx->key,iv);
+                        EVP_EncryptUpdate(&ciph_ctx,epms,&outl,tmp_buf,
+                                SSL_MAX_MASTER_KEY_LENGTH);
+                        EVP_EncryptFinal_ex(&ciph_ctx,&(epms[outl]),&padl);
+                        outl += padl;
+                        EVP_CIPHER_CTX_cleanup(&ciph_ctx);
+
+                        /*  KerberosWrapper.EncryptedPreMasterSecret    */
+                        s2n(outl,p);
+                        memcpy(p, epms, outl);
+                        p+=outl;
+                        n+=outl + 2;
+
+                        s->session->master_key_length=
+                                s->method->ssl3_enc->generate_master_secret(s,
+                                        s->session->master_key,
+                                        tmp_buf, SSL_MAX_MASTER_KEY_LENGTH);
+
+                        memset(tmp_buf, 0, SSL_MAX_MASTER_KEY_LENGTH);
+                        memset(epms, 0, outl);
+                        }
+#endif
+#ifndef OPENSSL_NO_DH
+                else if (l & (SSL_kEDH|SSL_kDHr|SSL_kDHd))
                         {
                         DH *dh_srvr,*dh_clnt;
 
-                        if (s->session->cert->dh_tmp != NULL)
-                                dh_srvr=s->session->cert->dh_tmp;
+                        if (s->session->sess_cert->peer_dh_tmp != NULL)
+                                dh_srvr=s->session->sess_cert->peer_dh_tmp;
                         else
                                 {
                                 /* we get them from the cert */
@@ -1391,11 +1660,11 @@ SSL *s;
 
                         /* perhaps clean things up a bit EAY EAY EAY EAY*/
                         }
-                else
 #endif
+                else
                         {
                         ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_HANDSHAKE_FAILURE);
-                        SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,SSL_R_INTERNAL_ERROR);
+                        SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
                         goto err;
                         }
                 
@@ -1414,15 +1683,16 @@ err:
         return(-1);
         }
 
-static int ssl3_send_client_verify(s)
-SSL *s;
+static int ssl3_send_client_verify(SSL *s)
         {
         unsigned char *p,*d;
         unsigned char data[MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH];
         EVP_PKEY *pkey;
-        int i=0;
+#ifndef OPENSSL_NO_RSA
+        unsigned u=0;
+#endif
         unsigned long n;
-#ifndef NO_DSA
+#ifndef OPENSSL_NO_DSA
         int j;
 #endif
 
@@ -1435,26 +1705,24 @@ SSL *s;
                 s->method->ssl3_enc->cert_verify_mac(s,&(s->s3->finish_dgst2),
                         &(data[MD5_DIGEST_LENGTH]));
 
-#ifndef NO_RSA
+#ifndef OPENSSL_NO_RSA
                 if (pkey->type == EVP_PKEY_RSA)
                         {
                         s->method->ssl3_enc->cert_verify_mac(s,
                                 &(s->s3->finish_dgst1),&(data[0]));
-                        i=RSA_private_encrypt(
-                                MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH,
-                                data,&(p[2]),pkey->pkey.rsa,
-                                RSA_PKCS1_PADDING);
-                        if (i <= 0)
+                        if (RSA_sign(NID_md5_sha1, data,
+                                         MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH,
+                                        &(p[2]), &u, pkey->pkey.rsa) <= 0 )
                                 {
                                 SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,ERR_R_RSA_LIB);
                                 goto err;
                                 }
-                        s2n(i,p);
-                        n=i+2;
+                        s2n(u,p);
+                        n=u+2;
                         }
                 else
 #endif
-#ifndef NO_DSA
+#ifndef OPENSSL_NO_DSA
                         if (pkey->type == EVP_PKEY_DSA)
                         {
                         if (!DSA_sign(pkey->save_type,
@@ -1471,7 +1739,7 @@ SSL *s;
                 else
 #endif
                         {
-                        SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,SSL_R_INTERNAL_ERROR);
+                        SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,ERR_R_INTERNAL_ERROR);
                         goto err;
                         }
                 *(d++)=SSL3_MT_CERTIFICATE_VERIFY;
@@ -1485,8 +1753,7 @@ err:
         return(-1);
         }
 
-static int ssl3_send_client_certificate(s)
-SSL *s;
+static int ssl3_send_client_certificate(SSL *s)
         {
         X509 *x509=NULL;
         EVP_PKEY *pkey=NULL;
@@ -1565,38 +1832,46 @@ SSL *s;
 
 #define has_bits(i,m)   (((i)&(m)) == (m))
 
-static int ssl3_check_cert_and_algorithm(s)
-SSL *s;
+static int ssl3_check_cert_and_algorithm(SSL *s)
         {
         int i,idx;
         long algs;
         EVP_PKEY *pkey=NULL;
-        CERT *c;
+        SESS_CERT *sc;
+#ifndef OPENSSL_NO_RSA
         RSA *rsa;
+#endif
+#ifndef OPENSSL_NO_DH
         DH *dh;
+#endif
 
-        c=s->session->cert;
+        sc=s->session->sess_cert;
 
-        if (c == NULL)
+        if (sc == NULL)
                 {
-                SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_INTERNAL_ERROR);
+                SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,ERR_R_INTERNAL_ERROR);
                 goto err;
                 }
 
         algs=s->s3->tmp.new_cipher->algorithms;
 
         /* we don't have a certificate */
-        if (algs & (SSL_aDH|SSL_aNULL))
+        if (algs & (SSL_aDH|SSL_aNULL|SSL_aKRB5))
                 return(1);
 
-        rsa=s->session->cert->rsa_tmp;
-        dh=s->session->cert->dh_tmp;
+#ifndef OPENSSL_NO_RSA
+        rsa=s->session->sess_cert->peer_rsa_tmp;
+#endif
+#ifndef OPENSSL_NO_DH
+        dh=s->session->sess_cert->peer_dh_tmp;
+#endif
 
         /* This is the passed certificate */
 
-        idx=c->cert_type;
-        pkey=X509_get_pubkey(c->pkeys[idx].x509);
-        i=X509_certificate_type(c->pkeys[idx].x509,pkey);
+        idx=sc->peer_cert_type;
+        pkey=X509_get_pubkey(sc->peer_pkeys[idx].x509);
+        i=X509_certificate_type(sc->peer_pkeys[idx].x509,pkey);
+        EVP_PKEY_free(pkey);
 
         
         /* Check that we have a certificate if we require one */
@@ -1605,22 +1880,23 @@ SSL *s;
                 SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_RSA_SIGNING_CERT);
                 goto f_err;
                 }
-#ifndef NO_DSA
+#ifndef OPENSSL_NO_DSA
         else if ((algs & SSL_aDSS) && !has_bits(i,EVP_PK_DSA|EVP_PKT_SIGN))
                 {
                 SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_DSA_SIGNING_CERT);
                 goto f_err;
                 }
 #endif
-
+#ifndef OPENSSL_NO_RSA
         if ((algs & SSL_kRSA) &&
                 !(has_bits(i,EVP_PK_RSA|EVP_PKT_ENC) || (rsa != NULL)))
                 {
                 SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_RSA_ENCRYPTING_CERT);
                 goto f_err;
                 }
-#ifndef NO_DH
-        else if ((algs & SSL_kEDH) &&
+#endif
+#ifndef OPENSSL_NO_DH
+        if ((algs & SSL_kEDH) &&
                 !(has_bits(i,EVP_PK_DH|EVP_PKT_EXCH) || (dh != NULL)))
                 {
                 SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_DH_KEY);
@@ -1631,7 +1907,7 @@ SSL *s;
                 SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_DH_RSA_CERT);
                 goto f_err;
                 }
-#ifndef NO_DSA
+#ifndef OPENSSL_NO_DSA
         else if ((algs & SSL_kDHd) && !has_bits(i,EVP_PK_DH|EVP_PKS_DSA))
                 {
                 SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_DH_DSA_CERT);
@@ -1640,12 +1916,13 @@ SSL *s;
 #endif
 #endif
 
-        if ((algs & SSL_EXP) && !has_bits(i,EVP_PKT_EXP))
+        if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) && !has_bits(i,EVP_PKT_EXP))
                 {
-#ifndef NO_RSA
+#ifndef OPENSSL_NO_RSA
                 if (algs & SSL_kRSA)
                         {
-                        if ((rsa == NULL) || (RSA_size(rsa) > 512))
+                        if (rsa == NULL
+                            || RSA_size(rsa) > SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher))
                                 {
                                 SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_EXPORT_TMP_RSA_KEY);
                                 goto f_err;
@@ -1653,10 +1930,11 @@ SSL *s;
                         }
                 else
 #endif
-#ifndef NO_DH
+#ifndef OPENSSL_NO_DH
                         if (algs & (SSL_kEDH|SSL_kDHr|SSL_kDHd))
-                        {
-                        if ((dh == NULL) || (DH_size(dh) > 512))
+                            {
+                            if (dh == NULL
+                                || DH_size(dh) > SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher))
                                 {
                                 SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_EXPORT_TMP_DH_KEY);
                                 goto f_err;
diff --git a/src/lib/libssl/s3_lib.c b/src/lib/libssl/s3_lib.c
index 0fd945025d..686992406c 100644
--- a/src/lib/libssl/s3_lib.c
+++ b/src/lib/libssl/s3_lib.c
@@ -55,40 +55,99 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
+/* ====================================================================
+ * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
 
 #include <stdio.h>
-#include "objects.h"
+#include <openssl/objects.h>
 #include "ssl_locl.h"
+#include "kssl_lcl.h"
+#include <openssl/md5.h>
 
-char *ssl3_version_str="SSLv3 part of SSLeay 0.9.0b 29-Jun-1998";
+const char *ssl3_version_str="SSLv3" OPENSSL_VERSION_PTEXT;
 
 #define SSL3_NUM_CIPHERS        (sizeof(ssl3_ciphers)/sizeof(SSL_CIPHER))
 
-#ifndef NOPROTO
 static long ssl3_default_timeout(void );
-#else
-static long ssl3_default_timeout();
-#endif
 
-SSL_CIPHER ssl3_ciphers[]={
+OPENSSL_GLOBAL SSL_CIPHER ssl3_ciphers[]={
 /* The RSA ciphers */
 /* Cipher 01 */
         {
         1,
         SSL3_TXT_RSA_NULL_MD5,
         SSL3_CK_RSA_NULL_MD5,
-        SSL_kRSA|SSL_aRSA|SSL_eNULL |SSL_MD5|SSL_NOT_EXP|SSL_SSLV3,
+        SSL_kRSA|SSL_aRSA|SSL_eNULL |SSL_MD5|SSL_SSLV3,
+        SSL_NOT_EXP,
+        0,
+        0,
         0,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 02 */
         {
         1,
         SSL3_TXT_RSA_NULL_SHA,
         SSL3_CK_RSA_NULL_SHA,
-        SSL_kRSA|SSL_aRSA|SSL_eNULL |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3,
+        SSL_kRSA|SSL_aRSA|SSL_eNULL |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP,
+        0,
+        0,
         0,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 
 /* anon DH */
@@ -97,45 +156,65 @@ SSL_CIPHER ssl3_ciphers[]={
         1,
         SSL3_TXT_ADH_RC4_40_MD5,
         SSL3_CK_ADH_RC4_40_MD5,
-        SSL_kEDH |SSL_aNULL|SSL_RC4  |SSL_MD5 |SSL_EXP|SSL_SSLV3,
+        SSL_kEDH |SSL_aNULL|SSL_RC4  |SSL_MD5 |SSL_SSLV3,
+        SSL_EXPORT|SSL_EXP40,
         0,
+        40,
+        128,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 18 */
         {
         1,
         SSL3_TXT_ADH_RC4_128_MD5,
         SSL3_CK_ADH_RC4_128_MD5,
-        SSL_kEDH |SSL_aNULL|SSL_RC4  |SSL_MD5|SSL_NOT_EXP|SSL_SSLV3,
+        SSL_kEDH |SSL_aNULL|SSL_RC4  |SSL_MD5 |SSL_SSLV3,
+        SSL_NOT_EXP|SSL_MEDIUM,
         0,
+        128,
+        128,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 19 */
         {
         1,
         SSL3_TXT_ADH_DES_40_CBC_SHA,
         SSL3_CK_ADH_DES_40_CBC_SHA,
-        SSL_kEDH |SSL_aNULL|SSL_DES|SSL_SHA1|SSL_EXP|SSL_SSLV3,
+        SSL_kEDH |SSL_aNULL|SSL_DES|SSL_SHA1|SSL_SSLV3,
+        SSL_EXPORT|SSL_EXP40,
         0,
+        40,
+        128,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 1A */
         {
         1,
         SSL3_TXT_ADH_DES_64_CBC_SHA,
         SSL3_CK_ADH_DES_64_CBC_SHA,
-        SSL_kEDH |SSL_aNULL|SSL_DES  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3,
+        SSL_kEDH |SSL_aNULL|SSL_DES  |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_LOW,
         0,
+        56,
+        56,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 1B */
         {
         1,
         SSL3_TXT_ADH_DES_192_CBC_SHA,
         SSL3_CK_ADH_DES_192_CBC_SHA,
-        SSL_kEDH |SSL_aNULL|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3,
+        SSL_kEDH |SSL_aNULL|SSL_3DES |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_HIGH,
         0,
+        168,
+        168,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 
 /* RSA again */
@@ -144,72 +223,104 @@ SSL_CIPHER ssl3_ciphers[]={
         1,
         SSL3_TXT_RSA_RC4_40_MD5,
         SSL3_CK_RSA_RC4_40_MD5,
-        SSL_kRSA|SSL_aRSA|SSL_RC4  |SSL_MD5 |SSL_EXP|SSL_SSLV3,
+        SSL_kRSA|SSL_aRSA|SSL_RC4  |SSL_MD5 |SSL_SSLV3,
+        SSL_EXPORT|SSL_EXP40,
         0,
+        40,
+        128,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 04 */
         {
         1,
         SSL3_TXT_RSA_RC4_128_MD5,
         SSL3_CK_RSA_RC4_128_MD5,
-        SSL_kRSA|SSL_aRSA|SSL_RC4  |SSL_MD5|SSL_NOT_EXP|SSL_SSLV3|SSL_MEDIUM,
+        SSL_kRSA|SSL_aRSA|SSL_RC4  |SSL_MD5|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_MEDIUM,
         0,
+        128,
+        128,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 05 */
         {
         1,
         SSL3_TXT_RSA_RC4_128_SHA,
         SSL3_CK_RSA_RC4_128_SHA,
-        SSL_kRSA|SSL_aRSA|SSL_RC4  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_MEDIUM,
+        SSL_kRSA|SSL_aRSA|SSL_RC4  |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_MEDIUM,
         0,
+        128,
+        128,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 06 */
         {
         1,
         SSL3_TXT_RSA_RC2_40_MD5,
         SSL3_CK_RSA_RC2_40_MD5,
-        SSL_kRSA|SSL_aRSA|SSL_RC2  |SSL_MD5 |SSL_EXP|SSL_SSLV3,
+        SSL_kRSA|SSL_aRSA|SSL_RC2  |SSL_MD5 |SSL_SSLV3,
+        SSL_EXPORT|SSL_EXP40,
         0,
+        40,
+        128,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 07 */
         {
         1,
         SSL3_TXT_RSA_IDEA_128_SHA,
         SSL3_CK_RSA_IDEA_128_SHA,
-        SSL_kRSA|SSL_aRSA|SSL_IDEA |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_MEDIUM,
+        SSL_kRSA|SSL_aRSA|SSL_IDEA |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_MEDIUM,
         0,
+        128,
+        128,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 08 */
         {
         1,
         SSL3_TXT_RSA_DES_40_CBC_SHA,
         SSL3_CK_RSA_DES_40_CBC_SHA,
-        SSL_kRSA|SSL_aRSA|SSL_DES|SSL_SHA1|SSL_EXP|SSL_SSLV3,
+        SSL_kRSA|SSL_aRSA|SSL_DES|SSL_SHA1|SSL_SSLV3,
+        SSL_EXPORT|SSL_EXP40,
         0,
+        40,
+        56,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 09 */
         {
         1,
         SSL3_TXT_RSA_DES_64_CBC_SHA,
         SSL3_CK_RSA_DES_64_CBC_SHA,
-        SSL_kRSA|SSL_aRSA|SSL_DES  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_LOW,
+        SSL_kRSA|SSL_aRSA|SSL_DES  |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_LOW,
         0,
+        56,
+        56,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 0A */
         {
         1,
         SSL3_TXT_RSA_DES_192_CBC3_SHA,
         SSL3_CK_RSA_DES_192_CBC3_SHA,
-        SSL_kRSA|SSL_aRSA|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_HIGH,
+        SSL_kRSA|SSL_aRSA|SSL_3DES |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_HIGH,
         0,
+        168,
+        168,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 
 /*  The DH ciphers */
@@ -218,54 +329,78 @@ SSL_CIPHER ssl3_ciphers[]={
         0,
         SSL3_TXT_DH_DSS_DES_40_CBC_SHA,
         SSL3_CK_DH_DSS_DES_40_CBC_SHA,
-        SSL_kDHd |SSL_aDH|SSL_DES|SSL_SHA1|SSL_EXP|SSL_SSLV3,
+        SSL_kDHd |SSL_aDH|SSL_DES|SSL_SHA1|SSL_SSLV3,
+        SSL_EXPORT|SSL_EXP40,
         0,
+        40,
+        56,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 0C */
         {
         0,
         SSL3_TXT_DH_DSS_DES_64_CBC_SHA,
         SSL3_CK_DH_DSS_DES_64_CBC_SHA,
-        SSL_kDHd |SSL_aDH|SSL_DES  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_LOW,
+        SSL_kDHd |SSL_aDH|SSL_DES  |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_LOW,
         0,
+        56,
+        56,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 0D */
         {
         0,
         SSL3_TXT_DH_DSS_DES_192_CBC3_SHA,
         SSL3_CK_DH_DSS_DES_192_CBC3_SHA,
-        SSL_kDHd |SSL_aDH|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_HIGH,
+        SSL_kDHd |SSL_aDH|SSL_3DES |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_HIGH,
         0,
+        168,
+        168,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 0E */
         {
         0,
         SSL3_TXT_DH_RSA_DES_40_CBC_SHA,
         SSL3_CK_DH_RSA_DES_40_CBC_SHA,
-        SSL_kDHr |SSL_aDH|SSL_DES|SSL_SHA1|SSL_EXP|SSL_SSLV3,
+        SSL_kDHr |SSL_aDH|SSL_DES|SSL_SHA1|SSL_SSLV3,
+        SSL_EXPORT|SSL_EXP40,
         0,
+        40,
+        56,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 0F */
         {
         0,
         SSL3_TXT_DH_RSA_DES_64_CBC_SHA,
         SSL3_CK_DH_RSA_DES_64_CBC_SHA,
-        SSL_kDHr |SSL_aDH|SSL_DES  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_LOW,
+        SSL_kDHr |SSL_aDH|SSL_DES  |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_LOW,
         0,
+        56,
+        56,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 10 */
         {
         0,
         SSL3_TXT_DH_RSA_DES_192_CBC3_SHA,
         SSL3_CK_DH_RSA_DES_192_CBC3_SHA,
-        SSL_kDHr |SSL_aDH|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_HIGH,
+        SSL_kDHr |SSL_aDH|SSL_3DES |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_HIGH,
         0,
+        168,
+        168,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 
 /* The Ephemeral DH ciphers */
@@ -274,54 +409,78 @@ SSL_CIPHER ssl3_ciphers[]={
         1,
         SSL3_TXT_EDH_DSS_DES_40_CBC_SHA,
         SSL3_CK_EDH_DSS_DES_40_CBC_SHA,
-        SSL_kEDH|SSL_aDSS|SSL_DES|SSL_SHA1|SSL_EXP|SSL_SSLV3,
+        SSL_kEDH|SSL_aDSS|SSL_DES|SSL_SHA1|SSL_SSLV3,
+        SSL_EXPORT|SSL_EXP40,
         0,
+        40,
+        56,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 12 */
         {
         1,
         SSL3_TXT_EDH_DSS_DES_64_CBC_SHA,
         SSL3_CK_EDH_DSS_DES_64_CBC_SHA,
-        SSL_kEDH|SSL_aDSS|SSL_DES  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_LOW,
+        SSL_kEDH|SSL_aDSS|SSL_DES  |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_LOW,
         0,
+        56,
+        56,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 13 */
         {
         1,
         SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA,
         SSL3_CK_EDH_DSS_DES_192_CBC3_SHA,
-        SSL_kEDH|SSL_aDSS|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_HIGH,
+        SSL_kEDH|SSL_aDSS|SSL_3DES |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_HIGH,
         0,
+        168,
+        168,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 14 */
         {
         1,
         SSL3_TXT_EDH_RSA_DES_40_CBC_SHA,
         SSL3_CK_EDH_RSA_DES_40_CBC_SHA,
-        SSL_kEDH|SSL_aRSA|SSL_DES|SSL_SHA1|SSL_EXP|SSL_SSLV3,
+        SSL_kEDH|SSL_aRSA|SSL_DES|SSL_SHA1|SSL_SSLV3,
+        SSL_EXPORT|SSL_EXP40,
         0,
+        40,
+        56,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 15 */
         {
         1,
         SSL3_TXT_EDH_RSA_DES_64_CBC_SHA,
         SSL3_CK_EDH_RSA_DES_64_CBC_SHA,
-        SSL_kEDH|SSL_aRSA|SSL_DES  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_LOW,
+        SSL_kEDH|SSL_aRSA|SSL_DES  |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_LOW,
         0,
+        56,
+        56,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 /* Cipher 16 */
         {
         1,
         SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA,
         SSL3_CK_EDH_RSA_DES_192_CBC3_SHA,
-        SSL_kEDH|SSL_aRSA|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_HIGH,
+        SSL_kEDH|SSL_aRSA|SSL_3DES |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_HIGH,
         0,
+        168,
+        168,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 
 /* Fortezza */
@@ -330,9 +489,13 @@ SSL_CIPHER ssl3_ciphers[]={
         0,
         SSL3_TXT_FZA_DMS_NULL_SHA,
         SSL3_CK_FZA_DMS_NULL_SHA,
-        SSL_kFZA|SSL_aFZA |SSL_eNULL |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3,
+        SSL_kFZA|SSL_aFZA |SSL_eNULL |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP,
+        0,
+        0,
         0,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 
 /* Cipher 1D */
@@ -340,9 +503,13 @@ SSL_CIPHER ssl3_ciphers[]={
         0,
         SSL3_TXT_FZA_DMS_FZA_SHA,
         SSL3_CK_FZA_DMS_FZA_SHA,
-        SSL_kFZA|SSL_aFZA |SSL_eFZA |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3,
+        SSL_kFZA|SSL_aFZA |SSL_eFZA |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP,
+        0,
+        0,
         0,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
 
 /* Cipher 1E */
@@ -350,10 +517,359 @@ SSL_CIPHER ssl3_ciphers[]={
         0,
         SSL3_TXT_FZA_DMS_RC4_SHA,
         SSL3_CK_FZA_DMS_RC4_SHA,
-        SSL_kFZA|SSL_aFZA |SSL_RC4  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3,
+        SSL_kFZA|SSL_aFZA |SSL_RC4  |SSL_SHA1|SSL_SSLV3,
+        SSL_NOT_EXP|SSL_MEDIUM,
+        0,
+        128,
+        128,
+        SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
+        },
+
+#ifndef OPENSSL_NO_KRB5
+/* The Kerberos ciphers
+** 20000107 VRS: And the first shall be last,
+** in hopes of avoiding the lynx ssl renegotiation problem.
+*/
+/* Cipher 21 VRS */
+        {
+        1,
+        SSL3_TXT_KRB5_DES_40_CBC_SHA,
+        SSL3_CK_KRB5_DES_40_CBC_SHA,
+        SSL_kKRB5|SSL_aKRB5|  SSL_DES|SSL_SHA1   |SSL_SSLV3,
+        SSL_EXPORT|SSL_EXP40,
+        0,
+        40,
+        56,
+        SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
+        },
+
+/* Cipher 22 VRS */
+        {
+        1,
+        SSL3_TXT_KRB5_DES_40_CBC_MD5,
+        SSL3_CK_KRB5_DES_40_CBC_MD5,
+        SSL_kKRB5|SSL_aKRB5|  SSL_DES|SSL_MD5    |SSL_SSLV3,
+        SSL_EXPORT|SSL_EXP40,
+        0,
+        40,
+        56,
+        SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
+        },
+
+/* Cipher 23 VRS */
+        {
+        1,
+        SSL3_TXT_KRB5_DES_64_CBC_SHA,
+        SSL3_CK_KRB5_DES_64_CBC_SHA,
+        SSL_kKRB5|SSL_aKRB5|  SSL_DES|SSL_SHA1   |SSL_SSLV3,
+        SSL_NOT_EXP|SSL_LOW,
+        0,
+        56,
+        56,
+        SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
+        },
+
+/* Cipher 24 VRS */
+        {
+        1,
+        SSL3_TXT_KRB5_DES_64_CBC_MD5,
+        SSL3_CK_KRB5_DES_64_CBC_MD5,
+        SSL_kKRB5|SSL_aKRB5|  SSL_DES|SSL_MD5    |SSL_SSLV3,
+        SSL_NOT_EXP|SSL_LOW,
+        0,
+        56,
+        56,
+        SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
+        },
+
+/* Cipher 25 VRS */
+        {
+        1,
+        SSL3_TXT_KRB5_DES_192_CBC3_SHA,
+        SSL3_CK_KRB5_DES_192_CBC3_SHA,
+        SSL_kKRB5|SSL_aKRB5|  SSL_3DES|SSL_SHA1  |SSL_SSLV3,
+        SSL_NOT_EXP|SSL_HIGH,
+        0,
+        112,
+        168,
+        SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
+        },
+
+/* Cipher 26 VRS */
+        {
+        1,
+        SSL3_TXT_KRB5_DES_192_CBC3_MD5,
+        SSL3_CK_KRB5_DES_192_CBC3_MD5,
+        SSL_kKRB5|SSL_aKRB5|  SSL_3DES|SSL_MD5   |SSL_SSLV3,
+        SSL_NOT_EXP|SSL_HIGH,
         0,
+        112,
+        168,
         SSL_ALL_CIPHERS,
+        SSL_ALL_STRENGTHS,
         },
+#endif  /* OPENSSL_NO_KRB5 */
+
+
+#if TLS1_ALLOW_EXPERIMENTAL_CIPHERSUITES
+        /* New TLS Export CipherSuites */
+        /* Cipher 60 */
+            {
+            1,
+            TLS1_TXT_RSA_EXPORT1024_WITH_RC4_56_MD5,
+            TLS1_CK_RSA_EXPORT1024_WITH_RC4_56_MD5,
+            SSL_kRSA|SSL_aRSA|SSL_RC4|SSL_MD5|SSL_TLSV1,
+            SSL_EXPORT|SSL_EXP56,
+            0,
+            56,
+            128,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 61 */
+            {
+            1,
+            TLS1_TXT_RSA_EXPORT1024_WITH_RC2_CBC_56_MD5,
+            TLS1_CK_RSA_EXPORT1024_WITH_RC2_CBC_56_MD5,
+            SSL_kRSA|SSL_aRSA|SSL_RC2|SSL_MD5|SSL_TLSV1,
+            SSL_EXPORT|SSL_EXP56,
+            0,
+            56,
+            128,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 62 */
+            {
+            1,
+            TLS1_TXT_RSA_EXPORT1024_WITH_DES_CBC_SHA,
+            TLS1_CK_RSA_EXPORT1024_WITH_DES_CBC_SHA,
+            SSL_kRSA|SSL_aRSA|SSL_DES|SSL_SHA|SSL_TLSV1,
+            SSL_EXPORT|SSL_EXP56,
+            0,
+            56,
+            56,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 63 */
+            {
+            1,
+            TLS1_TXT_DHE_DSS_EXPORT1024_WITH_DES_CBC_SHA,
+            TLS1_CK_DHE_DSS_EXPORT1024_WITH_DES_CBC_SHA,
+            SSL_kEDH|SSL_aDSS|SSL_DES|SSL_SHA|SSL_TLSV1,
+            SSL_EXPORT|SSL_EXP56,
+            0,
+            56,
+            56,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 64 */
+            {
+            1,
+            TLS1_TXT_RSA_EXPORT1024_WITH_RC4_56_SHA,
+            TLS1_CK_RSA_EXPORT1024_WITH_RC4_56_SHA,
+            SSL_kRSA|SSL_aRSA|SSL_RC4|SSL_SHA|SSL_TLSV1,
+            SSL_EXPORT|SSL_EXP56,
+            0,
+            56,
+            128,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 65 */
+            {
+            1,
+            TLS1_TXT_DHE_DSS_EXPORT1024_WITH_RC4_56_SHA,
+            TLS1_CK_DHE_DSS_EXPORT1024_WITH_RC4_56_SHA,
+            SSL_kEDH|SSL_aDSS|SSL_RC4|SSL_SHA|SSL_TLSV1,
+            SSL_EXPORT|SSL_EXP56,
+            0,
+            56,
+            128,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 66 */
+            {
+            1,
+            TLS1_TXT_DHE_DSS_WITH_RC4_128_SHA,
+            TLS1_CK_DHE_DSS_WITH_RC4_128_SHA,
+            SSL_kEDH|SSL_aDSS|SSL_RC4|SSL_SHA|SSL_TLSV1,
+            SSL_NOT_EXP|SSL_MEDIUM,
+            0,
+            128,
+            128,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS
+            },
+#endif
+        /* New AES ciphersuites */
+
+        /* Cipher 2F */
+            {
+            1,
+            TLS1_TXT_RSA_WITH_AES_128_SHA,
+            TLS1_CK_RSA_WITH_AES_128_SHA,
+            SSL_kRSA|SSL_aRSA|SSL_AES|SSL_SHA |SSL_TLSV1,
+            SSL_NOT_EXP|SSL_MEDIUM,
+            0,
+            128,
+            128,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 30 */
+            {
+            0,
+            TLS1_TXT_DH_DSS_WITH_AES_128_SHA,
+            TLS1_CK_DH_DSS_WITH_AES_128_SHA,
+            SSL_kDHd|SSL_aDH|SSL_AES|SSL_SHA|SSL_TLSV1,
+            SSL_NOT_EXP|SSL_MEDIUM,
+            0,
+            128,
+            128,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 31 */
+            {
+            0,
+            TLS1_TXT_DH_RSA_WITH_AES_128_SHA,
+            TLS1_CK_DH_RSA_WITH_AES_128_SHA,
+            SSL_kDHr|SSL_aDH|SSL_AES|SSL_SHA|SSL_TLSV1,
+            SSL_NOT_EXP|SSL_MEDIUM,
+            0,
+            128,
+            128,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 32 */
+            {
+            1,
+            TLS1_TXT_DHE_DSS_WITH_AES_128_SHA,
+            TLS1_CK_DHE_DSS_WITH_AES_128_SHA,
+            SSL_kEDH|SSL_aDSS|SSL_AES|SSL_SHA|SSL_TLSV1,
+            SSL_NOT_EXP|SSL_MEDIUM,
+            0,
+            128,
+            128,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 33 */
+            {
+            1,
+            TLS1_TXT_DHE_RSA_WITH_AES_128_SHA,
+            TLS1_CK_DHE_RSA_WITH_AES_128_SHA,
+            SSL_kEDH|SSL_aRSA|SSL_AES|SSL_SHA|SSL_TLSV1,
+            SSL_NOT_EXP|SSL_MEDIUM,
+            0,
+            128,
+            128,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 34 */
+            {
+            1,
+            TLS1_TXT_ADH_WITH_AES_128_SHA,
+            TLS1_CK_ADH_WITH_AES_128_SHA,
+            SSL_kEDH|SSL_aNULL|SSL_AES|SSL_SHA|SSL_TLSV1,
+            SSL_NOT_EXP|SSL_MEDIUM,
+            0,
+            128,
+            128,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+
+        /* Cipher 35 */
+            {
+            1,
+            TLS1_TXT_RSA_WITH_AES_256_SHA,
+            TLS1_CK_RSA_WITH_AES_256_SHA,
+            SSL_kRSA|SSL_aRSA|SSL_AES|SSL_SHA |SSL_TLSV1,
+            SSL_NOT_EXP|SSL_HIGH,
+            0,
+            256,
+            256,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 36 */
+            {
+            0,
+            TLS1_TXT_DH_DSS_WITH_AES_256_SHA,
+            TLS1_CK_DH_DSS_WITH_AES_256_SHA,
+            SSL_kDHd|SSL_aDH|SSL_AES|SSL_SHA|SSL_TLSV1,
+            SSL_NOT_EXP|SSL_HIGH,
+            0,
+            256,
+            256,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 37 */
+            {
+            0,
+            TLS1_TXT_DH_RSA_WITH_AES_256_SHA,
+            TLS1_CK_DH_RSA_WITH_AES_256_SHA,
+            SSL_kDHr|SSL_aDH|SSL_AES|SSL_SHA|SSL_TLSV1,
+            SSL_NOT_EXP|SSL_HIGH,
+            0,
+            256,
+            256,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 38 */
+            {
+            1,
+            TLS1_TXT_DHE_DSS_WITH_AES_256_SHA,
+            TLS1_CK_DHE_DSS_WITH_AES_256_SHA,
+            SSL_kEDH|SSL_aDSS|SSL_AES|SSL_SHA|SSL_TLSV1,
+            SSL_NOT_EXP|SSL_HIGH,
+            0,
+            256,
+            256,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 39 */
+            {
+            1,
+            TLS1_TXT_DHE_RSA_WITH_AES_256_SHA,
+            TLS1_CK_DHE_RSA_WITH_AES_256_SHA,
+            SSL_kEDH|SSL_aRSA|SSL_AES|SSL_SHA|SSL_TLSV1,
+            SSL_NOT_EXP|SSL_HIGH,
+            0,
+            256,
+            256,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
+        /* Cipher 3A */
+            {
+            1,
+            TLS1_TXT_ADH_WITH_AES_256_SHA,
+            TLS1_CK_ADH_WITH_AES_256_SHA,
+            SSL_kEDH|SSL_aNULL|SSL_AES|SSL_SHA|SSL_TLSV1,
+            SSL_NOT_EXP|SSL_HIGH,
+            0,
+            256,
+            256,
+            SSL_ALL_CIPHERS,
+            SSL_ALL_STRENGTHS,
+            },
 
 /* end of list */
         };
@@ -384,6 +900,7 @@ static SSL_METHOD SSLv3_data= {
         ssl3_write,
         ssl3_shutdown,
         ssl3_renegotiate,
+        ssl3_renegotiate_check,
         ssl3_ctrl,
         ssl3_ctx_ctrl,
         ssl3_get_cipher_by_char,
@@ -394,27 +911,29 @@ static SSL_METHOD SSLv3_data= {
         ssl_bad_method,
         ssl3_default_timeout,
         &SSLv3_enc_data,
+        ssl_undefined_function,
+        ssl3_callback_ctrl,
+        ssl3_ctx_callback_ctrl,
         };
 
-static long ssl3_default_timeout()
+static long ssl3_default_timeout(void)
         {
         /* 2 hours, the 24 hours mentioned in the SSLv3 spec
          * is way too long for http, the cache would over fill */
         return(60*60*2);
         }
 
-SSL_METHOD *sslv3_base_method()
+SSL_METHOD *sslv3_base_method(void)
         {
         return(&SSLv3_data);
         }
 
-int ssl3_num_ciphers()
+int ssl3_num_ciphers(void)
         {
         return(SSL3_NUM_CIPHERS);
         }
 
-SSL_CIPHER *ssl3_get_cipher(u)
-unsigned int u;
+SSL_CIPHER *ssl3_get_cipher(unsigned int u)
         {
         if (u < SSL3_NUM_CIPHERS)
                 return(&(ssl3_ciphers[SSL3_NUM_CIPHERS-1-u]));
@@ -422,29 +941,24 @@ unsigned int u;
                 return(NULL);
         }
 
-/* The problem is that it may not be the correct record type */
-int ssl3_pending(s)
-SSL *s;
+int ssl3_pending(SSL *s)
         {
-        return(s->s3->rrec.length);
+        if (s->rstate == SSL_ST_READ_BODY)
+                return 0;
+        
+        return (s->s3->rrec.type == SSL3_RT_APPLICATION_DATA) ? s->s3->rrec.length : 0;
         }
 
-int ssl3_new(s)
-SSL *s;
+int ssl3_new(SSL *s)
         {
-        SSL3_CTX *s3;
+        SSL3_STATE *s3;
 
-        if ((s3=(SSL3_CTX *)Malloc(sizeof(SSL3_CTX))) == NULL) goto err;
-        memset(s3,0,sizeof(SSL3_CTX));
+        if ((s3=OPENSSL_malloc(sizeof *s3)) == NULL) goto err;
+        memset(s3,0,sizeof *s3);
+        EVP_MD_CTX_init(&s3->finish_dgst1);
+        EVP_MD_CTX_init(&s3->finish_dgst2);
 
         s->s3=s3;
-        /*
-        s->s3->tmp.ca_names=NULL;
-        s->s3->tmp.key_block=NULL;
-        s->s3->tmp.key_block_length=0;
-        s->s3->rbuf.buf=NULL;
-        s->s3->wbuf.buf=NULL;
-        */
 
         s->method->ssl_clear(s);
         return(1);
@@ -452,40 +966,66 @@ err:
         return(0);
         }
 
-void ssl3_free(s)
-SSL *s;
+void ssl3_free(SSL *s)
         {
+        if(s == NULL)
+            return;
+
         ssl3_cleanup_key_block(s);
         if (s->s3->rbuf.buf != NULL)
-                Free(s->s3->rbuf.buf);
+                OPENSSL_free(s->s3->rbuf.buf);
         if (s->s3->wbuf.buf != NULL)
-                Free(s->s3->wbuf.buf);
-#ifndef NO_DH
+                OPENSSL_free(s->s3->wbuf.buf);
+        if (s->s3->rrec.comp != NULL)
+                OPENSSL_free(s->s3->rrec.comp);
+#ifndef OPENSSL_NO_DH
         if (s->s3->tmp.dh != NULL)
                 DH_free(s->s3->tmp.dh);
 #endif
         if (s->s3->tmp.ca_names != NULL)
-                sk_pop_free(s->s3->tmp.ca_names,X509_NAME_free);
-        memset(s->s3,0,sizeof(SSL3_CTX));
-        Free(s->s3);
+                sk_X509_NAME_pop_free(s->s3->tmp.ca_names,X509_NAME_free);
+        EVP_MD_CTX_cleanup(&s->s3->finish_dgst1);
+        EVP_MD_CTX_cleanup(&s->s3->finish_dgst2);
+        memset(s->s3,0,sizeof *s->s3);
+        OPENSSL_free(s->s3);
         s->s3=NULL;
         }
 
-void ssl3_clear(s)
-SSL *s;
+void ssl3_clear(SSL *s)
         {
         unsigned char *rp,*wp;
+        size_t rlen, wlen;
 
         ssl3_cleanup_key_block(s);
         if (s->s3->tmp.ca_names != NULL)
-                sk_pop_free(s->s3->tmp.ca_names,X509_NAME_free);
+                sk_X509_NAME_pop_free(s->s3->tmp.ca_names,X509_NAME_free);
 
-        rp=s->s3->rbuf.buf;
-        wp=s->s3->wbuf.buf;
+        if (s->s3->rrec.comp != NULL)
+                {
+                OPENSSL_free(s->s3->rrec.comp);
+                s->s3->rrec.comp=NULL;
+                }
+#ifndef OPENSSL_NO_DH
+        if (s->s3->tmp.dh != NULL)
+                DH_free(s->s3->tmp.dh);
+#endif
+
+        rp = s->s3->rbuf.buf;
+        wp = s->s3->wbuf.buf;
+        rlen = s->s3->rbuf.len;
+        wlen = s->s3->wbuf.len;
+
+        EVP_MD_CTX_cleanup(&s->s3->finish_dgst1);
+        EVP_MD_CTX_cleanup(&s->s3->finish_dgst2);
+
+        memset(s->s3,0,sizeof *s->s3);
+        s->s3->rbuf.buf = rp;
+        s->s3->wbuf.buf = wp;
+        s->s3->rbuf.len = rlen;
+        s->s3->wbuf.len = wlen;
+
+        ssl_free_wbio_buffer(s);
 
-        memset(s->s3,0,sizeof(SSL3_CTX));
-        if (rp != NULL) s->s3->rbuf.buf=rp;
-        if (wp != NULL) s->s3->wbuf.buf=wp;
         s->packet_length=0;
         s->s3->renegotiate=0;
         s->s3->total_renegotiations=0;
@@ -494,14 +1034,30 @@ SSL *s;
         s->version=SSL3_VERSION;
         }
 
-long ssl3_ctrl(s,cmd,larg,parg)
-SSL *s;
-int cmd;
-long larg;
-char *parg;
+long ssl3_ctrl(SSL *s, int cmd, long larg, void *parg)
         {
         int ret=0;
 
+#if !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_RSA)
+        if (
+#ifndef OPENSSL_NO_RSA
+            cmd == SSL_CTRL_SET_TMP_RSA ||
+            cmd == SSL_CTRL_SET_TMP_RSA_CB ||
+#endif
+#ifndef OPENSSL_NO_DSA
+            cmd == SSL_CTRL_SET_TMP_DH ||
+            cmd == SSL_CTRL_SET_TMP_DH_CB ||
+#endif
+                0)
+                {
+                if (!ssl_cert_inst(&s->cert))
+                        {
+                        SSLerr(SSL_F_SSL3_CTRL, ERR_R_MALLOC_FAILURE);
+                        return(0);
+                        }
+                }
+#endif
+
         switch (cmd)
                 {
         case SSL_CTRL_GET_SESSION_REUSED:
@@ -519,25 +1075,137 @@ char *parg;
         case SSL_CTRL_GET_TOTAL_RENEGOTIATIONS:
                 ret=s->s3->total_renegotiations;
                 break;
+        case SSL_CTRL_GET_FLAGS:
+                ret=(int)(s->s3->flags);
+                break;
+#ifndef OPENSSL_NO_RSA
+        case SSL_CTRL_NEED_TMP_RSA:
+                if ((s->cert != NULL) && (s->cert->rsa_tmp == NULL) &&
+                    ((s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey == NULL) ||
+                     (EVP_PKEY_size(s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey) > (512/8))))
+                        ret = 1;
+                break;
+        case SSL_CTRL_SET_TMP_RSA:
+                {
+                        RSA *rsa = (RSA *)parg;
+                        if (rsa == NULL)
+                                {
+                                SSLerr(SSL_F_SSL3_CTRL, ERR_R_PASSED_NULL_PARAMETER);
+                                return(ret);
+                                }
+                        if ((rsa = RSAPrivateKey_dup(rsa)) == NULL)
+                                {
+                                SSLerr(SSL_F_SSL3_CTRL, ERR_R_RSA_LIB);
+                                return(ret);
+                                }
+                        if (s->cert->rsa_tmp != NULL)
+                                RSA_free(s->cert->rsa_tmp);
+                        s->cert->rsa_tmp = rsa;
+                        ret = 1;
+                }
+                break;
+        case SSL_CTRL_SET_TMP_RSA_CB:
+                {
+                SSLerr(SSL_F_SSL3_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+                return(ret);
+                }
+                break;
+#endif
+#ifndef OPENSSL_NO_DH
+        case SSL_CTRL_SET_TMP_DH:
+                {
+                        DH *dh = (DH *)parg;
+                        if (dh == NULL)
+                                {
+                                SSLerr(SSL_F_SSL3_CTRL, ERR_R_PASSED_NULL_PARAMETER);
+                                return(ret);
+                                }
+                        if ((dh = DHparams_dup(dh)) == NULL)
+                                {
+                                SSLerr(SSL_F_SSL3_CTRL, ERR_R_DH_LIB);
+                                return(ret);
+                                }
+                        if (!(s->options & SSL_OP_SINGLE_DH_USE))
+                                {
+                                if (!DH_generate_key(dh))
+                                        {
+                                        DH_free(dh);
+                                        SSLerr(SSL_F_SSL3_CTRL, ERR_R_DH_LIB);
+                                        return(ret);
+                                        }
+                                }
+                        if (s->cert->dh_tmp != NULL)
+                                DH_free(s->cert->dh_tmp);
+                        s->cert->dh_tmp = dh;
+                        ret = 1;
+                }
+                break;
+        case SSL_CTRL_SET_TMP_DH_CB:
+                {
+                SSLerr(SSL_F_SSL3_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+                return(ret);
+                }
+                break;
+#endif
         default:
                 break;
                 }
         return(ret);
         }
 
-long ssl3_ctx_ctrl(ctx,cmd,larg,parg)
-SSL_CTX *ctx;
-int cmd;
-long larg;
-char *parg;
+long ssl3_callback_ctrl(SSL *s, int cmd, void (*fp)())
+        {
+        int ret=0;
+
+#if !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_RSA)
+        if (
+#ifndef OPENSSL_NO_RSA
+            cmd == SSL_CTRL_SET_TMP_RSA_CB ||
+#endif
+#ifndef OPENSSL_NO_DSA
+            cmd == SSL_CTRL_SET_TMP_DH_CB ||
+#endif
+                0)
+                {
+                if (!ssl_cert_inst(&s->cert))
+                        {
+                        SSLerr(SSL_F_SSL3_CALLBACK_CTRL, ERR_R_MALLOC_FAILURE);
+                        return(0);
+                        }
+                }
+#endif
+
+        switch (cmd)
+                {
+#ifndef OPENSSL_NO_RSA
+        case SSL_CTRL_SET_TMP_RSA_CB:
+                {
+                s->cert->rsa_tmp_cb = (RSA *(*)(SSL *, int, int))fp;
+                }
+                break;
+#endif
+#ifndef OPENSSL_NO_DH
+        case SSL_CTRL_SET_TMP_DH_CB:
+                {
+                s->cert->dh_tmp_cb = (DH *(*)(SSL *, int, int))fp;
+                }
+                break;
+#endif
+        default:
+                break;
+                }
+        return(ret);
+        }
+
+long ssl3_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
         {
         CERT *cert;
 
-        cert=ctx->default_cert;
+        cert=ctx->cert;
 
         switch (cmd)
                 {
-#ifndef NO_RSA
+#ifndef OPENSSL_NO_RSA
         case SSL_CTRL_NEED_TMP_RSA:
                 if (    (cert->rsa_tmp == NULL) &&
                         ((cert->pkeys[SSL_PKEY_RSA_ENC].privatekey == NULL) ||
@@ -546,7 +1214,7 @@ char *parg;
                         return(1);
                 else
                         return(0);
-                break;
+                /* break; */
         case SSL_CTRL_SET_TMP_RSA:
                 {
                 RSA *rsa;
@@ -574,35 +1242,83 @@ char *parg;
                         return(1);
                         }
                 }
-                break;
+                /* break; */
         case SSL_CTRL_SET_TMP_RSA_CB:
-                cert->rsa_tmp_cb=(RSA *(*)())parg;
+                {
+                SSLerr(SSL_F_SSL3_CTX_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+                return(0);
+                }
                 break;
 #endif
-#ifndef NO_DH
+#ifndef OPENSSL_NO_DH
         case SSL_CTRL_SET_TMP_DH:
                 {
                 DH *new=NULL,*dh;
 
                 dh=(DH *)parg;
-                if (    ((new=DHparams_dup(dh)) == NULL) ||
-                        (!DH_generate_key(new)))
+                if ((new=DHparams_dup(dh)) == NULL)
                         {
                         SSLerr(SSL_F_SSL3_CTX_CTRL,ERR_R_DH_LIB);
-                        if (new != NULL) DH_free(new);
-                        return(0);
+                        return 0;
                         }
-                else
+                if (!(ctx->options & SSL_OP_SINGLE_DH_USE))
                         {
-                        if (cert->dh_tmp != NULL)
-                                DH_free(cert->dh_tmp);
-                        cert->dh_tmp=new;
-                        return(1);
+                        if (!DH_generate_key(new))
+                                {
+                                SSLerr(SSL_F_SSL3_CTX_CTRL,ERR_R_DH_LIB);
+                                DH_free(new);
+                                return 0;
+                                }
                         }
+                if (cert->dh_tmp != NULL)
+                        DH_free(cert->dh_tmp);
+                cert->dh_tmp=new;
+                return 1;
+                }
+                /*break; */
+        case SSL_CTRL_SET_TMP_DH_CB:
+                {
+                SSLerr(SSL_F_SSL3_CTX_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+                return(0);
                 }
                 break;
+#endif
+        /* A Thawte special :-) */
+        case SSL_CTRL_EXTRA_CHAIN_CERT:
+                if (ctx->extra_certs == NULL)
+                        {
+                        if ((ctx->extra_certs=sk_X509_new_null()) == NULL)
+                                return(0);
+                        }
+                sk_X509_push(ctx->extra_certs,(X509 *)parg);
+                break;
+
+        default:
+                return(0);
+                }
+        return(1);
+        }
+
+long ssl3_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)())
+        {
+        CERT *cert;
+
+        cert=ctx->cert;
+
+        switch (cmd)
+                {
+#ifndef OPENSSL_NO_RSA
+        case SSL_CTRL_SET_TMP_RSA_CB:
+                {
+                cert->rsa_tmp_cb = (RSA *(*)(SSL *, int, int))fp;
+                }
+                break;
+#endif
+#ifndef OPENSSL_NO_DH
         case SSL_CTRL_SET_TMP_DH_CB:
-                cert->dh_tmp_cb=(DH *(*)())parg;
+                {
+                cert->dh_tmp_cb = (DH *(*)(SSL *, int, int))fp;
+                }
                 break;
 #endif
         default:
@@ -613,8 +1329,7 @@ char *parg;
 
 /* This function needs to check if the ciphers required are actually
  * available */
-SSL_CIPHER *ssl3_get_cipher_by_char(p)
-unsigned char *p;
+SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p)
         {
         static int init=1;
         static SSL_CIPHER *sorted[SSL3_NUM_CIPHERS];
@@ -624,7 +1339,7 @@ unsigned char *p;
 
         if (init)
                 {
-                init=0;
+                CRYPTO_w_lock(CRYPTO_LOCK_SSL);
 
                 for (i=0; i<SSL3_NUM_CIPHERS; i++)
                         sorted[i]= &(ssl3_ciphers[i]);
@@ -632,6 +1347,10 @@ unsigned char *p;
                 qsort(  (char *)sorted,
                         SSL3_NUM_CIPHERS,sizeof(SSL_CIPHER *),
                         FP_ICC ssl_cipher_ptr_id_cmp);
+
+                CRYPTO_w_unlock(CRYPTO_LOCK_SSL);
+
+                init=0;
                 }
 
         id=0x03000000L|((unsigned long)p[0]<<8L)|(unsigned long)p[1];
@@ -639,16 +1358,14 @@ unsigned char *p;
         cpp=(SSL_CIPHER **)OBJ_bsearch((char *)&cp,
                 (char *)sorted,
                 SSL3_NUM_CIPHERS,sizeof(SSL_CIPHER *),
-                (int (*)())ssl_cipher_ptr_id_cmp);
+                FP_ICC ssl_cipher_ptr_id_cmp);
         if ((cpp == NULL) || !(*cpp)->valid)
                 return(NULL);
         else
                 return(*cpp);
         }
 
-int ssl3_put_cipher_by_char(c,p)
-SSL_CIPHER *c;
-unsigned char *p;
+int ssl3_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p)
         {
         long l;
 
@@ -662,114 +1379,141 @@ unsigned char *p;
         return(2);
         }
 
-int ssl3_part_read(s,i)
-SSL *s;
-int i;
-        {
-        s->rwstate=SSL_READING;
-
-        if (i < 0)
-                {
-                return(i);
-                }
-        else
-                {
-                s->init_num+=i;
-                return(0);
-                }
-        }
-
-SSL_CIPHER *ssl3_choose_cipher(s,have,pref)
-SSL *s;
-STACK *have,*pref;
+SSL_CIPHER *ssl3_choose_cipher(SSL *s, STACK_OF(SSL_CIPHER) *clnt,
+             STACK_OF(SSL_CIPHER) *srvr)
         {
         SSL_CIPHER *c,*ret=NULL;
+        STACK_OF(SSL_CIPHER) *prio, *allow;
         int i,j,ok;
         CERT *cert;
         unsigned long alg,mask,emask;
 
-        /* Lets see which ciphers we can supported */
-        if (s->cert != NULL)
-                cert=s->cert;
+        /* Let's see which ciphers we can support */
+        cert=s->cert;
+
+#if 0
+        /* Do not set the compare functions, because this may lead to a
+         * reordering by "id". We want to keep the original ordering.
+         * We may pay a price in performance during sk_SSL_CIPHER_find(),
+         * but would have to pay with the price of sk_SSL_CIPHER_dup().
+         */
+        sk_SSL_CIPHER_set_cmp_func(srvr, ssl_cipher_ptr_id_cmp);
+        sk_SSL_CIPHER_set_cmp_func(clnt, ssl_cipher_ptr_id_cmp);
+#endif
+
+#ifdef CIPHER_DEBUG
+        printf("Server has %d from %p:\n", sk_SSL_CIPHER_num(srvr), srvr);
+        for(i=0 ; i < sk_SSL_CIPHER_num(srvr) ; ++i)
+            {
+            c=sk_SSL_CIPHER_value(srvr,i);
+            printf("%p:%s\n",c,c->name);
+            }
+        printf("Client sent %d from %p:\n", sk_SSL_CIPHER_num(clnt), clnt);
+        for(i=0 ; i < sk_SSL_CIPHER_num(clnt) ; ++i)
+            {
+            c=sk_SSL_CIPHER_value(clnt,i);
+            printf("%p:%s\n",c,c->name);
+            }
+#endif
+
+        if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE)
+            {
+            prio = srvr;
+            allow = clnt;
+            }
         else
-                cert=s->ctx->default_cert;
+            {
+            prio = clnt;
+            allow = srvr;
+            }
+
+        for (i=0; i<sk_SSL_CIPHER_num(prio); i++)
+                {
+                c=sk_SSL_CIPHER_value(prio,i);
 
-        ssl_set_cert_masks(cert);
-        mask=cert->mask;
-        emask=cert->export_mask;
+                ssl_set_cert_masks(cert,c);
+                mask=cert->mask;
+                emask=cert->export_mask;
                         
-        sk_set_cmp_func(pref,ssl_cipher_ptr_id_cmp);
+#ifdef KSSL_DEBUG
+                printf("ssl3_choose_cipher %d alg= %lx\n", i,c->algorithms);
+#endif    /* KSSL_DEBUG */
 
-        for (i=0; i<sk_num(have); i++)
-                {
-                c=(SSL_CIPHER *)sk_value(have,i);
                 alg=c->algorithms&(SSL_MKEY_MASK|SSL_AUTH_MASK);
-                if (alg & SSL_EXPORT)
+#ifndef OPENSSL_NO_KRB5
+                if (alg & SSL_KRB5) 
+                        {
+                        if ( !kssl_keytab_is_available(s->kssl_ctx) )
+                            continue;
+                        }
+#endif /* OPENSSL_NO_KRB5 */
+                if (SSL_C_IS_EXPORT(c))
                         {
                         ok=((alg & emask) == alg)?1:0;
 #ifdef CIPHER_DEBUG
-                        printf("%d:[%08lX:%08lX]%s\n",ok,alg,mask,c->name);
+                        printf("%d:[%08lX:%08lX]%p:%s (export)\n",ok,alg,emask,
+                               c,c->name);
 #endif
                         }
                 else
                         {
                         ok=((alg & mask) == alg)?1:0;
 #ifdef CIPHER_DEBUG
-                        printf("%d:[%08lX:%08lX]%s\n",ok,alg,mask,c->name);
+                        printf("%d:[%08lX:%08lX]%p:%s\n",ok,alg,mask,c,
+                               c->name);
 #endif
                         }
 
                 if (!ok) continue;
         
-                j=sk_find(pref,(char *)c);
+                j=sk_SSL_CIPHER_find(allow,c);
                 if (j >= 0)
                         {
-                        ret=(SSL_CIPHER *)sk_value(pref,j);
+                        ret=sk_SSL_CIPHER_value(allow,j);
                         break;
                         }
                 }
         return(ret);
         }
 
-int ssl3_get_req_cert_type(s,p)
-SSL *s;
-unsigned char *p;
+int ssl3_get_req_cert_type(SSL *s, unsigned char *p)
         {
         int ret=0;
         unsigned long alg;
 
         alg=s->s3->tmp.new_cipher->algorithms;
 
-#ifndef NO_DH
+#ifndef OPENSSL_NO_DH
         if (alg & (SSL_kDHr|SSL_kEDH))
                 {
-#ifndef NO_RSA
+#  ifndef OPENSSL_NO_RSA
                 p[ret++]=SSL3_CT_RSA_FIXED_DH;
-#endif
-#ifndef NO_DSA
+#  endif
+#  ifndef OPENSSL_NO_DSA
                 p[ret++]=SSL3_CT_DSS_FIXED_DH;
-#endif
+#  endif
                 }
         if ((s->version == SSL3_VERSION) &&
                 (alg & (SSL_kEDH|SSL_kDHd|SSL_kDHr)))
                 {
-#ifndef NO_RSA
+#  ifndef OPENSSL_NO_RSA
                 p[ret++]=SSL3_CT_RSA_EPHEMERAL_DH;
-#endif
-#ifndef NO_DSA
+#  endif
+#  ifndef OPENSSL_NO_DSA
                 p[ret++]=SSL3_CT_DSS_EPHEMERAL_DH;
-#endif
+#  endif
                 }
-#endif /* !NO_DH */
-#ifndef NO_RSA
+#endif /* !OPENSSL_NO_DH */
+#ifndef OPENSSL_NO_RSA
         p[ret++]=SSL3_CT_RSA_SIGN;
 #endif
+#ifndef OPENSSL_NO_DSA
         p[ret++]=SSL3_CT_DSS_SIGN;
+#endif
         return(ret);
         }
 
-int ssl3_shutdown(s)
-SSL *s;
+int ssl3_shutdown(SSL *s)
         {
 
         /* Don't do anything much if we have not done the handshake or
@@ -799,7 +1543,7 @@ SSL *s;
         else if (!(s->shutdown & SSL_RECEIVED_SHUTDOWN))
                 {
                 /* If we are waiting for a close from our peer, we are closed */
-                ssl3_read_bytes(s,0,NULL,0);
+                ssl3_read_bytes(s,0,NULL,0,0);
                 }
 
         if ((s->shutdown == (SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN)) &&
@@ -809,13 +1553,9 @@ SSL *s;
                 return(0);
         }
 
-int ssl3_write(s,buf,len)
-SSL *s;
-char *buf;
-int len;
+int ssl3_write(SSL *s, const void *buf, int len)
         {
         int ret,n;
-        BIO *under;
 
 #if 0
         if (s->shutdown & SSL_SEND_SHUTDOWN)
@@ -838,7 +1578,7 @@ int len;
                 if (s->s3->delay_buf_pop_ret == 0)
                         {
                         ret=ssl3_write_bytes(s,SSL3_RT_APPLICATION_DATA,
-                                (char *)buf,len);
+                                             buf,len);
                         if (ret <= 0) return(ret);
 
                         s->s3->delay_buf_pop_ret=ret;
@@ -849,43 +1589,40 @@ int len;
                 if (n <= 0) return(n);
                 s->rwstate=SSL_NOTHING;
 
-                /* We have flushed the buffer */
-                under=BIO_pop(s->wbio);
-                s->wbio=under;
-                BIO_free(s->bbio);
-                s->bbio=NULL;
+                /* We have flushed the buffer, so remove it */
+                ssl_free_wbio_buffer(s);
+                s->s3->flags&= ~SSL3_FLAGS_POP_BUFFER;
+
                 ret=s->s3->delay_buf_pop_ret;
                 s->s3->delay_buf_pop_ret=0;
-
-                s->s3->flags&= ~SSL3_FLAGS_POP_BUFFER;
                 }
         else
                 {
                 ret=ssl3_write_bytes(s,SSL3_RT_APPLICATION_DATA,
-                        (char *)buf,len);
+                                     buf,len);
                 if (ret <= 0) return(ret);
                 }
 
         return(ret);
         }
 
-int ssl3_read(s,buf,len)
-SSL *s;
-char *buf;
-int len;
+static int ssl3_read_internal(SSL *s, void *buf, int len, int peek)
         {
         int ret;
         
         clear_sys_error();
         if (s->s3->renegotiate) ssl3_renegotiate_check(s);
         s->s3->in_read_app_data=1;
-        ret=ssl3_read_bytes(s,SSL3_RT_APPLICATION_DATA,buf,len);
-        if ((ret == -1) && (s->s3->in_read_app_data == 0))
+        ret=ssl3_read_bytes(s,SSL3_RT_APPLICATION_DATA,buf,len,peek);
+        if ((ret == -1) && (s->s3->in_read_app_data == 2))
                 {
-                ERR_get_error(); /* clear the error */
-                s->s3->in_read_app_data=0;
+                /* ssl3_read_bytes decided to call s->handshake_func, which
+                 * called ssl3_read_bytes to read handshake data.
+                 * However, ssl3_read_bytes actually found application data
+                 * and thinks that application data makes sense here; so disable
+                 * handshake processing and try to read application data again. */
                 s->in_handshake++;
-                ret=ssl3_read_bytes(s,SSL3_RT_APPLICATION_DATA,buf,len);
+                ret=ssl3_read_bytes(s,SSL3_RT_APPLICATION_DATA,buf,len,peek);
                 s->in_handshake--;
                 }
         else
@@ -894,33 +1631,17 @@ int len;
         return(ret);
         }
 
-int ssl3_peek(s,buf,len)
-SSL *s;
-char *buf;
-int len;
+int ssl3_read(SSL *s, void *buf, int len)
         {
-        SSL3_RECORD *rr;
-        int n;
-
-        rr= &(s->s3->rrec);
-        if ((rr->length == 0) || (rr->type != SSL3_RT_APPLICATION_DATA))
-                {
-                n=ssl3_read(s,buf,1);
-                if (n <= 0) return(n);
-                rr->length++;
-                rr->off--;
-                }
+        return ssl3_read_internal(s, buf, len, 0);
+        }
 
-        if ((unsigned int)len > rr->length)
-                n=rr->length;
-        else
-                n=len;
-        memcpy(buf,&(rr->data[rr->off]),(unsigned int)n);
-        return(n);
+int ssl3_peek(SSL *s, void *buf, int len)
+        {
+        return ssl3_read_internal(s, buf, len, 1);
         }
 
-int ssl3_renegotiate(s)
-SSL *s;
+int ssl3_renegotiate(SSL *s)
         {
         if (s->handshake_func == NULL)
                 return(1);
@@ -932,8 +1653,7 @@ SSL *s;
         return(1);
         }
 
-int ssl3_renegotiate_check(s)
-SSL *s;
+int ssl3_renegotiate_check(SSL *s)
         {
         int ret=0;
 
@@ -945,7 +1665,7 @@ SSL *s;
                         {
 /*
 if we are the server, and we have sent a 'RENEGOTIATE' message, we
-need to go to SSL_ST_ACCEPT.
+need to go to SSL_ST_ACCEPT.
 */
                         /* SSL_ST_ACCEPT */
                         s->state=SSL_ST_RENEGOTIATE;
@@ -958,4 +1678,3 @@ need to go to SSL_ST_ACCEPT.
         return(ret);
         }
 
-
diff --git a/src/lib/libssl/s3_pkt.c b/src/lib/libssl/s3_pkt.c
index 2385080347..43e8502b66 100644
--- a/src/lib/libssl/s3_pkt.c
+++ b/src/lib/libssl/s3_pkt.c
@@ -55,150 +55,165 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
+/* ====================================================================
+ * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
 
 #include <stdio.h>
 #include <errno.h>
 #define USE_SOCKETS
-#include "evp.h"
-#include "buffer.h"
+#include <openssl/evp.h>
+#include <openssl/buffer.h>
 #include "ssl_locl.h"
 
-/* SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_PEER_ERROR_NO_CIPHER);
- * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_PEER_ERROR_NO_CERTIFICATE);
- * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_PEER_ERROR_CERTIFICATE);
- * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE);
- * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_UNKNOWN_REMOTE_ERROR_TYPE);
- * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE);
- * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_BAD_RECORD_MAC);
- * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE);
- * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE);
- * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_NO_CERTIFICATE);
- * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_BAD_CERTIFICATE);
- * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE);
- * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED);
- * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED);
- * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN);
- * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER);
- */
-
-#ifndef NOPROTO
-static int do_ssl3_write(SSL *s, int type, char *buf, unsigned int len);
-static int ssl3_write_pending(SSL *s, int type, char *buf, unsigned int len);
+static int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
+                         unsigned int len, int create_empty_fragment);
+static int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
+                              unsigned int len);
 static int ssl3_get_record(SSL *s);
 static int do_compress(SSL *ssl);
 static int do_uncompress(SSL *ssl);
 static int do_change_cipher_spec(SSL *ssl);
-#else
-static int do_ssl3_write();
-static int ssl3_write_pending();
-static int ssl3_get_record();
-static int do_compress();
-static int do_uncompress();
-static int do_change_cipher_spec();
-#endif
 
-static int ssl3_read_n(s,n,max,extend)
-SSL *s;
-int n;
-int max;
-int extend;
+/* used only by ssl3_get_record */
+static int ssl3_read_n(SSL *s, int n, int max, int extend)
         {
+        /* If extend == 0, obtain new n-byte packet; if extend == 1, increase
+         * packet by another n bytes.
+         * The packet will be in the sub-array of s->s3->rbuf.buf specified
+         * by s->packet and s->packet_length.
+         * (If s->read_ahead is set, 'max' bytes may be stored in rbuf
+         * [plus s->packet_length bytes if extend == 1].)
+         */
         int i,off,newb;
 
-        /* if there is stuff still in the buffer from a previous read,
-         * and there is more than we want, take some. */
+        if (!extend)
+                {
+                /* start with empty packet ... */
+                if (s->s3->rbuf.left == 0)
+                        s->s3->rbuf.offset = 0;
+                s->packet = s->s3->rbuf.buf + s->s3->rbuf.offset;
+                s->packet_length = 0;
+                /* ... now we can act as if 'extend' was set */
+                }
+
+        /* if there is enough in the buffer from a previous read, take some */
         if (s->s3->rbuf.left >= (int)n)
                 {
-                if (extend)
-                        s->packet_length+=n;
-                else
-                        {
-                        s->packet= &(s->s3->rbuf.buf[s->s3->rbuf.offset]);
-                        s->packet_length=n;
-                        }
+                s->packet_length+=n;
                 s->s3->rbuf.left-=n;
                 s->s3->rbuf.offset+=n;
                 return(n);
                 }
 
         /* else we need to read more data */
-        if (!s->read_ahead) max=n;
-        if (max > SSL3_RT_MAX_PACKET_SIZE)
-                max=SSL3_RT_MAX_PACKET_SIZE;
-
-        /* First check if there is some left or we want to extend */
-        off=0;
-        if (    (s->s3->rbuf.left != 0) ||
-                ((s->packet_length != 0) && extend))
-                {
-                newb=s->s3->rbuf.left;
-                if (extend)
-                        {
-                        /* Copy bytes back to the front of the buffer 
-                         * Take the bytes already pointed to by 'packet'
-                         * and take the extra ones on the end. */
-                        off=s->packet_length;
-                        if (s->packet != s->s3->rbuf.buf)
-                                memcpy(s->s3->rbuf.buf,s->packet,newb+off);
-                        }
-                else if (s->s3->rbuf.offset != 0)
-                        { /* so the data is not at the start of the buffer */
-                        memcpy(s->s3->rbuf.buf,
-                                &(s->s3->rbuf.buf[s->s3->rbuf.offset]),newb);
-                        s->s3->rbuf.offset=0;
-                        }
+        if (!s->read_ahead)
+                max=n;
 
-                s->s3->rbuf.left=0;
+        {
+                /* avoid buffer overflow */
+                int max_max = s->s3->rbuf.len - s->packet_length;
+                if (max > max_max)
+                        max = max_max;
+        }
+        if (n > max) /* does not happen */
+                {
+                SSLerr(SSL_F_SSL3_READ_N,ERR_R_INTERNAL_ERROR);
+                return -1;
                 }
-        else
-                newb=0;
 
-        /* So we now have 'newb' bytes at the front of 
-         * s->s3->rbuf.buf and need to read some more in on the end
-         * We start reading into the buffer at 's->s3->rbuf.offset'
-         */
-        s->packet=s->s3->rbuf.buf;
+        off = s->packet_length;
+        newb = s->s3->rbuf.left;
+        /* Move any available bytes to front of buffer:
+         * 'off' bytes already pointed to by 'packet',
+         * 'newb' extra ones at the end */
+        if (s->packet != s->s3->rbuf.buf)
+                {
+                /*  off > 0 */
+                memmove(s->s3->rbuf.buf, s->packet, off+newb);
+                s->packet = s->s3->rbuf.buf;
+                }
 
         while (newb < n)
                 {
+                /* Now we have off+newb bytes at the front of s->s3->rbuf.buf and need
+                 * to read in more until we have off+n (up to off+max if possible) */
+
                 clear_sys_error();
                 if (s->rbio != NULL)
                         {
                         s->rwstate=SSL_READING;
-                        i=BIO_read(s->rbio,
-                                (char *)&(s->s3->rbuf.buf[off+newb]),
-                                max-newb);
+                        i=BIO_read(s->rbio,     &(s->s3->rbuf.buf[off+newb]), max-newb);
                         }
                 else
                         {
                         SSLerr(SSL_F_SSL3_READ_N,SSL_R_READ_BIO_NOT_SET);
-                        i= -1;
+                        i = -1;
                         }
 
                 if (i <= 0)
                         {
-                        s->s3->rbuf.left+=newb;
+                        s->s3->rbuf.left = newb;
                         return(i);
                         }
                 newb+=i;
                 }
 
-        /* record used data read */
-        if (newb > n)
-                {
-                s->s3->rbuf.offset=n+off;
-                s->s3->rbuf.left=newb-n;
-                }
-        else
-                {
-                s->s3->rbuf.offset=0;
-                s->s3->rbuf.left=0;
-                }
-
-        if (extend)
-                s->packet_length+=n;
-        else
-                s->packet_length+=n;
+        /* done reading, now the book-keeping */
+        s->s3->rbuf.offset = off + n;
+        s->s3->rbuf.left = newb - n;
+        s->packet_length += n;
+        s->rwstate=SSL_NOTHING;
         return(n);
         }
 
@@ -206,41 +221,45 @@ int extend;
  * It will return <= 0 if more data is needed, normally due to an error
  * or non-blocking IO.
  * When it finishes, one packet has been decoded and can be found in
- * ssl->s3->rrec.type   - is the type of record
- * ssl->s3->rrec.data,  - data
+ * ssl->s3->rrec.type    - is the type of record
+ * ssl->s3->rrec.data,   - data
  * ssl->s3->rrec.length, - number of bytes
  */
-static int ssl3_get_record(s)
-SSL *s;
+/* used only by ssl3_read_bytes */
+static int ssl3_get_record(SSL *s)
         {
-        char tmp_buf[512];
         int ssl_major,ssl_minor,al;
-        int n,i,ret= -1;
-        SSL3_BUFFER *rb;
+        int enc_err,n,i,ret= -1;
         SSL3_RECORD *rr;
         SSL_SESSION *sess;
         unsigned char *p;
         unsigned char md[EVP_MAX_MD_SIZE];
         short version;
         unsigned int mac_size;
-        int clear=0,extra;
+        int clear=0;
+        size_t extra;
 
         rr= &(s->s3->rrec);
-        rb= &(s->s3->rbuf);
         sess=s->session;
 
         if (s->options & SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER)
                 extra=SSL3_RT_MAX_EXTRA;
         else
                 extra=0;
+        if (extra != s->s3->rbuf.len - SSL3_RT_MAX_PACKET_SIZE)
+                {
+                /* actually likely an application error: SLS_OP_MICROSOFT_BIG_SSLV3_BUFFER
+                 * set after ssl3_setup_buffers() was done */
+                SSLerr(SSL_F_SSL3_GET_RECORD, ERR_R_INTERNAL_ERROR);
+                return -1;
+                }
 
 again:
         /* check if we have the header */
         if (    (s->rstate != SSL_ST_READ_BODY) ||
                 (s->packet_length < SSL3_RT_HEADER_LENGTH)) 
                 {
-                n=ssl3_read_n(s,SSL3_RT_HEADER_LENGTH,
-                        SSL3_RT_MAX_PACKET_SIZE,0);
+                n=ssl3_read_n(s, SSL3_RT_HEADER_LENGTH, s->s3->rbuf.len, 0);
                 if (n <= 0) return(n); /* error or non-blocking */
                 s->rstate=SSL_ST_READ_BODY;
 
@@ -277,35 +296,33 @@ again:
                         goto err;
                         }
 
-                if (rr->length > 
-                        (unsigned int)SSL3_RT_MAX_ENCRYPTED_LENGTH+extra)
+                if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH+extra)
                         {
                         al=SSL_AD_RECORD_OVERFLOW;
                         SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_PACKET_LENGTH_TOO_LONG);
                         goto f_err;
                         }
 
-                s->rstate=SSL_ST_READ_BODY;
+                /* now s->rstate == SSL_ST_READ_BODY */
                 }
 
-        /* get and decode the data */
-        if (s->rstate == SSL_ST_READ_BODY)
+        /* s->rstate == SSL_ST_READ_BODY, get and decode the data */
+
+        if (rr->length > s->packet_length-SSL3_RT_HEADER_LENGTH)
                 {
-                if (rr->length > (s->packet_length-SSL3_RT_HEADER_LENGTH))
-                        {
-                        i=rr->length;
-                        /*-(s->packet_length-SSL3_RT_HEADER_LENGTH); */
-                        n=ssl3_read_n(s,i,i,1);
-                        if (n <= 0) return(n); /* error or non-blocking io */
-                        }
-                s->rstate=SSL_ST_READ_HEADER;
+                /* now s->packet_length == SSL3_RT_HEADER_LENGTH */
+                i=rr->length;
+                n=ssl3_read_n(s,i,i,1);
+                if (n <= 0) return(n); /* error or non-blocking io */
+                /* now n == rr->length,
+                 * and s->packet_length == SSL3_RT_HEADER_LENGTH + rr->length */
                 }
 
-        /* At this point, we have the data in s->packet and there should be
-         * s->packet_length bytes, we must not 'overrun' this buffer :-)
-         * One of the following functions will copy the data from the
-         * s->packet buffer */
+        s->rstate=SSL_ST_READ_HEADER; /* set state for later operations */
 
+        /* At this point, s->packet_length == SSL3_RT_HEADER_LNGTH + rr->length,
+         * and we have that many bytes in s->packet
+         */
         rr->input= &(s->packet[SSL3_RT_HEADER_LENGTH]);
 
         /* ok, we can now read from 's->packet' data into 'rr'
@@ -315,14 +332,11 @@ again:
          * When the data is 'copied' into the rr->data buffer,
          * rr->input will be pointed at the new buffer */ 
 
-        /* Set the state for the following operations */
-        s->rstate=SSL_ST_READ_HEADER;
-
         /* We now have - encrypted [ MAC [ compressed [ plain ] ] ]
          * rr->length bytes of encrypted compressed stuff. */
 
-        /* check is not needed I belive */
-        if (rr->length > (unsigned int)SSL3_RT_MAX_ENCRYPTED_LENGTH+extra)
+        /* check is not needed I believe */
+        if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH+extra)
                 {
                 al=SSL_AD_RECORD_OVERFLOW;
                 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
@@ -331,18 +345,24 @@ again:
 
         /* decrypt in place in 'rr->input' */
         rr->data=rr->input;
-        memcpy(tmp_buf,rr->input,(rr->length > 512)?512:rr->length);
 
-        if (!s->method->ssl3_enc->enc(s,0))
+        enc_err = s->method->ssl3_enc->enc(s,0);
+        if (enc_err <= 0)
                 {
-                al=SSL_AD_DECRYPT_ERROR;
-                goto f_err;
+                if (enc_err == 0)
+                        /* SSLerr() and ssl3_send_alert() have been called */
+                        goto err;
+
+                /* otherwise enc_err == -1 */
+                goto decryption_failed_or_bad_record_mac;
                 }
+
 #ifdef TLS_DEBUG
 printf("dec %d\n",rr->length);
-{ int z; for (z=0; z<rr->length; z++) printf("%02X%c",rr->data[z],((z+1)%16)?' ':'\n'); }
+{ unsigned int z; for (z=0; z<rr->length; z++) printf("%02X%c",rr->data[z],((z+1)%16)?' ':'\n'); }
 printf("\n");
 #endif
+
         /* r->length is now the compressed data plus mac */
         if (    (sess == NULL) ||
                 (s->enc_read_ctx == NULL) ||
@@ -355,33 +375,37 @@ printf("\n");
 
                 if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH+extra+mac_size)
                         {
+#if 0 /* OK only for stream ciphers (then rr->length is visible from ciphertext anyway) */
                         al=SSL_AD_RECORD_OVERFLOW;
                         SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_PRE_MAC_LENGTH_TOO_LONG);
                         goto f_err;
+#else
+                        goto decryption_failed_or_bad_record_mac;
+#endif                  
                         }
-                /* check MAC for rr->input' */
+                /* check the MAC for rr->input (it's in mac_size bytes at the tail) */
                 if (rr->length < mac_size)
                         {
+#if 0 /* OK only for stream ciphers */
                         al=SSL_AD_DECODE_ERROR;
                         SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_LENGTH_TOO_SHORT);
                         goto f_err;
+#else
+                        goto decryption_failed_or_bad_record_mac;
+#endif
                         }
                 rr->length-=mac_size;
                 i=s->method->ssl3_enc->mac(s,md,0);
                 if (memcmp(md,&(rr->data[rr->length]),mac_size) != 0)
                         {
-                        al=SSL_AD_BAD_RECORD_MAC;
-                        SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_BAD_MAC_DECODE);
-                        ret= -1;
-                        goto f_err;
+                        goto decryption_failed_or_bad_record_mac;
                         }
                 }
 
         /* r->length is now just compressed */
-        if ((sess != NULL) && (sess->read_compression != NULL))
+        if (s->expand != NULL)
                 {
-                if (rr->length > 
-                        (unsigned int)SSL3_RT_MAX_COMPRESSED_LENGTH+extra)
+                if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH+extra)
                         {
                         al=SSL_AD_RECORD_OVERFLOW;
                         SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_COMPRESSED_LENGTH_TOO_LONG);
@@ -395,7 +419,7 @@ printf("\n");
                         }
                 }
 
-        if (rr->length > (unsigned int)SSL3_RT_MAX_PLAIN_LENGTH+extra)
+        if (rr->length > SSL3_RT_MAX_PLAIN_LENGTH+extra)
                 {
                 al=SSL_AD_RECORD_OVERFLOW;
                 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_DATA_LENGTH_TOO_LONG);
@@ -418,33 +442,62 @@ printf("\n");
         if (rr->length == 0) goto again;
 
         return(1);
+
+decryption_failed_or_bad_record_mac:
+        /* Separate 'decryption_failed' alert was introduced with TLS 1.0,
+         * SSL 3.0 only has 'bad_record_mac'.  But unless a decryption
+         * failure is directly visible from the ciphertext anyway,
+         * we should not reveal which kind of error occured -- this
+         * might become visible to an attacker (e.g. via logfile) */
+        al=SSL_AD_BAD_RECORD_MAC;
+        SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
 f_err:
         ssl3_send_alert(s,SSL3_AL_FATAL,al);
 err:
         return(ret);
         }
 
-static int do_uncompress(ssl)
-SSL *ssl;
+static int do_uncompress(SSL *ssl)
         {
+        int i;
+        SSL3_RECORD *rr;
+
+        rr= &(ssl->s3->rrec);
+        i=COMP_expand_block(ssl->expand,rr->comp,
+                SSL3_RT_MAX_PLAIN_LENGTH,rr->data,(int)rr->length);
+        if (i < 0)
+                return(0);
+        else
+                rr->length=i;
+        rr->data=rr->comp;
+
         return(1);
         }
 
-static int do_compress(ssl)
-SSL *ssl;
+static int do_compress(SSL *ssl)
         {
+        int i;
+        SSL3_RECORD *wr;
+
+        wr= &(ssl->s3->wrec);
+        i=COMP_compress_block(ssl->compress,wr->data,
+                SSL3_RT_MAX_COMPRESSED_LENGTH,
+                wr->input,(int)wr->length);
+        if (i < 0)
+                return(0);
+        else
+                wr->length=i;
+
+        wr->input=wr->data;
         return(1);
         }
 
-/* Call this to write data
+/* Call this to write data in records of type 'type'
  * It will return <= 0 if not all data has been sent or non-blocking IO.
  */
-int ssl3_write_bytes(s,type,buf,len)
-SSL *s;
-int type;
-char *buf;
-int len;
+int ssl3_write_bytes(SSL *s, int type, const void *buf_, int len)
         {
+        const unsigned char *buf=buf_;
         unsigned int tot,n,nw;
         int i;
 
@@ -459,7 +512,7 @@ int len;
                 if (i == 0)
                         {
                         SSLerr(SSL_F_SSL3_WRITE_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE);
-                        return(-1);
+                        return -1;
                         }
                 }
 
@@ -470,37 +523,41 @@ int len;
                         nw=SSL3_RT_MAX_PLAIN_LENGTH;
                 else
                         nw=n;
-                        
-                i=do_ssl3_write(s,type,&(buf[tot]),nw);
+
+                i=do_ssl3_write(s, type, &(buf[tot]), nw, 0);
                 if (i <= 0)
                         {
                         s->s3->wnum=tot;
-                        return(i);
+                        return i;
                         }
 
-                if (type == SSL3_RT_HANDSHAKE)
-                        ssl3_finish_mac(s,(unsigned char *)&(buf[tot]),i);
-
-                if (i == (int)n) return(tot+i);
+                if ((i == (int)n) ||
+                        (type == SSL3_RT_APPLICATION_DATA &&
+                         (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE)))
+                        {
+                        /* next chunk of data should get another prepended empty fragment
+                         * in ciphersuites with known-IV weakness: */
+                        s->s3->empty_fragment_done = 0;
+                        
+                        return tot+i;
+                        }
 
                 n-=i;
                 tot+=i;
                 }
         }
 
-static int do_ssl3_write(s,type,buf,len)
-SSL *s;
-int type;
-char *buf;
-unsigned int len;
+static int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
+                         unsigned int len, int create_empty_fragment)
         {
         unsigned char *p,*plen;
         int i,mac_size,clear=0;
+        int prefix_len = 0;
         SSL3_RECORD *wr;
         SSL3_BUFFER *wb;
         SSL_SESSION *sess;
 
-        /* first check is there is a SSL3_RECORD still being written
+        /* first check if there is a SSL3_BUFFER still being written
          * out.  This will happen with non blocking IO */
         if (s->s3->wbuf.left != 0)
                 return(ssl3_write_pending(s,type,buf,len));
@@ -514,8 +571,9 @@ unsigned int len;
                 /* if it went, fall through and send more stuff */
                 }
 
-        if (len <= 0) return(len);
-        
+        if (len == 0 && !create_empty_fragment)
+                return 0;
+
         wr= &(s->s3->wrec);
         wb= &(s->s3->wbuf);
         sess=s->session;
@@ -530,19 +588,47 @@ unsigned int len;
         else
                 mac_size=EVP_MD_size(s->write_hash);
 
-        p=wb->buf;
+        /* 'create_empty_fragment' is true only when this function calls itself */
+        if (!clear && !create_empty_fragment && !s->s3->empty_fragment_done)
+                {
+                /* countermeasure against known-IV weakness in CBC ciphersuites
+                 * (see http://www.openssl.org/~bodo/tls-cbc.txt) */
+
+                if (s->s3->need_empty_fragments && type == SSL3_RT_APPLICATION_DATA)
+                        {
+                        /* recursive function call with 'create_empty_fragment' set;
+                         * this prepares and buffers the data for an empty fragment
+                         * (these 'prefix_len' bytes are sent out later
+                         * together with the actual payload) */
+                        prefix_len = do_ssl3_write(s, type, buf, 0, 1);
+                        if (prefix_len <= 0)
+                                goto err;
+
+                        if (s->s3->wbuf.len < (size_t)prefix_len + SSL3_RT_MAX_PACKET_SIZE)
+                                {
+                                /* insufficient space */
+                                SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);
+                                goto err;
+                                }
+                        }
+                
+                s->s3->empty_fragment_done = 1;
+                }
+
+        p = wb->buf + prefix_len;
 
         /* write the header */
+
         *(p++)=type&0xff;
         wr->type=type;
 
         *(p++)=(s->version>>8);
         *(p++)=s->version&0xff;
-        
-        /* record where we are to write out packet length */
+
+        /* field where we are to write out packet length */
         plen=p; 
         p+=2;
-        
+
         /* lets setup the record stuff. */
         wr->data=p;
         wr->length=(int)len;
@@ -552,7 +638,7 @@ unsigned int len;
          * wr->data */
 
         /* first we compress */
-        if ((sess != NULL) && (sess->write_compression != NULL))
+        if (s->compress != NULL)
                 {
                 if (!do_compress(s))
                         {
@@ -590,32 +676,40 @@ unsigned int len;
         wr->type=type; /* not needed but helps for debugging */
         wr->length+=SSL3_RT_HEADER_LENGTH;
 
-        /* Now lets setup wb */
-        wb->left=wr->length;
-        wb->offset=0;
+        if (create_empty_fragment)
+                {
+                /* we are in a recursive call;
+                 * just return the length, don't write out anything here
+                 */
+                return wr->length;
+                }
+
+        /* now let's set up wb */
+        wb->left = prefix_len + wr->length;
+        wb->offset = 0;
 
+        /* memorize arguments so that ssl3_write_pending can detect bad write retries later */
         s->s3->wpend_tot=len;
         s->s3->wpend_buf=buf;
         s->s3->wpend_type=type;
         s->s3->wpend_ret=len;
 
         /* we now just need to write the buffer */
-        return(ssl3_write_pending(s,type,buf,len));
+        return ssl3_write_pending(s,type,buf,len);
 err:
-        return(-1);
+        return -1;
         }
 
 /* if s->s3->wbuf.left != 0, we need to call this */
-static int ssl3_write_pending(s,type,buf,len)
-SSL *s;
-int type;
-char *buf;
-unsigned int len;
+static int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
+                              unsigned int len)
         {
         int i;
 
 /* XXXX */
-        if ((s->s3->wpend_tot > (int)len) || (s->s3->wpend_buf != buf)
+        if ((s->s3->wpend_tot > (int)len)
+                || ((s->s3->wpend_buf != buf) &&
+                        !(s->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER))
                 || (s->s3->wpend_type != type))
                 {
                 SSLerr(SSL_F_SSL3_WRITE_PENDING,SSL_R_BAD_WRITE_RETRY);
@@ -650,23 +744,77 @@ unsigned int len;
                 }
         }
 
-int ssl3_read_bytes(s,type,buf,len)
-SSL *s;
-int type;
-char *buf;
-int len;
+/* Return up to 'len' payload bytes received in 'type' records.
+ * 'type' is one of the following:
+ *
+ *   -  SSL3_RT_HANDSHAKE (when ssl3_get_message calls us)
+ *   -  SSL3_RT_APPLICATION_DATA (when ssl3_read calls us)
+ *   -  0 (during a shutdown, no data has to be returned)
+ *
+ * If we don't have stored data to work from, read a SSL/TLS record first
+ * (possibly multiple records if we still don't have anything to return).
+ *
+ * This function must handle any surprises the peer may have for us, such as
+ * Alert records (e.g. close_notify), ChangeCipherSpec records (not really
+ * a surprise, but handled as if it were), or renegotiation requests.
+ * Also if record payloads contain fragments too small to process, we store
+ * them until there is enough for the respective protocol (the record protocol
+ * may use arbitrary fragmentation and even interleaving):
+ *     Change cipher spec protocol
+ *             just 1 byte needed, no need for keeping anything stored
+ *     Alert protocol
+ *             2 bytes needed (AlertLevel, AlertDescription)
+ *     Handshake protocol
+ *             4 bytes needed (HandshakeType, uint24 length) -- we just have
+ *             to detect unexpected Client Hello and Hello Request messages
+ *             here, anything else is handled by higher layers
+ *     Application data protocol
+ *             none of our business
+ */
+int ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
         {
-        int al,i,j,n,ret;
+        int al,i,j,ret;
+        unsigned int n;
         SSL3_RECORD *rr;
-        void (*cb)()=NULL;
-        BIO *bio;
+        void (*cb)(const SSL *ssl,int type2,int val)=NULL;
 
-        if (s->s3->rbuf.buf == NULL) /* Not initalised yet */
+        if (s->s3->rbuf.buf == NULL) /* Not initialized yet */
                 if (!ssl3_setup_buffers(s))
                         return(-1);
 
+        if ((type && (type != SSL3_RT_APPLICATION_DATA) && (type != SSL3_RT_HANDSHAKE) && type) ||
+            (peek && (type != SSL3_RT_APPLICATION_DATA)))
+                {
+                SSLerr(SSL_F_SSL3_READ_BYTES, ERR_R_INTERNAL_ERROR);
+                return -1;
+                }
+
+        if ((type == SSL3_RT_HANDSHAKE) && (s->s3->handshake_fragment_len > 0))
+                /* (partially) satisfy request from storage */
+                {
+                unsigned char *src = s->s3->handshake_fragment;
+                unsigned char *dst = buf;
+                unsigned int k;
+
+                /* peek == 0 */
+                n = 0;
+                while ((len > 0) && (s->s3->handshake_fragment_len > 0))
+                        {
+                        *dst++ = *src++;
+                        len--; s->s3->handshake_fragment_len--;
+                        n++;
+                        }
+                /* move any remaining fragment bytes: */
+                for (k = 0; k < s->s3->handshake_fragment_len; k++)
+                        s->s3->handshake_fragment[k] = *src++;
+                return n;
+        }
+
+        /* Now s->s3->handshake_fragment_len == 0 if type == SSL3_RT_HANDSHAKE. */
+
         if (!s->in_handshake && SSL_in_init(s))
                 {
+                /* type == SSL3_RT_APPLICATION_DATA */
                 i=s->handshake_func(s);
                 if (i < 0) return(i);
                 if (i == 0)
@@ -678,13 +826,13 @@ int len;
 start:
         s->rwstate=SSL_NOTHING;
 
-        /* s->s3->rrec.type     - is the type of record
-         * s->s3->rrec.data,    - data
-         * s->s3->rrec.off,     - ofset into 'data' for next read
-         * s->s3->rrec.length,  - number of bytes. */
-        rr= &(s->s3->rrec);
+        /* s->s3->rrec.type         - is the type of record
+         * s->s3->rrec.data,    - data
+         * s->s3->rrec.off,     - offset into 'data' for next read
+         * s->s3->rrec.length,  - number of bytes. */
+        rr = &(s->s3->rrec);
 
-        /* get new packet */
+        /* get new packet if necessary */
         if ((rr->length == 0) || (s->rstate == SSL_ST_READ_BODY))
                 {
                 ret=ssl3_get_record(s);
@@ -693,14 +841,17 @@ start:
 
         /* we now have a packet which can be read and processed */
 
-        if (s->s3->change_cipher_spec && (rr->type != SSL3_RT_HANDSHAKE))
+        if (s->s3->change_cipher_spec /* set when we receive ChangeCipherSpec,
+                                       * reset by ssl3_get_finished */
+                && (rr->type != SSL3_RT_HANDSHAKE))
                 {
                 al=SSL_AD_UNEXPECTED_MESSAGE;
                 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_DATA_BETWEEN_CCS_AND_FINISHED);
                 goto err;
                 }
 
-        /* If the other end has shutdown, throw anything we read away */
+        /* If the other end has shut down, throw anything we read away
+         * (even in 'peek' mode) */
         if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
                 {
                 rr->length=0;
@@ -708,19 +859,107 @@ start:
                 return(0);
                 }
 
-        /* Check for an incoming 'Client Request' message */
-        if ((rr->type == SSL3_RT_HANDSHAKE) && (rr->length == 4) &&
-                (rr->data[0] == SSL3_MT_CLIENT_REQUEST) &&
+
+        if (type == rr->type) /* SSL3_RT_APPLICATION_DATA or SSL3_RT_HANDSHAKE */
+                {
+                /* make sure that we are not getting application data when we
+                 * are doing a handshake for the first time */
+                if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) &&
+                        (s->enc_read_ctx == NULL))
+                        {
+                        al=SSL_AD_UNEXPECTED_MESSAGE;
+                        SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_APP_DATA_IN_HANDSHAKE);
+                        goto f_err;
+                        }
+
+                if (len <= 0) return(len);
+
+                if ((unsigned int)len > rr->length)
+                        n = rr->length;
+                else
+                        n = (unsigned int)len;
+
+                memcpy(buf,&(rr->data[rr->off]),n);
+                if (!peek)
+                        {
+                        rr->length-=n;
+                        rr->off+=n;
+                        if (rr->length == 0)
+                                {
+                                s->rstate=SSL_ST_READ_HEADER;
+                                rr->off=0;
+                                }
+                        }
+                return(n);
+                }
+
+
+        /* If we get here, then type != rr->type; if we have a handshake
+         * message, then it was unexpected (Hello Request or Client Hello). */
+
+        /* In case of record types for which we have 'fragment' storage,
+         * fill that so that we can process the data at a fixed place.
+         */
+                {
+                unsigned int dest_maxlen = 0;
+                unsigned char *dest = NULL;
+                unsigned int *dest_len = NULL;
+
+                if (rr->type == SSL3_RT_HANDSHAKE)
+                        {
+                        dest_maxlen = sizeof s->s3->handshake_fragment;
+                        dest = s->s3->handshake_fragment;
+                        dest_len = &s->s3->handshake_fragment_len;
+                        }
+                else if (rr->type == SSL3_RT_ALERT)
+                        {
+                        dest_maxlen = sizeof s->s3->alert_fragment;
+                        dest = s->s3->alert_fragment;
+                        dest_len = &s->s3->alert_fragment_len;
+                        }
+
+                if (dest_maxlen > 0)
+                        {
+                        n = dest_maxlen - *dest_len; /* available space in 'dest' */
+                        if (rr->length < n)
+                                n = rr->length; /* available bytes */
+
+                        /* now move 'n' bytes: */
+                        while (n-- > 0)
+                                {
+                                dest[(*dest_len)++] = rr->data[rr->off++];
+                                rr->length--;
+                                }
+
+                        if (*dest_len < dest_maxlen)
+                                goto start; /* fragment was too small */
+                        }
+                }
+
+        /* s->s3->handshake_fragment_len == 4  iff  rr->type == SSL3_RT_HANDSHAKE;
+         * s->s3->alert_fragment_len == 2      iff  rr->type == SSL3_RT_ALERT.
+         * (Possibly rr is 'empty' now, i.e. rr->length may be 0.) */
+
+        /* If we are a client, check for an incoming 'Hello Request': */
+        if ((!s->server) &&
+                (s->s3->handshake_fragment_len >= 4) &&
+                (s->s3->handshake_fragment[0] == SSL3_MT_HELLO_REQUEST) &&
                 (s->session != NULL) && (s->session->cipher != NULL))
                 {
-                if ((rr->data[1] != 0) || (rr->data[2] != 0) ||
-                        (rr->data[3] != 0))
+                s->s3->handshake_fragment_len = 0;
+
+                if ((s->s3->handshake_fragment[1] != 0) ||
+                        (s->s3->handshake_fragment[2] != 0) ||
+                        (s->s3->handshake_fragment[3] != 0))
                         {
                         al=SSL_AD_DECODE_ERROR;
-                        SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_BAD_CLIENT_REQUEST);
+                        SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_BAD_HELLO_REQUEST);
                         goto err;
                         }
 
+                if (s->msg_callback)
+                        s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, s->s3->handshake_fragment, 4, s, s->msg_callback_arg);
+
                 if (SSL_is_init_finished(s) &&
                         !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS) &&
                         !s->s3->renegotiate)
@@ -728,228 +967,231 @@ start:
                         ssl3_renegotiate(s);
                         if (ssl3_renegotiate_check(s))
                                 {
-                                n=s->handshake_func(s);
-                                if (n < 0) return(n);
-                                if (n == 0)
+                                i=s->handshake_func(s);
+                                if (i < 0) return(i);
+                                if (i == 0)
                                         {
                                         SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE);
                                         return(-1);
                                         }
+
+                                if (!(s->mode & SSL_MODE_AUTO_RETRY))
+                                        {
+                                        if (s->s3->rbuf.left == 0) /* no read-ahead left? */
+                                                {
+                                                BIO *bio;
+                                                /* In the case where we try to read application data,
+                                                 * but we trigger an SSL handshake, we return -1 with
+                                                 * the retry option set.  Otherwise renegotiation may
+                                                 * cause nasty problems in the blocking world */
+                                                s->rwstate=SSL_READING;
+                                                bio=SSL_get_rbio(s);
+                                                BIO_clear_retry_flags(bio);
+                                                BIO_set_retry_read(bio);
+                                                return(-1);
+                                                }
+                                        }
                                 }
                         }
-                rr->length=0;
-/* ZZZ */       goto start;
+                /* we either finished a handshake or ignored the request,
+                 * now try again to obtain the (application) data we were asked for */
+                goto start;
                 }
 
-        /* if it is not the type we want, or we have shutdown and want
-         * the peer shutdown */
-        if ((rr->type != type) || (s->shutdown & SSL_SENT_SHUTDOWN))
+        if (s->s3->alert_fragment_len >= 2)
                 {
-                if (rr->type == SSL3_RT_ALERT)
-                        {
-                        if ((rr->length != 2) || (rr->off != 0))
-                                {
-                                al=SSL_AD_DECODE_ERROR;
-                                SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_BAD_ALERT_RECORD);
-                                goto f_err;
-                                }
+                int alert_level = s->s3->alert_fragment[0];
+                int alert_descr = s->s3->alert_fragment[1];
 
-                        i=rr->data[0];
-                        n=rr->data[1];
+                s->s3->alert_fragment_len = 0;
 
-                        /* clear from buffer */
-                        rr->length=0;
+                if (s->msg_callback)
+                        s->msg_callback(0, s->version, SSL3_RT_ALERT, s->s3->alert_fragment, 2, s, s->msg_callback_arg);
 
-                        if (s->info_callback != NULL)
-                                cb=s->info_callback;
-                        else if (s->ctx->info_callback != NULL)
-                                cb=s->ctx->info_callback;
+                if (s->info_callback != NULL)
+                        cb=s->info_callback;
+                else if (s->ctx->info_callback != NULL)
+                        cb=s->ctx->info_callback;
 
-                        if (cb != NULL)
-                                {
-                                j=(i<<8)|n;
-                                cb(s,SSL_CB_READ_ALERT,j);
-                                }
+                if (cb != NULL)
+                        {
+                        j = (alert_level << 8) | alert_descr;
+                        cb(s, SSL_CB_READ_ALERT, j);
+                        }
 
-                        if (i == 1)
-                                {
-                                s->s3->warn_alert=n;
-                                if (n == SSL_AD_CLOSE_NOTIFY)
-                                        {
-                                        s->shutdown|=SSL_RECEIVED_SHUTDOWN;
-                                        return(0);
-                                        }
-                                }
-                        else if (i == 2)
+                if (alert_level == 1) /* warning */
+                        {
+                        s->s3->warn_alert = alert_descr;
+                        if (alert_descr == SSL_AD_CLOSE_NOTIFY)
                                 {
-                                char tmp[16];
-
-                                s->rwstate=SSL_NOTHING;
-                                s->s3->fatal_alert=n;
-                                SSLerr(SSL_F_SSL3_READ_BYTES,1000+n);
-                                sprintf(tmp,"%d",n);
-                                ERR_add_error_data(2,"SSL alert number ",tmp);
-                                s->shutdown|=SSL_RECEIVED_SHUTDOWN;
-                                SSL_CTX_remove_session(s->ctx,s->session);
+                                s->shutdown |= SSL_RECEIVED_SHUTDOWN;
                                 return(0);
                                 }
-                        else
-                                {
-                                al=SSL_AD_ILLEGAL_PARAMETER;
-                                SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNKNOWN_ALERT_TYPE);
-                                goto f_err;
-                                }
-
-                        rr->length=0;
-                        goto start;
                         }
-
-                if (s->shutdown & SSL_SENT_SHUTDOWN)
+                else if (alert_level == 2) /* fatal */
                         {
+                        char tmp[16];
+
                         s->rwstate=SSL_NOTHING;
-                        rr->length=0;
+                        s->s3->fatal_alert = alert_descr;
+                        SSLerr(SSL_F_SSL3_READ_BYTES, SSL_AD_REASON_OFFSET + alert_descr);
+                        BIO_snprintf(tmp,sizeof tmp,"%d",alert_descr);
+                        ERR_add_error_data(2,"SSL alert number ",tmp);
+                        s->shutdown|=SSL_RECEIVED_SHUTDOWN;
+                        SSL_CTX_remove_session(s->ctx,s->session);
                         return(0);
                         }
-
-                if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC)
+                else
                         {
-                        if (    (rr->length != 1) || (rr->off != 0) ||
-                                (rr->data[0] != SSL3_MT_CCS))
-                                {
-                                i=SSL_AD_ILLEGAL_PARAMETER;
-                                SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_BAD_CHANGE_CIPHER_SPEC);
-                                goto err;
-                                }
-
-                        rr->length=0;
-                        s->s3->change_cipher_spec=1;
-                        if (!do_change_cipher_spec(s))
-                                goto err;
-                        else
-                                goto start;
+                        al=SSL_AD_ILLEGAL_PARAMETER;
+                        SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNKNOWN_ALERT_TYPE);
+                        goto f_err;
                         }
 
-                /* else we have a handshake */
-                if ((rr->type == SSL3_RT_HANDSHAKE) &&
-                        !s->in_handshake)
+                goto start;
+                }
+
+        if (s->shutdown & SSL_SENT_SHUTDOWN) /* but we have not received a shutdown */
+                {
+                s->rwstate=SSL_NOTHING;
+                rr->length=0;
+                return(0);
+                }
+
+        if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC)
+                {
+                /* 'Change Cipher Spec' is just a single byte, so we know
+                 * exactly what the record payload has to look like */
+                if (    (rr->length != 1) || (rr->off != 0) ||
+                        (rr->data[0] != SSL3_MT_CCS))
                         {
-                        if (((s->state&SSL_ST_MASK) == SSL_ST_OK) &&
-                                !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS))
-                                {
-                                s->state=SSL_ST_BEFORE;
-                                s->new_session=1;
-                                }
-                        n=s->handshake_func(s);
-                        if (n < 0) return(n);
-                        if (n == 0)
-                                {
-                                SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE);
-                                return(-1);
-                                }
+                        i=SSL_AD_ILLEGAL_PARAMETER;
+                        SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_BAD_CHANGE_CIPHER_SPEC);
+                        goto err;
+                        }
+
+                rr->length=0;
 
-                        /* In the case where we try to read application data
-                         * the first time, but we trigger an SSL handshake, we
-                         * return -1 with the retry option set.  I do this
-                         * otherwise renegotiation can cause nasty problems 
-                         * in the non-blocking world */
+                if (s->msg_callback)
+                        s->msg_callback(0, s->version, SSL3_RT_CHANGE_CIPHER_SPEC, rr->data, 1, s, s->msg_callback_arg);
 
-                        s->rwstate=SSL_READING;
-                        bio=SSL_get_rbio(s);
-                        BIO_clear_retry_flags(bio);
-                        BIO_set_retry_read(bio);
+                s->s3->change_cipher_spec=1;
+                if (!do_change_cipher_spec(s))
+                        goto err;
+                else
+                        goto start;
+                }
+
+        /* Unexpected handshake message (Client Hello, or protocol violation) */
+        if ((s->s3->handshake_fragment_len >= 4) &&     !s->in_handshake)
+                {
+                if (((s->state&SSL_ST_MASK) == SSL_ST_OK) &&
+                        !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS))
+                        {
+#if 0 /* worked only because C operator preferences are not as expected (and
+       * because this is not really needed for clients except for detecting
+       * protocol violations): */
+                        s->state=SSL_ST_BEFORE|(s->server)
+                                ?SSL_ST_ACCEPT
+                                :SSL_ST_CONNECT;
+#else
+                        s->state = s->server ? SSL_ST_ACCEPT : SSL_ST_CONNECT;
+#endif
+                        s->new_session=1;
+                        }
+                i=s->handshake_func(s);
+                if (i < 0) return(i);
+                if (i == 0)
+                        {
+                        SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE);
                         return(-1);
                         }
 
-                switch (rr->type)
+                if (!(s->mode & SSL_MODE_AUTO_RETRY))
                         {
-                default:
-#ifndef NO_TLS
-                        /* TLS just ignores unknown message types */
-                        if (s->version == TLS1_VERSION)
-                                {
-                                goto start;
-                                }
-#endif
-                case SSL3_RT_CHANGE_CIPHER_SPEC:
-                case SSL3_RT_ALERT:
-                case SSL3_RT_HANDSHAKE:
-                        al=SSL_AD_UNEXPECTED_MESSAGE;
-                        SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD);
-                        goto f_err;
-                case SSL3_RT_APPLICATION_DATA:
-                        /* At this point, we were expecting something else,
-                         * but have application data.  What we do is set the
-                         * error, and return -1.  On the way out, if the
-                         * library was running inside ssl3_read() and it makes
-                         * sense to read application data at this point, we
-                         * will indulge it.  This will mostly happen during
-                         * session renegotiation.
-                         */
-                        if (s->s3->in_read_app_data &&
-                                (s->s3->total_renegotiations != 0) &&
-                                ((
-                                  (s->state & SSL_ST_CONNECT) &&
-                                  (s->state >= SSL3_ST_CW_CLNT_HELLO_A) &&
-                                  (s->state <= SSL3_ST_CR_SRVR_HELLO_A)
-                                 ) || (
-                                  (s->state & SSL_ST_ACCEPT) &&
-                                  (s->state <= SSL3_ST_SW_HELLO_REQ_A) &&
-                                  (s->state >= SSL3_ST_SR_CLNT_HELLO_A)
-                                 )
-                                ))
+                        if (s->s3->rbuf.left == 0) /* no read-ahead left? */
                                 {
-                                s->s3->in_read_app_data=0;
+                                BIO *bio;
+                                /* In the case where we try to read application data,
+                                 * but we trigger an SSL handshake, we return -1 with
+                                 * the retry option set.  Otherwise renegotiation may
+                                 * cause nasty problems in the blocking world */
+                                s->rwstate=SSL_READING;
+                                bio=SSL_get_rbio(s);
+                                BIO_clear_retry_flags(bio);
+                                BIO_set_retry_read(bio);
                                 return(-1);
                                 }
-                        else
-                                {
-                                al=SSL_AD_UNEXPECTED_MESSAGE;
-                                SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD);
-                                goto f_err;
-                                }
                         }
+                goto start;
                 }
 
-        /* make sure that we are not getting application data when we
-         * are doing a handshake for the first time */
-        if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) &&
-                (s->enc_read_ctx == NULL))
+        switch (rr->type)
                 {
+        default:
+#ifndef OPENSSL_NO_TLS
+                /* TLS just ignores unknown message types */
+                if (s->version == TLS1_VERSION)
+                        {
+                        rr->length = 0;
+                        goto start;
+                        }
+#endif
                 al=SSL_AD_UNEXPECTED_MESSAGE;
-                SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_APP_DATA_IN_HANDSHAKE);
+                SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD);
                 goto f_err;
+        case SSL3_RT_CHANGE_CIPHER_SPEC:
+        case SSL3_RT_ALERT:
+        case SSL3_RT_HANDSHAKE:
+                /* we already handled all of these, with the possible exception
+                 * of SSL3_RT_HANDSHAKE when s->in_handshake is set, but that
+                 * should not happen when type != rr->type */
+                al=SSL_AD_UNEXPECTED_MESSAGE;
+                SSLerr(SSL_F_SSL3_READ_BYTES,ERR_R_INTERNAL_ERROR);
+                goto f_err;
+        case SSL3_RT_APPLICATION_DATA:
+                /* At this point, we were expecting handshake data,
+                 * but have application data.  If the library was
+                 * running inside ssl3_read() (i.e. in_read_app_data
+                 * is set) and it makes sense to read application data
+                 * at this point (session renegotiation not yet started),
+                 * we will indulge it.
+                 */
+                if (s->s3->in_read_app_data &&
+                        (s->s3->total_renegotiations != 0) &&
+                        ((
+                                (s->state & SSL_ST_CONNECT) &&
+                                (s->state >= SSL3_ST_CW_CLNT_HELLO_A) &&
+                                (s->state <= SSL3_ST_CR_SRVR_HELLO_A)
+                                ) || (
+                                        (s->state & SSL_ST_ACCEPT) &&
+                                        (s->state <= SSL3_ST_SW_HELLO_REQ_A) &&
+                                        (s->state >= SSL3_ST_SR_CLNT_HELLO_A)
+                                        )
+                                ))
+                        {
+                        s->s3->in_read_app_data=2;
+                        return(-1);
+                        }
+                else
+                        {
+                        al=SSL_AD_UNEXPECTED_MESSAGE;
+                        SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD);
+                        goto f_err;
+                        }
                 }
+        /* not reached */
 
-        if (len <= 0) return(len);
-
-        if ((unsigned int)len > rr->length)
-                n=rr->length;
-        else
-                n=len;
-
-        memcpy(buf,&(rr->data[rr->off]),(unsigned int)n);
-        rr->length-=n;
-        rr->off+=n;
-        if (rr->length <= 0)
-                {
-                s->rstate=SSL_ST_READ_HEADER;
-                rr->off=0;
-                }
-
-        if (type == SSL3_RT_HANDSHAKE)
-                ssl3_finish_mac(s,(unsigned char *)buf,n);
-        return(n);
 f_err:
         ssl3_send_alert(s,SSL3_AL_FATAL,al);
 err:
         return(-1);
         }
 
-static int do_change_cipher_spec(s)
-SSL *s;
+static int do_change_cipher_spec(SSL *s)
         {
         int i;
-        unsigned char *sender;
+        const char *sender;
         int slen;
 
         if (s->state & SSL_ST_ACCEPT)
@@ -971,46 +1213,29 @@ SSL *s;
          * the finished message */
         if (s->state & SSL_ST_CONNECT)
                 {
-                sender=s->method->ssl3_enc->server_finished;
-                slen=s->method->ssl3_enc->server_finished_len;
+                sender=s->method->ssl3_enc->server_finished_label;
+                slen=s->method->ssl3_enc->server_finished_label_len;
                 }
         else
                 {
-                sender=s->method->ssl3_enc->client_finished;
-                slen=s->method->ssl3_enc->client_finished_len;
+                sender=s->method->ssl3_enc->client_finished_label;
+                slen=s->method->ssl3_enc->client_finished_label_len;
                 }
 
-        s->method->ssl3_enc->final_finish_mac(s,
+        s->s3->tmp.peer_finish_md_len = s->method->ssl3_enc->final_finish_mac(s,
                 &(s->s3->finish_dgst1),
                 &(s->s3->finish_dgst2),
-                sender,slen,&(s->s3->tmp.finish_md[0]));
+                sender,slen,s->s3->tmp.peer_finish_md);
 
         return(1);
         }
 
-int ssl3_do_write(s,type)
-SSL *s;
-int type;
-        {
-        int ret;
-
-        ret=ssl3_write_bytes(s,type,(char *)
-                &(s->init_buf->data[s->init_off]),s->init_num);
-        if (ret == s->init_num)
-                return(1);
-        if (ret < 0) return(-1);
-        s->init_off+=ret;
-        s->init_num-=ret;
-        return(0);
-        }
-
-void ssl3_send_alert(s,level,desc)
-SSL *s;
-int level;
-int desc;
+void ssl3_send_alert(SSL *s, int level, int desc)
         {
         /* Map tls/ssl alert value to correct one */
         desc=s->method->ssl3_enc->alert_value(desc);
+        if (s->version == SSL3_VERSION && desc == SSL_AD_PROTOCOL_VERSION)
+                desc = SSL_AD_HANDSHAKE_FAILURE; /* SSL 3.0 does not have protocol_version alerts */
         if (desc < 0) return;
         /* If a fatal one, remove from cache */
         if ((level == 2) && (s->session != NULL))
@@ -1019,37 +1244,39 @@ int desc;
         s->s3->alert_dispatch=1;
         s->s3->send_alert[0]=level;
         s->s3->send_alert[1]=desc;
-        if (s->s3->wbuf.left == 0) /* data still being written out */
+        if (s->s3->wbuf.left == 0) /* data still being written out? */
                 ssl3_dispatch_alert(s);
         /* else data is still being written out, we will get written
          * some time in the future */
         }
 
-int ssl3_dispatch_alert(s)
-SSL *s;
+int ssl3_dispatch_alert(SSL *s)
         {
         int i,j;
-        void (*cb)()=NULL;
+        void (*cb)(const SSL *ssl,int type,int val)=NULL;
 
         s->s3->alert_dispatch=0;
-        i=do_ssl3_write(s,SSL3_RT_ALERT,&(s->s3->send_alert[0]),2);
+        i = do_ssl3_write(s, SSL3_RT_ALERT, &s->s3->send_alert[0], 2, 0);
         if (i <= 0)
                 {
                 s->s3->alert_dispatch=1;
                 }
         else
                 {
-                /* If it is important, send it now.  If the message
-                 * does not get sent due to non-blocking IO, we will
-                 * not worry too much. */
+                /* Alert sent to BIO.  If it is important, flush it now.
+                 * If the message does not get sent due to non-blocking IO,
+                 * we will not worry too much. */
                 if (s->s3->send_alert[0] == SSL3_AL_FATAL)
-                        BIO_flush(s->wbio);
+                        (void)BIO_flush(s->wbio);
+
+                if (s->msg_callback)
+                        s->msg_callback(1, s->version, SSL3_RT_ALERT, s->s3->send_alert, 2, s, s->msg_callback_arg);
 
                 if (s->info_callback != NULL)
                         cb=s->info_callback;
                 else if (s->ctx->info_callback != NULL)
                         cb=s->ctx->info_callback;
-                
+
                 if (cb != NULL)
                         {
                         j=(s->s3->send_alert[0]<<8)|s->s3->send_alert[1];
@@ -1058,4 +1285,3 @@ SSL *s;
                 }
         return(i);
         }
-
diff --git a/src/lib/libssl/s3_srvr.c b/src/lib/libssl/s3_srvr.c
index 64903af151..99b6a86983 100644
--- a/src/lib/libssl/s3_srvr.c
+++ b/src/lib/libssl/s3_srvr.c
@@ -55,52 +55,88 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
+/* ====================================================================
+ * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
 
 #define REUSE_CIPHER_BUG
+#define NETSCAPE_HANG_BUG
+
 
 #include <stdio.h>
-#include "buffer.h"
-#include "rand.h"
-#include "objects.h"
-#include "evp.h"
-#include "x509.h"
+#include <openssl/buffer.h>
+#include <openssl/rand.h>
+#include <openssl/objects.h>
+#include <openssl/evp.h>
+#include <openssl/x509.h>
+#include <openssl/krb5_asn.h>
 #include "ssl_locl.h"
+#include "kssl_lcl.h"
+#include <openssl/md5.h>
 
-#define BREAK   break
-/* SSLerr(SSL_F_SSL3_ACCEPT,ERR_R_MALLOC_FAILURE);
- * SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,ERR_R_MALLOC_FAILURE);
- * SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,ERR_R_MALLOC_FAILURE);
- * SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,ERR_R_MALLOC_FAILURE);
- * SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,ERR_R_MALLOC_FAILURE);
- */
-
-#ifndef NOPROTO
+static SSL_METHOD *ssl3_get_server_method(int ver);
 static int ssl3_get_client_hello(SSL *s);
+static int ssl3_check_client_hello(SSL *s);
 static int ssl3_send_server_hello(SSL *s);
 static int ssl3_send_server_key_exchange(SSL *s);
 static int ssl3_send_certificate_request(SSL *s);
 static int ssl3_send_server_done(SSL *s);
-static int ssl3_get_cert_verify(SSL *s);
 static int ssl3_get_client_key_exchange(SSL *s);
 static int ssl3_get_client_certificate(SSL *s);
+static int ssl3_get_cert_verify(SSL *s);
 static int ssl3_send_hello_request(SSL *s);
 
-#else
-
-static int ssl3_get_client_hello();
-static int ssl3_send_server_hello();
-static int ssl3_send_server_key_exchange();
-static int ssl3_send_certificate_request();
-static int ssl3_send_server_done();
-static int ssl3_get_cert_verify();
-static int ssl3_get_client_key_exchange();
-static int ssl3_get_client_certificate();
-static int ssl3_send_hello_request();
-
-#endif
-
-static SSL_METHOD *ssl3_get_server_method(ver)
-int ver;
+static SSL_METHOD *ssl3_get_server_method(int ver)
         {
         if (ver == SSL3_VERSION)
                 return(SSLv3_server_method());
@@ -108,35 +144,32 @@ int ver;
                 return(NULL);
         }
 
-SSL_METHOD *SSLv3_server_method()
+SSL_METHOD *SSLv3_server_method(void)
         {
         static int init=1;
         static SSL_METHOD SSLv3_server_data;
 
         if (init)
                 {
-                init=0;
                 memcpy((char *)&SSLv3_server_data,(char *)sslv3_base_method(),
                         sizeof(SSL_METHOD));
                 SSLv3_server_data.ssl_accept=ssl3_accept;
                 SSLv3_server_data.get_ssl_method=ssl3_get_server_method;
+                init=0;
                 }
         return(&SSLv3_server_data);
         }
 
-int ssl3_accept(s)
-SSL *s;
+int ssl3_accept(SSL *s)
         {
         BUF_MEM *buf;
         unsigned long l,Time=time(NULL);
-        void (*cb)()=NULL;
+        void (*cb)(const SSL *ssl,int type,int val)=NULL;
         long num1;
         int ret= -1;
-        CERT *ct;
-        BIO *under;
         int new_state,state,skip=0;
 
-        RAND_seed((unsigned char *)&Time,sizeof(Time));
+        RAND_add(&Time,sizeof(Time),0);
         ERR_clear_error();
         clear_sys_error();
 
@@ -146,20 +179,14 @@ SSL *s;
                 cb=s->ctx->info_callback;
 
         /* init things to blank */
-        if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s);
         s->in_handshake++;
+        if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s);
 
-#ifdef undef
-        /* FIX THIS EAY EAY EAY */
-        /* we don't actually need a cert, we just need a cert or a DH_tmp */
-        if (((s->session == NULL) || (s->session->cert == NULL)) &&
-                (s->cert == NULL))
+        if (s->cert == NULL)
                 {
                 SSLerr(SSL_F_SSL3_ACCEPT,SSL_R_NO_CERTIFICATE_SET);
-                ret= -1;
-                goto end;
+                return(-1);
                 }
-#endif
 
         for (;;)
                 {
@@ -176,11 +203,14 @@ SSL *s;
                 case SSL_ST_BEFORE|SSL_ST_ACCEPT:
                 case SSL_ST_OK|SSL_ST_ACCEPT:
 
+                        s->server=1;
                         if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
 
                         if ((s->version>>8) != 3)
-                                abort();
-                        /* s->version=SSL3_VERSION; */
+                                {
+                                SSLerr(SSL_F_SSL3_ACCEPT, ERR_R_INTERNAL_ERROR);
+                                return -1;
+                                }
                         s->type=SSL_ST_ACCEPT;
 
                         if (s->init_buf == NULL)
@@ -204,22 +234,24 @@ SSL *s;
                                 goto end;
                                 }
 
-                        /* Ok, we now need to push on a buffering BIO so that
-                         * the output is sent in a way that TCP likes :-)
-                         */
-                        if (!ssl_init_wbio_buffer(s,1)) { ret= -1; goto end; }
-
                         s->init_num=0;
 
                         if (s->state != SSL_ST_RENEGOTIATE)
                                 {
-                                s->state=SSL3_ST_SR_CLNT_HELLO_A;
+                                /* Ok, we now need to push on a buffering BIO so that
+                                 * the output is sent in a way that TCP likes :-)
+                                 */
+                                if (!ssl_init_wbio_buffer(s,1)) { ret= -1; goto end; }
+                                
                                 ssl3_init_finished_mac(s);
-                                s->ctx->sess_accept++;
+                                s->state=SSL3_ST_SR_CLNT_HELLO_A;
+                                s->ctx->stats.sess_accept++;
                                 }
                         else
                                 {
-                                s->ctx->sess_accept_renegotiate++;
+                                /* s->state == SSL_ST_RENEGOTIATE,
+                                 * we will just send a HelloRequest */
+                                s->ctx->stats.sess_accept_renegotiate++;
                                 s->state=SSL3_ST_SW_HELLO_REQ_A;
                                 }
                         break;
@@ -238,19 +270,8 @@ SSL *s;
                         break;
 
                 case SSL3_ST_SW_HELLO_REQ_C:
-                        /* remove buffering on output */
-                        under=BIO_pop(s->wbio);
-                        if (under != NULL)
-                                s->wbio=under;
-                        else
-                                abort(); /* ok */
-                        BIO_free(s->bbio);
-                        s->bbio=NULL;
-
                         s->state=SSL_ST_OK;
-                        ret=1;
-                        goto end;
-                        /* break; */
+                        break;
 
                 case SSL3_ST_SR_CLNT_HELLO_A:
                 case SSL3_ST_SR_CLNT_HELLO_B:
@@ -259,6 +280,7 @@ SSL *s;
                         s->shutdown=0;
                         ret=ssl3_get_client_hello(s);
                         if (ret <= 0) goto end;
+                        s->new_session = 2;
                         s->state=SSL3_ST_SW_SRVR_HELLO_A;
                         s->init_num=0;
                         break;
@@ -292,40 +314,34 @@ SSL *s;
                 case SSL3_ST_SW_KEY_EXCH_A:
                 case SSL3_ST_SW_KEY_EXCH_B:
                         l=s->s3->tmp.new_cipher->algorithms;
-                        if (s->session->cert == NULL)
-                                {
-                                if (s->cert != NULL)
-                                        {
-                                        CRYPTO_add(&s->cert->references,1,CRYPTO_LOCK_SSL_CERT);
-                                        s->session->cert=s->cert;
-                                        }
-                                else
-                                        {
-                                        CRYPTO_add(&s->ctx->default_cert->references,1,CRYPTO_LOCK_SSL_CERT);
-                                        s->session->cert=s->ctx->default_cert;
-                                        }
-                                }
-                        ct=s->session->cert;
 
                         /* clear this, it may get reset by
                          * send_server_key_exchange */
-                        if (s->options & SSL_OP_EPHEMERAL_RSA)
+                        if ((s->options & SSL_OP_EPHEMERAL_RSA)
+#ifndef OPENSSL_NO_KRB5
+                                && !(l & SSL_KRB5)
+#endif /* OPENSSL_NO_KRB5 */
+                                )
+                                /* option SSL_OP_EPHEMERAL_RSA sends temporary RSA key
+                                 * even when forbidden by protocol specs
+                                 * (handshake may fail as clients are not required to
+                                 * be able to handle this) */
                                 s->s3->tmp.use_rsa_tmp=1;
                         else
                                 s->s3->tmp.use_rsa_tmp=0;
 
                         /* only send if a DH key exchange, fortezza or
                          * RSA but we have a sign only certificate */
-                        if ( s->s3->tmp.use_rsa_tmp ||
-                            (l & (SSL_DH|SSL_kFZA)) ||
-                            ((l & SSL_kRSA) &&
-                             ((ct->pkeys[SSL_PKEY_RSA_ENC].privatekey == NULL)||
-                              ((l & SSL_EXPORT) &&
-                               (EVP_PKEY_size(ct->pkeys[SSL_PKEY_RSA_ENC].privatekey)*8 > 512)
-                              )
-                             )
+                        if (s->s3->tmp.use_rsa_tmp
+                            || (l & (SSL_DH|SSL_kFZA))
+                            || ((l & SSL_kRSA)
+                                && (s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey == NULL
+                                    || (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher)
+                                        && EVP_PKEY_size(s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey)*8 > SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)
+                                        )
+                                    )
+                                )
                             )
-                           )
                                 {
                                 ret=ssl3_send_server_key_exchange(s);
                                 if (ret <= 0) goto end;
@@ -339,9 +355,21 @@ SSL *s;
 
                 case SSL3_ST_SW_CERT_REQ_A:
                 case SSL3_ST_SW_CERT_REQ_B:
-                        if (!(s->verify_mode & SSL_VERIFY_PEER) ||
+                        if (/* don't request cert unless asked for it: */
+                                !(s->verify_mode & SSL_VERIFY_PEER) ||
+                                /* if SSL_VERIFY_CLIENT_ONCE is set,
+                                 * don't request cert during re-negotiation: */
                                 ((s->session->peer != NULL) &&
-                                 (s->verify_mode & SSL_VERIFY_CLIENT_ONCE)))
+                                 (s->verify_mode & SSL_VERIFY_CLIENT_ONCE)) ||
+                                /* never request cert in anonymous ciphersuites
+                                 * (see section "Certificate request" in SSL 3 drafts
+                                 * and in RFC 2246): */
+                                ((s->s3->tmp.new_cipher->algorithms & SSL_aNULL) &&
+                                 /* ... except when the application insists on verification
+                                  * (against the specs, but s3_clnt.c accepts this for SSL 3) */
+                                 !(s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) ||
+                                 /* never request cert in Kerberos ciphersuites */
+                                (s->s3->tmp.new_cipher->algorithms & SSL_aKRB5))
                                 {
                                 /* no cert request */
                                 skip=1;
@@ -353,7 +381,12 @@ SSL *s;
                                 s->s3->tmp.cert_request=1;
                                 ret=ssl3_send_certificate_request(s);
                                 if (ret <= 0) goto end;
+#ifndef NETSCAPE_HANG_BUG
                                 s->state=SSL3_ST_SW_SRVR_DONE_A;
+#else
+                                s->state=SSL3_ST_SW_FLUSH;
+                                s->s3->tmp.next_state=SSL3_ST_SR_CERT_A;
+#endif
                                 s->init_num=0;
                                 }
                         break;
@@ -383,12 +416,20 @@ SSL *s;
 
                 case SSL3_ST_SR_CERT_A:
                 case SSL3_ST_SR_CERT_B:
-                        /* could be sent for a DH cert, even if we
-                         * have not asked for it :-) */
-                        ret=ssl3_get_client_certificate(s);
-                        if (ret <= 0) goto end;
-                        s->init_num=0;
-                        s->state=SSL3_ST_SR_KEY_EXCH_A;
+                        /* Check for second client hello (MS SGC) */
+                        ret = ssl3_check_client_hello(s);
+                        if (ret <= 0)
+                                goto end;
+                        if (ret == 2)
+                                s->state = SSL3_ST_SR_CLNT_HELLO_C;
+                        else {
+                                /* could be sent for a DH cert, even if we
+                                 * have not asked for it :-) */
+                                ret=ssl3_get_client_certificate(s);
+                                if (ret <= 0) goto end;
+                                s->init_num=0;
+                                s->state=SSL3_ST_SR_KEY_EXCH_A;
+                        }
                         break;
 
                 case SSL3_ST_SR_KEY_EXCH_A:
@@ -402,10 +443,10 @@ SSL *s;
                          * a client cert, it can be verified */ 
                         s->method->ssl3_enc->cert_verify_mac(s,
                                 &(s->s3->finish_dgst1),
-                                &(s->s3->tmp.finish_md[0]));
+                                &(s->s3->tmp.cert_verify_md[0]));
                         s->method->ssl3_enc->cert_verify_mac(s,
                                 &(s->s3->finish_dgst2),
-                                &(s->s3->tmp.finish_md[MD5_DIGEST_LENGTH]));
+                                &(s->s3->tmp.cert_verify_md[MD5_DIGEST_LENGTH]));
 
                         break;
 
@@ -459,8 +500,8 @@ SSL *s;
                 case SSL3_ST_SW_FINISHED_B:
                         ret=ssl3_send_finished(s,
                                 SSL3_ST_SW_FINISHED_A,SSL3_ST_SW_FINISHED_B,
-                                s->method->ssl3_enc->server_finished,
-                                s->method->ssl3_enc->server_finished_len);
+                                s->method->ssl3_enc->server_finished_label,
+                                s->method->ssl3_enc->server_finished_label_len);
                         if (ret <= 0) goto end;
                         s->state=SSL3_ST_SW_FLUSH;
                         if (s->hit)
@@ -478,26 +519,27 @@ SSL *s;
                         s->init_buf=NULL;
 
                         /* remove buffering on output */
-                        under=BIO_pop(s->wbio);
-                        if (under != NULL)
-                                s->wbio=under;
-                        else
-                                abort(); /* ok */
-                        BIO_free(s->bbio);
-                        s->bbio=NULL;
+                        ssl_free_wbio_buffer(s);
 
-                        s->new_session=0;
                         s->init_num=0;
 
-                        ssl_update_cache(s,SSL_SESS_CACHE_SERVER);
-
-                        s->ctx->sess_accept_good++;
-                        /* s->server=1; */
-                        s->handshake_func=ssl3_accept;
-                        ret=1;
-
-                        if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_DONE,1);
-
+                        if (s->new_session == 2) /* skipped if we just sent a HelloRequest */
+                                {
+                                /* actually not necessarily a 'new' session unless
+                                 * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION is set */
+                                
+                                s->new_session=0;
+                                
+                                ssl_update_cache(s,SSL_SESS_CACHE_SERVER);
+                                
+                                s->ctx->stats.sess_accept_good++;
+                                /* s->server=1; */
+                                s->handshake_func=ssl3_accept;
+
+                                if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_DONE,1);
+                                }
+                        
+                        ret = 1;
                         goto end;
                         /* break; */
 
@@ -530,21 +572,20 @@ SSL *s;
 end:
         /* BIO_flush(s->wbio); */
 
+        s->in_handshake--;
         if (cb != NULL)
                 cb(s,SSL_CB_ACCEPT_EXIT,ret);
-        s->in_handshake--;
         return(ret);
         }
 
-static int ssl3_send_hello_request(s)
-SSL *s;
+static int ssl3_send_hello_request(SSL *s)
         {
         unsigned char *p;
 
         if (s->state == SSL3_ST_SW_HELLO_REQ_A)
                 {
                 p=(unsigned char *)s->init_buf->data;
-                *(p++)=SSL3_MT_CLIENT_REQUEST;
+                *(p++)=SSL3_MT_HELLO_REQUEST;
                 *(p++)=0;
                 *(p++)=0;
                 *(p++)=0;
@@ -559,15 +600,48 @@ SSL *s;
         return(ssl3_do_write(s,SSL3_RT_HANDSHAKE));
         }
 
-static int ssl3_get_client_hello(s)
-SSL *s;
+static int ssl3_check_client_hello(SSL *s)
+        {
+        int ok;
+        long n;
+
+        /* this function is called when we really expect a Certificate message,
+         * so permit appropriate message length */
+        n=ssl3_get_message(s,
+                SSL3_ST_SR_CERT_A,
+                SSL3_ST_SR_CERT_B,
+                -1,
+                s->max_cert_list,
+                &ok);
+        if (!ok) return((int)n);
+        s->s3->tmp.reuse_message = 1;
+        if (s->s3->tmp.message_type == SSL3_MT_CLIENT_HELLO)
+                {
+                /* Throw away what we have done so far in the current handshake,
+                 * which will now be aborted. (A full SSL_clear would be too much.)
+                 * I hope that tmp.dh is the only thing that may need to be cleared
+                 * when a handshake is not completed ... */
+#ifndef OPENSSL_NO_DH
+                if (s->s3->tmp.dh != NULL)
+                        {
+                        DH_free(s->s3->tmp.dh);
+                        s->s3->tmp.dh = NULL;
+                        }
+#endif
+                return 2;
+                }
+        return 1;
+}
+
+static int ssl3_get_client_hello(SSL *s)
         {
         int i,j,ok,al,ret= -1;
         long n;
         unsigned long id;
-        unsigned char *p,*d;
+        unsigned char *p,*d,*q;
         SSL_CIPHER *c;
-        STACK *ciphers=NULL;
+        SSL_COMP *comp=NULL;
+        STACK_OF(SSL_CIPHER) *ciphers=NULL;
 
         /* We do this so that we will respond with our native type.
          * If we are TLSv1 and we get SSLv3, we will respond with TLSv1,
@@ -588,13 +662,25 @@ SSL *s;
                 &ok);
 
         if (!ok) return((int)n);
-        d=p=(unsigned char *)s->init_buf->data;
+        d=p=(unsigned char *)s->init_msg;
 
-        /* The version number has already been checked in ssl3_get_message.
-         * I a native TLSv1/SSLv3 method, the match must be correct except
-         * perhaps for the first message */
+        /* use version from inside client hello, not from record header
+         * (may differ: see RFC 2246, Appendix E, second paragraph) */
+        s->client_version=(((int)p[0])<<8)|(int)p[1];
         p+=2;
 
+        if (s->client_version < s->version)
+                {
+                SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_WRONG_VERSION_NUMBER);
+                if ((s->client_version>>8) == SSL3_VERSION_MAJOR) 
+                        {
+                        /* similar to ssl3_get_record, send alert using remote version number */
+                        s->version = s->client_version;
+                        }
+                al = SSL_AD_PROTOCOL_VERSION;
+                goto f_err;
+                }
+
         /* load the client random */
         memcpy(s->s3->client_random,p,SSL3_RANDOM_SIZE);
         p+=SSL3_RANDOM_SIZE;
@@ -603,7 +689,15 @@ SSL *s;
         j= *(p++);
 
         s->hit=0;
-        if (j == 0)
+        /* Versions before 0.9.7 always allow session reuse during renegotiation
+         * (i.e. when s->new_session is true), option
+         * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION is new with 0.9.7.
+         * Maybe this optional behaviour should always have been the default,
+         * but we cannot safely change the default behaviour (or new applications
+         * might be written that become totally unsecure when compiled with
+         * an earlier library version)
+         */
+        if (j == 0 || (s->new_session && (s->options & SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION)))
                 {
                 if (!ssl_get_new_session(s,1))
                         goto err;
@@ -615,7 +709,9 @@ SSL *s;
                         { /* previous session */
                         s->hit=1;
                         }
-                else
+                else if (i == -1)
+                        goto err;
+                else /* i == 0 */
                         {
                         if (!ssl_get_new_session(s,1))
                                 goto err;
@@ -631,7 +727,7 @@ SSL *s;
                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_NO_CIPHERS_SPECIFIED);
                 goto f_err;
                 }
-        if ((i+p) > (d+n))
+        if ((p+i) >= (d+n))
                 {
                 /* not enough data */
                 al=SSL_AD_DECODE_ERROR;
@@ -651,9 +747,16 @@ SSL *s;
                 j=0;
                 id=s->session->cipher->id;
 
-                for (i=0; i<sk_num(ciphers); i++)
+#ifdef CIPHER_DEBUG
+                printf("client sent %d ciphers\n",sk_num(ciphers));
+#endif
+                for (i=0; i<sk_SSL_CIPHER_num(ciphers); i++)
                         {
-                        c=(SSL_CIPHER *)sk_value(ciphers,i);
+                        c=sk_SSL_CIPHER_value(ciphers,i);
+#ifdef CIPHER_DEBUG
+                        printf("client [%2d of %2d]:%s\n",
+                                i,sk_num(ciphers),SSL_CIPHER_get_name(c));
+#endif
                         if (c->id == id)
                                 {
                                 j=1;
@@ -662,11 +765,11 @@ SSL *s;
                         }
                 if (j == 0)
                         {
-                        if ((s->options & SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG) && (sk_num(ciphers) == 1))
+                        if ((s->options & SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG) && (sk_SSL_CIPHER_num(ciphers) == 1))
                                 {
                                 /* Very bad for multi-threading.... */
-                                s->session->cipher=
-                                        (SSL_CIPHER *)sk_value(ciphers,0);
+                                s->session->cipher=sk_SSL_CIPHER_value(ciphers,
+                                                                       0);
                                 }
                         else
                                 {
@@ -681,8 +784,18 @@ SSL *s;
 
         /* compression */
         i= *(p++);
+        if ((p+i) > (d+n))
+                {
+                /* not enough data */
+                al=SSL_AD_DECODE_ERROR;
+                SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_LENGTH_MISMATCH);
+                goto f_err;
+                }
+        q=p;
         for (j=0; j<i; j++)
+                {
                 if (p[j] == 0) break;
+                }
 
         p+=i;
         if (j >= i)
@@ -693,10 +806,39 @@ SSL *s;
                 goto f_err;
                 }
 
+        /* Worst case, we will use the NULL compression, but if we have other
+         * options, we will now look for them.  We have i-1 compression
+         * algorithms from the client, starting at q. */
+        s->s3->tmp.new_compression=NULL;
+        if (s->ctx->comp_methods != NULL)
+                { /* See if we have a match */
+                int m,nn,o,v,done=0;
+
+                nn=sk_SSL_COMP_num(s->ctx->comp_methods);
+                for (m=0; m<nn; m++)
+                        {
+                        comp=sk_SSL_COMP_value(s->ctx->comp_methods,m);
+                        v=comp->id;
+                        for (o=0; o<i; o++)
+                                {
+                                if (v == q[o])
+                                        {
+                                        done=1;
+                                        break;
+                                        }
+                                }
+                        if (done) break;
+                        }
+                if (done)
+                        s->s3->tmp.new_compression=comp;
+                else
+                        comp=NULL;
+                }
+
         /* TLS does not mind if there is extra stuff */
         if (s->version == SSL3_VERSION)
                 {
-                if (p > (d+n))
+                if (p < (d+n))
                         {
                         /* wrong number of bytes,
                          * there could be more to follow */
@@ -706,15 +848,14 @@ SSL *s;
                         }
                 }
 
-        /* do nothing with compression */
-
-        /* Given s->session->ciphers and ssl_get_ciphers_by_id(s), we must
+        /* Given s->session->ciphers and SSL_get_ciphers, we must
          * pick a cipher */
 
         if (!s->hit)
                 {
+                s->session->compress_meth=(comp == NULL)?0:comp->id;
                 if (s->session->ciphers != NULL)
-                        sk_free(s->session->ciphers);
+                        sk_SSL_CIPHER_free(s->session->ciphers);
                 s->session->ciphers=ciphers;
                 if (ciphers == NULL)
                         {
@@ -724,7 +865,7 @@ SSL *s;
                         }
                 ciphers=NULL;
                 c=ssl3_choose_cipher(s,s->session->ciphers,
-                        ssl_get_ciphers_by_id(s));
+                                     SSL_get_ciphers(s));
 
                 if (c == NULL)
                         {
@@ -738,19 +879,19 @@ SSL *s;
                 {
                 /* Session-id reuse */
 #ifdef REUSE_CIPHER_BUG
-                STACK *sk;
+                STACK_OF(SSL_CIPHER) *sk;
                 SSL_CIPHER *nc=NULL;
                 SSL_CIPHER *ec=NULL;
 
                 if (s->options & SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG)
                         {
                         sk=s->session->ciphers;
-                        for (i=0; i<sk_num(sk); i++)
+                        for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
                                 {
-                                c=(SSL_CIPHER *)sk_value(sk,i);
+                                c=sk_SSL_CIPHER_value(sk,i);
                                 if (c->algorithms & SSL_eNULL)
                                         nc=c;
-                                if (c->algorithms & SSL_EXP)
+                                if (SSL_C_IS_EXPORT(c))
                                         ec=c;
                                 }
                         if (nc != NULL)
@@ -772,7 +913,7 @@ SSL *s;
          * compression          - basically ignored right now
          * ssl version is set   - sslv3
          * s->session           - The ssl session has been setup.
-         * s->hit               - sesson reuse flag
+         * s->hit               - session reuse flag
          * s->tmp.new_cipher    - the new cipher to use.
          */
 
@@ -783,12 +924,11 @@ f_err:
                 ssl3_send_alert(s,SSL3_AL_FATAL,al);
                 }
 err:
-        if (ciphers != NULL) sk_free(ciphers);
+        if (ciphers != NULL) sk_SSL_CIPHER_free(ciphers);
         return(ret);
         }
 
-static int ssl3_send_server_hello(s)
-SSL *s;
+static int ssl3_send_server_hello(SSL *s)
         {
         unsigned char *buf;
         unsigned char *p,*d;
@@ -801,7 +941,7 @@ SSL *s;
                 p=s->s3->server_random;
                 Time=time(NULL);                        /* Time */
                 l2n(Time,p);
-                RAND_bytes(p,SSL3_RANDOM_SIZE-sizeof(Time));
+                RAND_pseudo_bytes(p,SSL3_RANDOM_SIZE-sizeof(Time));
                 /* Do the message type and length last */
                 d=p= &(buf[4]);
 
@@ -833,7 +973,10 @@ SSL *s;
                 p+=i;
 
                 /* put the compression method */
-                *(p++)=0;
+                if (s->s3->tmp.new_compression == NULL)
+                        *(p++)=0;
+                else
+                        *(p++)=s->s3->tmp.new_compression->id;
 
                 /* do the header */
                 l=(p-d);
@@ -851,8 +994,7 @@ SSL *s;
         return(ssl3_do_write(s,SSL3_RT_HANDSHAKE));
         }
 
-static int ssl3_send_server_done(s)
-SSL *s;
+static int ssl3_send_server_done(SSL *s)
         {
         unsigned char *p;
 
@@ -876,17 +1018,17 @@ SSL *s;
         return(ssl3_do_write(s,SSL3_RT_HANDSHAKE));
         }
 
-static int ssl3_send_server_key_exchange(s)
-SSL *s;
+static int ssl3_send_server_key_exchange(SSL *s)
         {
-#ifndef NO_RSA
+#ifndef OPENSSL_NO_RSA
         unsigned char *q;
         int j,num;
         RSA *rsa;
         unsigned char md_buf[MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH];
+        unsigned int u;
 #endif
-#ifndef NO_DH
-        DH *dh,*dhp;
+#ifndef OPENSSL_NO_DH
+        DH *dh=NULL,*dhp;
 #endif
         EVP_PKEY *pkey;
         unsigned char *p,*d;
@@ -899,25 +1041,32 @@ SSL *s;
         BUF_MEM *buf;
         EVP_MD_CTX md_ctx;
 
+        EVP_MD_CTX_init(&md_ctx);
         if (s->state == SSL3_ST_SW_KEY_EXCH_A)
                 {
                 type=s->s3->tmp.new_cipher->algorithms & SSL_MKEY_MASK;
-                cert=s->session->cert;
+                cert=s->cert;
 
                 buf=s->init_buf;
 
                 r[0]=r[1]=r[2]=r[3]=NULL;
                 n=0;
-#ifndef NO_RSA
+#ifndef OPENSSL_NO_RSA
                 if (type & SSL_kRSA)
                         {
                         rsa=cert->rsa_tmp;
-                        if ((rsa == NULL) && (s->ctx->default_cert->rsa_tmp_cb != NULL))
+                        if ((rsa == NULL) && (s->cert->rsa_tmp_cb != NULL))
+                                {
+                                rsa=s->cert->rsa_tmp_cb(s,
+                                      SSL_C_IS_EXPORT(s->s3->tmp.new_cipher),
+                                      SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher));
+                                if(rsa == NULL)
                                 {
-                                rsa=s->ctx->default_cert->rsa_tmp_cb(s,
-                                        (s->s3->tmp.new_cipher->algorithms|
-                                        SSL_NOT_EXP)?0:1);
-                                CRYPTO_add(&rsa->references,1,CRYPTO_LOCK_RSA);
+                                        al=SSL_AD_HANDSHAKE_FAILURE;
+                                        SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_ERROR_GENERATING_TMP_RSA_KEY);
+                                        goto f_err;
+                                }
+                                RSA_up_ref(rsa);
                                 cert->rsa_tmp=rsa;
                                 }
                         if (rsa == NULL)
@@ -932,20 +1081,28 @@ SSL *s;
                         }
                 else
 #endif
-#ifndef NO_DH
+#ifndef OPENSSL_NO_DH
                         if (type & SSL_kEDH)
                         {
                         dhp=cert->dh_tmp;
-                        if ((dhp == NULL) && (cert->dh_tmp_cb != NULL))
-                                dhp=cert->dh_tmp_cb(s,
-                                        (s->s3->tmp.new_cipher->algorithms|
-                                        SSL_NOT_EXP)?0:1);
+                        if ((dhp == NULL) && (s->cert->dh_tmp_cb != NULL))
+                                dhp=s->cert->dh_tmp_cb(s,
+                                      SSL_C_IS_EXPORT(s->s3->tmp.new_cipher),
+                                      SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher));
                         if (dhp == NULL)
                                 {
                                 al=SSL_AD_HANDSHAKE_FAILURE;
                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_MISSING_TMP_DH_KEY);
                                 goto f_err;
                                 }
+
+                        if (s->s3->tmp.dh != NULL)
+                                {
+                                DH_free(dh);
+                                SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
+                                goto err;
+                                }
+
                         if ((dh=DHparams_dup(dhp)) == NULL)
                                 {
                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_DH_LIB);
@@ -953,13 +1110,16 @@ SSL *s;
                                 }
 
                         s->s3->tmp.dh=dh;
-                        if (((dhp->pub_key == NULL) ||
-                             (dhp->priv_key == NULL) ||
-                             (s->options & SSL_OP_SINGLE_DH_USE)) &&
-                            (!DH_generate_key(dh)))
+                        if ((dhp->pub_key == NULL ||
+                             dhp->priv_key == NULL ||
+                             (s->options & SSL_OP_SINGLE_DH_USE)))
                                 {
-                                SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_DH_LIB);
-                                goto err;
+                                if(!DH_generate_key(dh))
+                                    {
+                                    SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
+                                           ERR_R_DH_LIB);
+                                    goto err;
+                                    }
                                 }
                         else
                                 {
@@ -1025,40 +1185,39 @@ SSL *s;
                         {
                         /* n is the length of the params, they start at &(d[4])
                          * and p points to the space at the end. */
-#ifndef NO_RSA
+#ifndef OPENSSL_NO_RSA
                         if (pkey->type == EVP_PKEY_RSA)
                                 {
                                 q=md_buf;
                                 j=0;
                                 for (num=2; num > 0; num--)
                                         {
-                                        EVP_DigestInit(&md_ctx,(num == 2)
-                                                ?s->ctx->md5:s->ctx->sha1);
+                                        EVP_DigestInit_ex(&md_ctx,(num == 2)
+                                                ?s->ctx->md5:s->ctx->sha1, NULL);
                                         EVP_DigestUpdate(&md_ctx,&(s->s3->client_random[0]),SSL3_RANDOM_SIZE);
                                         EVP_DigestUpdate(&md_ctx,&(s->s3->server_random[0]),SSL3_RANDOM_SIZE);
                                         EVP_DigestUpdate(&md_ctx,&(d[4]),n);
-                                        EVP_DigestFinal(&md_ctx,q,
+                                        EVP_DigestFinal_ex(&md_ctx,q,
                                                 (unsigned int *)&i);
                                         q+=i;
                                         j+=i;
                                         }
-                                i=RSA_private_encrypt(j,md_buf,&(p[2]),
-                                        pkey->pkey.rsa,RSA_PKCS1_PADDING);
-                                if (i <= 0)
+                                if (RSA_sign(NID_md5_sha1, md_buf, j,
+                                        &(p[2]), &u, pkey->pkey.rsa) <= 0)
                                         {
                                         SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_LIB_RSA);
                                         goto err;
                                         }
-                                s2n(i,p);
-                                n+=i+2;
+                                s2n(u,p);
+                                n+=u+2;
                                 }
                         else
 #endif
-#if !defined(NO_DSA)
+#if !defined(OPENSSL_NO_DSA)
                                 if (pkey->type == EVP_PKEY_DSA)
                                 {
                                 /* lets do DSS */
-                                EVP_SignInit(&md_ctx,EVP_dss1());
+                                EVP_SignInit_ex(&md_ctx,EVP_dss1(), NULL);
                                 EVP_SignUpdate(&md_ctx,&(s->s3->client_random[0]),SSL3_RANDOM_SIZE);
                                 EVP_SignUpdate(&md_ctx,&(s->s3->server_random[0]),SSL3_RANDOM_SIZE);
                                 EVP_SignUpdate(&md_ctx,&(d[4]),n);
@@ -1090,20 +1249,21 @@ SSL *s;
                 s->init_off=0;
                 }
 
-        /* SSL3_ST_SW_KEY_EXCH_B */
+        s->state = SSL3_ST_SW_KEY_EXCH_B;
+        EVP_MD_CTX_cleanup(&md_ctx);
         return(ssl3_do_write(s,SSL3_RT_HANDSHAKE));
 f_err:
         ssl3_send_alert(s,SSL3_AL_FATAL,al);
 err:
+        EVP_MD_CTX_cleanup(&md_ctx);
         return(-1);
         }
 
-static int ssl3_send_certificate_request(s)
-SSL *s;
+static int ssl3_send_certificate_request(SSL *s)
         {
         unsigned char *p,*d;
         int i,j,nl,off,n;
-        STACK *sk=NULL;
+        STACK_OF(X509_NAME) *sk=NULL;
         X509_NAME *name;
         BUF_MEM *buf;
 
@@ -1128,9 +1288,9 @@ SSL *s;
                 nl=0;
                 if (sk != NULL)
                         {
-                        for (i=0; i<sk_num(sk); i++)
+                        for (i=0; i<sk_X509_NAME_num(sk); i++)
                                 {
-                                name=(X509_NAME *)sk_value(sk,i);
+                                name=sk_X509_NAME_value(sk,i);
                                 j=i2d_X509_NAME(name,NULL);
                                 if (!BUF_MEM_grow(buf,4+n+j+2))
                                         {
@@ -1168,6 +1328,17 @@ SSL *s;
 
                 s->init_num=n+4;
                 s->init_off=0;
+#ifdef NETSCAPE_HANG_BUG
+                p=(unsigned char *)s->init_buf->data + s->init_num;
+
+                /* do the header */
+                *(p++)=SSL3_MT_SERVER_DONE;
+                *(p++)=0;
+                *(p++)=0;
+                *(p++)=0;
+                s->init_num += 4;
+#endif
+
                 }
 
         /* SSL3_ST_SW_CERT_REQ_B */
@@ -1176,44 +1347,44 @@ err:
         return(-1);
         }
 
-static int ssl3_get_client_key_exchange(s)
-SSL *s;
+static int ssl3_get_client_key_exchange(SSL *s)
         {
         int i,al,ok;
         long n;
         unsigned long l;
         unsigned char *p;
+#ifndef OPENSSL_NO_RSA
         RSA *rsa=NULL;
         EVP_PKEY *pkey=NULL;
-#ifndef NO_DH
+#endif
+#ifndef OPENSSL_NO_DH
         BIGNUM *pub=NULL;
         DH *dh_srvr;
 #endif
+#ifndef OPENSSL_NO_KRB5
+        KSSL_ERR kssl_err;
+#endif /* OPENSSL_NO_KRB5 */
 
         n=ssl3_get_message(s,
                 SSL3_ST_SR_KEY_EXCH_A,
                 SSL3_ST_SR_KEY_EXCH_B,
                 SSL3_MT_CLIENT_KEY_EXCHANGE,
-                400, /* ???? */
+                2048, /* ??? */
                 &ok);
 
         if (!ok) return((int)n);
-        p=(unsigned char *)s->init_buf->data;
+        p=(unsigned char *)s->init_msg;
 
         l=s->s3->tmp.new_cipher->algorithms;
 
-#ifndef NO_RSA
+#ifndef OPENSSL_NO_RSA
         if (l & SSL_kRSA)
                 {
                 /* FIX THIS UP EAY EAY EAY EAY */
                 if (s->s3->tmp.use_rsa_tmp)
                         {
-                        if ((s->session->cert != NULL) &&
-                                (s->session->cert->rsa_tmp != NULL))
-                                rsa=s->session->cert->rsa_tmp;
-                        else if ((s->ctx->default_cert != NULL) &&
-                                (s->ctx->default_cert->rsa_tmp != NULL))
-                                rsa=s->ctx->default_cert->rsa_tmp;
+                        if ((s->cert != NULL) && (s->cert->rsa_tmp != NULL))
+                                rsa=s->cert->rsa_tmp;
                         /* Don't do a callback because rsa_tmp should
                          * be sent already */
                         if (rsa == NULL)
@@ -1258,33 +1429,53 @@ SSL *s;
 
                 i=RSA_private_decrypt((int)n,p,p,rsa,RSA_PKCS1_PADDING);
 
-#if 1
-                /* If a bad decrypt, use a dud master key */
-                if ((i != SSL_MAX_MASTER_KEY_LENGTH) ||
-                        ((p[0] != (s->version>>8)) ||
-                         (p[1] != (s->version & 0xff))))
-                        {
-                        p[0]=(s->version>>8);
-                        p[1]=(s->version & 0xff);
-                        RAND_bytes(&(p[2]),SSL_MAX_MASTER_KEY_LENGTH-2);
-                        i=SSL_MAX_MASTER_KEY_LENGTH;
-                        }
-#else
+                al = -1;
+                
                 if (i != SSL_MAX_MASTER_KEY_LENGTH)
                         {
                         al=SSL_AD_DECODE_ERROR;
                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_BAD_RSA_DECRYPT);
-                        goto f_err;
                         }
 
-                if ((p[0] != (s->version>>8)) || (p[1] != (s->version & 0xff)))
+                if ((al == -1) && !((p[0] == (s->client_version>>8)) && (p[1] == (s->client_version & 0xff))))
                         {
-                        al=SSL_AD_DECODE_ERROR;
-                        SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_BAD_PROTOCOL_VERSION_NUMBER);
-                        goto f_err;
+                        /* The premaster secret must contain the same version number as the
+                         * ClientHello to detect version rollback attacks (strangely, the
+                         * protocol does not offer such protection for DH ciphersuites).
+                         * However, buggy clients exist that send the negotiated protocol
+                         * version instead if the server does not support the requested
+                         * protocol version.
+                         * If SSL_OP_TLS_ROLLBACK_BUG is set, tolerate such clients. */
+                        if (!((s->options & SSL_OP_TLS_ROLLBACK_BUG) &&
+                                (p[0] == (s->version>>8)) && (p[1] == (s->version & 0xff))))
+                                {
+                                al=SSL_AD_DECODE_ERROR;
+                                SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_BAD_PROTOCOL_VERSION_NUMBER);
+                                goto f_err;
+                                }
                         }
-#endif
 
+                if (al != -1)
+                        {
+#if 0
+                        goto f_err;
+#else
+                        /* Some decryption failure -- use random value instead as countermeasure
+                         * against Bleichenbacher's attack on PKCS #1 v1.5 RSA padding
+                         * (see RFC 2246, section 7.4.7.1).
+                         * But note that due to length and protocol version checking, the
+                         * attack is impractical anyway (see section 5 in D. Bleichenbacher:
+                         * "Chosen Ciphertext Attacks Against Protocols Based on the RSA
+                         * Encryption Standard PKCS #1", CRYPTO '98, LNCS 1462, pp. 1-12).
+                         */
+                        ERR_clear_error();
+                        i = SSL_MAX_MASTER_KEY_LENGTH;
+                        p[0] = s->client_version >> 8;
+                        p[1] = s->client_version & 0xff;
+                        RAND_pseudo_bytes(p+2, i-2); /* should be RAND_bytes, but we cannot work around a failure */
+#endif
+                        }
+        
                 s->session->master_key_length=
                         s->method->ssl3_enc->generate_master_secret(s,
                                 s->session->master_key,
@@ -1293,7 +1484,7 @@ SSL *s;
                 }
         else
 #endif
-#ifndef NO_DH
+#ifndef OPENSSL_NO_DH
                 if (l & (SSL_kEDH|SSL_kDHr|SSL_kDHd))
                 {
                 n2s(p,i);
@@ -1352,26 +1543,175 @@ SSL *s;
                 s->session->master_key_length=
                         s->method->ssl3_enc->generate_master_secret(s,
                                 s->session->master_key,p,i);
+                memset(p,0,i);
                 }
         else
 #endif
+#ifndef OPENSSL_NO_KRB5
+        if (l & SSL_kKRB5)
+                {
+                krb5_error_code         krb5rc;
+                krb5_data               enc_ticket;
+                krb5_data               authenticator;
+                krb5_data               enc_pms;
+                KSSL_CTX                *kssl_ctx = s->kssl_ctx;
+                EVP_CIPHER_CTX          ciph_ctx;
+                EVP_CIPHER              *enc = NULL;
+                unsigned char           iv[EVP_MAX_IV_LENGTH];
+                unsigned char           pms[SSL_MAX_MASTER_KEY_LENGTH
+                                                + EVP_MAX_IV_LENGTH + 1];
+                int                     padl, outl = sizeof(pms);
+                krb5_timestamp          authtime = 0;
+                krb5_ticket_times       ttimes;
+
+                EVP_CIPHER_CTX_init(&ciph_ctx);
+
+                if (!kssl_ctx)  kssl_ctx = kssl_ctx_new();
+
+                n2s(p,i);
+                enc_ticket.length = i;
+                enc_ticket.data = (char *)p;
+                p+=enc_ticket.length;
+
+                n2s(p,i);
+                authenticator.length = i;
+                authenticator.data = (char *)p;
+                p+=authenticator.length;
+
+                n2s(p,i);
+                enc_pms.length = i;
+                enc_pms.data = (char *)p;
+                p+=enc_pms.length;
+
+                if (n != enc_ticket.length + authenticator.length +
+                                                enc_pms.length + 6)
+                        {
+                        SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
+                                SSL_R_DATA_LENGTH_TOO_LONG);
+                        goto err;
+                        }
+
+                if ((krb5rc = kssl_sget_tkt(kssl_ctx, &enc_ticket, &ttimes,
+                                        &kssl_err)) != 0)
+                        {
+#ifdef KSSL_DEBUG
+                        printf("kssl_sget_tkt rtn %d [%d]\n",
+                                krb5rc, kssl_err.reason);
+                        if (kssl_err.text)
+                                printf("kssl_err text= %s\n", kssl_err.text);
+#endif  /* KSSL_DEBUG */
+                        SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
+                                kssl_err.reason);
+                        goto err;
+                        }
+
+                /*  Note: no authenticator is not considered an error,
+                **  but will return authtime == 0.
+                */
+                if ((krb5rc = kssl_check_authent(kssl_ctx, &authenticator,
+                                        &authtime, &kssl_err)) != 0)
+                        {
+#ifdef KSSL_DEBUG
+                        printf("kssl_check_authent rtn %d [%d]\n",
+                                krb5rc, kssl_err.reason);
+                        if (kssl_err.text)
+                                printf("kssl_err text= %s\n", kssl_err.text);
+#endif  /* KSSL_DEBUG */
+                        SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
+                                kssl_err.reason);
+                        goto err;
+                        }
+
+                if ((krb5rc = kssl_validate_times(authtime, &ttimes)) != 0)
+                        {
+                        SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE, krb5rc);
+                        goto err;
+                        }
+
+#ifdef KSSL_DEBUG
+                kssl_ctx_show(kssl_ctx);
+#endif  /* KSSL_DEBUG */
+
+                enc = kssl_map_enc(kssl_ctx->enctype);
+                if (enc == NULL)
+                    goto err;
+
+                memset(iv, 0, EVP_MAX_IV_LENGTH);       /* per RFC 1510 */
+
+                if (!EVP_DecryptInit_ex(&ciph_ctx,enc,NULL,kssl_ctx->key,iv))
+                        {
+                        SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
+                                SSL_R_DECRYPTION_FAILED);
+                        goto err;
+                        }
+                if (!EVP_DecryptUpdate(&ciph_ctx, pms,&outl,
+                                        (unsigned char *)enc_pms.data, enc_pms.length))
+                        {
+                        SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
+                                SSL_R_DECRYPTION_FAILED);
+                        goto err;
+                        }
+                if (outl > SSL_MAX_MASTER_KEY_LENGTH)
+                        {
+                        SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
+                                SSL_R_DATA_LENGTH_TOO_LONG);
+                        goto err;
+                        }
+                if (!EVP_DecryptFinal_ex(&ciph_ctx,&(pms[outl]),&padl))
+                        {
+                        SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
+                                SSL_R_DECRYPTION_FAILED);
+                        goto err;
+                        }
+                outl += padl;
+                if (outl > SSL_MAX_MASTER_KEY_LENGTH)
+                        {
+                        SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
+                                SSL_R_DATA_LENGTH_TOO_LONG);
+                        goto err;
+                        }
+                EVP_CIPHER_CTX_cleanup(&ciph_ctx);
+
+                s->session->master_key_length=
+                        s->method->ssl3_enc->generate_master_secret(s,
+                                s->session->master_key, pms, outl);
+
+                if (kssl_ctx->client_princ)
+                        {
+                        int len = strlen(kssl_ctx->client_princ);
+                        if ( len < SSL_MAX_KRB5_PRINCIPAL_LENGTH ) 
+                                {
+                                s->session->krb5_client_princ_len = len;
+                                memcpy(s->session->krb5_client_princ,kssl_ctx->client_princ,len);
+                                }
+                        }
+
+
+                /*  Was doing kssl_ctx_free() here,
+                **  but it caused problems for apache.
+                **  kssl_ctx = kssl_ctx_free(kssl_ctx);
+                **  if (s->kssl_ctx)  s->kssl_ctx = NULL;
+                */
+                }
+        else
+#endif  /* OPENSSL_NO_KRB5 */
                 {
                 al=SSL_AD_HANDSHAKE_FAILURE;
-                SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_UNKNOWN_CIPHER_TYPE);
+                SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
+                                SSL_R_UNKNOWN_CIPHER_TYPE);
                 goto f_err;
                 }
 
         return(1);
 f_err:
         ssl3_send_alert(s,SSL3_AL_FATAL,al);
-#if !defined(NO_DH) || !defined(NO_RSA)
+#if !defined(OPENSSL_NO_DH) || !defined(OPENSSL_NO_RSA)
 err:
 #endif
         return(-1);
         }
 
-static int ssl3_get_cert_verify(s)
-SSL *s;
+static int ssl3_get_cert_verify(SSL *s)
         {
         EVP_PKEY *pkey=NULL;
         unsigned char *p;
@@ -1436,7 +1776,7 @@ SSL *s;
                 }
 
         /* we now have a signature that we need to verify */
-        p=(unsigned char *)s->init_buf->data;
+        p=(unsigned char *)s->init_msg;
         n2s(p,i);
         n-=2;
         if (i > n)
@@ -1454,19 +1794,19 @@ SSL *s;
                 goto f_err;
                 }
 
-#ifndef NO_RSA 
+#ifndef OPENSSL_NO_RSA 
         if (pkey->type == EVP_PKEY_RSA)
                 {
-                i=RSA_public_decrypt(i,p,p,pkey->pkey.rsa,RSA_PKCS1_PADDING);
+                i=RSA_verify(NID_md5_sha1, s->s3->tmp.cert_verify_md,
+                        MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH, p, i, 
+                                                        pkey->pkey.rsa);
                 if (i < 0)
                         {
                         al=SSL_AD_DECRYPT_ERROR;
                         SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_BAD_RSA_DECRYPT);
                         goto f_err;
                         }
-                if ((i != (MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH)) ||
-                        memcmp(&(s->s3->tmp.finish_md[0]),p,
-                                MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH))
+                if (i == 0)
                         {
                         al=SSL_AD_DECRYPT_ERROR;
                         SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_BAD_RSA_SIGNATURE);
@@ -1475,11 +1815,11 @@ SSL *s;
                 }
         else
 #endif
-#ifndef NO_DSA
+#ifndef OPENSSL_NO_DSA
                 if (pkey->type == EVP_PKEY_DSA)
                 {
                 j=DSA_verify(pkey->save_type,
-                        &(s->s3->tmp.finish_md[MD5_DIGEST_LENGTH]),
+                        &(s->s3->tmp.cert_verify_md[MD5_DIGEST_LENGTH]),
                         SHA_DIGEST_LENGTH,p,i,pkey->pkey.dsa);
                 if (j <= 0)
                         {
@@ -1492,7 +1832,7 @@ SSL *s;
         else
 #endif
                 {
-                SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_INTERNAL_ERROR);
+                SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,ERR_R_INTERNAL_ERROR);
                 al=SSL_AD_UNSUPPORTED_CERTIFICATE;
                 goto f_err;
                 }
@@ -1505,27 +1845,23 @@ f_err:
                 ssl3_send_alert(s,SSL3_AL_FATAL,al);
                 }
 end:
+        EVP_PKEY_free(pkey);
         return(ret);
         }
 
-static int ssl3_get_client_certificate(s)
-SSL *s;
+static int ssl3_get_client_certificate(SSL *s)
         {
         int i,ok,al,ret= -1;
         X509 *x=NULL;
         unsigned long l,nc,llen,n;
         unsigned char *p,*d,*q;
-        STACK *sk=NULL;
+        STACK_OF(X509) *sk=NULL;
 
         n=ssl3_get_message(s,
                 SSL3_ST_SR_CERT_A,
                 SSL3_ST_SR_CERT_B,
                 -1,
-#if defined(MSDOS) && !defined(WIN32)
-                1024*30, /* 30k max cert list :-) */
-#else
-                1024*100, /* 100k max cert list :-) */
-#endif
+                s->max_cert_list,
                 &ok);
 
         if (!ok) return((int)n);
@@ -1539,7 +1875,7 @@ SSL *s;
                         al=SSL_AD_HANDSHAKE_FAILURE;
                         goto f_err;
                         }
-                /* If tls asked for a client cert we must return a 0 list */
+                /* If tls asked for a client cert, the client must return a 0 list */
                 if ((s->version > SSL3_VERSION) && s->s3->tmp.cert_request)
                         {
                         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST);
@@ -1556,9 +1892,9 @@ SSL *s;
                 SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_WRONG_MESSAGE_TYPE);
                 goto f_err;
                 }
-        d=p=(unsigned char *)s->init_buf->data;
+        d=p=(unsigned char *)s->init_msg;
 
-        if ((sk=sk_new_null()) == NULL)
+        if ((sk=sk_X509_new_null()) == NULL)
                 {
                 SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,ERR_R_MALLOC_FAILURE);
                 goto err;
@@ -1594,7 +1930,7 @@ SSL *s;
                         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_CERT_LENGTH_MISMATCH);
                         goto f_err;
                         }
-                if (!sk_push(sk,(char *)x))
+                if (!sk_X509_push(sk,x))
                         {
                         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,ERR_R_MALLOC_FAILURE);
                         goto err;
@@ -1603,7 +1939,7 @@ SSL *s;
                 nc+=l+3;
                 }
 
-        if (sk_num(sk) <= 0)
+        if (sk_X509_num(sk) <= 0)
                 {
                 /* TLS does not mind 0 certs returned */
                 if (s->version == SSL3_VERSION)
@@ -1632,10 +1968,29 @@ SSL *s;
                         }
                 }
 
-        /* This should not be needed */
-        if (s->session->peer != NULL)
+        if (s->session->peer != NULL) /* This should not be needed */
                 X509_free(s->session->peer);
-        s->session->peer=(X509 *)sk_shift(sk);
+        s->session->peer=sk_X509_shift(sk);
+        s->session->verify_result = s->verify_result;
+
+        /* With the current implementation, sess_cert will always be NULL
+         * when we arrive here. */
+        if (s->session->sess_cert == NULL)
+                {
+                s->session->sess_cert = ssl_sess_cert_new();
+                if (s->session->sess_cert == NULL)
+                        {
+                        SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
+                        goto err;
+                        }
+                }
+        if (s->session->sess_cert->cert_chain != NULL)
+                sk_X509_pop_free(s->session->sess_cert->cert_chain, X509_free);
+        s->session->sess_cert->cert_chain=sk;
+        /* Inconsistency alert: cert_chain does *not* include the
+         * peer's own certificate, while we do include it in s3_clnt.c */
+
+        sk=NULL;
 
         ret=1;
         if (0)
@@ -1645,12 +2000,11 @@ f_err:
                 }
 err:
         if (x != NULL) X509_free(x);
-        if (sk != NULL) sk_pop_free(sk,X509_free);
+        if (sk != NULL) sk_X509_pop_free(sk,X509_free);
         return(ret);
         }
 
-int ssl3_send_server_certificate(s)
-SSL *s;
+int ssl3_send_server_certificate(SSL *s)
         {
         unsigned long l;
         X509 *x;
@@ -1658,9 +2012,13 @@ SSL *s;
         if (s->state == SSL3_ST_SW_CERT_A)
                 {
                 x=ssl_get_server_send_cert(s);
-                if (x == NULL)
+                if (x == NULL &&
+                        /* VRS: allow null cert if auth == KRB5 */
+                        (s->s3->tmp.new_cipher->algorithms
+                                & (SSL_MKEY_MASK|SSL_AUTH_MASK))
+                        != (SSL_aKRB5|SSL_kKRB5))
                         {
-                        SSLerr(SSL_F_SSL3_SEND_SERVER_CERTIFICATE,SSL_R_INTERNAL_ERROR);
+                        SSLerr(SSL_F_SSL3_SEND_SERVER_CERTIFICATE,ERR_R_INTERNAL_ERROR);
                         return(0);
                         }
 
diff --git a/src/lib/libssl/ssl.h b/src/lib/libssl/ssl.h
index cf8f9651b2..833f761690 100644
--- a/src/lib/libssl/ssl.h
+++ b/src/lib/libssl/ssl.h
@@ -55,10 +55,131 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
+/* ====================================================================
+ * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
+/* ====================================================================
+ * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
 
 #ifndef HEADER_SSL_H 
 #define HEADER_SSL_H 
 
+#include <openssl/e_os2.h>
+
+#ifndef OPENSSL_NO_COMP
+#include <openssl/comp.h>
+#endif
+#ifndef OPENSSL_NO_BIO
+#include <openssl/bio.h>
+#endif
+#ifndef OPENSSL_NO_X509
+#include <openssl/x509.h>
+#endif
+#include <openssl/kssl.h>
+#include <openssl/safestack.h>
+#include <openssl/symhacks.h>
+
 #ifdef  __cplusplus
 extern "C" {
 #endif
@@ -81,7 +202,18 @@ extern "C" {
 #define SSL_TXT_DES_192_EDE3_CBC_WITH_MD5 SSL2_TXT_DES_192_EDE3_CBC_WITH_MD5    
 #define SSL_TXT_DES_192_EDE3_CBC_WITH_SHA SSL2_TXT_DES_192_EDE3_CBC_WITH_SHA    
 
+/*    VRS Additional Kerberos5 entries
+ */
+#define SSL_TXT_KRB5_DES_40_CBC_SHA   SSL3_TXT_KRB5_DES_40_CBC_SHA
+#define SSL_TXT_KRB5_DES_40_CBC_MD5   SSL3_TXT_KRB5_DES_40_CBC_MD5
+#define SSL_TXT_KRB5_DES_64_CBC_SHA   SSL3_TXT_KRB5_DES_64_CBC_SHA
+#define SSL_TXT_KRB5_DES_64_CBC_MD5   SSL3_TXT_KRB5_DES_64_CBC_MD5
+#define SSL_TXT_KRB5_DES_192_CBC3_SHA SSL3_TXT_KRB5_DES_192_CBC3_SHA
+#define SSL_TXT_KRB5_DES_192_CBC3_MD5 SSL3_TXT_KRB5_DES_192_CBC3_MD5
+#define SSL_MAX_KRB5_PRINCIPAL_LENGTH  256
+
 #define SSL_MAX_SSL_SESSION_ID_LENGTH           32
+#define SSL_MAX_SID_CTX_LENGTH                  32
 
 #define SSL_MIN_RSA_MODULUS_LENGTH_IN_BYTES     (512/8)
 #define SSL_MAX_KEY_ARG_LENGTH                  8
@@ -100,6 +232,10 @@ extern "C" {
 #define SSL_TXT_eNULL           "eNULL"
 #define SSL_TXT_NULL            "NULL"
 
+#define SSL_TXT_kKRB5           "kKRB5"
+#define SSL_TXT_aKRB5           "aKRB5"
+#define SSL_TXT_KRB5            "KRB5"
+
 #define SSL_TXT_kRSA            "kRSA"
 #define SSL_TXT_kDHr            "kDHr"
 #define SSL_TXT_kDHd            "kDHd"
@@ -117,33 +253,46 @@ extern "C" {
 #define SSL_TXT_RC4             "RC4"
 #define SSL_TXT_RC2             "RC2"
 #define SSL_TXT_IDEA            "IDEA"
+#define SSL_TXT_AES             "AESdraft" /* AES ciphersuites are not yet official (thus excluded from 'ALL') */
 #define SSL_TXT_MD5             "MD5"
 #define SSL_TXT_SHA1            "SHA1"
 #define SSL_TXT_SHA             "SHA"
 #define SSL_TXT_EXP             "EXP"
 #define SSL_TXT_EXPORT          "EXPORT"
+#define SSL_TXT_EXP40           "EXPORT40"
+#define SSL_TXT_EXP56           "EXPORT56"
 #define SSL_TXT_SSLV2           "SSLv2"
 #define SSL_TXT_SSLV3           "SSLv3"
+#define SSL_TXT_TLSV1           "TLSv1"
 #define SSL_TXT_ALL             "ALL"
 
-/* 'DEFAULT' at the start of the cipher list insert the following string
- * in addition to this being the default cipher string */
-#ifndef NO_RSA
-#define SSL_DEFAULT_CIPHER_LIST "ALL:!ADH:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP"
-#else
-#define SSL_ALLOW_ADH
-#define SSL_DEFAULT_CIPHER_LIST "HIGH:MEDIUM:LOW:ADH+3DES:ADH+RC4:ADH+DES:+EXP"
-#endif
+/* The following cipher list is used by default.
+ * It also is substituted when an application-defined cipher list string
+ * starts with 'DEFAULT'. */
+#define SSL_DEFAULT_CIPHER_LIST "ALL:!ADH:+RC4:@STRENGTH" /* low priority for RC4 */
 
 /* Used in SSL_set_shutdown()/SSL_get_shutdown(); */
 #define SSL_SENT_SHUTDOWN       1
 #define SSL_RECEIVED_SHUTDOWN   2
 
-#include "crypto.h"
-#include "lhash.h"
-#include "buffer.h"
-#include "bio.h"
-#include "x509.h"
+#ifdef __cplusplus
+}
+#endif
+
+#include <openssl/crypto.h>
+#include <openssl/lhash.h>
+#include <openssl/buffer.h>
+#include <openssl/bio.h>
+#include <openssl/pem.h>
+#include <openssl/x509.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#if (defined(OPENSSL_NO_RSA) || defined(OPENSSL_NO_MD5)) && !defined(OPENSSL_NO_SSL2)
+#define OPENSSL_NO_SSL2
+#endif
 
 #define SSL_FILETYPE_ASN1       X509_FILETYPE_ASN1
 #define SSL_FILETYPE_PEM        X509_FILETYPE_PEM
@@ -157,44 +306,52 @@ typedef struct ssl_st *ssl_crock_st;
 typedef struct ssl_cipher_st
         {
         int valid;
-        char *name;                     /* text name */
+        const char *name;               /* text name */
         unsigned long id;               /* id, 4 bytes, first is version */
         unsigned long algorithms;       /* what ciphers are used */
+        unsigned long algo_strength;    /* strength and export flags */
         unsigned long algorithm2;       /* Extra flags */
+        int strength_bits;              /* Number of bits really used */
+        int alg_bits;                   /* Number of bits for algorithm */
         unsigned long mask;             /* used for matching */
+        unsigned long mask_strength;    /* also used for matching */
         } SSL_CIPHER;
 
+DECLARE_STACK_OF(SSL_CIPHER)
+
+typedef struct ssl_st SSL;
+typedef struct ssl_ctx_st SSL_CTX;
+
 /* Used to hold functions for SSLv2 or SSLv3/TLSv1 functions */
 typedef struct ssl_method_st
         {
         int version;
-        int (*ssl_new)();
-        void (*ssl_clear)();
-        void (*ssl_free)();
-        int (*ssl_accept)();
-        int (*ssl_connect)();
-        int (*ssl_read)();
-        int (*ssl_peek)();
-        int (*ssl_write)();
-        int (*ssl_shutdown)();
-        int (*ssl_renegotiate)();
-        long (*ssl_ctrl)();
-        long (*ssl_ctx_ctrl)();
-        SSL_CIPHER *(*get_cipher_by_char)();
-        int (*put_cipher_by_char)();
-        int (*ssl_pending)();
-        int (*num_ciphers)();
-        SSL_CIPHER *(*get_cipher)();
-        struct ssl_method_st *(*get_ssl_method)();
-        long (*get_timeout)();
+        int (*ssl_new)(SSL *s);
+        void (*ssl_clear)(SSL *s);
+        void (*ssl_free)(SSL *s);
+        int (*ssl_accept)(SSL *s);
+        int (*ssl_connect)(SSL *s);
+        int (*ssl_read)(SSL *s,void *buf,int len);
+        int (*ssl_peek)(SSL *s,void *buf,int len);
+        int (*ssl_write)(SSL *s,const void *buf,int len);
+        int (*ssl_shutdown)(SSL *s);
+        int (*ssl_renegotiate)(SSL *s);
+        int (*ssl_renegotiate_check)(SSL *s);
+        long (*ssl_ctrl)(SSL *s,int cmd,long larg,void *parg);
+        long (*ssl_ctx_ctrl)(SSL_CTX *ctx,int cmd,long larg,void *parg);
+        SSL_CIPHER *(*get_cipher_by_char)(const unsigned char *ptr);
+        int (*put_cipher_by_char)(const SSL_CIPHER *cipher,unsigned char *ptr);
+        int (*ssl_pending)(SSL *s);
+        int (*num_ciphers)(void);
+        SSL_CIPHER *(*get_cipher)(unsigned ncipher);
+        struct ssl_method_st *(*get_ssl_method)(int version);
+        long (*get_timeout)(void);
         struct ssl3_enc_method *ssl3_enc; /* Extra SSLv3/TLS stuff */
+        int (*ssl_version)();
+        long (*ssl_callback_ctrl)(SSL *s, int cb_id, void (*fp)());
+        long (*ssl_ctx_callback_ctrl)(SSL_CTX *s, int cb_id, void (*fp)());
         } SSL_METHOD;
 
-typedef struct ssl_compression_st
-        {
-        char *stuff;
-        } SSL_COMPRESSION;
-
 /* Lets make this into an ASN.1 type structure as follows
  * SSL_SESSION_ID ::= SEQUENCE {
  *      version                 INTEGER,        -- structure version number
@@ -202,10 +359,14 @@ typedef struct ssl_compression_st
  *      Cipher                  OCTET_STRING,   -- the 3 byte cipher ID
  *      Session_ID              OCTET_STRING,   -- the Session ID
  *      Master_key              OCTET_STRING,   -- the master key
+ *      KRB5_principal          OCTET_STRING    -- optional Kerberos principal
  *      Key_Arg [ 0 ] IMPLICIT  OCTET_STRING,   -- the optional Key argument
  *      Time [ 1 ] EXPLICIT     INTEGER,        -- optional Start Time
  *      Timeout [ 2 ] EXPLICIT  INTEGER,        -- optional Timeout ins seconds
  *      Peer [ 3 ] EXPLICIT     X509,           -- optional Peer Certificate
+ *      Session_ID_context [ 4 ] EXPLICIT OCTET_STRING,   -- the Session ID context
+ *      Verify_result [ 5 ] EXPLICIT INTEGER    -- X509_V_... code for `Peer'
+ *      Compression [6] IMPLICIT ASN1_OBJECT    -- compression OID XXXXX
  *      }
  * Look in ssl/ssl_asn1.c for more details
  * I'm using EXPLICIT tags so I can read the damn things using asn1parse :-).
@@ -223,29 +384,43 @@ typedef struct ssl_session_st
         /* session_id - valid? */
         unsigned int session_id_length;
         unsigned char session_id[SSL_MAX_SSL_SESSION_ID_LENGTH];
+        /* this is used to determine whether the session is being reused in
+         * the appropriate context. It is up to the application to set this,
+         * via SSL_new */
+        unsigned int sid_ctx_length;
+        unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH];
+
+#ifndef OPENSSL_NO_KRB5
+        unsigned int krb5_client_princ_len;
+        unsigned char krb5_client_princ[SSL_MAX_KRB5_PRINCIPAL_LENGTH];
+#endif /* OPENSSL_NO_KRB5 */
 
         int not_resumable;
 
         /* The cert is the certificate used to establish this connection */
-        struct cert_st /* CERT */ *cert;
+        struct sess_cert_st /* SESS_CERT */ *sess_cert;
 
-        /* This is the cert for the other end.  On servers, it will be
-         * the same as cert->x509 */
+        /* This is the cert for the other end.
+         * On clients, it will be the same as sess_cert->peer_key->x509
+         * (the latter is not enough as sess_cert is not retained
+         * in the external representation of sessions, see ssl_asn1.c). */
         X509 *peer;
+        /* when app_verify_callback accepts a session where the peer's certificate
+         * is not ok, we must remember the error for session reuse: */
+        long verify_result; /* only for servers */
 
         int references;
         long timeout;
         long time;
 
-        SSL_COMPRESSION *read_compression;
-        SSL_COMPRESSION *write_compression;
+        int compress_meth;              /* Need to lookup the method */
 
         SSL_CIPHER *cipher;
         unsigned long cipher_id;        /* when ASN.1 loaded, this
                                          * needs to be used to load
                                          * the 'cipher' structure */
 
-        STACK /* SSL_CIPHER */ *ciphers; /* shared ciphers? */
+        STACK_OF(SSL_CIPHER) *ciphers; /* shared ciphers? */
 
         CRYPTO_EX_DATA ex_data; /* application specific data */
 
@@ -262,47 +437,126 @@ typedef struct ssl_session_st
 #define SSL_OP_MSIE_SSLV2_RSA_PADDING                   0x00000040L
 #define SSL_OP_SSLEAY_080_CLIENT_DH_BUG                 0x00000080L
 #define SSL_OP_TLS_D5_BUG                               0x00000100L
-#define SSL_OP_TLS_BLOCK_PADDING_BUG                    0x00000200L
+#define SSL_OP_TLS_BLOCK_PADDING_BUG                    0x00000200L
 
-/* If set, only use tmp_dh parameters once */
+/* If set, always create a new key when using tmp_dh parameters */
 #define SSL_OP_SINGLE_DH_USE                            0x00100000L
-/* Set to also use the tmp_rsa key when doing RSA operations. */
+/* Set to always use the tmp_rsa key when doing RSA operations,
+ * even when this violates protocol specs */
 #define SSL_OP_EPHEMERAL_RSA                            0x00200000L
-
+/* Set on servers to choose the cipher according to the server's
+ * preferences */
+#define SSL_OP_CIPHER_SERVER_PREFERENCE                 0x00400000L
+/* If set, a server will allow a client to issue a SSLv3.0 version number
+ * as latest version supported in the premaster secret, even when TLSv1.0
+ * (version 3.1) was announced in the client hello. Normally this is
+ * forbidden to prevent version rollback attacks. */
+#define SSL_OP_TLS_ROLLBACK_BUG                         0x00800000L
+/* As server, disallow session resumption on renegotiation */
+#define SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION   0x01000000L
+
+/* The next flag deliberately changes the ciphertest, this is a check
+ * for the PKCS#1 attack */
+#define SSL_OP_PKCS1_CHECK_1                            0x08000000L
+#define SSL_OP_PKCS1_CHECK_2                            0x10000000L
 #define SSL_OP_NETSCAPE_CA_DN_BUG                       0x20000000L
-#define SSL_OP_NON_EXPORT_FIRST                         0x40000000L
-#define SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG          0x80000000L
+#define SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG          0x40000000L
 #define SSL_OP_ALL                                      0x000FFFFFL
 
-#define SSL_CTX_set_options(ctx,op)     ((ctx)->options|=(op))
-#define SSL_set_options(ssl,op)         ((ssl)->options|=(op))
-
 #define SSL_OP_NO_SSLv2                                 0x01000000L
 #define SSL_OP_NO_SSLv3                                 0x02000000L
 #define SSL_OP_NO_TLSv1                                 0x04000000L
 
-/* Normally you will only use these if your application wants to use
- * the certificate store in other places, perhaps PKCS7 */
-#define SSL_CTX_get_cert_store(ctx)     ((ctx)->cert_store)
-#define SSL_CTX_set_cert_store(ctx,cs) \
-                (X509_STORE_free((ctx)->cert_store),(ctx)->cert_store=(cs))
-
+/* Allow SSL_write(..., n) to return r with 0 < r < n (i.e. report success
+ * when just a single record has been written): */
+#define SSL_MODE_ENABLE_PARTIAL_WRITE       0x00000001L
+/* Make it possible to retry SSL_write() with changed buffer location
+ * (buffer contents must stay the same!); this is not the default to avoid
+ * the misconception that non-blocking SSL_write() behaves like
+ * non-blocking write(): */
+#define SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER 0x00000002L
+/* Never bother the application with retries if the transport
+ * is blocking: */
+#define SSL_MODE_AUTO_RETRY 0x00000004L
+
+/* Note: SSL[_CTX]_set_{options,mode} use |= op on the previous value,
+ * they cannot be used to clear bits. */
+
+#define SSL_CTX_set_options(ctx,op) \
+        SSL_CTX_ctrl((ctx),SSL_CTRL_OPTIONS,(op),NULL)
+#define SSL_CTX_get_options(ctx) \
+        SSL_CTX_ctrl((ctx),SSL_CTRL_OPTIONS,0,NULL)
+#define SSL_set_options(ssl,op) \
+        SSL_ctrl((ssl),SSL_CTRL_OPTIONS,(op),NULL)
+#define SSL_get_options(ssl) \
+        SSL_ctrl((ssl),SSL_CTRL_OPTIONS,0,NULL)
+
+#define SSL_CTX_set_mode(ctx,op) \
+        SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,(op),NULL)
+#define SSL_CTX_get_mode(ctx) \
+        SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,0,NULL)
+#define SSL_set_mode(ssl,op) \
+        SSL_ctrl((ssl),SSL_CTRL_MODE,(op),NULL)
+#define SSL_get_mode(ssl) \
+        SSL_ctrl((ssl),SSL_CTRL_MODE,0,NULL)
+
+
+void SSL_CTX_set_msg_callback(SSL_CTX *ctx, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg));
+void SSL_set_msg_callback(SSL *ssl, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg));
+#define SSL_CTX_set_msg_callback_arg(ctx, arg) SSL_CTX_ctrl((ctx), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg))
+#define SSL_set_msg_callback_arg(ssl, arg) SSL_ctrl((ssl), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg))
+
+
+
+#if defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_WIN32)
+#define SSL_MAX_CERT_LIST_DEFAULT 1024*30 /* 30k max cert list :-) */
+#else
+#define SSL_MAX_CERT_LIST_DEFAULT 1024*100 /* 100k max cert list :-) */
+#endif
 
 #define SSL_SESSION_CACHE_MAX_SIZE_DEFAULT      (1024*20)
 
-typedef struct ssl_ctx_st
+/* This callback type is used inside SSL_CTX, SSL, and in the functions that set
+ * them. It is used to override the generation of SSL/TLS session IDs in a
+ * server. Return value should be zero on an error, non-zero to proceed. Also,
+ * callbacks should themselves check if the id they generate is unique otherwise
+ * the SSL handshake will fail with an error - callbacks can do this using the
+ * 'ssl' value they're passed by;
+ *      SSL_has_matching_session_id(ssl, id, *id_len)
+ * The length value passed in is set at the maximum size the session ID can be.
+ * In SSLv2 this is 16 bytes, whereas SSLv3/TLSv1 it is 32 bytes. The callback
+ * can alter this length to be less if desired, but under SSLv2 session IDs are
+ * supposed to be fixed at 16 bytes so the id will be padded after the callback
+ * returns in this case. It is also an error for the callback to set the size to
+ * zero. */
+typedef int (*GEN_SESSION_CB)(const SSL *ssl, unsigned char *id,
+                                unsigned int *id_len);
+
+typedef struct ssl_comp_st
+        {
+        int id;
+        char *name;
+#ifndef OPENSSL_NO_COMP
+        COMP_METHOD *method;
+#else
+        char *method;
+#endif
+        } SSL_COMP;
+
+DECLARE_STACK_OF(SSL_COMP)
+
+struct ssl_ctx_st
         {
         SSL_METHOD *method;
-        unsigned long options;
 
-        STACK /* SSL_CIPHER */ *cipher_list;
+        STACK_OF(SSL_CIPHER) *cipher_list;
         /* same as above but sorted for lookup */
-        STACK /* SSL_CIPHER */ *cipher_list_by_id;
+        STACK_OF(SSL_CIPHER) *cipher_list_by_id;
 
         struct x509_store_st /* X509_STORE */ *cert_store;
-        struct lhash_st /* LHASH */ *sessions;  /* a set of SSL_SESSION's */
+        struct lhash_st /* LHASH */ *sessions;  /* a set of SSL_SESSIONs */
         /* Most session-ids that will be cached, default is
-         * SSL_SESSION_CACHE_SIZE_DEFAULT. 0 is unlimited. */
+         * SSL_SESSION_CACHE_MAX_SIZE_DEFAULT. 0 is unlimited. */
         unsigned long session_cache_size;
         struct ssl_session_st *session_cache_head;
         struct ssl_session_st *session_cache_tail;
@@ -325,67 +579,95 @@ typedef struct ssl_ctx_st
          * SSL_SESSION_free() when it has finished using it.  Otherwise,
          * on 0, it means the callback has finished with it.
          * If remove_session_cb is not null, it will be called when
-         * a session-id is removed from the cache.  Again, a return
-         * of 0 mens that SSLeay should not SSL_SESSION_free() since
-         * the application is doing something with it. */
-#ifndef NOPROTO
+         * a session-id is removed from the cache.  After the call,
+         * OpenSSL will SSL_SESSION_free() it. */
         int (*new_session_cb)(struct ssl_st *ssl,SSL_SESSION *sess);
         void (*remove_session_cb)(struct ssl_ctx_st *ctx,SSL_SESSION *sess);
         SSL_SESSION *(*get_session_cb)(struct ssl_st *ssl,
                 unsigned char *data,int len,int *copy);
-#else
-        int (*new_session_cb)();
-        void (*remove_session_cb)();
-        SSL_SESSION *(*get_session_cb)();
-#endif
 
-        int sess_connect;       /* SSL new connection - started */
-        int sess_connect_renegotiate;/* SSL renegotiatene  - requested */
-        int sess_connect_good;  /* SSL new connection/renegotiate - finished */
-        int sess_accept;        /* SSL new accept - started */
-        int sess_accept_renegotiate;/* SSL renegotiatene - requested */
-        int sess_accept_good;   /* SSL accept/renegotiate - finished */
-        int sess_miss;          /* session lookup misses  */
-        int sess_timeout;       /* session reuse attempt on timeouted session */
-        int sess_cache_full;    /* session removed due to full cache */
-        int sess_hit;           /* session reuse actually done */
-        int sess_cb_hit;        /* session-id that was not in the cache was
-                                 * passed back via the callback.  This
-                                 * indicates that the application is supplying
-                                 * session-id's from other processes -
-                                 * spooky :-) */
+        struct
+                {
+                int sess_connect;       /* SSL new conn - started */
+                int sess_connect_renegotiate;/* SSL reneg - requested */
+                int sess_connect_good;  /* SSL new conne/reneg - finished */
+                int sess_accept;        /* SSL new accept - started */
+                int sess_accept_renegotiate;/* SSL reneg - requested */
+                int sess_accept_good;   /* SSL accept/reneg - finished */
+                int sess_miss;          /* session lookup misses  */
+                int sess_timeout;       /* reuse attempt on timeouted session */
+                int sess_cache_full;    /* session removed due to full cache */
+                int sess_hit;           /* session reuse actually done */
+                int sess_cb_hit;        /* session-id that was not
+                                         * in the cache was
+                                         * passed back via the callback.  This
+                                         * indicates that the application is
+                                         * supplying session-id's from other
+                                         * processes - spooky :-) */
+                } stats;
 
         int references;
 
-        void (*info_callback)();
-
         /* if defined, these override the X509_verify_cert() calls */
-        int (*app_verify_callback)();
-        char *app_verify_arg;
-
-        /* default values to use in SSL structures */
-        struct cert_st /* CERT */ *default_cert;
-        int default_read_ahead;
-        int default_verify_mode;
-        int (*default_verify_callback)();
+        int (*app_verify_callback)(X509_STORE_CTX *, void *);
+        void *app_verify_arg;
+        /* before OpenSSL 0.9.7, 'app_verify_arg' was ignored
+         * ('app_verify_callback' was called with just one argument) */
 
         /* Default password callback. */
-        int (*default_passwd_callback)();
+        pem_password_cb *default_passwd_callback;
+
+        /* Default password callback user data. */
+        void *default_passwd_callback_userdata;
 
         /* get client cert callback */
-        int (*client_cert_cb)(/* SSL *ssl, X509 **x509, EVP_PKEY **pkey */);
+        int (*client_cert_cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey);
 
-        /* what we put in client requests */
-        STACK *client_CA;
+        CRYPTO_EX_DATA ex_data;
 
-        int quiet_shutdown;
+        const EVP_MD *rsa_md5;/* For SSLv2 - name is 'ssl2-md5' */
+        const EVP_MD *md5;      /* For SSLv3/TLSv1 'ssl3-md5' */
+        const EVP_MD *sha1;   /* For SSLv3/TLSv1 'ssl3->sha1' */
 
-        CRYPTO_EX_DATA ex_data;
+        STACK_OF(X509) *extra_certs;
+        STACK_OF(SSL_COMP) *comp_methods; /* stack of SSL_COMP, SSLv3/TLSv1 */
+
+
+        /* Default values used when no per-SSL value is defined follow */
+
+        void (*info_callback)(const SSL *ssl,int type,int val); /* used if SSL's info_callback is NULL */
+
+        /* what we put in client cert requests */
+        STACK_OF(X509_NAME) *client_CA;
 
-        EVP_MD *rsa_md5;/* For SSLv2 - name is 'ssl2-md5' */
-        EVP_MD *md5;    /* For SSLv3/TLSv1 'ssl3-md5' */
-        EVP_MD *sha1;   /* For SSLv3/TLSv1 'ssl3->sha1' */
-        } SSL_CTX;
+
+        /* Default values to use in SSL structures follow (these are copied by SSL_new) */
+
+        unsigned long options;
+        unsigned long mode;
+        long max_cert_list;
+
+        struct cert_st /* CERT */ *cert;
+        int read_ahead;
+
+        /* callback that allows applications to peek at protocol messages */
+        void (*msg_callback)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg);
+        void *msg_callback_arg;
+
+        int verify_mode;
+        int verify_depth;
+        unsigned int sid_ctx_length;
+        unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH];
+        int (*default_verify_callback)(int ok,X509_STORE_CTX *ctx); /* called 'verify_callback' in the SSL */
+
+        /* Default generate session ID callback. */
+        GEN_SESSION_CB generate_session_id;
+
+        int purpose;            /* Purpose setting */
+        int trust;              /* Trust setting */
+
+        int quiet_shutdown;
+        };
 
 #define SSL_SESS_CACHE_OFF                      0x0000
 #define SSL_SESS_CACHE_CLIENT                   0x0001
@@ -397,23 +679,31 @@ typedef struct ssl_ctx_st
  * defined, this will still get called. */
 #define SSL_SESS_CACHE_NO_INTERNAL_LOOKUP       0x0100
 
-#define SSL_CTX_sessions(ctx)           ((ctx)->sessions)
-/* You will need to include lhash.h to access the following #define */
-#define SSL_CTX_sess_number(ctx)        ((ctx)->sessions->num_items)
-#define SSL_CTX_sess_connect(ctx)       ((ctx)->sess_connect)
-#define SSL_CTX_sess_connect_good(ctx)  ((ctx)->sess_connect_good)
-#define SSL_CTX_sess_accept(ctx)        ((ctx)->sess_accept)
-#define SSL_CTX_sess_accept_renegotiate(ctx)    ((ctx)->sess_accept_renegotiate)
-#define SSL_CTX_sess_connect_renegotiate(ctx)   ((ctx)->sess_connect_renegotiate)
-#define SSL_CTX_sess_accept_good(ctx)   ((ctx)->sess_accept_good)
-#define SSL_CTX_sess_hits(ctx)          ((ctx)->sess_hit)
-#define SSL_CTX_sess_cb_hits(ctx)       ((ctx)->sess_cb_hit)
-#define SSL_CTX_sess_misses(ctx)        ((ctx)->sess_miss)
-#define SSL_CTX_sess_timeouts(ctx)      ((ctx)->sess_timeout)
-#define SSL_CTX_sess_cache_full(ctx)    ((ctx)->sess_cache_full)
-
-#define SSL_CTX_sess_set_cache_size(ctx,t) ((ctx)->session_cache_size=(t))
-#define SSL_CTX_sess_get_cache_size(ctx)   ((ctx)->session_cache_size)
+  struct lhash_st *SSL_CTX_sessions(SSL_CTX *ctx);
+#define SSL_CTX_sess_number(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_NUMBER,0,NULL)
+#define SSL_CTX_sess_connect(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT,0,NULL)
+#define SSL_CTX_sess_connect_good(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_GOOD,0,NULL)
+#define SSL_CTX_sess_connect_renegotiate(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_RENEGOTIATE,0,NULL)
+#define SSL_CTX_sess_accept(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT,0,NULL)
+#define SSL_CTX_sess_accept_renegotiate(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_RENEGOTIATE,0,NULL)
+#define SSL_CTX_sess_accept_good(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_GOOD,0,NULL)
+#define SSL_CTX_sess_hits(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_HIT,0,NULL)
+#define SSL_CTX_sess_cb_hits(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CB_HIT,0,NULL)
+#define SSL_CTX_sess_misses(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_MISSES,0,NULL)
+#define SSL_CTX_sess_timeouts(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_TIMEOUTS,0,NULL)
+#define SSL_CTX_sess_cache_full(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CACHE_FULL,0,NULL)
 
 #define SSL_CTX_sess_set_new_cb(ctx,cb) ((ctx)->new_session_cb=(cb))
 #define SSL_CTX_sess_get_new_cb(ctx)    ((ctx)->new_session_cb)
@@ -421,15 +711,8 @@ typedef struct ssl_ctx_st
 #define SSL_CTX_sess_get_remove_cb(ctx) ((ctx)->remove_session_cb)
 #define SSL_CTX_sess_set_get_cb(ctx,cb) ((ctx)->get_session_cb=(cb))
 #define SSL_CTX_sess_get_get_cb(ctx)    ((ctx)->get_session_cb)
-#define SSL_CTX_set_session_cache_mode(ctx,m)   ((ctx)->session_cache_mode=(m))
-#define SSL_CTX_get_session_cache_mode(ctx)     ((ctx)->session_cache_mode)
-#define SSL_CTX_set_timeout(ctx,t)      ((ctx)->session_timeout=(t))
-#define SSL_CTX_get_timeout(ctx)        ((ctx)->session_timeout)
-
 #define SSL_CTX_set_info_callback(ctx,cb)       ((ctx)->info_callback=(cb))
 #define SSL_CTX_get_info_callback(ctx)          ((ctx)->info_callback)
-#define SSL_CTX_set_default_read_ahead(ctx,m) (((ctx)->default_read_ahead)=(m))
-
 #define SSL_CTX_set_client_cert_cb(ctx,cb)      ((ctx)->client_cert_cb=(cb))
 #define SSL_CTX_get_client_cert_cb(ctx)         ((ctx)->client_cert_cb)
 
@@ -439,18 +722,16 @@ typedef struct ssl_ctx_st
 #define SSL_X509_LOOKUP 4
 
 /* These will only be used when doing non-blocking IO */
-#define SSL_want(s)             ((s)->rwstate)
-#define SSL_want_nothing(s)     ((s)->rwstate == SSL_NOTHING)
-#define SSL_want_read(s)        ((s)->rwstate == SSL_READING)
-#define SSL_want_write(s)       ((s)->rwstate == SSL_WRITING)
-#define SSL_want_x509_lookup(s) ((s)->rwstate == SSL_X509_LOOKUP)
+#define SSL_want_nothing(s)     (SSL_want(s) == SSL_NOTHING)
+#define SSL_want_read(s)        (SSL_want(s) == SSL_READING)
+#define SSL_want_write(s)       (SSL_want(s) == SSL_WRITING)
+#define SSL_want_x509_lookup(s) (SSL_want(s) == SSL_X509_LOOKUP)
 
-typedef struct ssl_st
+struct ssl_st
         {
-        /* procol version
-         * 2 for SSLv2
-         * 3 for SSLv3
-         * -3 for SSLv3 but accept SSLv2 */
+        /* protocol version
+         * (one of SSL2_VERSION, SSL3_VERSION, TLS1_VERSION)
+         */
         int version;
         int type; /* SSL_ST_CONNECT or SSL_ST_ACCEPT */
 
@@ -460,10 +741,10 @@ typedef struct ssl_st
          * same.  This is so data can be read and written to different
          * handlers */
 
-#ifdef HEADER_BIO_H
+#ifndef OPENSSL_NO_BIO
         BIO *rbio; /* used by SSL_read */
         BIO *wbio; /* used by SSL_write */
-        BIO *bbio; /* used during session-id reuse to concatinate
+        BIO *bbio; /* used during session-id reuse to concatenate
                     * messages */
 #else
         char *rbio; /* used by SSL_read */
@@ -480,9 +761,22 @@ typedef struct ssl_st
         int in_handshake;
         int (*handshake_func)();
 
-/*      int server;*/   /* are we the server side? */
-
-        int new_session;/* 1 if we are to use a new session */
+        /* Imagine that here's a boolean member "init" that is
+         * switched as soon as SSL_set_{accept/connect}_state
+         * is called for the first time, so that "state" and
+         * "handshake_func" are properly initialized.  But as
+         * handshake_func is == 0 until then, we use this
+         * test instead of an "init" member.
+         */
+
+        int server;     /* are we the server side? - mostly used by SSL_clear*/
+
+        int new_session;/* 1 if we are to use a new session.
+                         * 2 if we are a server and are inside a handshake
+                         *   (i.e. not just sending a HelloRequest)
+                         * NB: For servers, the 'new' session may actually be a previously
+                         * cached session or even the previous session unless
+                         * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION is set */
         int quiet_shutdown;/* don't send shutdown packets */
         int shutdown;   /* we have shut things down, 0x01 sent, 0x02
                          * for received */
@@ -490,6 +784,7 @@ typedef struct ssl_st
         int rstate;     /* where we are when reading */
 
         BUF_MEM *init_buf;      /* buffer used during init */
+        void *init_msg;         /* pointer to handshake message body, set by ssl3_get_message() */
         int init_num;           /* amount read/written */
         int init_off;           /* amount read/written */
 
@@ -497,26 +792,43 @@ typedef struct ssl_st
         unsigned char *packet;
         unsigned int packet_length;
 
-        struct ssl2_ctx_st *s2; /* SSLv2 variables */
-        struct ssl3_ctx_st *s3; /* SSLv3 variables */
+        struct ssl2_state_st *s2; /* SSLv2 variables */
+        struct ssl3_state_st *s3; /* SSLv3 variables */
+
+        int read_ahead;         /* Read as many input bytes as possible
+                                 * (for non-blocking reads) */
+
+        /* callback that allows applications to peek at protocol messages */
+        void (*msg_callback)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg);
+        void *msg_callback_arg;
 
-        int read_ahead;         /* Read as many input bytes as possible */
         int hit;                /* reusing a previous session */
 
+        int purpose;            /* Purpose setting */
+        int trust;              /* Trust setting */
+
         /* crypto */
-        STACK /* SSL_CIPHER */ *cipher_list;
-        STACK /* SSL_CIPHER */ *cipher_list_by_id;
+        STACK_OF(SSL_CIPHER) *cipher_list;
+        STACK_OF(SSL_CIPHER) *cipher_list_by_id;
 
-        /* These are the ones being used, the ones is SSL_SESSION are
+        /* These are the ones being used, the ones in SSL_SESSION are
          * the ones to be 'copied' into these ones */
 
         EVP_CIPHER_CTX *enc_read_ctx;           /* cryptographic state */
-        EVP_MD *read_hash;                      /* used for mac generation */
-        SSL_COMPRESSION *read_compression;      /* compression */
+        const EVP_MD *read_hash;                /* used for mac generation */
+#ifndef OPENSSL_NO_COMP
+        COMP_CTX *expand;                       /* uncompress */
+#else
+        char *expand;
+#endif
 
         EVP_CIPHER_CTX *enc_write_ctx;          /* cryptographic state */
-        EVP_MD *write_hash;                     /* used for mac generation */
-        SSL_COMPRESSION *write_compression;     /* compression */
+        const EVP_MD *write_hash;               /* used for mac generation */
+#ifndef OPENSSL_NO_COMP
+        COMP_CTX *compress;                     /* compression */
+#else
+        char *compress; 
+#endif
 
         /* session info */
 
@@ -524,18 +836,32 @@ typedef struct ssl_st
         /* This is used to hold the server certificate used */
         struct cert_st /* CERT */ *cert;
 
+        /* the session_id_context is used to ensure sessions are only reused
+         * in the appropriate context */
+        unsigned int sid_ctx_length;
+        unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH];
+
         /* This can also be in the session once a session is established */
         SSL_SESSION *session;
 
+        /* Default generate session ID callback. */
+        GEN_SESSION_CB generate_session_id;
+
         /* Used in SSL2 and SSL3 */
         int verify_mode;        /* 0 don't care about verify failure.
                                  * 1 fail if verify fails */
-        int (*verify_callback)(); /* fail if callback returns 0 */
-        void (*info_callback)(); /* optional informational callback */
+        int verify_depth;
+        int (*verify_callback)(int ok,X509_STORE_CTX *ctx); /* fail if callback returns 0 */
+
+        void (*info_callback)(const SSL *ssl,int type,int val); /* optional informational callback */
 
         int error;              /* error bytes to be written */
         int error_code;         /* actual code */
 
+#ifndef OPENSSL_NO_KRB5
+        KSSL_CTX *kssl_ctx;     /* Kerberos 5 context */
+#endif  /* OPENSSL_NO_KRB5 */
+
         SSL_CTX *ctx;
         /* set this flag to 1 and a sleep(1) is put into all SSL_read()
          * and SSL_write() calls, good for nbio debuging :-) */
@@ -546,19 +872,31 @@ typedef struct ssl_st
         CRYPTO_EX_DATA ex_data;
 
         /* for server side, keep the list of CA_dn we can use */
-        STACK /* X509_NAME */ *client_CA;
+        STACK_OF(X509_NAME) *client_CA;
 
         int references;
-        unsigned long options;
+        unsigned long options; /* protocol behaviour */
+        unsigned long mode; /* API behaviour */
+        long max_cert_list;
         int first_packet;
-        } SSL;
+        int client_version;     /* what was passed, used for
+                                 * SSLv3/TLS rollback check */
+        };
 
-#include "ssl2.h"
-#include "ssl3.h"
-#include "tls1.h" /* This is mostly sslv3 with a few tweaks */
-#include "ssl23.h"
+#ifdef __cplusplus
+}
+#endif
 
-/* compatablity */
+#include <openssl/ssl2.h>
+#include <openssl/ssl3.h>
+#include <openssl/tls1.h> /* This is mostly sslv3 with a few tweaks */
+#include <openssl/ssl23.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* compatibility */
 #define SSL_set_app_data(s,arg)         (SSL_set_ex_data(s,0,(char *)arg))
 #define SSL_get_app_data(s)             (SSL_get_ex_data(s,0))
 #define SSL_SESSION_set_app_data(s,a)   (SSL_SESSION_set_ex_data(s,0,(char *)a))
@@ -567,7 +905,7 @@ typedef struct ssl_st
 #define SSL_CTX_set_app_data(ctx,arg)   (SSL_CTX_set_ex_data(ctx,0,(char *)arg))
 
 /* The following are the possible values for ssl->state are are
- * used to indicate where we are upto in the SSL connection establishment.
+ * used to indicate where we are up to in the SSL connection establishment.
  * The macros that follow are about the only things you should need to use
  * and even then, only when using non-blocking IO.
  * It can also be useful to work out where you were when the connection
@@ -609,6 +947,13 @@ typedef struct ssl_st
 #define SSL_ST_READ_BODY                        0xF1
 #define SSL_ST_READ_DONE                        0xF2
 
+/* Obtain latest Finished message
+ *   -- that we sent (SSL_get_finished)
+ *   -- that we expected from peer (SSL_get_peer_finished).
+ * Returns length (0 == no Finished so far), copies up to 'count' bytes. */
+size_t SSL_get_finished(SSL *s, void *buf, size_t count);
+size_t SSL_get_peer_finished(SSL *s, void *buf, size_t count);
+
 /* use either SSL_VERIFY_NONE or SSL_VERIFY_PEER, the last 2 options
  * are 'ored' with SSL_VERIFY_PEER if they are desired */
 #define SSL_VERIFY_NONE                 0x00
@@ -616,7 +961,10 @@ typedef struct ssl_st
 #define SSL_VERIFY_FAIL_IF_NO_PEER_CERT 0x02
 #define SSL_VERIFY_CLIENT_ONCE          0x04
 
-/* this is for backward compatablility */
+#define OpenSSL_add_ssl_algorithms()    SSL_library_init()
+#define SSLeay_add_ssl_algorithms()     SSL_library_init()
+
+/* this is for backward compatibility */
 #if 0 /* NEW_SSLEAY */
 #define SSL_CTX_set_default_verify(a,b,c) SSL_CTX_set_verify(a,b,c)
 #define SSL_set_pref_cipher(c,n)        SSL_set_cipher_list(c,n)
@@ -624,7 +972,7 @@ typedef struct ssl_st
 #define SSL_remove_session(a,b)         SSL_CTX_remove_session((a),(b))
 #define SSL_flush_sessions(a,b)         SSL_CTX_flush_sessions((a),(b))
 #endif
-/* More backward compatablity */
+/* More backward compatibility */
 #define SSL_get_cipher(s) \
                 SSL_CIPHER_get_name(SSL_get_current_cipher(s))
 #define SSL_get_cipher_bits(s,np) \
@@ -638,28 +986,25 @@ typedef struct ssl_st
 #define SSL_get_timeout(a)      SSL_SESSION_get_timeout(a)
 #define SSL_set_timeout(a,b)    SSL_SESSION_set_timeout((a),(b))
 
-/* VMS linker has a 31 char name limit */
-#define SSL_CTX_set_cert_verify_callback(a,b,c) \
-                SSL_CTX_set_cert_verify_cb((a),(b),(c))
-
 #if 1 /*SSLEAY_MACROS*/
 #define d2i_SSL_SESSION_bio(bp,s_id) (SSL_SESSION *)ASN1_d2i_bio( \
         (char *(*)())SSL_SESSION_new,(char *(*)())d2i_SSL_SESSION, \
         (bp),(unsigned char **)(s_id))
 #define i2d_SSL_SESSION_bio(bp,s_id) ASN1_i2d_bio(i2d_SSL_SESSION, \
         bp,(unsigned char *)s_id)
-#define PEM_read_SSL_SESSION(fp,x,cb) (SSL_SESSION *)PEM_ASN1_read( \
-        (char *(*)())d2i_SSL_SESSION,PEM_STRING_SSL_SESSION,fp,(char **)x,cb)
-#define PEM_read_bio_SSL_SESSION(bp,x,cb) (SSL_SESSION *)PEM_ASN1_read_bio( \
-        (char *(*)())d2i_SSL_SESSION,PEM_STRING_SSL_SESSION,bp,(char **)x,cb)
+#define PEM_read_SSL_SESSION(fp,x,cb,u) (SSL_SESSION *)PEM_ASN1_read( \
+        (char *(*)())d2i_SSL_SESSION,PEM_STRING_SSL_SESSION,fp,(char **)x,cb,u)
+#define PEM_read_bio_SSL_SESSION(bp,x,cb,u) (SSL_SESSION *)PEM_ASN1_read_bio( \
+        (char *(*)())d2i_SSL_SESSION,PEM_STRING_SSL_SESSION,bp,(char **)x,cb,u)
 #define PEM_write_SSL_SESSION(fp,x) \
         PEM_ASN1_write((int (*)())i2d_SSL_SESSION, \
-                PEM_STRING_SSL_SESSION,fp, (char *)x, NULL,NULL,0,NULL)
+                PEM_STRING_SSL_SESSION,fp, (char *)x, NULL,NULL,0,NULL,NULL)
 #define PEM_write_bio_SSL_SESSION(bp,x) \
         PEM_ASN1_write_bio((int (*)())i2d_SSL_SESSION, \
-                PEM_STRING_SSL_SESSION,bp, (char *)x, NULL,NULL,0,NULL)
+                PEM_STRING_SSL_SESSION,bp, (char *)x, NULL,NULL,0,NULL,NULL)
 #endif
 
+#define SSL_AD_REASON_OFFSET            1000
 /* These alert types are for SSLv3 and TLSv1 */
 #define SSL_AD_CLOSE_NOTIFY             SSL3_AD_CLOSE_NOTIFY
 #define SSL_AD_UNEXPECTED_MESSAGE       SSL3_AD_UNEXPECTED_MESSAGE /* fatal */
@@ -679,11 +1024,11 @@ typedef struct ssl_st
 #define SSL_AD_ACCESS_DENIED            TLS1_AD_ACCESS_DENIED   /* fatal */
 #define SSL_AD_DECODE_ERROR             TLS1_AD_DECODE_ERROR    /* fatal */
 #define SSL_AD_DECRYPT_ERROR            TLS1_AD_DECRYPT_ERROR
-#define SSL_AD_EXPORT_RESTRICION        TLS1_AD_EXPORT_RESTRICION/* fatal */
+#define SSL_AD_EXPORT_RESTRICTION       TLS1_AD_EXPORT_RESTRICTION/* fatal */
 #define SSL_AD_PROTOCOL_VERSION         TLS1_AD_PROTOCOL_VERSION /* fatal */
 #define SSL_AD_INSUFFICIENT_SECURITY    TLS1_AD_INSUFFICIENT_SECURITY/* fatal */
 #define SSL_AD_INTERNAL_ERROR           TLS1_AD_INTERNAL_ERROR  /* fatal */
-#define SSL_AD_USER_CANCLED             TLS1_AD_USER_CANCLED
+#define SSL_AD_USER_CANCELLED           TLS1_AD_USER_CANCELLED
 #define SSL_AD_NO_RENEGOTIATION         TLS1_AD_NO_RENEGOTIATION
 
 #define SSL_ERROR_NONE                  0
@@ -691,21 +1036,53 @@ typedef struct ssl_st
 #define SSL_ERROR_WANT_READ             2
 #define SSL_ERROR_WANT_WRITE            3
 #define SSL_ERROR_WANT_X509_LOOKUP      4
-#define SSL_ERROR_SYSCALL               5 /* look at errno */
+#define SSL_ERROR_SYSCALL               5 /* look at error stack/return value/errno */
 #define SSL_ERROR_ZERO_RETURN           6
 #define SSL_ERROR_WANT_CONNECT          7
+#define SSL_ERROR_WANT_ACCEPT           8
 
 #define SSL_CTRL_NEED_TMP_RSA                   1
 #define SSL_CTRL_SET_TMP_RSA                    2
 #define SSL_CTRL_SET_TMP_DH                     3
 #define SSL_CTRL_SET_TMP_RSA_CB                 4
 #define SSL_CTRL_SET_TMP_DH_CB                  5
-/* Add these ones */
+
 #define SSL_CTRL_GET_SESSION_REUSED             6
 #define SSL_CTRL_GET_CLIENT_CERT_REQUEST        7
 #define SSL_CTRL_GET_NUM_RENEGOTIATIONS         8
 #define SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS       9
 #define SSL_CTRL_GET_TOTAL_RENEGOTIATIONS       10
+#define SSL_CTRL_GET_FLAGS                      11
+#define SSL_CTRL_EXTRA_CHAIN_CERT               12
+
+#define SSL_CTRL_SET_MSG_CALLBACK               13
+#define SSL_CTRL_SET_MSG_CALLBACK_ARG           14
+
+/* Stats */
+#define SSL_CTRL_SESS_NUMBER                    20
+#define SSL_CTRL_SESS_CONNECT                   21
+#define SSL_CTRL_SESS_CONNECT_GOOD              22
+#define SSL_CTRL_SESS_CONNECT_RENEGOTIATE       23
+#define SSL_CTRL_SESS_ACCEPT                    24
+#define SSL_CTRL_SESS_ACCEPT_GOOD               25
+#define SSL_CTRL_SESS_ACCEPT_RENEGOTIATE        26
+#define SSL_CTRL_SESS_HIT                       27
+#define SSL_CTRL_SESS_CB_HIT                    28
+#define SSL_CTRL_SESS_MISSES                    29
+#define SSL_CTRL_SESS_TIMEOUTS                  30
+#define SSL_CTRL_SESS_CACHE_FULL                31
+#define SSL_CTRL_OPTIONS                        32
+#define SSL_CTRL_MODE                           33
+
+#define SSL_CTRL_GET_READ_AHEAD                 40
+#define SSL_CTRL_SET_READ_AHEAD                 41
+#define SSL_CTRL_SET_SESS_CACHE_SIZE            42
+#define SSL_CTRL_GET_SESS_CACHE_SIZE            43
+#define SSL_CTRL_SET_SESS_CACHE_MODE            44
+#define SSL_CTRL_GET_SESS_CACHE_MODE            45
+
+#define SSL_CTRL_GET_MAX_CERT_LIST              50
+#define SSL_CTRL_SET_MAX_CERT_LIST              51
 
 #define SSL_session_reused(ssl) \
         SSL_ctrl((ssl),SSL_CTRL_GET_SESSION_REUSED,0,NULL)
@@ -723,18 +1100,17 @@ typedef struct ssl_st
 #define SSL_CTX_set_tmp_dh(ctx,dh) \
         SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_DH,0,(char *)dh)
 
-/* For the next 2, the callbacks are 
- * RSA *tmp_rsa_cb(int export)
- * DH *tmp_dh_cb(int export)
- */
-#define SSL_CTX_set_tmp_rsa_callback(ctx,cb) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_RSA_CB,0,(char *)cb)
-#define SSL_CTX_set_tmp_dh_callback(ctx,dh) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_DH_CB,0,(char *)dh)
+#define SSL_need_tmp_RSA(ssl) \
+        SSL_ctrl(ssl,SSL_CTRL_NEED_TMP_RSA,0,NULL)
+#define SSL_set_tmp_rsa(ssl,rsa) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TMP_RSA,0,(char *)rsa)
+#define SSL_set_tmp_dh(ssl,dh) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TMP_DH,0,(char *)dh)
 
-#ifndef NOPROTO
+#define SSL_CTX_add_extra_chain_cert(ctx,x509) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_EXTRA_CHAIN_CERT,0,(char *)x509)
 
-#ifdef HEADER_BIO_H
+#ifndef OPENSSL_NO_BIO
 BIO_METHOD *BIO_f_ssl(void);
 BIO *BIO_new_ssl(SSL_CTX *ctx,int client);
 BIO *BIO_new_ssl_connect(SSL_CTX *ctx);
@@ -744,60 +1120,84 @@ void BIO_ssl_shutdown(BIO *ssl_bio);
 
 #endif
 
-int     SSL_CTX_set_cipher_list(SSL_CTX *,char *str);
+int     SSL_CTX_set_cipher_list(SSL_CTX *,const char *str);
 SSL_CTX *SSL_CTX_new(SSL_METHOD *meth);
 void    SSL_CTX_free(SSL_CTX *);
-void    SSL_clear(SSL *s);
+long SSL_CTX_set_timeout(SSL_CTX *ctx,long t);
+long SSL_CTX_get_timeout(SSL_CTX *ctx);
+X509_STORE *SSL_CTX_get_cert_store(SSL_CTX *);
+void SSL_CTX_set_cert_store(SSL_CTX *,X509_STORE *);
+int SSL_want(SSL *s);
+int     SSL_clear(SSL *s);
+
 void    SSL_CTX_flush_sessions(SSL_CTX *ctx,long tm);
 
 SSL_CIPHER *SSL_get_current_cipher(SSL *s);
 int     SSL_CIPHER_get_bits(SSL_CIPHER *c,int *alg_bits);
 char *  SSL_CIPHER_get_version(SSL_CIPHER *c);
-char *  SSL_CIPHER_get_name(SSL_CIPHER *c);
+const char *    SSL_CIPHER_get_name(SSL_CIPHER *c);
 
 int     SSL_get_fd(SSL *s);
-char  * SSL_get_cipher_list(SSL *s,int n);
+int     SSL_get_rfd(SSL *s);
+int     SSL_get_wfd(SSL *s);
+const char  * SSL_get_cipher_list(SSL *s,int n);
 char *  SSL_get_shared_ciphers(SSL *s, char *buf, int len);
 int     SSL_get_read_ahead(SSL * s);
 int     SSL_pending(SSL *s);
-#ifndef NO_SOCK
+#ifndef OPENSSL_NO_SOCK
 int     SSL_set_fd(SSL *s, int fd);
 int     SSL_set_rfd(SSL *s, int fd);
 int     SSL_set_wfd(SSL *s, int fd);
 #endif
-#ifdef HEADER_BIO_H
+#ifndef OPENSSL_NO_BIO
 void    SSL_set_bio(SSL *s, BIO *rbio,BIO *wbio);
 BIO *   SSL_get_rbio(SSL *s);
 BIO *   SSL_get_wbio(SSL *s);
 #endif
-int     SSL_set_cipher_list(SSL *s, char *str);
+int     SSL_set_cipher_list(SSL *s, const char *str);
 void    SSL_set_read_ahead(SSL *s, int yes);
 int     SSL_get_verify_mode(SSL *s);
-int     (*SSL_get_verify_callback(SSL *s))();
-void    SSL_set_verify(SSL *s, int mode, int (*callback) ());
+int     SSL_get_verify_depth(SSL *s);
+int     (*SSL_get_verify_callback(SSL *s))(int,X509_STORE_CTX *);
+void    SSL_set_verify(SSL *s, int mode,
+                       int (*callback)(int ok,X509_STORE_CTX *ctx));
+void    SSL_set_verify_depth(SSL *s, int depth);
+#ifndef OPENSSL_NO_RSA
 int     SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa);
+#endif
 int     SSL_use_RSAPrivateKey_ASN1(SSL *ssl, unsigned char *d, long len);
 int     SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey);
 int     SSL_use_PrivateKey_ASN1(int pk,SSL *ssl, unsigned char *d, long len);
 int     SSL_use_certificate(SSL *ssl, X509 *x);
-int     SSL_use_certificate_ASN1(SSL *ssl, int len, unsigned char *d);
-
-#ifndef NO_STDIO
-int     SSL_use_RSAPrivateKey_file(SSL *ssl, char *file, int type);
-int     SSL_use_PrivateKey_file(SSL *ssl, char *file, int type);
-int     SSL_use_certificate_file(SSL *ssl, char *file, int type);
-int     SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, char *file, int type);
-int     SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, char *file, int type);
-int     SSL_CTX_use_certificate_file(SSL_CTX *ctx, char *file, int type);
-STACK * SSL_load_client_CA_file(char *file);
+int     SSL_use_certificate_ASN1(SSL *ssl, unsigned char *d, int len);
+
+#ifndef OPENSSL_NO_STDIO
+int     SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type);
+int     SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type);
+int     SSL_use_certificate_file(SSL *ssl, const char *file, int type);
+int     SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file, int type);
+int     SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type);
+int     SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file, int type);
+int     SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file); /* PEM type */
+STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file);
+int     SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stackCAs,
+                                            const char *file);
+#ifndef OPENSSL_SYS_WIN32
+#ifndef OPENSSL_SYS_VMS
+#ifndef OPENSSL_SYS_MACINTOSH_CLASSIC /* XXXXX: Better scheme needed! [was: #ifndef MAC_OS_pre_X] */
+int     SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stackCAs,
+                                           const char *dir);
+#endif
+#endif
+#endif
+
 #endif
 
-void    ERR_load_SSL_strings(void );
 void    SSL_load_error_strings(void );
-char *  SSL_state_string(SSL *s);
-char *  SSL_rstate_string(SSL *s);
-char *  SSL_state_string_long(SSL *s);
-char *  SSL_rstate_string_long(SSL *s);
+const char *SSL_state_string(const SSL *s);
+const char *SSL_rstate_string(const SSL *s);
+const char *SSL_state_string_long(const SSL *s);
+const char *SSL_rstate_string_long(const SSL *s);
 long    SSL_SESSION_get_time(SSL_SESSION *s);
 long    SSL_SESSION_set_time(SSL_SESSION *s, long t);
 long    SSL_SESSION_get_timeout(SSL_SESSION *s);
@@ -807,10 +1207,10 @@ void	SSL_copy_session_id(SSL *to,SSL *from);
 SSL_SESSION *SSL_SESSION_new(void);
 unsigned long SSL_SESSION_hash(SSL_SESSION *a);
 int     SSL_SESSION_cmp(SSL_SESSION *a,SSL_SESSION *b);
-#ifndef NO_FP_API
+#ifndef OPENSSL_NO_FP_API
 int     SSL_SESSION_print_fp(FILE *fp,SSL_SESSION *ses);
 #endif
-#ifdef HEADER_BIO_H
+#ifndef OPENSSL_NO_BIO
 int     SSL_SESSION_print(BIO *fp,SSL_SESSION *ses);
 #endif
 void    SSL_SESSION_free(SSL_SESSION *ses);
@@ -818,19 +1218,28 @@ int	i2d_SSL_SESSION(SSL_SESSION *in,unsigned char **pp);
 int     SSL_set_session(SSL *to, SSL_SESSION *session);
 int     SSL_CTX_add_session(SSL_CTX *s, SSL_SESSION *c);
 int     SSL_CTX_remove_session(SSL_CTX *,SSL_SESSION *c);
+int     SSL_CTX_set_generate_session_id(SSL_CTX *, GEN_SESSION_CB);
+int     SSL_set_generate_session_id(SSL *, GEN_SESSION_CB);
+int     SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
+                                        unsigned int id_len);
 SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a,unsigned char **pp,long length);
 
 #ifdef HEADER_X509_H
 X509 *  SSL_get_peer_certificate(SSL *s);
 #endif
 
-STACK * SSL_get_peer_cert_chain(SSL *s);
+STACK_OF(X509) *SSL_get_peer_cert_chain(SSL *s);
 
 int SSL_CTX_get_verify_mode(SSL_CTX *ctx);
-int (*SSL_CTX_get_verify_callback(SSL_CTX *ctx))();
-void SSL_CTX_set_verify(SSL_CTX *ctx,int mode,int (*callback)());
-void SSL_CTX_set_cert_verify_cb(SSL_CTX *ctx, int (*cb)(),char *arg);
+int SSL_CTX_get_verify_depth(SSL_CTX *ctx);
+int (*SSL_CTX_get_verify_callback(SSL_CTX *ctx))(int,X509_STORE_CTX *);
+void SSL_CTX_set_verify(SSL_CTX *ctx,int mode,
+                        int (*callback)(int, X509_STORE_CTX *));
+void SSL_CTX_set_verify_depth(SSL_CTX *ctx,int depth);
+void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx, int (*cb)(X509_STORE_CTX *,void *), void *arg);
+#ifndef OPENSSL_NO_RSA
 int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa);
+#endif
 int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, unsigned char *d, long len);
 int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey);
 int SSL_CTX_use_PrivateKey_ASN1(int pk,SSL_CTX *ctx,
@@ -838,24 +1247,37 @@ int SSL_CTX_use_PrivateKey_ASN1(int pk,SSL_CTX *ctx,
 int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x);
 int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len, unsigned char *d);
 
-void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx,int (*cb)());
+void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb);
+void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u);
 
 int SSL_CTX_check_private_key(SSL_CTX *ctx);
 int SSL_check_private_key(SSL *ctx);
 
+int     SSL_CTX_set_session_id_context(SSL_CTX *ctx,const unsigned char *sid_ctx,
+                                       unsigned int sid_ctx_len);
+
 SSL *   SSL_new(SSL_CTX *ctx);
-void    SSL_clear(SSL *s);
+int     SSL_set_session_id_context(SSL *ssl,const unsigned char *sid_ctx,
+                                   unsigned int sid_ctx_len);
+
+int SSL_CTX_set_purpose(SSL_CTX *s, int purpose);
+int SSL_set_purpose(SSL *s, int purpose);
+int SSL_CTX_set_trust(SSL_CTX *s, int trust);
+int SSL_set_trust(SSL *s, int trust);
+
 void    SSL_free(SSL *ssl);
 int     SSL_accept(SSL *ssl);
 int     SSL_connect(SSL *ssl);
-int     SSL_read(SSL *ssl,char *buf,int num);
-int     SSL_peek(SSL *ssl,char *buf,int num);
-int     SSL_write(SSL *ssl,char *buf,int num);
-long    SSL_ctrl(SSL *ssl,int cmd, long larg, char *parg);
-long    SSL_CTX_ctrl(SSL_CTX *ctx,int cmd, long larg, char *parg);
+int     SSL_read(SSL *ssl,void *buf,int num);
+int     SSL_peek(SSL *ssl,void *buf,int num);
+int     SSL_write(SSL *ssl,const void *buf,int num);
+long    SSL_ctrl(SSL *ssl,int cmd, long larg, void *parg);
+long    SSL_callback_ctrl(SSL *, int, void (*)());
+long    SSL_CTX_ctrl(SSL_CTX *ctx,int cmd, long larg, void *parg);
+long    SSL_CTX_callback_ctrl(SSL_CTX *, int, void (*)());
 
 int     SSL_get_error(SSL *s,int ret_code);
-char *  SSL_get_version(SSL *s);
+const char *SSL_get_version(SSL *s);
 
 /* This sets the 'default' SSL version that SSL_new() will create */
 int SSL_CTX_set_ssl_version(SSL_CTX *ctx,SSL_METHOD *meth);
@@ -876,23 +1298,24 @@ SSL_METHOD *TLSv1_method(void);		/* TLSv1.0 */
 SSL_METHOD *TLSv1_server_method(void);  /* TLSv1.0 */
 SSL_METHOD *TLSv1_client_method(void);  /* TLSv1.0 */
 
-STACK *SSL_get_ciphers(SSL *s);
+STACK_OF(SSL_CIPHER) *SSL_get_ciphers(SSL *s);
 
 int SSL_do_handshake(SSL *s);
 int SSL_renegotiate(SSL *s);
+int SSL_renegotiate_pending(SSL *s);
 int SSL_shutdown(SSL *s);
 
 SSL_METHOD *SSL_get_ssl_method(SSL *s);
 int SSL_set_ssl_method(SSL *s,SSL_METHOD *method);
-char *SSL_alert_type_string_long(int value);
-char *SSL_alert_type_string(int value);
-char *SSL_alert_desc_string_long(int value);
-char *SSL_alert_desc_string(int value);
-
-void SSL_set_client_CA_list(SSL *s, STACK *list);
-void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK *list);
-STACK *SSL_get_client_CA_list(SSL *s);
-STACK *SSL_CTX_get_client_CA_list(SSL_CTX *s);
+const char *SSL_alert_type_string_long(int value);
+const char *SSL_alert_type_string(int value);
+const char *SSL_alert_desc_string_long(int value);
+const char *SSL_alert_desc_string(int value);
+
+void SSL_set_client_CA_list(SSL *s, STACK_OF(X509_NAME) *list);
+void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *list);
+STACK_OF(X509_NAME) *SSL_get_client_CA_list(SSL *s);
+STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(SSL_CTX *s);
 int SSL_add_client_CA(SSL *ssl,X509 *x);
 int SSL_CTX_add_client_CA(SSL_CTX *ctx,X509 *x);
 
@@ -901,10 +1324,10 @@ void SSL_set_accept_state(SSL *s);
 
 long SSL_get_default_timeout(SSL *s);
 
-void SSLeay_add_ssl_algorithms(void );
+int SSL_library_init(void );
 
 char *SSL_CIPHER_description(SSL_CIPHER *,char *buf,int size);
-STACK *SSL_dup_CA_list(STACK *sk);
+STACK_OF(X509_NAME) *SSL_dup_CA_list(STACK_OF(X509_NAME) *sk);
 
 SSL *SSL_dup(SSL *ssl);
 
@@ -919,242 +1342,92 @@ void SSL_set_shutdown(SSL *ssl,int mode);
 int SSL_get_shutdown(SSL *ssl);
 int SSL_version(SSL *ssl);
 int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx);
-int SSL_CTX_load_verify_locations(SSL_CTX *ctx,char *CAfile,char *CApath);
+int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
+        const char *CApath);
+#define SSL_get0_session SSL_get_session /* just peek at pointer */
 SSL_SESSION *SSL_get_session(SSL *ssl);
+SSL_SESSION *SSL_get1_session(SSL *ssl); /* obtain a reference count */
 SSL_CTX *SSL_get_SSL_CTX(SSL *ssl);
-void SSL_set_info_callback(SSL *ssl,void (*cb)());
-void (*SSL_get_info_callback(SSL *ssl))();
+void SSL_set_info_callback(SSL *ssl,
+                           void (*cb)(const SSL *ssl,int type,int val));
+void (*SSL_get_info_callback(SSL *ssl))(const SSL *ssl,int type,int val);
 int SSL_state(SSL *ssl);
 
 void SSL_set_verify_result(SSL *ssl,long v);
 long SSL_get_verify_result(SSL *ssl);
 
-int SSL_set_ex_data(SSL *ssl,int idx,char *data);
-char *SSL_get_ex_data(SSL *ssl,int idx);
-int SSL_get_ex_new_index(long argl, char *argp, int (*new_func)(),
-        int (*dup_func)(), void (*free_func)());
-
-int SSL_SESSION_set_ex_data(SSL_SESSION *ss,int idx,char *data);
-char *SSL_SESSION_get_ex_data(SSL_SESSION *ss,int idx);
-int SSL_SESSION_get_ex_new_index(long argl, char *argp, int (*new_func)(),
-        int (*dup_func)(), void (*free_func)());
-
-int SSL_CTX_set_ex_data(SSL_CTX *ssl,int idx,char *data);
-char *SSL_CTX_get_ex_data(SSL_CTX *ssl,int idx);
-int SSL_CTX_get_ex_new_index(long argl, char *argp, int (*new_func)(),
-        int (*dup_func)(), void (*free_func)());
-
-#else
-
-BIO_METHOD *BIO_f_ssl();
-BIO *BIO_new_ssl();
-BIO *BIO_new_ssl_connect();
-BIO *BIO_new_buffer_ssl_connect();
-int BIO_ssl_copy_session_id();
-void BIO_ssl_shutdown();
-
-int     SSL_CTX_set_cipher_list();
-SSL_CTX *SSL_CTX_new();
-void    SSL_CTX_free();
-void    SSL_clear();
-void    SSL_CTX_flush_sessions();
-
-SSL_CIPHER *SSL_get_current_cipher();
-int     SSL_CIPHER_get_bits();
-char *  SSL_CIPHER_get_version();
-char *  SSL_CIPHER_get_name();
-
-int     SSL_get_fd();
-char  * SSL_get_cipher_list();
-char *  SSL_get_shared_ciphers();
-int     SSL_get_read_ahead();
-int     SSL_pending();
-#ifndef NO_SOCK
-int     SSL_set_fd();
-int     SSL_set_rfd();
-int     SSL_set_wfd();
-#endif
-#ifdef HEADER_BIO_H
-void    SSL_set_bio();
-BIO *   SSL_get_rbio();
-BIO *   SSL_get_wbio();
-#endif
-int     SSL_set_cipher_list();
-void    SSL_set_read_ahead();
-int     SSL_get_verify_mode();
-
-void    SSL_set_verify();
-int     SSL_use_RSAPrivateKey();
-int     SSL_use_RSAPrivateKey_ASN1();
-int     SSL_use_PrivateKey();
-int     SSL_use_PrivateKey_ASN1();
-int     SSL_use_certificate();
-int     SSL_use_certificate_ASN1();
-
-#ifndef NO_STDIO
-int     SSL_use_RSAPrivateKey_file();
-int     SSL_use_PrivateKey_file();
-int     SSL_use_certificate_file();
-int     SSL_CTX_use_RSAPrivateKey_file();
-int     SSL_CTX_use_PrivateKey_file();
-int     SSL_CTX_use_certificate_file();
-STACK * SSL_load_client_CA_file();
-#endif
-
-void    ERR_load_SSL_strings();
-void    SSL_load_error_strings();
-char *  SSL_state_string();
-char *  SSL_rstate_string();
-char *  SSL_state_string_long();
-char *  SSL_rstate_string_long();
-long    SSL_SESSION_get_time();
-long    SSL_SESSION_set_time();
-long    SSL_SESSION_get_timeout();
-long    SSL_SESSION_set_timeout();
-void    SSL_copy_session_id();
-
-SSL_SESSION *SSL_SESSION_new();
-unsigned long SSL_SESSION_hash();
-int     SSL_SESSION_cmp();
-#ifndef NO_FP_API
-int     SSL_SESSION_print_fp();
-#endif
-#ifdef HEADER_BIO_H
-int     SSL_SESSION_print();
-#endif
-void    SSL_SESSION_free();
-int     i2d_SSL_SESSION();
-int     SSL_set_session();
-int     SSL_CTX_add_session();
-int     SSL_CTX_remove_session();
-SSL_SESSION *d2i_SSL_SESSION();
-
-#ifdef HEADER_X509_H
-X509 *  SSL_get_peer_certificate();
+int SSL_set_ex_data(SSL *ssl,int idx,void *data);
+void *SSL_get_ex_data(SSL *ssl,int idx);
+int SSL_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
+        CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
+
+int SSL_SESSION_set_ex_data(SSL_SESSION *ss,int idx,void *data);
+void *SSL_SESSION_get_ex_data(SSL_SESSION *ss,int idx);
+int SSL_SESSION_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
+        CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
+
+int SSL_CTX_set_ex_data(SSL_CTX *ssl,int idx,void *data);
+void *SSL_CTX_get_ex_data(SSL_CTX *ssl,int idx);
+int SSL_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
+        CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
+
+int SSL_get_ex_data_X509_STORE_CTX_idx(void );
+
+#define SSL_CTX_sess_set_cache_size(ctx,t) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SESS_CACHE_SIZE,t,NULL)
+#define SSL_CTX_sess_get_cache_size(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_SESS_CACHE_SIZE,0,NULL)
+#define SSL_CTX_set_session_cache_mode(ctx,m) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SESS_CACHE_MODE,m,NULL)
+#define SSL_CTX_get_session_cache_mode(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_SESS_CACHE_MODE,0,NULL)
+
+#define SSL_CTX_get_default_read_ahead(ctx) SSL_CTX_get_read_ahead(ctx)
+#define SSL_CTX_set_default_read_ahead(ctx,m) SSL_CTX_set_read_ahead(ctx,m)
+#define SSL_CTX_get_read_ahead(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_READ_AHEAD,0,NULL)
+#define SSL_CTX_set_read_ahead(ctx,m) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_READ_AHEAD,m,NULL)
+#define SSL_CTX_get_max_cert_list(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_MAX_CERT_LIST,0,NULL)
+#define SSL_CTX_set_max_cert_list(ctx,m) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_MAX_CERT_LIST,m,NULL)
+#define SSL_get_max_cert_list(ssl) \
+        SSL_ctrl(ssl,SSL_CTRL_GET_MAX_CERT_LIST,0,NULL)
+#define SSL_set_max_cert_list(ssl,m) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_MAX_CERT_LIST,m,NULL)
+
+     /* NB: the keylength is only applicable when is_export is true */
+#ifndef OPENSSL_NO_RSA
+void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx,
+                                  RSA *(*cb)(SSL *ssl,int is_export,
+                                             int keylength));
+
+void SSL_set_tmp_rsa_callback(SSL *ssl,
+                                  RSA *(*cb)(SSL *ssl,int is_export,
+                                             int keylength));
 #endif
-
-STACK * SSL_get_peer_cert_chain();
-
-int SSL_CTX_get_verify_mode();
-int (*SSL_CTX_get_verify_callback())();
-void SSL_CTX_set_verify();
-void SSL_CTX_set_cert_verify_cb();
-int SSL_CTX_use_RSAPrivateKey();
-int SSL_CTX_use_RSAPrivateKey_ASN1();
-int SSL_CTX_use_PrivateKey();
-int SSL_CTX_use_PrivateKey_ASN1();
-int SSL_CTX_use_certificate();
-int SSL_CTX_use_certificate_ASN1();
-
-void SSL_CTX_set_default_passwd_cb();
-
-int SSL_CTX_check_private_key();
-int SSL_check_private_key();
-
-SSL *   SSL_new();
-void    SSL_clear();
-void    SSL_free();
-int     SSL_accept();
-int     SSL_connect();
-int     SSL_read();
-int     SSL_peek();
-int     SSL_write();
-long    SSL_ctrl();
-long    SSL_CTX_ctrl();
-
-int     SSL_get_error();
-char *  SSL_get_version();
-
-int SSL_CTX_set_ssl_version();
-
-SSL_METHOD *SSLv2_method();
-SSL_METHOD *SSLv2_server_method();
-SSL_METHOD *SSLv2_client_method();
-
-SSL_METHOD *SSLv3_method();
-SSL_METHOD *SSLv3_server_method();
-SSL_METHOD *SSLv3_client_method();
-
-SSL_METHOD *SSLv23_method();
-SSL_METHOD *SSLv23_server_method();
-SSL_METHOD *SSLv23_client_method();
-
-SSL_METHOD *TLSv1_method();
-SSL_METHOD *TLSv1_server_method();
-SSL_METHOD *TLSv1_client_method();
-
-STACK *SSL_get_ciphers();
-
-int SSL_do_handshake();
-int SSL_renegotiate();
-int SSL_shutdown();
-
-SSL_METHOD *SSL_get_ssl_method();
-int SSL_set_ssl_method();
-char *SSL_alert_type_string_long();
-char *SSL_alert_type_string();
-char *SSL_alert_desc_string_long();
-char *SSL_alert_desc_string();
-
-void SSL_set_client_CA_list();
-void SSL_CTX_set_client_CA_list();
-STACK *SSL_get_client_CA_list();
-STACK *SSL_CTX_get_client_CA_list();
-int SSL_add_client_CA();
-int SSL_CTX_add_client_CA();
-
-void SSL_set_connect_state();
-void SSL_set_accept_state();
-
-long SSL_get_default_timeout();
-
-void SSLeay_add_ssl_algorithms();
-
-char *SSL_CIPHER_description();
-STACK *SSL_dup_CA_list();
-
-SSL *SSL_dup();
-
-X509 *SSL_get_certificate();
-/* EVP * */ struct evp_pkey_st *SSL_get_privatekey();
-
-#ifdef this_is_for_mk1mf_pl
-EVP *SSL_get_privatekey();
-
-void SSL_CTX_set_quiet_shutdown();
-int SSL_CTX_get_quiet_shutdown();
-void SSL_set_quiet_shutdown();
-int SSL_get_quiet_shutdown();
-void SSL_set_shutdown();
-int SSL_get_shutdown();
-int SSL_version();
-int SSL_CTX_set_default_verify_paths();
-int SSL_CTX_load_verify_locations();
-SSL_SESSION *SSL_get_session();
-SSL_CTX *SSL_get_SSL_CTX();
-void SSL_set_info_callback();
-int (*SSL_get_info_callback())();
-int SSL_state();
-void SSL_set_verify_result();
-long SSL_get_verify_result();
-
-int SSL_set_ex_data();
-char *SSL_get_ex_data();
-int SSL_get_ex_new_index();
-
-int SSL_SESSION_set_ex_data();
-char *SSL_SESSION_get_ex_data();
-int SSL_SESSION_get_ex_new_index();
-
-int SSL_CTX_set_ex_data();
-char *SSL_CTX_get_ex_data();
-int SSL_CTX_get_ex_new_index();
-
+#ifndef OPENSSL_NO_DH
+void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,
+                                 DH *(*dh)(SSL *ssl,int is_export,
+                                           int keylength));
+void SSL_set_tmp_dh_callback(SSL *ssl,
+                                 DH *(*dh)(SSL *ssl,int is_export,
+                                           int keylength));
 #endif
 
+#ifndef OPENSSL_NO_COMP
+int SSL_COMP_add_compression_method(int id,COMP_METHOD *cm);
+#else
+int SSL_COMP_add_compression_method(int id,char *cm);
 #endif
 
 /* BEGIN ERROR CODES */
+/* The following lines are auto generated by the script mkerr.pl. Any changes
+ * made after this point may be overwritten when the script is next run.
+ */
+void ERR_load_SSL_strings(void);
+
 /* Error codes for the SSL functions. */
 
 /* Function codes. */
@@ -1178,21 +1451,27 @@ int SSL_CTX_get_ex_new_index();
 #define SSL_F_SSL23_CONNECT                              117
 #define SSL_F_SSL23_GET_CLIENT_HELLO                     118
 #define SSL_F_SSL23_GET_SERVER_HELLO                     119
+#define SSL_F_SSL23_PEEK                                 237
 #define SSL_F_SSL23_READ                                 120
 #define SSL_F_SSL23_WRITE                                121
 #define SSL_F_SSL2_ACCEPT                                122
 #define SSL_F_SSL2_CONNECT                               123
 #define SSL_F_SSL2_ENC_INIT                              124
+#define SSL_F_SSL2_PEEK                                  234
 #define SSL_F_SSL2_READ                                  125
+#define SSL_F_SSL2_READ_INTERNAL                         236
 #define SSL_F_SSL2_SET_CERTIFICATE                       126
 #define SSL_F_SSL2_WRITE                                 127
 #define SSL_F_SSL3_ACCEPT                                128
+#define SSL_F_SSL3_CALLBACK_CTRL                         233
 #define SSL_F_SSL3_CHANGE_CIPHER_STATE                   129
 #define SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM              130
 #define SSL_F_SSL3_CLIENT_HELLO                          131
 #define SSL_F_SSL3_CONNECT                               132
+#define SSL_F_SSL3_CTRL                                  213
 #define SSL_F_SSL3_CTX_CTRL                              133
 #define SSL_F_SSL3_ENC                                   134
+#define SSL_F_SSL3_GENERATE_KEY_BLOCK                    238
 #define SSL_F_SSL3_GET_CERTIFICATE_REQUEST               135
 #define SSL_F_SSL3_GET_CERT_VERIFY                       136
 #define SSL_F_SSL3_GET_CLIENT_CERTIFICATE                137
@@ -1206,6 +1485,7 @@ int SSL_CTX_get_ex_new_index();
 #define SSL_F_SSL3_GET_SERVER_DONE                       145
 #define SSL_F_SSL3_GET_SERVER_HELLO                      146
 #define SSL_F_SSL3_OUTPUT_CERT_CHAIN                     147
+#define SSL_F_SSL3_PEEK                                  235
 #define SSL_F_SSL3_READ_BYTES                            148
 #define SSL_F_SSL3_READ_N                                149
 #define SSL_F_SSL3_SEND_CERTIFICATE_REQUEST              150
@@ -1218,63 +1498,85 @@ int SSL_CTX_get_ex_new_index();
 #define SSL_F_SSL3_SETUP_KEY_BLOCK                       157
 #define SSL_F_SSL3_WRITE_BYTES                           158
 #define SSL_F_SSL3_WRITE_PENDING                         159
+#define SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK         215
+#define SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK        216
 #define SSL_F_SSL_BAD_METHOD                             160
 #define SSL_F_SSL_BYTES_TO_CIPHER_LIST                   161
+#define SSL_F_SSL_CERT_DUP                               221
+#define SSL_F_SSL_CERT_INST                              222
+#define SSL_F_SSL_CERT_INSTANTIATE                       214
 #define SSL_F_SSL_CERT_NEW                               162
 #define SSL_F_SSL_CHECK_PRIVATE_KEY                      163
-#define SSL_F_SSL_CREATE_CIPHER_LIST                     164
-#define SSL_F_SSL_CTX_CHECK_PRIVATE_KEY                  165
-#define SSL_F_SSL_CTX_NEW                                166
-#define SSL_F_SSL_CTX_SET_SSL_VERSION                    167
-#define SSL_F_SSL_CTX_USE_CERTIFICATE                    168
-#define SSL_F_SSL_CTX_USE_CERTIFICATE_ASN1               169
-#define SSL_F_SSL_CTX_USE_CERTIFICATE_FILE               170
-#define SSL_F_SSL_CTX_USE_PRIVATEKEY                     171
-#define SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1                172
-#define SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE                173
-#define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY                  174
-#define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_ASN1             175
-#define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE             176
-#define SSL_F_SSL_DO_HANDSHAKE                           177
-#define SSL_F_SSL_GET_NEW_SESSION                        178
-#define SSL_F_SSL_GET_SERVER_SEND_CERT                   179
-#define SSL_F_SSL_GET_SIGN_PKEY                          180
-#define SSL_F_SSL_INIT_WBIO_BUFFER                       181
-#define SSL_F_SSL_LOAD_CLIENT_CA_FILE                    182
-#define SSL_F_SSL_NEW                                    183
-#define SSL_F_SSL_RSA_PRIVATE_DECRYPT                    184
-#define SSL_F_SSL_RSA_PUBLIC_ENCRYPT                     185
-#define SSL_F_SSL_SESSION_NEW                            186
-#define SSL_F_SSL_SESSION_PRINT_FP                       187
-#define SSL_F_SSL_SET_CERT                               188
-#define SSL_F_SSL_SET_FD                                 189
-#define SSL_F_SSL_SET_PKEY                               190
-#define SSL_F_SSL_SET_RFD                                191
-#define SSL_F_SSL_SET_SESSION                            192
-#define SSL_F_SSL_SET_WFD                                193
-#define SSL_F_SSL_UNDEFINED_FUNCTION                     194
-#define SSL_F_SSL_USE_CERTIFICATE                        195
-#define SSL_F_SSL_USE_CERTIFICATE_ASN1                   196
-#define SSL_F_SSL_USE_CERTIFICATE_FILE                   197
-#define SSL_F_SSL_USE_PRIVATEKEY                         198
-#define SSL_F_SSL_USE_PRIVATEKEY_ASN1                    199
-#define SSL_F_SSL_USE_PRIVATEKEY_FILE                    200
-#define SSL_F_SSL_USE_RSAPRIVATEKEY                      201
-#define SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1                 202
-#define SSL_F_SSL_USE_RSAPRIVATEKEY_FILE                 203
-#define SSL_F_SSL_WRITE                                  204
-#define SSL_F_TLS1_CHANGE_CIPHER_STATE                   205
-#define SSL_F_TLS1_ENC                                   206
-#define SSL_F_TLS1_SETUP_KEY_BLOCK                       207
-#define SSL_F_WRITE_PENDING                              208
+#define SSL_F_SSL_CIPHER_PROCESS_RULESTR                 230
+#define SSL_F_SSL_CIPHER_STRENGTH_SORT                   231
+#define SSL_F_SSL_CLEAR                                  164
+#define SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD            165
+#define SSL_F_SSL_CREATE_CIPHER_LIST                     166
+#define SSL_F_SSL_CTRL                                   232
+#define SSL_F_SSL_CTX_CHECK_PRIVATE_KEY                  168
+#define SSL_F_SSL_CTX_NEW                                169
+#define SSL_F_SSL_CTX_SET_PURPOSE                        226
+#define SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT             219
+#define SSL_F_SSL_CTX_SET_SSL_VERSION                    170
+#define SSL_F_SSL_CTX_SET_TRUST                          229
+#define SSL_F_SSL_CTX_USE_CERTIFICATE                    171
+#define SSL_F_SSL_CTX_USE_CERTIFICATE_ASN1               172
+#define SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE         220
+#define SSL_F_SSL_CTX_USE_CERTIFICATE_FILE               173
+#define SSL_F_SSL_CTX_USE_PRIVATEKEY                     174
+#define SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1                175
+#define SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE                176
+#define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY                  177
+#define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_ASN1             178
+#define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE             179
+#define SSL_F_SSL_DO_HANDSHAKE                           180
+#define SSL_F_SSL_GET_NEW_SESSION                        181
+#define SSL_F_SSL_GET_PREV_SESSION                       217
+#define SSL_F_SSL_GET_SERVER_SEND_CERT                   182
+#define SSL_F_SSL_GET_SIGN_PKEY                          183
+#define SSL_F_SSL_INIT_WBIO_BUFFER                       184
+#define SSL_F_SSL_LOAD_CLIENT_CA_FILE                    185
+#define SSL_F_SSL_NEW                                    186
+#define SSL_F_SSL_READ                                   223
+#define SSL_F_SSL_RSA_PRIVATE_DECRYPT                    187
+#define SSL_F_SSL_RSA_PUBLIC_ENCRYPT                     188
+#define SSL_F_SSL_SESSION_NEW                            189
+#define SSL_F_SSL_SESSION_PRINT_FP                       190
+#define SSL_F_SSL_SESS_CERT_NEW                          225
+#define SSL_F_SSL_SET_CERT                               191
+#define SSL_F_SSL_SET_FD                                 192
+#define SSL_F_SSL_SET_PKEY                               193
+#define SSL_F_SSL_SET_PURPOSE                            227
+#define SSL_F_SSL_SET_RFD                                194
+#define SSL_F_SSL_SET_SESSION                            195
+#define SSL_F_SSL_SET_SESSION_ID_CONTEXT                 218
+#define SSL_F_SSL_SET_TRUST                              228
+#define SSL_F_SSL_SET_WFD                                196
+#define SSL_F_SSL_SHUTDOWN                               224
+#define SSL_F_SSL_UNDEFINED_FUNCTION                     197
+#define SSL_F_SSL_USE_CERTIFICATE                        198
+#define SSL_F_SSL_USE_CERTIFICATE_ASN1                   199
+#define SSL_F_SSL_USE_CERTIFICATE_FILE                   200
+#define SSL_F_SSL_USE_PRIVATEKEY                         201
+#define SSL_F_SSL_USE_PRIVATEKEY_ASN1                    202
+#define SSL_F_SSL_USE_PRIVATEKEY_FILE                    203
+#define SSL_F_SSL_USE_RSAPRIVATEKEY                      204
+#define SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1                 205
+#define SSL_F_SSL_USE_RSAPRIVATEKEY_FILE                 206
+#define SSL_F_SSL_VERIFY_CERT_CHAIN                      207
+#define SSL_F_SSL_WRITE                                  208
+#define SSL_F_TLS1_CHANGE_CIPHER_STATE                   209
+#define SSL_F_TLS1_ENC                                   210
+#define SSL_F_TLS1_SETUP_KEY_BLOCK                       211
+#define SSL_F_WRITE_PENDING                              212
 
 /* Reason codes. */
 #define SSL_R_APP_DATA_IN_HANDSHAKE                      100
+#define SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT 272
 #define SSL_R_BAD_ALERT_RECORD                           101
 #define SSL_R_BAD_AUTHENTICATION_TYPE                    102
 #define SSL_R_BAD_CHANGE_CIPHER_SPEC                     103
 #define SSL_R_BAD_CHECKSUM                               104
-#define SSL_R_BAD_CLIENT_REQUEST                         105
 #define SSL_R_BAD_DATA_RETURNED_BY_CALLBACK              106
 #define SSL_R_BAD_DECOMPRESSION                          107
 #define SSL_R_BAD_DH_G_LENGTH                            108
@@ -1282,6 +1584,8 @@ int SSL_CTX_get_ex_new_index();
 #define SSL_R_BAD_DH_P_LENGTH                            110
 #define SSL_R_BAD_DIGEST_LENGTH                          111
 #define SSL_R_BAD_DSA_SIGNATURE                          112
+#define SSL_R_BAD_HELLO_REQUEST                          105
+#define SSL_R_BAD_LENGTH                                 271
 #define SSL_R_BAD_MAC_DECODE                             113
 #define SSL_R_BAD_MESSAGE_TYPE                           114
 #define SSL_R_BAD_PACKET_LENGTH                          115
@@ -1311,83 +1615,108 @@ int SSL_CTX_get_ex_new_index();
 #define SSL_R_CIPHER_TABLE_SRC_ERROR                     139
 #define SSL_R_COMPRESSED_LENGTH_TOO_LONG                 140
 #define SSL_R_COMPRESSION_FAILURE                        141
-#define SSL_R_CONNECTION_ID_IS_DIFFERENT                 142
-#define SSL_R_CONNECTION_TYPE_NOT_SET                    143
-#define SSL_R_DATA_BETWEEN_CCS_AND_FINISHED              144
-#define SSL_R_DATA_LENGTH_TOO_LONG                       145
-#define SSL_R_DECRYPTION_FAILED                          146
-#define SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG            147
-#define SSL_R_DIGEST_CHECK_FAILED                        148
-#define SSL_R_ENCRYPTED_LENGTH_TOO_LONG                  149
-#define SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST              150
-#define SSL_R_EXCESSIVE_MESSAGE_SIZE                     151
-#define SSL_R_EXTRA_DATA_IN_MESSAGE                      152
-#define SSL_R_GOT_A_FIN_BEFORE_A_CCS                     153
-#define SSL_R_HTTPS_PROXY_REQUEST                        154
-#define SSL_R_HTTP_REQUEST                               155
-#define SSL_R_INTERNAL_ERROR                             156
-#define SSL_R_INVALID_CHALLENGE_LENGTH                   157
-#define SSL_R_LENGTH_MISMATCH                            158
-#define SSL_R_LENGTH_TOO_SHORT                           159
-#define SSL_R_LIBRARY_HAS_NO_CIPHERS                     160
-#define SSL_R_MISSING_DH_DSA_CERT                        161
-#define SSL_R_MISSING_DH_KEY                             162
-#define SSL_R_MISSING_DH_RSA_CERT                        163
-#define SSL_R_MISSING_DSA_SIGNING_CERT                   164
-#define SSL_R_MISSING_EXPORT_TMP_DH_KEY                  165
-#define SSL_R_MISSING_EXPORT_TMP_RSA_KEY                 166
-#define SSL_R_MISSING_RSA_CERTIFICATE                    167
-#define SSL_R_MISSING_RSA_ENCRYPTING_CERT                168
-#define SSL_R_MISSING_RSA_SIGNING_CERT                   169
-#define SSL_R_MISSING_TMP_DH_KEY                         170
-#define SSL_R_MISSING_TMP_RSA_KEY                        171
-#define SSL_R_MISSING_TMP_RSA_PKEY                       172
-#define SSL_R_MISSING_VERIFY_MESSAGE                     173
-#define SSL_R_NON_SSLV2_INITIAL_PACKET                   174
-#define SSL_R_NO_CERTIFICATES_RETURNED                   175
-#define SSL_R_NO_CERTIFICATE_ASSIGNED                    176
-#define SSL_R_NO_CERTIFICATE_RETURNED                    177
-#define SSL_R_NO_CERTIFICATE_SET                         178
-#define SSL_R_NO_CERTIFICATE_SPECIFIED                   179
-#define SSL_R_NO_CIPHERS_AVAILABLE                       180
-#define SSL_R_NO_CIPHERS_PASSED                          181
-#define SSL_R_NO_CIPHERS_SPECIFIED                       182
-#define SSL_R_NO_CIPHER_LIST                             183
-#define SSL_R_NO_CIPHER_MATCH                            184
-#define SSL_R_NO_CLIENT_CERT_RECEIVED                    185
-#define SSL_R_NO_COMPRESSION_SPECIFIED                   186
-#define SSL_R_NO_PRIVATEKEY                              187
-#define SSL_R_NO_PRIVATE_KEY_ASSIGNED                    188
-#define SSL_R_NO_PROTOCOLS_AVAILABLE                     189
-#define SSL_R_NO_PUBLICKEY                               190
-#define SSL_R_NO_SHARED_CIPHER                           191
-#define SSL_R_NULL_SSL_CTX                               192
-#define SSL_R_NULL_SSL_METHOD_PASSED                     193
-#define SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED            194
-#define SSL_R_PACKET_LENGTH_TOO_LONG                     195
-#define SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE          196
-#define SSL_R_PEER_ERROR                                 197
-#define SSL_R_PEER_ERROR_CERTIFICATE                     198
-#define SSL_R_PEER_ERROR_NO_CERTIFICATE                  199
-#define SSL_R_PEER_ERROR_NO_CIPHER                       200
-#define SSL_R_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE    201
-#define SSL_R_PRE_MAC_LENGTH_TOO_LONG                    202
-#define SSL_R_PROBLEMS_MAPPING_CIPHER_FUNCTIONS          203
-#define SSL_R_PROTOCOL_IS_SHUTDOWN                       204
-#define SSL_R_PUBLIC_KEY_ENCRYPT_ERROR                   205
-#define SSL_R_PUBLIC_KEY_IS_NOT_RSA                      206
-#define SSL_R_PUBLIC_KEY_NOT_RSA                         207
-#define SSL_R_READ_BIO_NOT_SET                           208
-#define SSL_R_READ_WRONG_PACKET_TYPE                     209
-#define SSL_R_RECORD_LENGTH_MISMATCH                     210
-#define SSL_R_RECORD_TOO_LARGE                           211
-#define SSL_R_REQUIRED_CIPHER_MISSING                    212
-#define SSL_R_REUSE_CERT_LENGTH_NOT_ZERO                 213
-#define SSL_R_REUSE_CERT_TYPE_NOT_ZERO                   214
-#define SSL_R_REUSE_CIPHER_LIST_NOT_ZERO                 215
-#define SSL_R_SHORT_READ                                 216
-#define SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE      217
-#define SSL_R_SSL3_SESSION_ID_TOO_SHORT                  218
+#define SSL_R_COMPRESSION_LIBRARY_ERROR                  142
+#define SSL_R_CONNECTION_ID_IS_DIFFERENT                 143
+#define SSL_R_CONNECTION_TYPE_NOT_SET                    144
+#define SSL_R_DATA_BETWEEN_CCS_AND_FINISHED              145
+#define SSL_R_DATA_LENGTH_TOO_LONG                       146
+#define SSL_R_DECRYPTION_FAILED                          147
+#define SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC        1109
+#define SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG            148
+#define SSL_R_DIGEST_CHECK_FAILED                        149
+#define SSL_R_ENCRYPTED_LENGTH_TOO_LONG                  150
+#define SSL_R_ERROR_GENERATING_TMP_RSA_KEY               1092
+#define SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST              151
+#define SSL_R_EXCESSIVE_MESSAGE_SIZE                     152
+#define SSL_R_EXTRA_DATA_IN_MESSAGE                      153
+#define SSL_R_GOT_A_FIN_BEFORE_A_CCS                     154
+#define SSL_R_HTTPS_PROXY_REQUEST                        155
+#define SSL_R_HTTP_REQUEST                               156
+#define SSL_R_ILLEGAL_PADDING                            1110
+#define SSL_R_INVALID_CHALLENGE_LENGTH                   158
+#define SSL_R_INVALID_COMMAND                            280
+#define SSL_R_INVALID_PURPOSE                            278
+#define SSL_R_INVALID_TRUST                              279
+#define SSL_R_KRB5                                       1104
+#define SSL_R_KRB5_C_CC_PRINC                            1094
+#define SSL_R_KRB5_C_GET_CRED                            1095
+#define SSL_R_KRB5_C_INIT                                1096
+#define SSL_R_KRB5_C_MK_REQ                              1097
+#define SSL_R_KRB5_S_BAD_TICKET                          1098
+#define SSL_R_KRB5_S_INIT                                1099
+#define SSL_R_KRB5_S_RD_REQ                              1108
+#define SSL_R_KRB5_S_TKT_EXPIRED                         1105
+#define SSL_R_KRB5_S_TKT_NYV                             1106
+#define SSL_R_KRB5_S_TKT_SKEW                            1107
+#define SSL_R_LENGTH_MISMATCH                            159
+#define SSL_R_LENGTH_TOO_SHORT                           160
+#define SSL_R_LIBRARY_BUG                                274
+#define SSL_R_LIBRARY_HAS_NO_CIPHERS                     161
+#define SSL_R_MESSAGE_TOO_LONG                           1111
+#define SSL_R_MISSING_DH_DSA_CERT                        162
+#define SSL_R_MISSING_DH_KEY                             163
+#define SSL_R_MISSING_DH_RSA_CERT                        164
+#define SSL_R_MISSING_DSA_SIGNING_CERT                   165
+#define SSL_R_MISSING_EXPORT_TMP_DH_KEY                  166
+#define SSL_R_MISSING_EXPORT_TMP_RSA_KEY                 167
+#define SSL_R_MISSING_RSA_CERTIFICATE                    168
+#define SSL_R_MISSING_RSA_ENCRYPTING_CERT                169
+#define SSL_R_MISSING_RSA_SIGNING_CERT                   170
+#define SSL_R_MISSING_TMP_DH_KEY                         171
+#define SSL_R_MISSING_TMP_RSA_KEY                        172
+#define SSL_R_MISSING_TMP_RSA_PKEY                       173
+#define SSL_R_MISSING_VERIFY_MESSAGE                     174
+#define SSL_R_NON_SSLV2_INITIAL_PACKET                   175
+#define SSL_R_NO_CERTIFICATES_RETURNED                   176
+#define SSL_R_NO_CERTIFICATE_ASSIGNED                    177
+#define SSL_R_NO_CERTIFICATE_RETURNED                    178
+#define SSL_R_NO_CERTIFICATE_SET                         179
+#define SSL_R_NO_CERTIFICATE_SPECIFIED                   180
+#define SSL_R_NO_CIPHERS_AVAILABLE                       181
+#define SSL_R_NO_CIPHERS_PASSED                          182
+#define SSL_R_NO_CIPHERS_SPECIFIED                       183
+#define SSL_R_NO_CIPHER_LIST                             184
+#define SSL_R_NO_CIPHER_MATCH                            185
+#define SSL_R_NO_CLIENT_CERT_RECEIVED                    186
+#define SSL_R_NO_COMPRESSION_SPECIFIED                   187
+#define SSL_R_NO_METHOD_SPECIFIED                        188
+#define SSL_R_NO_PRIVATEKEY                              189
+#define SSL_R_NO_PRIVATE_KEY_ASSIGNED                    190
+#define SSL_R_NO_PROTOCOLS_AVAILABLE                     191
+#define SSL_R_NO_PUBLICKEY                               192
+#define SSL_R_NO_SHARED_CIPHER                           193
+#define SSL_R_NO_VERIFY_CALLBACK                         194
+#define SSL_R_NULL_SSL_CTX                               195
+#define SSL_R_NULL_SSL_METHOD_PASSED                     196
+#define SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED            197
+#define SSL_R_PACKET_LENGTH_TOO_LONG                     198
+#define SSL_R_PATH_TOO_LONG                              270
+#define SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE          199
+#define SSL_R_PEER_ERROR                                 200
+#define SSL_R_PEER_ERROR_CERTIFICATE                     201
+#define SSL_R_PEER_ERROR_NO_CERTIFICATE                  202
+#define SSL_R_PEER_ERROR_NO_CIPHER                       203
+#define SSL_R_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE    204
+#define SSL_R_PRE_MAC_LENGTH_TOO_LONG                    205
+#define SSL_R_PROBLEMS_MAPPING_CIPHER_FUNCTIONS          206
+#define SSL_R_PROTOCOL_IS_SHUTDOWN                       207
+#define SSL_R_PUBLIC_KEY_ENCRYPT_ERROR                   208
+#define SSL_R_PUBLIC_KEY_IS_NOT_RSA                      209
+#define SSL_R_PUBLIC_KEY_NOT_RSA                         210
+#define SSL_R_READ_BIO_NOT_SET                           211
+#define SSL_R_READ_WRONG_PACKET_TYPE                     212
+#define SSL_R_RECORD_LENGTH_MISMATCH                     213
+#define SSL_R_RECORD_TOO_LARGE                           214
+#define SSL_R_RECORD_TOO_SMALL                           1093
+#define SSL_R_REQUIRED_CIPHER_MISSING                    215
+#define SSL_R_REUSE_CERT_LENGTH_NOT_ZERO                 216
+#define SSL_R_REUSE_CERT_TYPE_NOT_ZERO                   217
+#define SSL_R_REUSE_CIPHER_LIST_NOT_ZERO                 218
+#define SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED           277
+#define SSL_R_SHORT_READ                                 219
+#define SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE      220
+#define SSL_R_SSL23_DOING_SESSION_ID_REUSE               221
+#define SSL_R_SSL3_SESSION_ID_TOO_SHORT                  222
 #define SSL_R_SSLV3_ALERT_BAD_CERTIFICATE                1042
 #define SSL_R_SSLV3_ALERT_BAD_RECORD_MAC                 1020
 #define SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED            1045
@@ -1397,57 +1726,75 @@ int SSL_CTX_get_ex_new_index();
 #define SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE              1040
 #define SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER              1047
 #define SSL_R_SSLV3_ALERT_NO_CERTIFICATE                 1041
-#define SSL_R_SSLV3_ALERT_PEER_ERROR_CERTIFICATE         219
-#define SSL_R_SSLV3_ALERT_PEER_ERROR_NO_CERTIFICATE      220
-#define SSL_R_SSLV3_ALERT_PEER_ERROR_NO_CIPHER           221
-#define SSL_R_SSLV3_ALERT_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE 222
+#define SSL_R_SSLV3_ALERT_PEER_ERROR_CERTIFICATE         223
+#define SSL_R_SSLV3_ALERT_PEER_ERROR_NO_CERTIFICATE      224
+#define SSL_R_SSLV3_ALERT_PEER_ERROR_NO_CIPHER           225
+#define SSL_R_SSLV3_ALERT_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE 226
 #define SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE             1010
-#define SSL_R_SSLV3_ALERT_UNKNOWN_REMOTE_ERROR_TYPE      223
+#define SSL_R_SSLV3_ALERT_UNKNOWN_REMOTE_ERROR_TYPE      227
 #define SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE        1043
-#define SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION         224
-#define SSL_R_SSL_HANDSHAKE_FAILURE                      225
-#define SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS                 226
-#define SSL_R_SSL_SESSION_ID_IS_DIFFERENT                227
-#define SSL_R_TLS_CLIENT_CERT_REQ_WITH_ANON_CIPHER       228
-#define SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST 229
-#define SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG    230
-#define SSL_R_TRIED_TO_USE_UNSUPPORTED_CIPHER            231
-#define SSL_R_UNABLE_TO_DECODE_DH_CERTS                  232
-#define SSL_R_UNABLE_TO_EXTRACT_PUBLIC_KEY               233
-#define SSL_R_UNABLE_TO_FIND_DH_PARAMETERS               234
-#define SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS       235
-#define SSL_R_UNABLE_TO_FIND_SSL_METHOD                  236
-#define SSL_R_UNABLE_TO_LOAD_SSL2_MD5_ROUTINES           237
-#define SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES           238
-#define SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES          239
-#define SSL_R_UNEXPECTED_MESSAGE                         240
-#define SSL_R_UNEXPECTED_RECORD                          241
-#define SSL_R_UNKNOWN_ALERT_TYPE                         242
-#define SSL_R_UNKNOWN_CERTIFICATE_TYPE                   243
-#define SSL_R_UNKNOWN_CIPHER_RETURNED                    244
-#define SSL_R_UNKNOWN_CIPHER_TYPE                        245
-#define SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE                  246
-#define SSL_R_UNKNOWN_PKEY_TYPE                          247
-#define SSL_R_UNKNOWN_PROTOCOL                           248
-#define SSL_R_UNKNOWN_REMOTE_ERROR_TYPE                  249
-#define SSL_R_UNKNOWN_SSL_VERSION                        250
-#define SSL_R_UNKNOWN_STATE                              251
-#define SSL_R_UNSUPPORTED_CIPHER                         252
-#define SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM          253
-#define SSL_R_UNSUPPORTED_PROTOCOL                       254
-#define SSL_R_UNSUPPORTED_SSL_VERSION                    255
-#define SSL_R_WRITE_BIO_NOT_SET                          256
-#define SSL_R_WRONG_CIPHER_RETURNED                      257
-#define SSL_R_WRONG_MESSAGE_TYPE                         258
-#define SSL_R_WRONG_NUMBER_OF_KEY_BITS                   259
-#define SSL_R_WRONG_SIGNATURE_LENGTH                     260
-#define SSL_R_WRONG_SIGNATURE_SIZE                       261
-#define SSL_R_WRONG_SSL_VERSION                          262
-#define SSL_R_WRONG_VERSION_NUMBER                       263
-#define SSL_R_X509_LIB                                   264
- 
+#define SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION         228
+#define SSL_R_SSL_HANDSHAKE_FAILURE                      229
+#define SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS                 230
+#define SSL_R_SSL_SESSION_ID_CALLBACK_FAILED             1102
+#define SSL_R_SSL_SESSION_ID_CONFLICT                    1103
+#define SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG            273
+#define SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH              1101
+#define SSL_R_SSL_SESSION_ID_IS_DIFFERENT                231
+#define SSL_R_TLSV1_ALERT_ACCESS_DENIED                  1049
+#define SSL_R_TLSV1_ALERT_DECODE_ERROR                   1050
+#define SSL_R_TLSV1_ALERT_DECRYPTION_FAILED              1021
+#define SSL_R_TLSV1_ALERT_DECRYPT_ERROR                  1051
+#define SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION             1060
+#define SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY          1071
+#define SSL_R_TLSV1_ALERT_INTERNAL_ERROR                 1080
+#define SSL_R_TLSV1_ALERT_NO_RENEGOTIATION               1100
+#define SSL_R_TLSV1_ALERT_PROTOCOL_VERSION               1070
+#define SSL_R_TLSV1_ALERT_RECORD_OVERFLOW                1022
+#define SSL_R_TLSV1_ALERT_UNKNOWN_CA                     1048
+#define SSL_R_TLSV1_ALERT_USER_CANCELLED                 1090
+#define SSL_R_TLS_CLIENT_CERT_REQ_WITH_ANON_CIPHER       232
+#define SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST 233
+#define SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG    234
+#define SSL_R_TRIED_TO_USE_UNSUPPORTED_CIPHER            235
+#define SSL_R_UNABLE_TO_DECODE_DH_CERTS                  236
+#define SSL_R_UNABLE_TO_EXTRACT_PUBLIC_KEY               237
+#define SSL_R_UNABLE_TO_FIND_DH_PARAMETERS               238
+#define SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS       239
+#define SSL_R_UNABLE_TO_FIND_SSL_METHOD                  240
+#define SSL_R_UNABLE_TO_LOAD_SSL2_MD5_ROUTINES           241
+#define SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES           242
+#define SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES          243
+#define SSL_R_UNEXPECTED_MESSAGE                         244
+#define SSL_R_UNEXPECTED_RECORD                          245
+#define SSL_R_UNINITIALIZED                              276
+#define SSL_R_UNKNOWN_ALERT_TYPE                         246
+#define SSL_R_UNKNOWN_CERTIFICATE_TYPE                   247
+#define SSL_R_UNKNOWN_CIPHER_RETURNED                    248
+#define SSL_R_UNKNOWN_CIPHER_TYPE                        249
+#define SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE                  250
+#define SSL_R_UNKNOWN_PKEY_TYPE                          251
+#define SSL_R_UNKNOWN_PROTOCOL                           252
+#define SSL_R_UNKNOWN_REMOTE_ERROR_TYPE                  253
+#define SSL_R_UNKNOWN_SSL_VERSION                        254
+#define SSL_R_UNKNOWN_STATE                              255
+#define SSL_R_UNSUPPORTED_CIPHER                         256
+#define SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM          257
+#define SSL_R_UNSUPPORTED_OPTION                         1091
+#define SSL_R_UNSUPPORTED_PROTOCOL                       258
+#define SSL_R_UNSUPPORTED_SSL_VERSION                    259
+#define SSL_R_WRITE_BIO_NOT_SET                          260
+#define SSL_R_WRONG_CIPHER_RETURNED                      261
+#define SSL_R_WRONG_MESSAGE_TYPE                         262
+#define SSL_R_WRONG_NUMBER_OF_KEY_BITS                   263
+#define SSL_R_WRONG_SIGNATURE_LENGTH                     264
+#define SSL_R_WRONG_SIGNATURE_SIZE                       265
+#define SSL_R_WRONG_SSL_VERSION                          266
+#define SSL_R_WRONG_VERSION_NUMBER                       267
+#define SSL_R_X509_LIB                                   268
+#define SSL_R_X509_VERIFICATION_SETUP_PROBLEMS           269
+
 #ifdef  __cplusplus
 }
 #endif
 #endif
-
diff --git a/src/lib/libssl/ssl2.h b/src/lib/libssl/ssl2.h
index 3dc94e520b..99a52ea0dd 100644
--- a/src/lib/libssl/ssl2.h
+++ b/src/lib/libssl/ssl2.h
@@ -67,8 +67,8 @@ extern "C" {
 #define SSL2_VERSION            0x0002
 #define SSL2_VERSION_MAJOR      0x00
 #define SSL2_VERSION_MINOR      0x02
-#define SSL2_CLIENT_VERSION     0x0002
-#define SSL2_SERVER_VERSION     0x0002
+/* #define SSL2_CLIENT_VERSION  0x0002 */
+/* #define SSL2_SERVER_VERSION  0x0002 */
 
 /* Protocol Message Codes */
 #define SSL2_MT_ERROR                   0
@@ -133,8 +133,12 @@ extern "C" {
 
 /* Upper/Lower Bounds */
 #define SSL2_MAX_MASTER_KEY_LENGTH_IN_BITS      256
-#define SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER    (unsigned int)32767 
-#define SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER    16383 /**/
+#ifdef OPENSSL_SYS_MPE
+#define SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER    29998u
+#else
+#define SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER    32767u  /* 2^15-1 */
+#endif
+#define SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER    16383 /* 2^14-1 */
 
 #define SSL2_CHALLENGE_LENGTH   16
 /*#define SSL2_CHALLENGE_LENGTH 32 */
@@ -151,7 +155,7 @@ extern "C" {
 #define  CERT           char
 #endif
 
-typedef struct ssl2_ctx_st
+typedef struct ssl2_state_st
         {
         int three_byte_header;
         int clear_text;         /* clear text */
@@ -162,7 +166,7 @@ typedef struct ssl2_ctx_st
          * args were passwd */
         unsigned int wnum;      /* number of bytes sent so far */
         int wpend_tot;
-        char *wpend_buf;
+        const unsigned char *wpend_buf;
 
         int wpend_off;  /* offset to data to write */
         int wpend_len;  /* number of bytes passwd to write */
@@ -185,7 +189,6 @@ typedef struct ssl2_ctx_st
         unsigned char *ract_data;
         unsigned char *wact_data;
         unsigned char *mac_data;
-        unsigned char *pad_data;
 
         unsigned char *read_key;
         unsigned char *write_key;
@@ -205,16 +208,16 @@ typedef struct ssl2_ctx_st
                 unsigned int conn_id_length;
                 unsigned int cert_type; 
                 unsigned int cert_length;
-                int csl; 
-                int clear;
+                unsigned int csl; 
+                unsigned int clear;
                 unsigned int enc; 
                 unsigned char ccl[SSL2_MAX_CERT_CHALLENGE_LENGTH];
-                int cipher_spec_length;
+                unsigned int cipher_spec_length;
                 unsigned int session_id_length;
                 unsigned int clen;
                 unsigned int rlen;
                 } tmp;
-        } SSL2_CTX;
+        } SSL2_STATE;
 
 /* SSLv2 */
 /* client */
diff --git a/src/lib/libssl/ssl3.h b/src/lib/libssl/ssl3.h
index 95772eef60..8fd6951d77 100644
--- a/src/lib/libssl/ssl3.h
+++ b/src/lib/libssl/ssl3.h
@@ -55,11 +55,69 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
+/* ====================================================================
+ * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
 
 #ifndef HEADER_SSL3_H 
 #define HEADER_SSL3_H 
 
-#include "buffer.h"
+#ifndef OPENSSL_NO_COMP
+#include <openssl/comp.h>
+#endif
+#include <openssl/buffer.h>
+#include <openssl/evp.h>
+#include <openssl/ssl.h>
 
 #ifdef  __cplusplus
 extern "C" {
@@ -100,6 +158,22 @@ extern "C" {
 #define SSL3_CK_FZA_DMS_FZA_SHA                 0x0300001D
 #define SSL3_CK_FZA_DMS_RC4_SHA                 0x0300001E
 
+/*    VRS Additional Kerberos5 entries
+ */
+#define SSL3_CK_KRB5_DES_40_CBC_SHA             0x03000021
+#define SSL3_CK_KRB5_DES_40_CBC_MD5             0x03000022
+#define SSL3_CK_KRB5_DES_64_CBC_SHA             0x03000023
+#define SSL3_CK_KRB5_DES_64_CBC_MD5             0x03000024
+#define SSL3_CK_KRB5_DES_192_CBC3_SHA           0x03000025
+#define SSL3_CK_KRB5_DES_192_CBC3_MD5           0x03000026
+
+#define SSL3_TXT_KRB5_DES_40_CBC_SHA            "EXP-KRB5-DES-CBC-SHA"
+#define SSL3_TXT_KRB5_DES_40_CBC_MD5            "EXP-KRB5-DES-CBC-MD5"
+#define SSL3_TXT_KRB5_DES_64_CBC_SHA            "KRB5-DES-CBC-SHA"
+#define SSL3_TXT_KRB5_DES_64_CBC_MD5            "KRB5-DES-CBC-MD5"
+#define SSL3_TXT_KRB5_DES_192_CBC3_SHA          "KRB5-DES-CBC3-SHA"
+#define SSL3_TXT_KRB5_DES_192_CBC3_MD5          "KRB5-DES-CBC3-MD5"
+
 #define SSL3_TXT_RSA_NULL_MD5                   "NULL-MD5"
 #define SSL3_TXT_RSA_NULL_SHA                   "NULL-SHA"
 #define SSL3_TXT_RSA_RC4_40_MD5                 "EXP-RC4-MD5"
@@ -144,7 +218,8 @@ extern "C" {
 #define SSL3_RT_HEADER_LENGTH                   5
 
 /* Due to MS stuffing up, this can change.... */
-#if defined(WIN16) || (defined(MSDOS) && !defined(WIN32))
+#if defined(OPENSSL_SYS_WIN16) || \
+        (defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_WIN32))
 #define SSL3_RT_MAX_EXTRA                       (14000)
 #else
 #define SSL3_RT_MAX_EXTRA                       (16384)
@@ -156,24 +231,8 @@ extern "C" {
 #define SSL3_RT_MAX_PACKET_SIZE         (SSL3_RT_MAX_ENCRYPTED_LENGTH+SSL3_RT_HEADER_LENGTH)
 #define SSL3_RT_MAX_DATA_SIZE                   (1024*1024)
 
-/* the states that a SSL3_RECORD can be in
- * For SSL_read it goes
- * rbuf->ENCODED        -> read 
- * ENCODED              -> we need to decode everything - call decode_record
- */
- 
-#define SSL3_RS_BLANK                   1
-#define SSL3_RS_DATA
-
-#define SSL3_RS_ENCODED                 2
-#define SSL3_RS_READ_MORE               3
-#define SSL3_RS_WRITE_MORE
-#define SSL3_RS_PLAIN                   3
-#define SSL3_RS_PART_READ               4
-#define SSL3_RS_PART_WRITE              5
-
-#define SSL3_MD_CLIENT_FINISHED_CONST   {0x43,0x4C,0x4E,0x54}
-#define SSL3_MD_SERVER_FINISHED_CONST   {0x53,0x52,0x56,0x52}
+#define SSL3_MD_CLIENT_FINISHED_CONST   "\x43\x4C\x4E\x54"
+#define SSL3_MD_SERVER_FINISHED_CONST   "\x53\x52\x56\x52"
 
 #define SSL3_VERSION                    0x0300
 #define SSL3_VERSION_MAJOR              0x03
@@ -202,28 +261,23 @@ extern "C" {
 
 typedef struct ssl3_record_st
         {
-/*r */  int type;               /* type of record */
-/*  */  /*int state;*/          /* any data in it? */
-/*rw*/  unsigned int length;    /* How many bytes available */
-/*r */  unsigned int off;       /* read/write offset into 'buf' */
-/*rw*/  unsigned char *data;    /* pointer to the record data */
-/*rw*/  unsigned char *input;   /* where the decode bytes are */
-/*rw*/  unsigned char *comp;    /* only used with decompression */
+/*r */  int type;               /* type of record */
+/*rw*/  unsigned int length;    /* How many bytes available */
+/*r */  unsigned int off;       /* read/write offset into 'buf' */
+/*rw*/  unsigned char *data;    /* pointer to the record data */
+/*rw*/  unsigned char *input;   /* where the decode bytes are */
+/*r */  unsigned char *comp;    /* only used with decompression - malloc()ed */
         } SSL3_RECORD;
 
 typedef struct ssl3_buffer_st
         {
-/*r */  int total;              /* used in non-blocking writes */
-/*r */  int wanted;             /* how many more bytes we need */
-/*rw*/  int left;               /* how many bytes left */
-/*rw*/  int offset;             /* where to 'copy from' */
-/*rw*/  unsigned char *buf;     /* SSL3_RT_MAX_PACKET_SIZE bytes */
+        unsigned char *buf;     /* at least SSL3_RT_MAX_PACKET_SIZE bytes,
+                                 * see ssl3_setup_buffers() */
+        size_t len;             /* buffer size */
+        int offset;             /* where to 'copy from' */
+        int left;               /* how many bytes left */
         } SSL3_BUFFER;
 
-typedef struct ssl3_compression_st {
-        int nothing;
-        } SSL3_COMPRESSION;
-
 #define SSL3_CT_RSA_SIGN                        1
 #define SSL3_CT_DSS_SIGN                        2
 #define SSL3_CT_RSA_FIXED_DH                    3
@@ -236,36 +290,9 @@ typedef struct ssl3_compression_st {
 #define SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS       0x0001
 #define SSL3_FLAGS_DELAY_CLIENT_FINISHED        0x0002
 #define SSL3_FLAGS_POP_BUFFER                   0x0004
-#define TLS1_FLAGS_TLS_PADDING_BUG              0x0008
-
-#if 0
-#define AD_CLOSE_NOTIFY                 0
-#define AD_UNEXPECTED_MESSAGE           1
-#define AD_BAD_RECORD_MAC               2
-#define AD_DECRYPTION_FAILED            3
-#define AD_RECORD_OVERFLOW              4
-#define AD_DECOMPRESSION_FAILURE        5       /* fatal */
-#define AD_HANDSHAKE_FAILURE            6       /* fatal */
-#define AD_NO_CERTIFICATE               7       /* Not under TLS */
-#define AD_BAD_CERTIFICATE              8
-#define AD_UNSUPPORTED_CERTIFICATE      9
-#define AD_CERTIFICATE_REVOKED          10      
-#define AD_CERTIFICATE_EXPIRED          11
-#define AD_CERTIFICATE_UNKNOWN          12
-#define AD_ILLEGAL_PARAMETER            13      /* fatal */
-#define AD_UNKNOWN_CA                   14      /* fatal */
-#define AD_ACCESS_DENIED                15      /* fatal */
-#define AD_DECODE_ERROR                 16      /* fatal */
-#define AD_DECRYPT_ERROR                17
-#define AD_EXPORT_RESTRICION            18      /* fatal */
-#define AD_PROTOCOL_VERSION             19      /* fatal */
-#define AD_INSUFFICIENT_SECURITY        20      /* fatal */
-#define AD_INTERNAL_ERROR               21      /* fatal */
-#define AD_USER_CANCLED                 22
-#define AD_NO_RENEGOTIATION             23
-#endif
+#define TLS1_FLAGS_TLS_PADDING_BUG              0x0008
 
-typedef struct ssl3_ctx_st
+typedef struct ssl3_state_st
         {
         long flags;
         int delay_buf_pop_ret;
@@ -278,19 +305,29 @@ typedef struct ssl3_ctx_st
         unsigned char server_random[SSL3_RANDOM_SIZE];
         unsigned char client_random[SSL3_RANDOM_SIZE];
 
+        /* flags for countermeasure against known-IV weakness */
+        int need_empty_fragments;
+        int empty_fragment_done;
+
         SSL3_BUFFER rbuf;       /* read IO goes into here */
         SSL3_BUFFER wbuf;       /* write IO goes into here */
+
         SSL3_RECORD rrec;       /* each decoded record goes in here */
         SSL3_RECORD wrec;       /* goes out from here */
-                                /* Used by ssl3_read_n to point
-                                 * to input data packet */
+
+        /* storage for Alert/Handshake protocol data received but not
+         * yet processed by ssl3_read_bytes: */
+        unsigned char alert_fragment[2];
+        unsigned int alert_fragment_len;
+        unsigned char handshake_fragment[4];
+        unsigned int handshake_fragment_len;
 
         /* partial write - check the numbers match */
         unsigned int wnum;      /* number of bytes sent so far */
         int wpend_tot;          /* number bytes written */
         int wpend_type;
         int wpend_ret;          /* number of bytes submitted */
-        char *wpend_buf;
+        const unsigned char *wpend_buf;
 
         /* used during startup, digest all incoming/outgoing packets */
         EVP_MD_CTX finish_dgst1;
@@ -302,10 +339,10 @@ typedef struct ssl3_ctx_st
 
         int warn_alert;
         int fatal_alert;
-        /* we alow one fatal and one warning alert to be outstanding,
+        /* we allow one fatal and one warning alert to be outstanding,
          * send close alert via the warning alert */
         int alert_dispatch;
-        char send_alert[2];
+        unsigned char send_alert[2];
 
         /* This flag is set when we should renegotiate ASAP, basically when
          * there is no more data in the read or write buffers */
@@ -316,16 +353,23 @@ typedef struct ssl3_ctx_st
         int in_read_app_data;
 
         struct  {
-                /* Actually only needs to be 16+20 for SSLv3 and 12 for TLS */
+                /* actually only needs to be 16+20 */
+                unsigned char cert_verify_md[EVP_MAX_MD_SIZE*2];
+
+                /* actually only need to be 16+20 for SSLv3 and 12 for TLS */
                 unsigned char finish_md[EVP_MAX_MD_SIZE*2];
+                int finish_md_len;
+                unsigned char peer_finish_md[EVP_MAX_MD_SIZE*2];
+                int peer_finish_md_len;
                 
                 unsigned long message_size;
                 int message_type;
 
                 /* used to hold the new cipher we are going to use */
                 SSL_CIPHER *new_cipher;
+#ifndef OPENSSL_NO_DH
                 DH *dh;
-
+#endif
                 /* used when SSL_ST_FLUSH_DATA is entered */
                 int next_state;                 
 
@@ -335,19 +379,24 @@ typedef struct ssl3_ctx_st
                 int cert_req;
                 int ctype_num;
                 char ctype[SSL3_CT_NUMBER];
-                STACK *ca_names;
+                STACK_OF(X509_NAME) *ca_names;
 
                 int use_rsa_tmp;
 
                 int key_block_length;
                 unsigned char *key_block;
 
-                EVP_CIPHER *new_sym_enc;
-                EVP_MD *new_hash;
-                SSL_COMPRESSION *new_compression;
+                const EVP_CIPHER *new_sym_enc;
+                const EVP_MD *new_hash;
+#ifndef OPENSSL_NO_COMP
+                const SSL_COMP *new_compression;
+#else
+                char *new_compression;
+#endif
                 int cert_request;
                 } tmp;
-        } SSL3_CTX;
+
+        } SSL3_STATE;
 
 /* SSLv3 */
 /*client */
@@ -425,7 +474,7 @@ typedef struct ssl3_ctx_st
 #define SSL3_ST_SW_FINISHED_A           (0x1E0|SSL_ST_ACCEPT)
 #define SSL3_ST_SW_FINISHED_B           (0x1E1|SSL_ST_ACCEPT)
 
-#define SSL3_MT_CLIENT_REQUEST                  0
+#define SSL3_MT_HELLO_REQUEST                   0
 #define SSL3_MT_CLIENT_HELLO                    1
 #define SSL3_MT_SERVER_HELLO                    2
 #define SSL3_MT_CERTIFICATE                     11
diff --git a/src/lib/libssl/ssl_algs.c b/src/lib/libssl/ssl_algs.c
index 65f3a59386..3d1299ee7b 100644
--- a/src/lib/libssl/ssl_algs.c
+++ b/src/lib/libssl/ssl_algs.c
@@ -57,46 +57,55 @@
  */
 
 #include <stdio.h>
-#include "objects.h"
-#include "lhash.h"
+#include <openssl/objects.h>
+#include <openssl/lhash.h>
 #include "ssl_locl.h"
 
-void SSLeay_add_ssl_algorithms()
+int SSL_library_init(void)
         {
-#ifndef NO_DES
+
+#ifndef OPENSSL_NO_DES
         EVP_add_cipher(EVP_des_cbc());
         EVP_add_cipher(EVP_des_ede3_cbc());
 #endif
-#ifndef NO_IDEA
+#ifndef OPENSSL_NO_IDEA
         EVP_add_cipher(EVP_idea_cbc());
 #endif
-#ifndef NO_RC4
-        EVP_add_cipher(EVP_rc4());
-#endif  
-#ifndef NO_RC2
-        EVP_add_cipher(EVP_rc2_cbc());
+#ifndef OPENSSL_NO_RC4
+        EVP_add_cipher(EVP_rc4());
 #endif  
-
-#ifndef NO_MD2
-        EVP_add_digest(EVP_md2());
+#ifndef OPENSSL_NO_RC2
+        EVP_add_cipher(EVP_rc2_cbc());
 #endif
-#ifndef NO_MD5
+#ifndef OPENSSL_NO_AES
+        EVP_add_cipher(EVP_aes_128_cbc());
+        EVP_add_cipher(EVP_aes_192_cbc());
+        EVP_add_cipher(EVP_aes_256_cbc());
+#endif
+#ifndef OPENSSL_NO_MD2
+        EVP_add_digest(EVP_md2());
+#endif
+#ifndef OPENSSL_NO_MD5
         EVP_add_digest(EVP_md5());
-        EVP_add_alias(SN_md5,"ssl2-md5");
-        EVP_add_alias(SN_md5,"ssl3-md5");
+        EVP_add_digest_alias(SN_md5,"ssl2-md5");
+        EVP_add_digest_alias(SN_md5,"ssl3-md5");
 #endif
-#ifndef NO_SHA1
+#ifndef OPENSSL_NO_SHA
         EVP_add_digest(EVP_sha1()); /* RSA with sha1 */
-        EVP_add_alias(SN_sha1,"ssl3-sha1");
+        EVP_add_digest_alias(SN_sha1,"ssl3-sha1");
+        EVP_add_digest_alias(SN_sha1WithRSAEncryption,SN_sha1WithRSA);
 #endif
-#if !defined(NO_SHA1) && !defined(NO_DSA)
+#if !defined(OPENSSL_NO_SHA) && !defined(OPENSSL_NO_DSA)
         EVP_add_digest(EVP_dss1()); /* DSA with sha1 */
+        EVP_add_digest_alias(SN_dsaWithSHA1,SN_dsaWithSHA1_2);
+        EVP_add_digest_alias(SN_dsaWithSHA1,"DSS1");
+        EVP_add_digest_alias(SN_dsaWithSHA1,"dss1");
 #endif
-
         /* If you want support for phased out ciphers, add the following */
 #if 0
         EVP_add_digest(EVP_sha());
         EVP_add_digest(EVP_dss());
 #endif
+        return(1);
         }
 
diff --git a/src/lib/libssl/ssl_asn1.c b/src/lib/libssl/ssl_asn1.c
index 116a83de64..c5eeeb6bc5 100644
--- a/src/lib/libssl/ssl_asn1.c
+++ b/src/lib/libssl/ssl_asn1.c
@@ -58,8 +58,9 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "asn1_mac.h"
-#include "objects.h"
+#include <openssl/asn1_mac.h>
+#include <openssl/objects.h>
+#include <openssl/x509.h>
 #include "ssl_locl.h"
 
 typedef struct ssl_session_asn1_st
@@ -69,24 +70,22 @@ typedef struct ssl_session_asn1_st
         ASN1_OCTET_STRING cipher;
         ASN1_OCTET_STRING master_key;
         ASN1_OCTET_STRING session_id;
+        ASN1_OCTET_STRING session_id_context;
         ASN1_OCTET_STRING key_arg;
+#ifndef OPENSSL_NO_KRB5
+        ASN1_OCTET_STRING krb5_princ;
+#endif /* OPENSSL_NO_KRB5 */
         ASN1_INTEGER time;
         ASN1_INTEGER timeout;
+        ASN1_INTEGER verify_result;
         } SSL_SESSION_ASN1;
 
-/*
- * SSLerr(SSL_F_I2D_SSL_SESSION,SSL_R_CIPHER_CODE_WRONG_LENGTH);
- * SSLerr(SSL_F_D2I_SSL_SESSION,SSL_R_UNSUPPORTED_CIPHER);
- */
-
-int i2d_SSL_SESSION(in,pp)
-SSL_SESSION *in;
-unsigned char **pp;
+int i2d_SSL_SESSION(SSL_SESSION *in, unsigned char **pp)
         {
 #define LSIZE2 (sizeof(long)*2)
-        int v1=0,v2=0,v3=0;
+        int v1=0,v2=0,v3=0,v4=0,v5=0;
         unsigned char buf[4],ibuf1[LSIZE2],ibuf2[LSIZE2];
-        unsigned char ibuf3[LSIZE2],ibuf4[LSIZE2];
+        unsigned char ibuf3[LSIZE2],ibuf4[LSIZE2],ibuf5[LSIZE2];
         long l;
         SSL_SESSION_ASN1 a;
         M_ASN1_I2D_vars(in);
@@ -95,8 +94,8 @@ unsigned char **pp;
                 return(0);
 
         /* Note that I cheat in the following 2 assignments.  I know
-         * that if the ASN1_INTERGER passed to ASN1_INTEGER_set
-         * is > sizeof(long)+1, the buffer will not be re-Malloc()ed.
+         * that if the ASN1_INTEGER passed to ASN1_INTEGER_set
+         * is > sizeof(long)+1, the buffer will not be re-OPENSSL_malloc()ed.
          * This is a bit evil but makes things simple, no dynamic allocation
          * to clean up :-) */
         a.version.length=LSIZE2;
@@ -138,10 +137,23 @@ unsigned char **pp;
         a.session_id.type=V_ASN1_OCTET_STRING;
         a.session_id.data=in->session_id;
 
+        a.session_id_context.length=in->sid_ctx_length;
+        a.session_id_context.type=V_ASN1_OCTET_STRING;
+        a.session_id_context.data=in->sid_ctx;
+
         a.key_arg.length=in->key_arg_length;
         a.key_arg.type=V_ASN1_OCTET_STRING;
         a.key_arg.data=in->key_arg;
 
+#ifndef OPENSSL_NO_KRB5
+        if (in->krb5_client_princ_len)
+                {
+                a.krb5_princ.length=in->krb5_client_princ_len;
+                a.krb5_princ.type=V_ASN1_OCTET_STRING;
+                a.krb5_princ.data=in->krb5_client_princ;
+                }
+#endif /* OPENSSL_NO_KRB5 */
+ 
         if (in->time != 0L)
                 {
                 a.time.length=LSIZE2;
@@ -158,11 +170,24 @@ unsigned char **pp;
                 ASN1_INTEGER_set(&(a.timeout),in->timeout);
                 }
 
+        if (in->verify_result != X509_V_OK)
+                {
+                a.verify_result.length=LSIZE2;
+                a.verify_result.type=V_ASN1_INTEGER;
+                a.verify_result.data=ibuf5;
+                ASN1_INTEGER_set(&a.verify_result,in->verify_result);
+                }
+
+
         M_ASN1_I2D_len(&(a.version),            i2d_ASN1_INTEGER);
         M_ASN1_I2D_len(&(a.ssl_version),        i2d_ASN1_INTEGER);
         M_ASN1_I2D_len(&(a.cipher),             i2d_ASN1_OCTET_STRING);
         M_ASN1_I2D_len(&(a.session_id),         i2d_ASN1_OCTET_STRING);
         M_ASN1_I2D_len(&(a.master_key),         i2d_ASN1_OCTET_STRING);
+#ifndef OPENSSL_NO_KRB5
+        if (in->krb5_client_princ_len)
+                M_ASN1_I2D_len(&(a.krb5_princ), i2d_ASN1_OCTET_STRING);
+#endif /* OPENSSL_NO_KRB5 */
         if (in->key_arg_length > 0)
                 M_ASN1_I2D_len_IMP_opt(&(a.key_arg),i2d_ASN1_OCTET_STRING);
         if (in->time != 0L)
@@ -171,6 +196,9 @@ unsigned char **pp;
                 M_ASN1_I2D_len_EXP_opt(&(a.timeout),i2d_ASN1_INTEGER,2,v2);
         if (in->peer != NULL)
                 M_ASN1_I2D_len_EXP_opt(in->peer,i2d_X509,3,v3);
+        M_ASN1_I2D_len_EXP_opt(&a.session_id_context,i2d_ASN1_OCTET_STRING,4,v4);
+        if (in->verify_result != X509_V_OK)
+                M_ASN1_I2D_len_EXP_opt(&(a.verify_result),i2d_ASN1_INTEGER,5,v5);
 
         M_ASN1_I2D_seq_total();
 
@@ -179,6 +207,10 @@ unsigned char **pp;
         M_ASN1_I2D_put(&(a.cipher),             i2d_ASN1_OCTET_STRING);
         M_ASN1_I2D_put(&(a.session_id),         i2d_ASN1_OCTET_STRING);
         M_ASN1_I2D_put(&(a.master_key),         i2d_ASN1_OCTET_STRING);
+#ifndef OPENSSL_NO_KRB5
+        if (in->krb5_client_princ_len)
+                M_ASN1_I2D_put(&(a.krb5_princ), i2d_ASN1_OCTET_STRING);
+#endif /* OPENSSL_NO_KRB5 */
         if (in->key_arg_length > 0)
                 M_ASN1_I2D_put_IMP_opt(&(a.key_arg),i2d_ASN1_OCTET_STRING,0);
         if (in->time != 0L)
@@ -187,14 +219,15 @@ unsigned char **pp;
                 M_ASN1_I2D_put_EXP_opt(&(a.timeout),i2d_ASN1_INTEGER,2,v2);
         if (in->peer != NULL)
                 M_ASN1_I2D_put_EXP_opt(in->peer,i2d_X509,3,v3);
-
+        M_ASN1_I2D_put_EXP_opt(&a.session_id_context,i2d_ASN1_OCTET_STRING,4,
+                               v4);
+        if (in->verify_result != X509_V_OK)
+                M_ASN1_I2D_put_EXP_opt(&a.verify_result,i2d_ASN1_INTEGER,5,v5);
         M_ASN1_I2D_finish();
         }
 
-SSL_SESSION *d2i_SSL_SESSION(a,pp,length)
-SSL_SESSION **a;
-unsigned char **pp;
-long length;
+SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, unsigned char **pp,
+             long length)
         {
         int version,ssl_version=0,i;
         long id;
@@ -211,13 +244,13 @@ long length;
         ai.data=NULL; ai.length=0;
         M_ASN1_D2I_get(aip,d2i_ASN1_INTEGER);
         version=(int)ASN1_INTEGER_get(aip);
-        if (ai.data != NULL) { Free(ai.data); ai.data=NULL; ai.length=0; }
+        if (ai.data != NULL) { OPENSSL_free(ai.data); ai.data=NULL; ai.length=0; }
 
         /* we don't care about the version right now :-) */
         M_ASN1_D2I_get(aip,d2i_ASN1_INTEGER);
         ssl_version=(int)ASN1_INTEGER_get(aip);
         ret->ssl_version=ssl_version;
-        if (ai.data != NULL) { Free(ai.data); ai.data=NULL; ai.length=0; }
+        if (ai.data != NULL) { OPENSSL_free(ai.data); ai.data=NULL; ai.length=0; }
 
         os.data=NULL; os.length=0;
         M_ASN1_D2I_get(osp,d2i_ASN1_OCTET_STRING);
@@ -273,20 +306,39 @@ long length;
         memcpy(ret->master_key,os.data,ret->master_key_length);
 
         os.length=0;
+
+#ifndef OPENSSL_NO_KRB5
+        os.length=0;
+        M_ASN1_D2I_get_opt(osp,d2i_ASN1_OCTET_STRING,V_ASN1_OCTET_STRING);
+        if (os.data)
+                {
+                if (os.length > SSL_MAX_KRB5_PRINCIPAL_LENGTH)
+                        ret->krb5_client_princ_len=0;
+                else
+                        ret->krb5_client_princ_len=os.length;
+                memcpy(ret->krb5_client_princ,os.data,ret->krb5_client_princ_len);
+                OPENSSL_free(os.data);
+                os.data = NULL;
+                os.length = 0;
+                }
+        else
+                ret->krb5_client_princ_len=0;
+#endif /* OPENSSL_NO_KRB5 */
+
         M_ASN1_D2I_get_IMP_opt(osp,d2i_ASN1_OCTET_STRING,0,V_ASN1_OCTET_STRING);
         if (os.length > SSL_MAX_KEY_ARG_LENGTH)
                 ret->key_arg_length=SSL_MAX_KEY_ARG_LENGTH;
         else
                 ret->key_arg_length=os.length;
         memcpy(ret->key_arg,os.data,ret->key_arg_length);
-        if (os.data != NULL) Free(os.data);
+        if (os.data != NULL) OPENSSL_free(os.data);
 
         ai.length=0;
         M_ASN1_D2I_get_EXP_opt(aip,d2i_ASN1_INTEGER,1);
         if (ai.data != NULL)
                 {
                 ret->time=ASN1_INTEGER_get(aip);
-                Free(ai.data); ai.data=NULL; ai.length=0;
+                OPENSSL_free(ai.data); ai.data=NULL; ai.length=0;
                 }
         else
                 ret->time=time(NULL);
@@ -296,7 +348,7 @@ long length;
         if (ai.data != NULL)
                 {
                 ret->timeout=ASN1_INTEGER_get(aip);
-                Free(ai.data); ai.data=NULL; ai.length=0;
+                OPENSSL_free(ai.data); ai.data=NULL; ai.length=0;
                 }
         else
                 ret->timeout=3;
@@ -308,6 +360,30 @@ long length;
                 }
         M_ASN1_D2I_get_EXP_opt(ret->peer,d2i_X509,3);
 
+        os.length=0;
+        os.data=NULL;
+        M_ASN1_D2I_get_EXP_opt(osp,d2i_ASN1_OCTET_STRING,4);
+
+        if(os.data != NULL)
+            {
+            if (os.length > SSL_MAX_SID_CTX_LENGTH)
+                SSLerr(SSL_F_D2I_SSL_SESSION,SSL_R_BAD_LENGTH);
+            ret->sid_ctx_length=os.length;
+            memcpy(ret->sid_ctx,os.data,os.length);
+            OPENSSL_free(os.data); os.data=NULL; os.length=0;
+            }
+        else
+            ret->sid_ctx_length=0;
+
+        ai.length=0;
+        M_ASN1_D2I_get_EXP_opt(aip,d2i_ASN1_INTEGER,5);
+        if (ai.data != NULL)
+                {
+                ret->verify_result=ASN1_INTEGER_get(aip);
+                OPENSSL_free(ai.data); ai.data=NULL; ai.length=0;
+                }
+        else
+                ret->verify_result=X509_V_OK;
+
         M_ASN1_D2I_Finish(a,SSL_SESSION_free,SSL_F_D2I_SSL_SESSION);
         }
-
diff --git a/src/lib/libssl/ssl_cert.c b/src/lib/libssl/ssl_cert.c
index c1cb86e1b7..3d31bbf05f 100644
--- a/src/lib/libssl/ssl_cert.c
+++ b/src/lib/libssl/ssl_cert.c
@@ -1,4 +1,4 @@
-/* ssl/ssl_cert.c */
+/*! \file ssl/ssl_cert.c */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -55,32 +55,113 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
+/* ====================================================================
+ * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@OpenSSL.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ */
 
 #include <stdio.h>
-#include "objects.h"
-#include "bio.h"
-#include "pem.h"
+
+#include "e_os.h"
+#ifndef NO_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#if !defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_SYS_VMS) && !defined(NeXT) && !defined(MAC_OS_pre_X)
+#include <dirent.h>
+#endif
+
+#if defined(WIN32)
+#include <windows.h>
+#endif
+
+#ifdef NeXT
+#include <sys/dir.h>
+#define dirent direct
+#endif
+
+#include <openssl/objects.h>
+#include <openssl/bio.h>
+#include <openssl/pem.h>
+#include <openssl/x509v3.h>
 #include "ssl_locl.h"
 
-CERT *ssl_cert_new()
+int SSL_get_ex_data_X509_STORE_CTX_idx(void)
+        {
+        static volatile int ssl_x509_store_ctx_idx= -1;
+
+        if (ssl_x509_store_ctx_idx < 0)
+                {
+                /* any write lock will do; usually this branch
+                 * will only be taken once anyway */
+                CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
+                
+                if (ssl_x509_store_ctx_idx < 0)
+                        {
+                        ssl_x509_store_ctx_idx=X509_STORE_CTX_get_ex_new_index(
+                                0,"SSL for verify callback",NULL,NULL,NULL);
+                        }
+                
+                CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
+                }
+        return ssl_x509_store_ctx_idx;
+        }
+
+CERT *ssl_cert_new(void)
         {
         CERT *ret;
 
-        ret=(CERT *)Malloc(sizeof(CERT));
+        ret=(CERT *)OPENSSL_malloc(sizeof(CERT));
         if (ret == NULL)
                 {
                 SSLerr(SSL_F_SSL_CERT_NEW,ERR_R_MALLOC_FAILURE);
                 return(NULL);
                 }
         memset(ret,0,sizeof(CERT));
-/*
-        ret->valid=0;
-        ret->mask=0;
-        ret->export_mask=0;
-        ret->cert_type=0;
-        ret->key->x509=NULL;
-        ret->key->publickey=NULL;
-        ret->key->privatekey=NULL; */
 
         ret->key= &(ret->pkeys[SSL_PKEY_RSA_ENC]);
         ret->references=1;
@@ -88,11 +169,151 @@ CERT *ssl_cert_new()
         return(ret);
         }
 
-void ssl_cert_free(c)
-CERT *c;
+CERT *ssl_cert_dup(CERT *cert)
         {
+        CERT *ret;
         int i;
 
+        ret = (CERT *)OPENSSL_malloc(sizeof(CERT));
+        if (ret == NULL)
+                {
+                SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
+                return(NULL);
+                }
+
+        memset(ret, 0, sizeof(CERT));
+
+        ret->key = &ret->pkeys[cert->key - &cert->pkeys[0]];
+        /* or ret->key = ret->pkeys + (cert->key - cert->pkeys),
+         * if you find that more readable */
+
+        ret->valid = cert->valid;
+        ret->mask = cert->mask;
+        ret->export_mask = cert->export_mask;
+
+#ifndef OPENSSL_NO_RSA
+        if (cert->rsa_tmp != NULL)
+                {
+                RSA_up_ref(cert->rsa_tmp);
+                ret->rsa_tmp = cert->rsa_tmp;
+                }
+        ret->rsa_tmp_cb = cert->rsa_tmp_cb;
+#endif
+
+#ifndef OPENSSL_NO_DH
+        if (cert->dh_tmp != NULL)
+                {
+                /* DH parameters don't have a reference count */
+                ret->dh_tmp = DHparams_dup(cert->dh_tmp);
+                if (ret->dh_tmp == NULL)
+                        {
+                        SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_DH_LIB);
+                        goto err;
+                        }
+                if (cert->dh_tmp->priv_key)
+                        {
+                        BIGNUM *b = BN_dup(cert->dh_tmp->priv_key);
+                        if (!b)
+                                {
+                                SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_BN_LIB);
+                                goto err;
+                                }
+                        ret->dh_tmp->priv_key = b;
+                        }
+                if (cert->dh_tmp->pub_key)
+                        {
+                        BIGNUM *b = BN_dup(cert->dh_tmp->pub_key);
+                        if (!b)
+                                {
+                                SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_BN_LIB);
+                                goto err;
+                                }
+                        ret->dh_tmp->pub_key = b;
+                        }
+                }
+        ret->dh_tmp_cb = cert->dh_tmp_cb;
+#endif
+
+        for (i = 0; i < SSL_PKEY_NUM; i++)
+                {
+                if (cert->pkeys[i].x509 != NULL)
+                        {
+                        ret->pkeys[i].x509 = cert->pkeys[i].x509;
+                        CRYPTO_add(&ret->pkeys[i].x509->references, 1,
+                                CRYPTO_LOCK_X509);
+                        }
+                
+                if (cert->pkeys[i].privatekey != NULL)
+                        {
+                        ret->pkeys[i].privatekey = cert->pkeys[i].privatekey;
+                        CRYPTO_add(&ret->pkeys[i].privatekey->references, 1,
+                                CRYPTO_LOCK_EVP_PKEY);
+
+                        switch(i) 
+                                {
+                                /* If there was anything special to do for
+                                 * certain types of keys, we'd do it here.
+                                 * (Nothing at the moment, I think.) */
+
+                        case SSL_PKEY_RSA_ENC:
+                        case SSL_PKEY_RSA_SIGN:
+                                /* We have an RSA key. */
+                                break;
+                                
+                        case SSL_PKEY_DSA_SIGN:
+                                /* We have a DSA key. */
+                                break;
+                                
+                        case SSL_PKEY_DH_RSA:
+                        case SSL_PKEY_DH_DSA:
+                                /* We have a DH key. */
+                                break;
+                                
+                        default:
+                                /* Can't happen. */
+                                SSLerr(SSL_F_SSL_CERT_DUP, SSL_R_LIBRARY_BUG);
+                                }
+                        }
+                }
+        
+        /* ret->extra_certs *should* exist, but currently the own certificate
+         * chain is held inside SSL_CTX */
+
+        ret->references=1;
+
+        return(ret);
+        
+#ifndef OPENSSL_NO_DH /* avoid 'unreferenced label' warning if OPENSSL_NO_DH is defined */
+err:
+#endif
+#ifndef OPENSSL_NO_RSA
+        if (ret->rsa_tmp != NULL)
+                RSA_free(ret->rsa_tmp);
+#endif
+#ifndef OPENSSL_NO_DH
+        if (ret->dh_tmp != NULL)
+                DH_free(ret->dh_tmp);
+#endif
+
+        for (i = 0; i < SSL_PKEY_NUM; i++)
+                {
+                if (ret->pkeys[i].x509 != NULL)
+                        X509_free(ret->pkeys[i].x509);
+                if (ret->pkeys[i].privatekey != NULL)
+                        EVP_PKEY_free(ret->pkeys[i].privatekey);
+                }
+
+        return NULL;
+        }
+
+
+void ssl_cert_free(CERT *c)
+        {
+        int i;
+
+        if(c == NULL)
+            return;
+
         i=CRYPTO_add(&c->references,-1,CRYPTO_LOCK_SSL_CERT);
 #ifdef REF_PRINT
         REF_PRINT("CERT",c);
@@ -106,10 +327,10 @@ CERT *c;
                 }
 #endif
 
-#ifndef NO_RSA
+#ifndef OPENSSL_NO_RSA
         if (c->rsa_tmp) RSA_free(c->rsa_tmp);
 #endif
-#ifndef NO_DH
+#ifndef OPENSSL_NO_DH
         if (c->dh_tmp) DH_free(c->dh_tmp);
 #endif
 
@@ -124,97 +345,209 @@ CERT *c;
                         EVP_PKEY_free(c->pkeys[i].publickey);
 #endif
                 }
-        if (c->cert_chain != NULL)
-                sk_pop_free(c->cert_chain,X509_free);
-        Free(c);
+        OPENSSL_free(c);
         }
 
-int ssl_set_cert_type(c, type)
-CERT *c;
-int type;
+int ssl_cert_inst(CERT **o)
         {
-        c->cert_type=type;
+        /* Create a CERT if there isn't already one
+         * (which cannot really happen, as it is initially created in
+         * SSL_CTX_new; but the earlier code usually allows for that one
+         * being non-existant, so we follow that behaviour, as it might
+         * turn out that there actually is a reason for it -- but I'm
+         * not sure that *all* of the existing code could cope with
+         * s->cert being NULL, otherwise we could do without the
+         * initialization in SSL_CTX_new).
+         */
+        
+        if (o == NULL) 
+                {
+                SSLerr(SSL_F_SSL_CERT_INST, ERR_R_PASSED_NULL_PARAMETER);
+                return(0);
+                }
+        if (*o == NULL)
+                {
+                if ((*o = ssl_cert_new()) == NULL)
+                        {
+                        SSLerr(SSL_F_SSL_CERT_INST, ERR_R_MALLOC_FAILURE);
+                        return(0);
+                        }
+                }
         return(1);
         }
 
-int ssl_verify_cert_chain(s,sk)
-SSL *s;
-STACK *sk;
+
+SESS_CERT *ssl_sess_cert_new(void)
+        {
+        SESS_CERT *ret;
+
+        ret = OPENSSL_malloc(sizeof *ret);
+        if (ret == NULL)
+                {
+                SSLerr(SSL_F_SSL_SESS_CERT_NEW, ERR_R_MALLOC_FAILURE);
+                return NULL;
+                }
+
+        memset(ret, 0 ,sizeof *ret);
+        ret->peer_key = &(ret->peer_pkeys[SSL_PKEY_RSA_ENC]);
+        ret->references = 1;
+
+        return ret;
+        }
+
+void ssl_sess_cert_free(SESS_CERT *sc)
+        {
+        int i;
+
+        if (sc == NULL)
+                return;
+
+        i = CRYPTO_add(&sc->references, -1, CRYPTO_LOCK_SSL_SESS_CERT);
+#ifdef REF_PRINT
+        REF_PRINT("SESS_CERT", sc);
+#endif
+        if (i > 0)
+                return;
+#ifdef REF_CHECK
+        if (i < 0)
+                {
+                fprintf(stderr,"ssl_sess_cert_free, bad reference count\n");
+                abort(); /* ok */
+                }
+#endif
+
+        /* i == 0 */
+        if (sc->cert_chain != NULL)
+                sk_X509_pop_free(sc->cert_chain, X509_free);
+        for (i = 0; i < SSL_PKEY_NUM; i++)
+                {
+                if (sc->peer_pkeys[i].x509 != NULL)
+                        X509_free(sc->peer_pkeys[i].x509);
+#if 0 /* We don't have the peer's private key.  These lines are just
+           * here as a reminder that we're still using a not-quite-appropriate
+           * data structure. */
+                if (sc->peer_pkeys[i].privatekey != NULL)
+                        EVP_PKEY_free(sc->peer_pkeys[i].privatekey);
+#endif
+                }
+
+#ifndef OPENSSL_NO_RSA
+        if (sc->peer_rsa_tmp != NULL)
+                RSA_free(sc->peer_rsa_tmp);
+#endif
+#ifndef OPENSSL_NO_DH
+        if (sc->peer_dh_tmp != NULL)
+                DH_free(sc->peer_dh_tmp);
+#endif
+
+        OPENSSL_free(sc);
+        }
+
+int ssl_set_peer_cert_type(SESS_CERT *sc,int type)
+        {
+        sc->peer_cert_type = type;
+        return(1);
+        }
+
+int ssl_verify_cert_chain(SSL *s,STACK_OF(X509) *sk)
         {
         X509 *x;
         int i;
         X509_STORE_CTX ctx;
 
-        if ((sk == NULL) || (sk_num(sk) == 0))
+        if ((sk == NULL) || (sk_X509_num(sk) == 0))
                 return(0);
 
-        x=(X509 *)sk_value(sk,0);
-        X509_STORE_CTX_init(&ctx,s->ctx->cert_store,x,sk);
-        X509_STORE_CTX_set_app_data(&ctx,(char *)s);
+        x=sk_X509_value(sk,0);
+        if(!X509_STORE_CTX_init(&ctx,s->ctx->cert_store,x,sk))
+                {
+                SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN,ERR_R_X509_LIB);
+                return(0);
+                }
+        if (SSL_get_verify_depth(s) >= 0)
+                X509_STORE_CTX_set_depth(&ctx, SSL_get_verify_depth(s));
+        X509_STORE_CTX_set_ex_data(&ctx,SSL_get_ex_data_X509_STORE_CTX_idx(),s);
+
+        /* We need to set the verify purpose. The purpose can be determined by
+         * the context: if its a server it will verify SSL client certificates
+         * or vice versa.
+         */
+        if (s->server)
+                i = X509_PURPOSE_SSL_CLIENT;
+        else
+                i = X509_PURPOSE_SSL_SERVER;
+
+        X509_STORE_CTX_purpose_inherit(&ctx, i, s->purpose, s->trust);
+
+        if (s->verify_callback)
+                X509_STORE_CTX_set_verify_cb(&ctx, s->verify_callback);
 
         if (s->ctx->app_verify_callback != NULL)
-                i=s->ctx->app_verify_callback(&ctx);
+#if 1 /* new with OpenSSL 0.9.7 */
+                i=s->ctx->app_verify_callback(&ctx, s->ctx->app_verify_arg); 
+#else
+                i=s->ctx->app_verify_callback(&ctx); /* should pass app_verify_arg */
+#endif
         else
+                {
+#ifndef OPENSSL_NO_X509_VERIFY
                 i=X509_verify_cert(&ctx);
+#else
+                i=0;
+                ctx.error=X509_V_ERR_APPLICATION_VERIFICATION;
+                SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN,SSL_R_NO_VERIFY_CALLBACK);
+#endif
+                }
 
-        X509_STORE_CTX_cleanup(&ctx);
         s->verify_result=ctx.error;
+        X509_STORE_CTX_cleanup(&ctx);
 
         return(i);
         }
 
-static void set_client_CA_list(ca_list,list)
-STACK **ca_list;
-STACK *list;
+static void set_client_CA_list(STACK_OF(X509_NAME) **ca_list,STACK_OF(X509_NAME) *list)
         {
         if (*ca_list != NULL)
-                sk_pop_free(*ca_list,X509_NAME_free);
+                sk_X509_NAME_pop_free(*ca_list,X509_NAME_free);
 
         *ca_list=list;
         }
 
-STACK *SSL_dup_CA_list(sk)
-STACK *sk;
+STACK_OF(X509_NAME) *SSL_dup_CA_list(STACK_OF(X509_NAME) *sk)
         {
         int i;
-        STACK *ret;
+        STACK_OF(X509_NAME) *ret;
         X509_NAME *name;
 
-        ret=sk_new_null();
-        for (i=0; i<sk_num(sk); i++)
+        ret=sk_X509_NAME_new_null();
+        for (i=0; i<sk_X509_NAME_num(sk); i++)
                 {
-                name=X509_NAME_dup((X509_NAME *)sk_value(sk,i));
-                if ((name == NULL) || !sk_push(ret,(char *)name))
+                name=X509_NAME_dup(sk_X509_NAME_value(sk,i));
+                if ((name == NULL) || !sk_X509_NAME_push(ret,name))
                         {
-                        sk_pop_free(ret,X509_NAME_free);
+                        sk_X509_NAME_pop_free(ret,X509_NAME_free);
                         return(NULL);
                         }
                 }
         return(ret);
         }
 
-void SSL_set_client_CA_list(s,list)
-SSL *s;
-STACK *list;
+void SSL_set_client_CA_list(SSL *s,STACK_OF(X509_NAME) *list)
         {
         set_client_CA_list(&(s->client_CA),list);
         }
 
-void SSL_CTX_set_client_CA_list(ctx,list)
-SSL_CTX *ctx;
-STACK *list;
+void SSL_CTX_set_client_CA_list(SSL_CTX *ctx,STACK_OF(X509_NAME) *list)
         {
         set_client_CA_list(&(ctx->client_CA),list);
         }
 
-STACK *SSL_CTX_get_client_CA_list(ctx)
-SSL_CTX *ctx;
+STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(SSL_CTX *ctx)
         {
         return(ctx->client_CA);
         }
 
-STACK *SSL_get_client_CA_list(s)
-SSL *s;
+STACK_OF(X509_NAME) *SSL_get_client_CA_list(SSL *s)
         {
         if (s->type == SSL_ST_CONNECT)
                 { /* we are in the client */
@@ -233,20 +566,18 @@ SSL *s;
                 }
         }
 
-static int add_client_CA(sk,x)
-STACK **sk;
-X509 *x;
+static int add_client_CA(STACK_OF(X509_NAME) **sk,X509 *x)
         {
         X509_NAME *name;
 
         if (x == NULL) return(0);
-        if ((*sk == NULL) && ((*sk=sk_new_null()) == NULL))
+        if ((*sk == NULL) && ((*sk=sk_X509_NAME_new_null()) == NULL))
                 return(0);
                 
         if ((name=X509_NAME_dup(X509_get_subject_name(x))) == NULL)
                 return(0);
 
-        if (!sk_push(*sk,(char *)name))
+        if (!sk_X509_NAME_push(*sk,name))
                 {
                 X509_NAME_free(name);
                 return(0);
@@ -254,37 +585,39 @@ X509 *x;
         return(1);
         }
 
-int SSL_add_client_CA(ssl,x)
-SSL *ssl;
-X509 *x;
+int SSL_add_client_CA(SSL *ssl,X509 *x)
         {
         return(add_client_CA(&(ssl->client_CA),x));
         }
 
-int SSL_CTX_add_client_CA(ctx,x)
-SSL_CTX *ctx;
-X509 *x;
+int SSL_CTX_add_client_CA(SSL_CTX *ctx,X509 *x)
         {
         return(add_client_CA(&(ctx->client_CA),x));
         }
 
-static int name_cmp(a,b)
-X509_NAME **a,**b;
+static int xname_cmp(const X509_NAME * const *a, const X509_NAME * const *b)
         {
         return(X509_NAME_cmp(*a,*b));
         }
 
-#ifndef NO_STDIO
-STACK *SSL_load_client_CA_file(file)
-char *file;
+#ifndef OPENSSL_NO_STDIO
+/*!
+ * Load CA certs from a file into a ::STACK. Note that it is somewhat misnamed;
+ * it doesn't really have anything to do with clients (except that a common use
+ * for a stack of CAs is to send it to the client). Actually, it doesn't have
+ * much to do with CAs, either, since it will load any old cert.
+ * \param file the file containing one or more certs.
+ * \return a ::STACK containing the certs.
+ */
+STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file)
         {
         BIO *in;
         X509 *x=NULL;
         X509_NAME *xn=NULL;
-        STACK *ret,*sk;
+        STACK_OF(X509_NAME) *ret,*sk;
 
-        ret=sk_new(NULL);
-        sk=sk_new(name_cmp);
+        ret=sk_X509_NAME_new_null();
+        sk=sk_X509_NAME_new(xname_cmp);
 
         in=BIO_new(BIO_s_file_internal());
 
@@ -299,31 +632,201 @@ char *file;
 
         for (;;)
                 {
-                if (PEM_read_bio_X509(in,&x,NULL) == NULL)
+                if (PEM_read_bio_X509(in,&x,NULL,NULL) == NULL)
                         break;
                 if ((xn=X509_get_subject_name(x)) == NULL) goto err;
                 /* check for duplicates */
                 xn=X509_NAME_dup(xn);
                 if (xn == NULL) goto err;
-                if (sk_find(sk,(char *)xn) >= 0)
+                if (sk_X509_NAME_find(sk,xn) >= 0)
                         X509_NAME_free(xn);
                 else
                         {
-                        sk_push(sk,(char *)xn);
-                        sk_push(ret,(char *)xn);
+                        sk_X509_NAME_push(sk,xn);
+                        sk_X509_NAME_push(ret,xn);
                         }
                 }
 
         if (0)
                 {
 err:
-                if (ret != NULL) sk_pop_free(ret,X509_NAME_free);
+                if (ret != NULL) sk_X509_NAME_pop_free(ret,X509_NAME_free);
                 ret=NULL;
                 }
-        if (sk != NULL) sk_free(sk);
+        if (sk != NULL) sk_X509_NAME_free(sk);
         if (in != NULL) BIO_free(in);
         if (x != NULL) X509_free(x);
         return(ret);
         }
 #endif
 
+/*!
+ * Add a file of certs to a stack.
+ * \param stack the stack to add to.
+ * \param file the file to add from. All certs in this file that are not
+ * already in the stack will be added.
+ * \return 1 for success, 0 for failure. Note that in the case of failure some
+ * certs may have been added to \c stack.
+ */
+
+int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
+                                        const char *file)
+        {
+        BIO *in;
+        X509 *x=NULL;
+        X509_NAME *xn=NULL;
+        int ret=1;
+        int (*oldcmp)(const X509_NAME * const *a, const X509_NAME * const *b);
+        
+        oldcmp=sk_X509_NAME_set_cmp_func(stack,xname_cmp);
+        
+        in=BIO_new(BIO_s_file_internal());
+        
+        if (in == NULL)
+                {
+                SSLerr(SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK,ERR_R_MALLOC_FAILURE);
+                goto err;
+                }
+        
+        if (!BIO_read_filename(in,file))
+                goto err;
+        
+        for (;;)
+                {
+                if (PEM_read_bio_X509(in,&x,NULL,NULL) == NULL)
+                        break;
+                if ((xn=X509_get_subject_name(x)) == NULL) goto err;
+                xn=X509_NAME_dup(xn);
+                if (xn == NULL) goto err;
+                if (sk_X509_NAME_find(stack,xn) >= 0)
+                        X509_NAME_free(xn);
+                else
+                        sk_X509_NAME_push(stack,xn);
+                }
+
+        if (0)
+                {
+err:
+                ret=0;
+                }
+        if(in != NULL)
+                BIO_free(in);
+        if(x != NULL)
+                X509_free(x);
+        
+        sk_X509_NAME_set_cmp_func(stack,oldcmp);
+
+        return ret;
+        }
+
+/*!
+ * Add a directory of certs to a stack.
+ * \param stack the stack to append to.
+ * \param dir the directory to append from. All files in this directory will be
+ * examined as potential certs. Any that are acceptable to
+ * SSL_add_dir_cert_subjects_to_stack() that are not already in the stack will be
+ * included.
+ * \return 1 for success, 0 for failure. Note that in the case of failure some
+ * certs may have been added to \c stack.
+ */
+
+#ifndef OPENSSL_SYS_WIN32
+#ifndef OPENSSL_SYS_VMS         /* XXXX This may be fixed in the future */
+#ifndef OPENSSL_SYS_MACINTOSH_CLASSIC /* XXXXX: Better scheme needed! */
+
+int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
+                                       const char *dir)
+        {
+        DIR *d;
+        struct dirent *dstruct;
+        int ret = 0;
+
+        CRYPTO_w_lock(CRYPTO_LOCK_READDIR);
+        d = opendir(dir);
+
+        /* Note that a side effect is that the CAs will be sorted by name */
+        if(!d)
+                {
+                SYSerr(SYS_F_OPENDIR, get_last_sys_error());
+                ERR_add_error_data(3, "opendir('", dir, "')");
+                SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK, ERR_R_SYS_LIB);
+                goto err;
+                }
+        
+        while((dstruct=readdir(d)))
+                {
+                char buf[1024];
+                int r;
+                
+                if(strlen(dir)+strlen(dstruct->d_name)+2 > sizeof buf)
+                        {
+                        SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK,SSL_R_PATH_TOO_LONG);
+                        goto err;
+                        }
+                
+                r = BIO_snprintf(buf,sizeof buf,"%s/%s",dir,dstruct->d_name);
+                if (r <= 0 || r >= sizeof buf)
+                        goto err;
+                if(!SSL_add_file_cert_subjects_to_stack(stack,buf))
+                        goto err;
+                }
+        ret = 1;
+
+err:    
+        if (d) closedir(d);
+        CRYPTO_w_unlock(CRYPTO_LOCK_READDIR);
+        return ret;
+        }
+
+#endif
+#endif
+
+#else
+
+int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
+                                       const char *dir)
+        {
+        WIN32_FIND_DATA FindFileData;
+        HANDLE hFind;
+        int ret = 0;
+
+        CRYPTO_w_lock(CRYPTO_LOCK_READDIR);
+        
+        hFind = FindFirstFile(dir, &FindFileData);
+        /* Note that a side effect is that the CAs will be sorted by name */
+        if(hFind == INVALID_HANDLE_VALUE)
+                {
+                SYSerr(SYS_F_OPENDIR, get_last_sys_error());
+                ERR_add_error_data(3, "opendir('", dir, "')");
+                SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK, ERR_R_SYS_LIB);
+                goto err_noclose;
+                }
+        
+        do 
+                {
+                char buf[1024];
+                int r;
+                
+                if(strlen(dir)+strlen(FindFileData.cFileName)+2 > sizeof buf)
+                        {
+                        SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK,SSL_R_PATH_TOO_LONG);
+                        goto err;
+                        }
+                
+                r = BIO_snprintf(buf,sizeof buf,"%s/%s",dir,FindFileData.cFileName);
+                if (r <= 0 || r >= sizeof buf)
+                        goto err;
+                if(!SSL_add_file_cert_subjects_to_stack(stack,buf))
+                        goto err;
+                }
+        while (FindNextFile(hFind, &FindFileData) != FALSE);
+        ret = 1;
+
+err:    
+        FindClose(hFind);
+err_noclose:
+        CRYPTO_w_unlock(CRYPTO_LOCK_READDIR);
+        return ret;
+        }
+
+#endif
diff --git a/src/lib/libssl/ssl_ciph.c b/src/lib/libssl/ssl_ciph.c
index 820994408b..cdd8dde128 100644
--- a/src/lib/libssl/ssl_ciph.c
+++ b/src/lib/libssl/ssl_ciph.c
@@ -57,7 +57,8 @@
  */
 
 #include <stdio.h>
-#include "objects.h"
+#include <openssl/objects.h>
+#include <openssl/comp.h>
 #include "ssl_locl.h"
 
 #define SSL_ENC_DES_IDX         0
@@ -67,37 +68,28 @@
 #define SSL_ENC_IDEA_IDX        4
 #define SSL_ENC_eFZA_IDX        5
 #define SSL_ENC_NULL_IDX        6
-#define SSL_ENC_NUM_IDX         7
+#define SSL_ENC_AES128_IDX      7
+#define SSL_ENC_AES256_IDX      8
+#define SSL_ENC_NUM_IDX         9
 
-static EVP_CIPHER *ssl_cipher_methods[SSL_ENC_NUM_IDX]={
+static const EVP_CIPHER *ssl_cipher_methods[SSL_ENC_NUM_IDX]={
         NULL,NULL,NULL,NULL,NULL,NULL,
         };
 
+static STACK_OF(SSL_COMP) *ssl_comp_methods=NULL;
+
 #define SSL_MD_MD5_IDX  0
 #define SSL_MD_SHA1_IDX 1
 #define SSL_MD_NUM_IDX  2
-static EVP_MD *ssl_digest_methods[SSL_MD_NUM_IDX]={
+static const EVP_MD *ssl_digest_methods[SSL_MD_NUM_IDX]={
         NULL,NULL,
         };
 
-typedef struct cipher_sort_st
-        {
-        SSL_CIPHER *cipher;
-        int pref;
-        } CIPHER_SORT;
-
 #define CIPHER_ADD      1
 #define CIPHER_KILL     2
 #define CIPHER_DEL      3
 #define CIPHER_ORD      4
-
-typedef struct cipher_choice_st
-        {
-        int type;
-        unsigned long algorithms;
-        unsigned long mask;
-        long top;
-        } CIPHER_CHOICE;
+#define CIPHER_SPECIAL  5
 
 typedef struct cipher_order_st
         {
@@ -107,59 +99,62 @@ typedef struct cipher_order_st
         struct cipher_order_st *next,*prev;
         } CIPHER_ORDER;
 
-static SSL_CIPHER cipher_aliases[]={
-        {0,SSL_TXT_ALL, 0,SSL_ALL,   0,SSL_ALL},        /* must be first */
-        {0,SSL_TXT_kRSA,0,SSL_kRSA,  0,SSL_MKEY_MASK},
-        {0,SSL_TXT_kDHr,0,SSL_kDHr,  0,SSL_MKEY_MASK},
-        {0,SSL_TXT_kDHd,0,SSL_kDHd,  0,SSL_MKEY_MASK},
-        {0,SSL_TXT_kEDH,0,SSL_kEDH,  0,SSL_MKEY_MASK},
-        {0,SSL_TXT_kFZA,0,SSL_kFZA,  0,SSL_MKEY_MASK},
-        {0,SSL_TXT_DH,  0,SSL_DH,    0,SSL_MKEY_MASK},
-        {0,SSL_TXT_EDH, 0,SSL_EDH,   0,SSL_MKEY_MASK|SSL_AUTH_MASK},
-
-        {0,SSL_TXT_aRSA,0,SSL_aRSA,  0,SSL_AUTH_MASK},
-        {0,SSL_TXT_aDSS,0,SSL_aDSS,  0,SSL_AUTH_MASK},
-        {0,SSL_TXT_aFZA,0,SSL_aFZA,  0,SSL_AUTH_MASK},
-        {0,SSL_TXT_aNULL,0,SSL_aNULL,0,SSL_AUTH_MASK},
-        {0,SSL_TXT_aDH, 0,SSL_aDH,   0,SSL_AUTH_MASK},
-        {0,SSL_TXT_DSS, 0,SSL_DSS,   0,SSL_AUTH_MASK},
-
-        {0,SSL_TXT_DES, 0,SSL_DES,   0,SSL_ENC_MASK},
-        {0,SSL_TXT_3DES,0,SSL_3DES,  0,SSL_ENC_MASK},
-        {0,SSL_TXT_RC4, 0,SSL_RC4,   0,SSL_ENC_MASK},
-        {0,SSL_TXT_RC2, 0,SSL_RC2,   0,SSL_ENC_MASK},
-        {0,SSL_TXT_IDEA,0,SSL_IDEA,  0,SSL_ENC_MASK},
-        {0,SSL_TXT_eNULL,0,SSL_eNULL,0,SSL_ENC_MASK},
-        {0,SSL_TXT_eFZA,0,SSL_eFZA,  0,SSL_ENC_MASK},
-
-        {0,SSL_TXT_MD5, 0,SSL_MD5,   0,SSL_MAC_MASK},
-        {0,SSL_TXT_SHA1,0,SSL_SHA1,  0,SSL_MAC_MASK},
-        {0,SSL_TXT_SHA, 0,SSL_SHA,   0,SSL_MAC_MASK},
-
-        {0,SSL_TXT_NULL,0,SSL_NULL,  0,SSL_ENC_MASK},
-        {0,SSL_TXT_RSA, 0,SSL_RSA,   0,SSL_AUTH_MASK|SSL_MKEY_MASK},
-        {0,SSL_TXT_ADH, 0,SSL_ADH,   0,SSL_AUTH_MASK|SSL_MKEY_MASK},
-        {0,SSL_TXT_FZA, 0,SSL_FZA,   0,SSL_AUTH_MASK|SSL_MKEY_MASK|SSL_ENC_MASK},
-
-        {0,SSL_TXT_EXP, 0,SSL_EXP,   0,SSL_EXP_MASK},
-        {0,SSL_TXT_EXPORT,0,SSL_EXPORT,0,SSL_EXP_MASK},
-        {0,SSL_TXT_SSLV2,0,SSL_SSLV2,0,SSL_SSL_MASK},
-        {0,SSL_TXT_SSLV3,0,SSL_SSLV3,0,SSL_SSL_MASK},
-        {0,SSL_TXT_LOW,  0,SSL_LOW,0,SSL_STRONG_MASK},
-        {0,SSL_TXT_MEDIUM,0,SSL_MEDIUM,0,SSL_STRONG_MASK},
-        {0,SSL_TXT_HIGH, 0,SSL_HIGH,0,SSL_STRONG_MASK},
+static const SSL_CIPHER cipher_aliases[]={
+        /* Don't include eNULL unless specifically enabled.
+         * Similarly, don't include AES in ALL because these ciphers are not yet official. */
+        {0,SSL_TXT_ALL, 0,SSL_ALL & ~SSL_eNULL & ~SSL_AES, SSL_ALL ,0,0,0,SSL_ALL,SSL_ALL}, /* must be first */
+        {0,SSL_TXT_kKRB5,0,SSL_kKRB5,0,0,0,0,SSL_MKEY_MASK,0},  /* VRS Kerberos5 */
+        {0,SSL_TXT_kRSA,0,SSL_kRSA,  0,0,0,0,SSL_MKEY_MASK,0},
+        {0,SSL_TXT_kDHr,0,SSL_kDHr,  0,0,0,0,SSL_MKEY_MASK,0},
+        {0,SSL_TXT_kDHd,0,SSL_kDHd,  0,0,0,0,SSL_MKEY_MASK,0},
+        {0,SSL_TXT_kEDH,0,SSL_kEDH,  0,0,0,0,SSL_MKEY_MASK,0},
+        {0,SSL_TXT_kFZA,0,SSL_kFZA,  0,0,0,0,SSL_MKEY_MASK,0},
+        {0,SSL_TXT_DH,  0,SSL_DH,    0,0,0,0,SSL_MKEY_MASK,0},
+        {0,SSL_TXT_EDH, 0,SSL_EDH,   0,0,0,0,SSL_MKEY_MASK|SSL_AUTH_MASK,0},
+
+        {0,SSL_TXT_aKRB5,0,SSL_aKRB5,0,0,0,0,SSL_AUTH_MASK,0},  /* VRS Kerberos5 */
+        {0,SSL_TXT_aRSA,0,SSL_aRSA,  0,0,0,0,SSL_AUTH_MASK,0},
+        {0,SSL_TXT_aDSS,0,SSL_aDSS,  0,0,0,0,SSL_AUTH_MASK,0},
+        {0,SSL_TXT_aFZA,0,SSL_aFZA,  0,0,0,0,SSL_AUTH_MASK,0},
+        {0,SSL_TXT_aNULL,0,SSL_aNULL,0,0,0,0,SSL_AUTH_MASK,0},
+        {0,SSL_TXT_aDH, 0,SSL_aDH,   0,0,0,0,SSL_AUTH_MASK,0},
+        {0,SSL_TXT_DSS, 0,SSL_DSS,   0,0,0,0,SSL_AUTH_MASK,0},
+
+        {0,SSL_TXT_DES, 0,SSL_DES,   0,0,0,0,SSL_ENC_MASK,0},
+        {0,SSL_TXT_3DES,0,SSL_3DES,  0,0,0,0,SSL_ENC_MASK,0},
+        {0,SSL_TXT_RC4, 0,SSL_RC4,   0,0,0,0,SSL_ENC_MASK,0},
+        {0,SSL_TXT_RC2, 0,SSL_RC2,   0,0,0,0,SSL_ENC_MASK,0},
+        {0,SSL_TXT_IDEA,0,SSL_IDEA,  0,0,0,0,SSL_ENC_MASK,0},
+        {0,SSL_TXT_eNULL,0,SSL_eNULL,0,0,0,0,SSL_ENC_MASK,0},
+        {0,SSL_TXT_eFZA,0,SSL_eFZA,  0,0,0,0,SSL_ENC_MASK,0},
+        {0,SSL_TXT_AES, 0,SSL_AES,   0,0,0,0,SSL_ENC_MASK,0},
+
+        {0,SSL_TXT_MD5, 0,SSL_MD5,   0,0,0,0,SSL_MAC_MASK,0},
+        {0,SSL_TXT_SHA1,0,SSL_SHA1,  0,0,0,0,SSL_MAC_MASK,0},
+        {0,SSL_TXT_SHA, 0,SSL_SHA,   0,0,0,0,SSL_MAC_MASK,0},
+
+        {0,SSL_TXT_NULL,0,SSL_NULL,  0,0,0,0,SSL_ENC_MASK,0},
+        {0,SSL_TXT_KRB5,0,SSL_KRB5,  0,0,0,0,SSL_AUTH_MASK|SSL_MKEY_MASK,0},
+        {0,SSL_TXT_RSA, 0,SSL_RSA,   0,0,0,0,SSL_AUTH_MASK|SSL_MKEY_MASK,0},
+        {0,SSL_TXT_ADH, 0,SSL_ADH,   0,0,0,0,SSL_AUTH_MASK|SSL_MKEY_MASK,0},
+        {0,SSL_TXT_FZA, 0,SSL_FZA,   0,0,0,0,SSL_AUTH_MASK|SSL_MKEY_MASK|SSL_ENC_MASK,0},
+
+        {0,SSL_TXT_SSLV2, 0,SSL_SSLV2, 0,0,0,0,SSL_SSL_MASK,0},
+        {0,SSL_TXT_SSLV3, 0,SSL_SSLV3, 0,0,0,0,SSL_SSL_MASK,0},
+        {0,SSL_TXT_TLSV1, 0,SSL_TLSV1, 0,0,0,0,SSL_SSL_MASK,0},
+
+        {0,SSL_TXT_EXP   ,0, 0,SSL_EXPORT, 0,0,0,0,SSL_EXP_MASK},
+        {0,SSL_TXT_EXPORT,0, 0,SSL_EXPORT, 0,0,0,0,SSL_EXP_MASK},
+        {0,SSL_TXT_EXP40, 0, 0, SSL_EXP40, 0,0,0,0,SSL_STRONG_MASK},
+        {0,SSL_TXT_EXP56, 0, 0, SSL_EXP56, 0,0,0,0,SSL_STRONG_MASK},
+        {0,SSL_TXT_LOW,   0, 0,   SSL_LOW, 0,0,0,0,SSL_STRONG_MASK},
+        {0,SSL_TXT_MEDIUM,0, 0,SSL_MEDIUM, 0,0,0,0,SSL_STRONG_MASK},
+        {0,SSL_TXT_HIGH,  0, 0,  SSL_HIGH, 0,0,0,0,SSL_STRONG_MASK},
         };
 
 static int init_ciphers=1;
-static void load_ciphers();
-
-static int cmp_by_name(a,b)
-SSL_CIPHER **a,**b;
-        {
-        return(strcmp((*a)->name,(*b)->name));
-        }
 
-static void load_ciphers()
+static void load_ciphers(void)
         {
         init_ciphers=0;
         ssl_cipher_methods[SSL_ENC_DES_IDX]= 
@@ -172,6 +167,10 @@ static void load_ciphers()
                 EVP_get_cipherbyname(SN_rc2_cbc);
         ssl_cipher_methods[SSL_ENC_IDEA_IDX]= 
                 EVP_get_cipherbyname(SN_idea_cbc);
+        ssl_cipher_methods[SSL_ENC_AES128_IDX]=
+          EVP_get_cipherbyname(SN_aes_128_cbc);
+        ssl_cipher_methods[SSL_ENC_AES256_IDX]=
+          EVP_get_cipherbyname(SN_aes_256_cbc);
 
         ssl_digest_methods[SSL_MD_MD5_IDX]=
                 EVP_get_digestbyname(SN_md5);
@@ -179,14 +178,38 @@ static void load_ciphers()
                 EVP_get_digestbyname(SN_sha1);
         }
 
-int ssl_cipher_get_evp(c,enc,md)
-SSL_CIPHER *c;
-EVP_CIPHER **enc;
-EVP_MD **md;
+int ssl_cipher_get_evp(SSL_SESSION *s, const EVP_CIPHER **enc,
+             const EVP_MD **md, SSL_COMP **comp)
         {
         int i;
+        SSL_CIPHER *c;
 
+        c=s->cipher;
         if (c == NULL) return(0);
+        if (comp != NULL)
+                {
+                SSL_COMP ctmp;
+
+                if (s->compress_meth == 0)
+                        *comp=NULL;
+                else if (ssl_comp_methods == NULL)
+                        {
+                        /* bad */
+                        *comp=NULL;
+                        }
+                else
+                        {
+
+                        ctmp.id=s->compress_meth;
+                        i=sk_SSL_COMP_find(ssl_comp_methods,&ctmp);
+                        if (i >= 0)
+                                *comp=sk_SSL_COMP_value(ssl_comp_methods,i);
+                        else
+                                *comp=NULL;
+                        }
+                }
+
+        if ((enc == NULL) || (md == NULL)) return(0);
 
         switch (c->algorithms & SSL_ENC_MASK)
                 {
@@ -208,6 +231,13 @@ EVP_MD **md;
         case SSL_eNULL:
                 i=SSL_ENC_NULL_IDX;
                 break;
+        case SSL_AES:
+                switch(c->alg_bits)
+                        {
+                case 128: i=SSL_ENC_AES128_IDX; break;
+                case 256: i=SSL_ENC_AES256_IDX; break;
+                default: i=-1; break;
+                        }
                 break;
         default:
                 i= -1;
@@ -250,8 +280,8 @@ EVP_MD **md;
 #define ITEM_SEP(a) \
         (((a) == ':') || ((a) == ' ') || ((a) == ';') || ((a) == ','))
 
-static void ll_append_tail(head,curr,tail)
-CIPHER_ORDER **head,*curr,**tail;
+static void ll_append_tail(CIPHER_ORDER **head, CIPHER_ORDER *curr,
+             CIPHER_ORDER **tail)
         {
         if (curr == *tail) return;
         if (curr == *head)
@@ -266,181 +296,359 @@ CIPHER_ORDER **head,*curr,**tail;
         *tail=curr;
         }
 
-STACK *ssl_create_cipher_list(ssl_method,cipher_list,cipher_list_by_id,str)
-SSL_METHOD *ssl_method;
-STACK **cipher_list,**cipher_list_by_id;
-char *str;
+static unsigned long ssl_cipher_get_disabled(void)
         {
-        SSL_CIPHER *c;
-        char *l;
-        STACK *ret=NULL,*ok=NULL;
-#define CL_BUF  40
-        char buf[CL_BUF];
-        char *tmp_str=NULL;
-        unsigned long mask,algorithms,ma;
-        char *start;
-        int i,j,k,num=0,ch,multi;
-        unsigned long al;
-        STACK *ca_list=NULL;
-        int current_x,num_x;
-        CIPHER_CHOICE *ops=NULL;
-        CIPHER_ORDER *list=NULL,*head=NULL,*tail=NULL,*curr,*tail2,*curr2;
-        int list_num;
-        int type;
-        SSL_CIPHER c_tmp,*cp;
-
-        if (str == NULL) return(NULL);
-
-        if (strncmp(str,"DEFAULT",7) == 0)
-                {
-                i=strlen(str)+2+strlen(SSL_DEFAULT_CIPHER_LIST);
-                if ((tmp_str=Malloc(i)) == NULL)
-                        {
-                        SSLerr(SSL_F_SSL_CREATE_CIPHER_LIST,ERR_R_MALLOC_FAILURE);
-                        goto err;
-                        }
-                strcpy(tmp_str,SSL_DEFAULT_CIPHER_LIST);
-                strcat(tmp_str,":");
-                strcat(tmp_str,&(str[7]));
-                str=tmp_str;
-                }
-        if (init_ciphers) load_ciphers();
-
-        num=ssl_method->num_ciphers();
-
-        if ((ret=(STACK *)sk_new(NULL)) == NULL) goto err;
-        if ((ca_list=(STACK *)sk_new(cmp_by_name)) == NULL) goto err;
+        unsigned long mask;
 
-        mask =SSL_kFZA;
-#ifdef NO_RSA
-        mask|=SSL_aRSA|SSL_kRSA;
+        mask = SSL_kFZA;
+#ifdef OPENSSL_NO_RSA
+        mask |= SSL_aRSA|SSL_kRSA;
 #endif
-#ifdef NO_DSA
-        mask|=SSL_aDSS;
+#ifdef OPENSSL_NO_DSA
+        mask |= SSL_aDSS;
 #endif
-#ifdef NO_DH
-        mask|=SSL_kDHr|SSL_kDHd|SSL_kEDH|SSL_aDH;
+#ifdef OPENSSL_NO_DH
+        mask |= SSL_kDHr|SSL_kDHd|SSL_kEDH|SSL_aDH;
+#endif
+#ifdef OPENSSL_NO_KRB5
+        mask |= SSL_kKRB5|SSL_aKRB5;
 #endif
 
-#ifndef SSL_ALLOW_ENULL
-        mask|=SSL_eNULL;
+#ifdef SSL_FORBID_ENULL
+        mask |= SSL_eNULL;
 #endif
 
-        mask|=(ssl_cipher_methods[SSL_ENC_DES_IDX ] == NULL)?SSL_DES :0;
-        mask|=(ssl_cipher_methods[SSL_ENC_3DES_IDX] == NULL)?SSL_3DES:0;
-        mask|=(ssl_cipher_methods[SSL_ENC_RC4_IDX ] == NULL)?SSL_RC4 :0;
-        mask|=(ssl_cipher_methods[SSL_ENC_RC2_IDX ] == NULL)?SSL_RC2 :0;
-        mask|=(ssl_cipher_methods[SSL_ENC_IDEA_IDX] == NULL)?SSL_IDEA:0;
-        mask|=(ssl_cipher_methods[SSL_ENC_eFZA_IDX] == NULL)?SSL_eFZA:0;
+        mask |= (ssl_cipher_methods[SSL_ENC_DES_IDX ] == NULL) ? SSL_DES :0;
+        mask |= (ssl_cipher_methods[SSL_ENC_3DES_IDX] == NULL) ? SSL_3DES:0;
+        mask |= (ssl_cipher_methods[SSL_ENC_RC4_IDX ] == NULL) ? SSL_RC4 :0;
+        mask |= (ssl_cipher_methods[SSL_ENC_RC2_IDX ] == NULL) ? SSL_RC2 :0;
+        mask |= (ssl_cipher_methods[SSL_ENC_IDEA_IDX] == NULL) ? SSL_IDEA:0;
+        mask |= (ssl_cipher_methods[SSL_ENC_eFZA_IDX] == NULL) ? SSL_eFZA:0;
+        mask |= (ssl_cipher_methods[SSL_ENC_AES128_IDX] == NULL) ? SSL_AES:0;
 
-        mask|=(ssl_digest_methods[SSL_MD_MD5_IDX ] == NULL)?SSL_MD5 :0;
-        mask|=(ssl_digest_methods[SSL_MD_SHA1_IDX] == NULL)?SSL_SHA1:0;
+        mask |= (ssl_digest_methods[SSL_MD_MD5_IDX ] == NULL) ? SSL_MD5 :0;
+        mask |= (ssl_digest_methods[SSL_MD_SHA1_IDX] == NULL) ? SSL_SHA1:0;
 
-        if ((list=(CIPHER_ORDER *)Malloc(sizeof(CIPHER_ORDER)*num)) == NULL)
-                goto err;
+        return(mask);
+        }
+
+static void ssl_cipher_collect_ciphers(const SSL_METHOD *ssl_method,
+                int num_of_ciphers, unsigned long mask, CIPHER_ORDER *list,
+                CIPHER_ORDER **head_p, CIPHER_ORDER **tail_p)
+        {
+        int i, list_num;
+        SSL_CIPHER *c;
+
+        /*
+         * We have num_of_ciphers descriptions compiled in, depending on the
+         * method selected (SSLv2 and/or SSLv3, TLSv1 etc).
+         * These will later be sorted in a linked list with at most num
+         * entries.
+         */
 
         /* Get the initial list of ciphers */
-        list_num=0;
-        for (i=0; i<num; i++)
+        list_num = 0;   /* actual count of ciphers */
+        for (i = 0; i < num_of_ciphers; i++)
                 {
-                c=ssl_method->get_cipher((unsigned int)i);
+                c = ssl_method->get_cipher(i);
                 /* drop those that use any of that is not available */
                 if ((c != NULL) && c->valid && !(c->algorithms & mask))
                         {
-                        list[list_num].cipher=c;
-                        list[list_num].next=NULL;
-                        list[list_num].prev=NULL;
-                        list[list_num].active=0;
+                        list[list_num].cipher = c;
+                        list[list_num].next = NULL;
+                        list[list_num].prev = NULL;
+                        list[list_num].active = 0;
                         list_num++;
+#ifdef KSSL_DEBUG
+                        printf("\t%d: %s %lx %lx\n",i,c->name,c->id,c->algorithms);
+#endif  /* KSSL_DEBUG */
+                        /*
                         if (!sk_push(ca_list,(char *)c)) goto err;
+                        */
                         }
                 }
-        
-        for (i=1; i<list_num-1; i++)
+
+        /*
+         * Prepare linked list from list entries
+         */     
+        for (i = 1; i < list_num - 1; i++)
                 {
-                list[i].prev= &(list[i-1]);
-                list[i].next= &(list[i+1]);
+                list[i].prev = &(list[i-1]);
+                list[i].next = &(list[i+1]);
                 }
         if (list_num > 0)
                 {
-                head= &(list[0]);
-                head->prev=NULL;
-                head->next= &(list[1]);
-                tail= &(list[list_num-1]);
-                tail->prev= &(list[list_num-2]);
-                tail->next=NULL;
+                (*head_p) = &(list[0]);
+                (*head_p)->prev = NULL;
+                (*head_p)->next = &(list[1]);
+                (*tail_p) = &(list[list_num - 1]);
+                (*tail_p)->prev = &(list[list_num - 2]);
+                (*tail_p)->next = NULL;
                 }
+        }
 
-        /* special case */
-        cipher_aliases[0].algorithms= ~mask;
+static void ssl_cipher_collect_aliases(SSL_CIPHER **ca_list,
+                        int num_of_group_aliases, unsigned long mask,
+                        CIPHER_ORDER *head)
+        {
+        CIPHER_ORDER *ciph_curr;
+        SSL_CIPHER **ca_curr;
+        int i;
 
-        /* get the aliases */
-        k=sizeof(cipher_aliases)/sizeof(SSL_CIPHER);
-        for (j=0; j<k; j++)
+        /*
+         * First, add the real ciphers as already collected
+         */
+        ciph_curr = head;
+        ca_curr = ca_list;
+        while (ciph_curr != NULL)
                 {
-                al=cipher_aliases[j].algorithms;
-                /* Drop those that are not relevent */
-                if ((al & mask) == al) continue;
-                if (!sk_push(ca_list,(char *)&(cipher_aliases[j]))) goto err;
+                *ca_curr = ciph_curr->cipher;
+                ca_curr++;
+                ciph_curr = ciph_curr->next;
                 }
 
-        /* ca_list now holds a 'stack' of SSL_CIPHERS, some real, some
-         * 'aliases' */
+        /*
+         * Now we add the available ones from the cipher_aliases[] table.
+         * They represent either an algorithm, that must be fully
+         * supported (not match any bit in mask) or represent a cipher
+         * strength value (will be added in any case because algorithms=0).
+         */
+        for (i = 0; i < num_of_group_aliases; i++)
+                {
+                if ((i == 0) ||         /* always fetch "ALL" */
+                    !(cipher_aliases[i].algorithms & mask))
+                        {
+                        *ca_curr = (SSL_CIPHER *)(cipher_aliases + i);
+                        ca_curr++;
+                        }
+                }
 
-        /* how many parameters are there? */
-        num=1;
-        for (l=str; *l; l++)
-                if (ITEM_SEP(*l))
-                        num++;
-        ops=(CIPHER_CHOICE *)Malloc(sizeof(CIPHER_CHOICE)*num);
-        if (ops == NULL) goto err;
-        memset(ops,0,sizeof(CIPHER_CHOICE)*num);
+        *ca_curr = NULL;        /* end of list */
+        }
+
+static void ssl_cipher_apply_rule(unsigned long algorithms, unsigned long mask,
+                unsigned long algo_strength, unsigned long mask_strength,
+                int rule, int strength_bits, CIPHER_ORDER *list,
+                CIPHER_ORDER **head_p, CIPHER_ORDER **tail_p)
+        {
+        CIPHER_ORDER *head, *tail, *curr, *curr2, *tail2;
+        SSL_CIPHER *cp;
+        unsigned long ma, ma_s;
 
-        /* we now parse the input string and create our operations */
-        l=str;
-        i=0;
-        current_x=0;
+#ifdef CIPHER_DEBUG
+        printf("Applying rule %d with %08lx %08lx %08lx %08lx (%d)\n",
+                rule, algorithms, mask, algo_strength, mask_strength,
+                strength_bits);
+#endif
 
+        curr = head = *head_p;
+        curr2 = head;
+        tail2 = tail = *tail_p;
         for (;;)
                 {
-                ch= *l;
+                if ((curr == NULL) || (curr == tail2)) break;
+                curr = curr2;
+                curr2 = curr->next;
+
+                cp = curr->cipher;
+
+                /*
+                 * Selection criteria is either the number of strength_bits
+                 * or the algorithm used.
+                 */
+                if (strength_bits == -1)
+                        {
+                        ma = mask & cp->algorithms;
+                        ma_s = mask_strength & cp->algo_strength;
+
+#ifdef CIPHER_DEBUG
+                        printf("\nName: %s:\nAlgo = %08lx Algo_strength = %08lx\nMask = %08lx Mask_strength %08lx\n", cp->name, cp->algorithms, cp->algo_strength, mask, mask_strength);
+                        printf("ma = %08lx ma_s %08lx, ma&algo=%08lx, ma_s&algos=%08lx\n", ma, ma_s, ma&algorithms, ma_s&algo_strength);
+#endif
+                        /*
+                         * Select: if none of the mask bit was met from the
+                         * cipher or not all of the bits were met, the
+                         * selection does not apply.
+                         */
+                        if (((ma == 0) && (ma_s == 0)) ||
+                            ((ma & algorithms) != ma) ||
+                            ((ma_s & algo_strength) != ma_s))
+                                continue; /* does not apply */
+                        }
+                else if (strength_bits != cp->strength_bits)
+                        continue;       /* does not apply */
+
+#ifdef CIPHER_DEBUG
+                printf("Action = %d\n", rule);
+#endif
+
+                /* add the cipher if it has not been added yet. */
+                if (rule == CIPHER_ADD)
+                        {
+                        if (!curr->active)
+                                {
+                                ll_append_tail(&head, curr, &tail);
+                                curr->active = 1;
+                                }
+                        }
+                /* Move the added cipher to this location */
+                else if (rule == CIPHER_ORD)
+                        {
+                        if (curr->active)
+                                {
+                                ll_append_tail(&head, curr, &tail);
+                                }
+                        }
+                else if (rule == CIPHER_DEL)
+                        curr->active = 0;
+                else if (rule == CIPHER_KILL)
+                        {
+                        if (head == curr)
+                                head = curr->next;
+                        else
+                                curr->prev->next = curr->next;
+                        if (tail == curr)
+                                tail = curr->prev;
+                        curr->active = 0;
+                        if (curr->next != NULL)
+                                curr->next->prev = curr->prev;
+                        if (curr->prev != NULL)
+                                curr->prev->next = curr->next;
+                        curr->next = NULL;
+                        curr->prev = NULL;
+                        }
+                }
+
+        *head_p = head;
+        *tail_p = tail;
+        }
+
+static int ssl_cipher_strength_sort(CIPHER_ORDER *list, CIPHER_ORDER **head_p,
+                                     CIPHER_ORDER **tail_p)
+        {
+        int max_strength_bits, i, *number_uses;
+        CIPHER_ORDER *curr;
+
+        /*
+         * This routine sorts the ciphers with descending strength. The sorting
+         * must keep the pre-sorted sequence, so we apply the normal sorting
+         * routine as '+' movement to the end of the list.
+         */
+        max_strength_bits = 0;
+        curr = *head_p;
+        while (curr != NULL)
+                {
+                if (curr->active &&
+                    (curr->cipher->strength_bits > max_strength_bits))
+                    max_strength_bits = curr->cipher->strength_bits;
+                curr = curr->next;
+                }
 
-                if (ch == '\0') break;
+        number_uses = OPENSSL_malloc((max_strength_bits + 1) * sizeof(int));
+        if (!number_uses)
+        {
+                SSLerr(SSL_F_SSL_CIPHER_STRENGTH_SORT,ERR_R_MALLOC_FAILURE);
+                return(0);
+        }
+        memset(number_uses, 0, (max_strength_bits + 1) * sizeof(int));
+
+        /*
+         * Now find the strength_bits values actually used
+         */
+        curr = *head_p;
+        while (curr != NULL)
+                {
+                if (curr->active)
+                        number_uses[curr->cipher->strength_bits]++;
+                curr = curr->next;
+                }
+        /*
+         * Go through the list of used strength_bits values in descending
+         * order.
+         */
+        for (i = max_strength_bits; i >= 0; i--)
+                if (number_uses[i] > 0)
+                        ssl_cipher_apply_rule(0, 0, 0, 0, CIPHER_ORD, i,
+                                        list, head_p, tail_p);
+
+        OPENSSL_free(number_uses);
+        return(1);
+        }
+
+static int ssl_cipher_process_rulestr(const char *rule_str,
+                CIPHER_ORDER *list, CIPHER_ORDER **head_p,
+                CIPHER_ORDER **tail_p, SSL_CIPHER **ca_list)
+        {
+        unsigned long algorithms, mask, algo_strength, mask_strength;
+        const char *l, *start, *buf;
+        int j, multi, found, rule, retval, ok, buflen;
+        char ch;
+
+        retval = 1;
+        l = rule_str;
+        for (;;)
+                {
+                ch = *l;
 
+                if (ch == '\0')
+                        break;          /* done */
                 if (ch == '-')
-                        { j=CIPHER_DEL; l++; }
+                        { rule = CIPHER_DEL; l++; }
                 else if (ch == '+')
-                        { j=CIPHER_ORD; l++; }
+                        { rule = CIPHER_ORD; l++; }
                 else if (ch == '!')
-                        { j=CIPHER_KILL; l++; }
-                else    
-                        { j=CIPHER_ADD; }
+                        { rule = CIPHER_KILL; l++; }
+                else if (ch == '@')
+                        { rule = CIPHER_SPECIAL; l++; }
+                else
+                        { rule = CIPHER_ADD; }
 
                 if (ITEM_SEP(ch))
                         {
                         l++;
                         continue;
                         }
-                ops[current_x].type=j;
-                ops[current_x].algorithms=0;
-                ops[current_x].mask=0;
+
+                algorithms = mask = algo_strength = mask_strength = 0;
 
                 start=l;
                 for (;;)
                         {
-                        ch= *l;
-                        i=0;
+                        ch = *l;
+                        buf = l;
+                        buflen = 0;
+#ifndef CHARSET_EBCDIC
                         while ( ((ch >= 'A') && (ch <= 'Z')) ||
                                 ((ch >= '0') && (ch <= '9')) ||
                                 ((ch >= 'a') && (ch <= 'z')) ||
                                  (ch == '-'))
+#else
+                        while ( isalnum(ch) || (ch == '-'))
+#endif
                                  {
-                                 buf[i]=ch;
-                                 ch= *(++l);
-                                 i++;
-                                 if (i >= (CL_BUF-2)) break;
+                                 ch = *(++l);
+                                 buflen++;
                                  }
-                        buf[i]='\0';
+
+                        if (buflen == 0)
+                                {
+                                /*
+                                 * We hit something we cannot deal with,
+                                 * it is no command or separator nor
+                                 * alphanumeric, so we call this an error.
+                                 */
+                                SSLerr(SSL_F_SSL_CIPHER_PROCESS_RULESTR,
+                                       SSL_R_INVALID_COMMAND);
+                                retval = found = 0;
+                                l++;
+                                break;
+                                }
+
+                        if (rule == CIPHER_SPECIAL)
+                                {
+                                found = 0; /* unused -- avoid compiler warning */
+                                break;  /* special treatment */
+                                }
 
                         /* check for multi-part specification */
                         if (ch == '+')
@@ -451,151 +659,262 @@ char *str;
                         else
                                 multi=0;
 
-                        c_tmp.name=buf;
-                        j=sk_find(ca_list,(char *)&c_tmp);
-                        if (j < 0)
-                                goto end_loop;
+                        /*
+                         * Now search for the cipher alias in the ca_list. Be careful
+                         * with the strncmp, because the "buflen" limitation
+                         * will make the rule "ADH:SOME" and the cipher
+                         * "ADH-MY-CIPHER" look like a match for buflen=3.
+                         * So additionally check whether the cipher name found
+                         * has the correct length. We can save a strlen() call:
+                         * just checking for the '\0' at the right place is
+                         * sufficient, we have to strncmp() anyway.
+                         */
+                         j = found = 0;
+                         while (ca_list[j])
+                                {
+                                if ((ca_list[j]->name[buflen] == '\0') &&
+                                    !strncmp(buf, ca_list[j]->name, buflen))
+                                        {
+                                        found = 1;
+                                        break;
+                                        }
+                                else
+                                        j++;
+                                }
+                        if (!found)
+                                break;  /* ignore this entry */
+
+                        algorithms |= ca_list[j]->algorithms;
+                        mask |= ca_list[j]->mask;
+                        algo_strength |= ca_list[j]->algo_strength;
+                        mask_strength |= ca_list[j]->mask_strength;
 
-                        cp=(SSL_CIPHER *)sk_value(ca_list,j);
-                        ops[current_x].algorithms|=cp->algorithms;
-                        /* We add the SSL_SSL_MASK so we can match the
-                         * SSLv2 and SSLv3 versions of RC4-MD5 */
-                        ops[current_x].mask|=cp->mask;
                         if (!multi) break;
                         }
-                current_x++;
-                if (ch == '\0') break;
-end_loop:
-                /* Make sure we scan until the next valid start point */
-                while ((*l != '\0') && ITEM_SEP(*l))
-                        l++;
+
+                /*
+                 * Ok, we have the rule, now apply it
+                 */
+                if (rule == CIPHER_SPECIAL)
+                        {       /* special command */
+                        ok = 0;
+                        if ((buflen == 8) &&
+                                !strncmp(buf, "STRENGTH", 8))
+                                ok = ssl_cipher_strength_sort(list,
+                                        head_p, tail_p);
+                        else
+                                SSLerr(SSL_F_SSL_CIPHER_PROCESS_RULESTR,
+                                        SSL_R_INVALID_COMMAND);
+                        if (ok == 0)
+                                retval = 0;
+                        /*
+                         * We do not support any "multi" options
+                         * together with "@", so throw away the
+                         * rest of the command, if any left, until
+                         * end or ':' is found.
+                         */
+                        while ((*l != '\0') && ITEM_SEP(*l))
+                                l++;
+                        }
+                else if (found)
+                        {
+                        ssl_cipher_apply_rule(algorithms, mask,
+                                algo_strength, mask_strength, rule, -1,
+                                list, head_p, tail_p);
+                        }
+                else
+                        {
+                        while ((*l != '\0') && ITEM_SEP(*l))
+                                l++;
+                        }
+                if (*l == '\0') break; /* done */
                 }
 
-        num_x=current_x;
-        current_x=0;
+        return(retval);
+        }
+
+STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(const SSL_METHOD *ssl_method,
+                STACK_OF(SSL_CIPHER) **cipher_list,
+                STACK_OF(SSL_CIPHER) **cipher_list_by_id,
+                const char *rule_str)
+        {
+        int ok, num_of_ciphers, num_of_alias_max, num_of_group_aliases;
+        unsigned long disabled_mask;
+        STACK_OF(SSL_CIPHER) *cipherstack;
+        const char *rule_p;
+        CIPHER_ORDER *list = NULL, *head = NULL, *tail = NULL, *curr;
+        SSL_CIPHER **ca_list = NULL;
+
+        /*
+         * Return with error if nothing to do.
+         */
+        if (rule_str == NULL) return(NULL);
+
+        if (init_ciphers) load_ciphers();
 
-        /* We will now process the list of ciphers, once for each category, to
-         * decide what we should do with it. */
-        for (j=0; j<num_x; j++)
+        /*
+         * To reduce the work to do we only want to process the compiled
+         * in algorithms, so we first get the mask of disabled ciphers.
+         */
+        disabled_mask = ssl_cipher_get_disabled();
+
+        /*
+         * Now we have to collect the available ciphers from the compiled
+         * in ciphers. We cannot get more than the number compiled in, so
+         * it is used for allocation.
+         */
+        num_of_ciphers = ssl_method->num_ciphers();
+#ifdef KSSL_DEBUG
+        printf("ssl_create_cipher_list() for %d ciphers\n", num_of_ciphers);
+#endif    /* KSSL_DEBUG */
+        list = (CIPHER_ORDER *)OPENSSL_malloc(sizeof(CIPHER_ORDER) * num_of_ciphers);
+        if (list == NULL)
                 {
-                algorithms=ops[j].algorithms;
-                type=ops[j].type;
-                mask=ops[j].mask;
+                SSLerr(SSL_F_SSL_CREATE_CIPHER_LIST,ERR_R_MALLOC_FAILURE);
+                return(NULL);   /* Failure */
+                }
 
-                curr=head;
-                curr2=head;
-                tail2=tail;
-                for (;;)
-                        {
-                        if ((curr == NULL) || (curr == tail2)) break;
-                        curr=curr2;
-                        curr2=curr->next;
+        ssl_cipher_collect_ciphers(ssl_method, num_of_ciphers, disabled_mask,
+                                   list, &head, &tail);
+
+        /*
+         * We also need cipher aliases for selecting based on the rule_str.
+         * There might be two types of entries in the rule_str: 1) names
+         * of ciphers themselves 2) aliases for groups of ciphers.
+         * For 1) we need the available ciphers and for 2) the cipher
+         * groups of cipher_aliases added together in one list (otherwise
+         * we would be happy with just the cipher_aliases table).
+         */
+        num_of_group_aliases = sizeof(cipher_aliases) / sizeof(SSL_CIPHER);
+        num_of_alias_max = num_of_ciphers + num_of_group_aliases + 1;
+        ca_list =
+                (SSL_CIPHER **)OPENSSL_malloc(sizeof(SSL_CIPHER *) * num_of_alias_max);
+        if (ca_list == NULL)
+                {
+                OPENSSL_free(list);
+                SSLerr(SSL_F_SSL_CREATE_CIPHER_LIST,ERR_R_MALLOC_FAILURE);
+                return(NULL);   /* Failure */
+                }
+        ssl_cipher_collect_aliases(ca_list, num_of_group_aliases, disabled_mask,
+                                   head);
+
+        /*
+         * If the rule_string begins with DEFAULT, apply the default rule
+         * before using the (possibly available) additional rules.
+         */
+        ok = 1;
+        rule_p = rule_str;
+        if (strncmp(rule_str,"DEFAULT",7) == 0)
+                {
+                ok = ssl_cipher_process_rulestr(SSL_DEFAULT_CIPHER_LIST,
+                        list, &head, &tail, ca_list);
+                rule_p += 7;
+                if (*rule_p == ':')
+                        rule_p++;
+                }
 
-                        cp=curr->cipher;
-                        ma=mask & cp->algorithms;
-                        if ((ma == 0) || ((ma & algorithms) != ma))
-                                {
-                                /* does not apply */
-                                continue;
-                                }
+        if (ok && (strlen(rule_p) > 0))
+                ok = ssl_cipher_process_rulestr(rule_p, list, &head, &tail,
+                                                ca_list);
 
-                        /* add the cipher if it has not been added yet. */
-                        if (type == CIPHER_ADD)
-                                {
-                                if (!curr->active)
-                                        {
-                                        ll_append_tail(&head,curr,&tail);
-                                        curr->active=1;
-                                        }
-                                }
-                        /* Move the added cipher to this location */
-                        else if (type == CIPHER_ORD)
-                                {
-                                if (curr->active)
-                                        {
-                                        ll_append_tail(&head,curr,&tail);
-                                        }
-                                }
-                        else if (type == CIPHER_DEL)
-                                curr->active=0;
-                        if (type == CIPHER_KILL)
-                                {
-                                if (head == curr)
-                                        head=curr->next;
-                                else
-                                        curr->prev->next=curr->next;
-                                if (tail == curr)
-                                        tail=curr->prev;
-                                curr->active=0;
-                                if (curr->next != NULL)
-                                        curr->next->prev=curr->prev;
-                                if (curr->prev != NULL)
-                                        curr->prev->next=curr->next;
-                                curr->next=NULL;
-                                curr->prev=NULL;
-                                }
-                        }
+        OPENSSL_free(ca_list);  /* Not needed anymore */
+
+        if (!ok)
+                {       /* Rule processing failure */
+                OPENSSL_free(list);
+                return(NULL);
+                }
+        /*
+         * Allocate new "cipherstack" for the result, return with error
+         * if we cannot get one.
+         */
+        if ((cipherstack = sk_SSL_CIPHER_new_null()) == NULL)
+                {
+                OPENSSL_free(list);
+                return(NULL);
                 }
 
-        for (curr=head; curr != NULL; curr=curr->next)
+        /*
+         * The cipher selection for the list is done. The ciphers are added
+         * to the resulting precedence to the STACK_OF(SSL_CIPHER).
+         */
+        for (curr = head; curr != NULL; curr = curr->next)
                 {
                 if (curr->active)
                         {
-                        sk_push(ret,(char *)curr->cipher);
+                        sk_SSL_CIPHER_push(cipherstack, curr->cipher);
 #ifdef CIPHER_DEBUG
                         printf("<%s>\n",curr->cipher->name);
 #endif
                         }
                 }
-
+        OPENSSL_free(list);     /* Not needed any longer */
+
+        /*
+         * The following passage is a little bit odd. If pointer variables
+         * were supplied to hold STACK_OF(SSL_CIPHER) return information,
+         * the old memory pointed to is free()ed. Then, however, the
+         * cipher_list entry will be assigned just a copy of the returned
+         * cipher stack. For cipher_list_by_id a copy of the cipher stack
+         * will be created. See next comment...
+         */
         if (cipher_list != NULL)
                 {
                 if (*cipher_list != NULL)
-                        sk_free(*cipher_list);
-                *cipher_list=ret;
+                        sk_SSL_CIPHER_free(*cipher_list);
+                *cipher_list = cipherstack;
                 }
 
         if (cipher_list_by_id != NULL)
                 {
                 if (*cipher_list_by_id != NULL)
-                        sk_free(*cipher_list_by_id);
-                *cipher_list_by_id=sk_dup(ret);
+                        sk_SSL_CIPHER_free(*cipher_list_by_id);
+                *cipher_list_by_id = sk_SSL_CIPHER_dup(cipherstack);
                 }
 
+        /*
+         * Now it is getting really strange. If something failed during
+         * the previous pointer assignment or if one of the pointers was
+         * not requested, the error condition is met. That might be
+         * discussable. The strange thing is however that in this case
+         * the memory "ret" pointed to is "free()ed" and hence the pointer
+         * cipher_list becomes wild. The memory reserved for
+         * cipher_list_by_id however is not "free()ed" and stays intact.
+         */
         if (    (cipher_list_by_id == NULL) ||
                 (*cipher_list_by_id == NULL) ||
                 (cipher_list == NULL) ||
                 (*cipher_list == NULL))
-                goto err;
-        sk_set_cmp_func(*cipher_list_by_id,ssl_cipher_ptr_id_cmp);
-
-        ok=ret;
-        ret=NULL;
-err:
-        if (tmp_str) Free(tmp_str);
-        if (ops != NULL) Free(ops);
-        if (ret != NULL) sk_free(ret);
-        if (ca_list != NULL) sk_free(ca_list);
-        if (list != NULL) Free(list);
-        return(ok);
+                {
+                sk_SSL_CIPHER_free(cipherstack);
+                return(NULL);
+                }
+
+        sk_SSL_CIPHER_set_cmp_func(*cipher_list_by_id,ssl_cipher_ptr_id_cmp);
+
+        return(cipherstack);
         }
 
-char *SSL_CIPHER_description(cipher,buf,len)
-SSL_CIPHER *cipher;
-char *buf;
-int len;
+char *SSL_CIPHER_description(SSL_CIPHER *cipher, char *buf, int len)
         {
-        int export;
+        int is_export,pkl,kl;
         char *ver,*exp;
         char *kx,*au,*enc,*mac;
-        unsigned long alg,alg2;
+        unsigned long alg,alg2,alg_s;
+#ifdef KSSL_DEBUG
+        static char *format="%-23s %s Kx=%-8s Au=%-4s Enc=%-9s Mac=%-4s%s AL=%lx\n";
+#else
         static char *format="%-23s %s Kx=%-8s Au=%-4s Enc=%-9s Mac=%-4s%s\n";
-        
+#endif /* KSSL_DEBUG */
+
         alg=cipher->algorithms;
+        alg_s=cipher->algo_strength;
         alg2=cipher->algorithm2;
 
-        export=(alg&SSL_EXP)?1:0;
-        exp=(export)?" export":"";
+        is_export=SSL_C_IS_EXPORT(cipher);
+        pkl=SSL_C_EXPORT_PKEYLENGTH(cipher);
+        kl=SSL_C_EXPORT_KEYLENGTH(cipher);
+        exp=is_export?" export":"";
 
         if (alg & SSL_SSLV2)
                 ver="SSLv2";
@@ -607,7 +926,7 @@ int len;
         switch (alg&SSL_MKEY_MASK)
                 {
         case SSL_kRSA:
-                kx=(export)?"RSA(512)":"RSA";
+                kx=is_export?(pkl == 512 ? "RSA(512)" : "RSA(1024)"):"RSA";
                 break;
         case SSL_kDHr:
                 kx="DH/RSA";
@@ -615,11 +934,15 @@ int len;
         case SSL_kDHd:
                 kx="DH/DSS";
                 break;
+        case SSL_kKRB5:         /* VRS */
+        case SSL_KRB5:          /* VRS */
+            kx="KRB5";
+            break;
         case SSL_kFZA:
                 kx="Fortezza";
                 break;
         case SSL_kEDH:
-                kx=(export)?"DH(512)":"DH";
+                kx=is_export?(pkl == 512 ? "DH(512)" : "DH(1024)"):"DH";
                 break;
         default:
                 kx="unknown";
@@ -636,6 +959,10 @@ int len;
         case SSL_aDH:
                 au="DH";
                 break;
+        case SSL_aKRB5:         /* VRS */
+        case SSL_KRB5:          /* VRS */
+            au="KRB5";
+            break;
         case SSL_aFZA:
         case SSL_aNULL:
                 au="None";
@@ -648,16 +975,17 @@ int len;
         switch (alg&SSL_ENC_MASK)
                 {
         case SSL_DES:
-                enc=export?"DES(40)":"DES(56)";
+                enc=(is_export && kl == 5)?"DES(40)":"DES(56)";
                 break;
         case SSL_3DES:
                 enc="3DES(168)";
                 break;
         case SSL_RC4:
-                enc=export?"RC4(40)":((alg2&SSL2_CF_8_BYTE_ENC)?"RC4(64)":"RC4(128)");
+                enc=is_export?(kl == 5 ? "RC4(40)" : "RC4(56)")
+                  :((alg2&SSL2_CF_8_BYTE_ENC)?"RC4(64)":"RC4(128)");
                 break;
         case SSL_RC2:
-                enc=export?"RC2(40)":"RC2(128)";
+                enc=is_export?(kl == 5 ? "RC2(40)" : "RC2(56)"):"RC2(128)";
                 break;
         case SSL_IDEA:
                 enc="IDEA(128)";
@@ -668,6 +996,15 @@ int len;
         case SSL_eNULL:
                 enc="None";
                 break;
+        case SSL_AES:
+                switch(cipher->strength_bits)
+                        {
+                case 128: enc="AESdraft(128)"; break;
+                case 192: enc="AESdraft(192)"; break;
+                case 256: enc="AESdraft(256)"; break;
+                default: enc="AESdraft(?""?""?)"; break;
+                        }
+                break;
         default:
                 enc="unknown";
                 break;
@@ -688,18 +1025,22 @@ int len;
 
         if (buf == NULL)
                 {
-                buf=Malloc(128);
-                if (buf == NULL) return("Malloc Error");
+                len=128;
+                buf=OPENSSL_malloc(len);
+                if (buf == NULL) return("OPENSSL_malloc Error");
                 }
         else if (len < 128)
                 return("Buffer too small");
 
-        sprintf(buf,format,cipher->name,ver,kx,au,enc,mac,exp);
+#ifdef KSSL_DEBUG
+        BIO_snprintf(buf,len,format,cipher->name,ver,kx,au,enc,mac,exp,alg);
+#else
+        BIO_snprintf(buf,len,format,cipher->name,ver,kx,au,enc,mac,exp);
+#endif /* KSSL_DEBUG */
         return(buf);
         }
 
-char *SSL_CIPHER_get_version(c)
-SSL_CIPHER *c;
+char *SSL_CIPHER_get_version(SSL_CIPHER *c)
         {
         int i;
 
@@ -714,45 +1055,78 @@ SSL_CIPHER *c;
         }
 
 /* return the actual cipher being used */
-char *SSL_CIPHER_get_name(c)
-SSL_CIPHER *c;
+const char *SSL_CIPHER_get_name(SSL_CIPHER *c)
         {
         if (c != NULL)
                 return(c->name);
         return("(NONE)");
         }
 
-/* number of bits for symetric cipher */
-int SSL_CIPHER_get_bits(c,alg_bits)
-SSL_CIPHER *c;
-int *alg_bits;
+/* number of bits for symmetric cipher */
+int SSL_CIPHER_get_bits(SSL_CIPHER *c, int *alg_bits)
         {
-        int ret=0,a=0;
-        EVP_CIPHER *enc;
-        EVP_MD *md;
+        int ret=0;
 
         if (c != NULL)
                 {
-                if (!ssl_cipher_get_evp(c,&enc,&md))
-                        return(0);
+                if (alg_bits != NULL) *alg_bits = c->alg_bits;
+                ret = c->strength_bits;
+                }
+        return(ret);
+        }
 
-                a=EVP_CIPHER_key_length(enc)*8;
+SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n)
+        {
+        SSL_COMP *ctmp;
+        int i,nn;
 
-                if (c->algorithms & SSL_EXP)
-                        {
-                        ret=40;
-                        }
-                else
-                        {
-                        if (c->algorithm2 & SSL2_CF_8_BYTE_ENC)
-                                ret=64;
-                        else
-                                ret=a;
-                        }
+        if ((n == 0) || (sk == NULL)) return(NULL);
+        nn=sk_SSL_COMP_num(sk);
+        for (i=0; i<nn; i++)
+                {
+                ctmp=sk_SSL_COMP_value(sk,i);
+                if (ctmp->id == n)
+                        return(ctmp);
                 }
+        return(NULL);
+        }
 
-        if (alg_bits != NULL) *alg_bits=a;
-        
-        return(ret);
+static int sk_comp_cmp(const SSL_COMP * const *a,
+                        const SSL_COMP * const *b)
+        {
+        return((*a)->id-(*b)->id);
         }
 
+STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void)
+        {
+        return(ssl_comp_methods);
+        }
+
+int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm)
+        {
+        SSL_COMP *comp;
+        STACK_OF(SSL_COMP) *sk;
+
+        if (cm == NULL || cm->type == NID_undef)
+                return 1;
+
+        MemCheck_off();
+        comp=(SSL_COMP *)OPENSSL_malloc(sizeof(SSL_COMP));
+        comp->id=id;
+        comp->method=cm;
+        if (ssl_comp_methods == NULL)
+                sk=ssl_comp_methods=sk_SSL_COMP_new(sk_comp_cmp);
+        else
+                sk=ssl_comp_methods;
+        if ((sk == NULL) || !sk_SSL_COMP_push(sk,comp))
+                {
+                MemCheck_on();
+                SSLerr(SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD,ERR_R_MALLOC_FAILURE);
+                return(0);
+                }
+        else
+                {
+                MemCheck_on();
+                return(1);
+                }
+        }
diff --git a/src/lib/libssl/ssl_err.c b/src/lib/libssl/ssl_err.c
index bcbb98591f..c32c4ef6e9 100644
--- a/src/lib/libssl/ssl_err.c
+++ b/src/lib/libssl/ssl_err.c
@@ -1,66 +1,69 @@
-/* lib/ssl/ssl_err.c */
-/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
+/* ssl/ssl_err.c */
+/* ====================================================================
+ * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
  *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- * 
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- * 
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from 
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- * 
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * 
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.]
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@OpenSSL.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
  */
+
+/* NOTE: this file was auto generated by the mkerr.pl script: any changes
+ * made to it will be overwritten when the script next updates this file,
+ * only reason strings will be preserved.
+ */
+
 #include <stdio.h>
-#include "err.h"
-#include "ssl.h"
+#include <openssl/err.h>
+#include <openssl/ssl.h>
 
 /* BEGIN ERROR CODES */
-#ifndef NO_ERR
+#ifndef OPENSSL_NO_ERR
 static ERR_STRING_DATA SSL_str_functs[]=
         {
 {ERR_PACK(0,SSL_F_CLIENT_CERTIFICATE,0),        "CLIENT_CERTIFICATE"},
@@ -83,21 +86,27 @@ static ERR_STRING_DATA SSL_str_functs[]=
 {ERR_PACK(0,SSL_F_SSL23_CONNECT,0),     "SSL23_CONNECT"},
 {ERR_PACK(0,SSL_F_SSL23_GET_CLIENT_HELLO,0),    "SSL23_GET_CLIENT_HELLO"},
 {ERR_PACK(0,SSL_F_SSL23_GET_SERVER_HELLO,0),    "SSL23_GET_SERVER_HELLO"},
+{ERR_PACK(0,SSL_F_SSL23_PEEK,0),        "SSL23_PEEK"},
 {ERR_PACK(0,SSL_F_SSL23_READ,0),        "SSL23_READ"},
 {ERR_PACK(0,SSL_F_SSL23_WRITE,0),       "SSL23_WRITE"},
 {ERR_PACK(0,SSL_F_SSL2_ACCEPT,0),       "SSL2_ACCEPT"},
 {ERR_PACK(0,SSL_F_SSL2_CONNECT,0),      "SSL2_CONNECT"},
 {ERR_PACK(0,SSL_F_SSL2_ENC_INIT,0),     "SSL2_ENC_INIT"},
+{ERR_PACK(0,SSL_F_SSL2_PEEK,0), "SSL2_PEEK"},
 {ERR_PACK(0,SSL_F_SSL2_READ,0), "SSL2_READ"},
+{ERR_PACK(0,SSL_F_SSL2_READ_INTERNAL,0),        "SSL2_READ_INTERNAL"},
 {ERR_PACK(0,SSL_F_SSL2_SET_CERTIFICATE,0),      "SSL2_SET_CERTIFICATE"},
 {ERR_PACK(0,SSL_F_SSL2_WRITE,0),        "SSL2_WRITE"},
 {ERR_PACK(0,SSL_F_SSL3_ACCEPT,0),       "SSL3_ACCEPT"},
+{ERR_PACK(0,SSL_F_SSL3_CALLBACK_CTRL,0),        "SSL3_CALLBACK_CTRL"},
 {ERR_PACK(0,SSL_F_SSL3_CHANGE_CIPHER_STATE,0),  "SSL3_CHANGE_CIPHER_STATE"},
 {ERR_PACK(0,SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,0),     "SSL3_CHECK_CERT_AND_ALGORITHM"},
 {ERR_PACK(0,SSL_F_SSL3_CLIENT_HELLO,0), "SSL3_CLIENT_HELLO"},
 {ERR_PACK(0,SSL_F_SSL3_CONNECT,0),      "SSL3_CONNECT"},
+{ERR_PACK(0,SSL_F_SSL3_CTRL,0), "SSL3_CTRL"},
 {ERR_PACK(0,SSL_F_SSL3_CTX_CTRL,0),     "SSL3_CTX_CTRL"},
 {ERR_PACK(0,SSL_F_SSL3_ENC,0),  "SSL3_ENC"},
+{ERR_PACK(0,SSL_F_SSL3_GENERATE_KEY_BLOCK,0),   "SSL3_GENERATE_KEY_BLOCK"},
 {ERR_PACK(0,SSL_F_SSL3_GET_CERTIFICATE_REQUEST,0),      "SSL3_GET_CERTIFICATE_REQUEST"},
 {ERR_PACK(0,SSL_F_SSL3_GET_CERT_VERIFY,0),      "SSL3_GET_CERT_VERIFY"},
 {ERR_PACK(0,SSL_F_SSL3_GET_CLIENT_CERTIFICATE,0),       "SSL3_GET_CLIENT_CERTIFICATE"},
@@ -111,6 +120,7 @@ static ERR_STRING_DATA SSL_str_functs[]=
 {ERR_PACK(0,SSL_F_SSL3_GET_SERVER_DONE,0),      "SSL3_GET_SERVER_DONE"},
 {ERR_PACK(0,SSL_F_SSL3_GET_SERVER_HELLO,0),     "SSL3_GET_SERVER_HELLO"},
 {ERR_PACK(0,SSL_F_SSL3_OUTPUT_CERT_CHAIN,0),    "SSL3_OUTPUT_CERT_CHAIN"},
+{ERR_PACK(0,SSL_F_SSL3_PEEK,0), "SSL3_PEEK"},
 {ERR_PACK(0,SSL_F_SSL3_READ_BYTES,0),   "SSL3_READ_BYTES"},
 {ERR_PACK(0,SSL_F_SSL3_READ_N,0),       "SSL3_READ_N"},
 {ERR_PACK(0,SSL_F_SSL3_SEND_CERTIFICATE_REQUEST,0),     "SSL3_SEND_CERTIFICATE_REQUEST"},
@@ -123,16 +133,30 @@ static ERR_STRING_DATA SSL_str_functs[]=
 {ERR_PACK(0,SSL_F_SSL3_SETUP_KEY_BLOCK,0),      "SSL3_SETUP_KEY_BLOCK"},
 {ERR_PACK(0,SSL_F_SSL3_WRITE_BYTES,0),  "SSL3_WRITE_BYTES"},
 {ERR_PACK(0,SSL_F_SSL3_WRITE_PENDING,0),        "SSL3_WRITE_PENDING"},
+{ERR_PACK(0,SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK,0),        "SSL_add_dir_cert_subjects_to_stack"},
+{ERR_PACK(0,SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK,0),       "SSL_add_file_cert_subjects_to_stack"},
 {ERR_PACK(0,SSL_F_SSL_BAD_METHOD,0),    "SSL_BAD_METHOD"},
 {ERR_PACK(0,SSL_F_SSL_BYTES_TO_CIPHER_LIST,0),  "SSL_BYTES_TO_CIPHER_LIST"},
+{ERR_PACK(0,SSL_F_SSL_CERT_DUP,0),      "SSL_CERT_DUP"},
+{ERR_PACK(0,SSL_F_SSL_CERT_INST,0),     "SSL_CERT_INST"},
+{ERR_PACK(0,SSL_F_SSL_CERT_INSTANTIATE,0),      "SSL_CERT_INSTANTIATE"},
 {ERR_PACK(0,SSL_F_SSL_CERT_NEW,0),      "SSL_CERT_NEW"},
 {ERR_PACK(0,SSL_F_SSL_CHECK_PRIVATE_KEY,0),     "SSL_check_private_key"},
+{ERR_PACK(0,SSL_F_SSL_CIPHER_PROCESS_RULESTR,0),        "SSL_CIPHER_PROCESS_RULESTR"},
+{ERR_PACK(0,SSL_F_SSL_CIPHER_STRENGTH_SORT,0),  "SSL_CIPHER_STRENGTH_SORT"},
+{ERR_PACK(0,SSL_F_SSL_CLEAR,0), "SSL_clear"},
+{ERR_PACK(0,SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD,0),   "SSL_COMP_add_compression_method"},
 {ERR_PACK(0,SSL_F_SSL_CREATE_CIPHER_LIST,0),    "SSL_CREATE_CIPHER_LIST"},
+{ERR_PACK(0,SSL_F_SSL_CTRL,0),  "SSL_ctrl"},
 {ERR_PACK(0,SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,0), "SSL_CTX_check_private_key"},
 {ERR_PACK(0,SSL_F_SSL_CTX_NEW,0),       "SSL_CTX_new"},
+{ERR_PACK(0,SSL_F_SSL_CTX_SET_PURPOSE,0),       "SSL_CTX_set_purpose"},
+{ERR_PACK(0,SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT,0),    "SSL_CTX_set_session_id_context"},
 {ERR_PACK(0,SSL_F_SSL_CTX_SET_SSL_VERSION,0),   "SSL_CTX_set_ssl_version"},
+{ERR_PACK(0,SSL_F_SSL_CTX_SET_TRUST,0), "SSL_CTX_set_trust"},
 {ERR_PACK(0,SSL_F_SSL_CTX_USE_CERTIFICATE,0),   "SSL_CTX_use_certificate"},
 {ERR_PACK(0,SSL_F_SSL_CTX_USE_CERTIFICATE_ASN1,0),      "SSL_CTX_use_certificate_ASN1"},
+{ERR_PACK(0,SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE,0),        "SSL_CTX_use_certificate_chain_file"},
 {ERR_PACK(0,SSL_F_SSL_CTX_USE_CERTIFICATE_FILE,0),      "SSL_CTX_use_certificate_file"},
 {ERR_PACK(0,SSL_F_SSL_CTX_USE_PRIVATEKEY,0),    "SSL_CTX_use_PrivateKey"},
 {ERR_PACK(0,SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1,0),       "SSL_CTX_use_PrivateKey_ASN1"},
@@ -142,21 +166,28 @@ static ERR_STRING_DATA SSL_str_functs[]=
 {ERR_PACK(0,SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE,0),    "SSL_CTX_use_RSAPrivateKey_file"},
 {ERR_PACK(0,SSL_F_SSL_DO_HANDSHAKE,0),  "SSL_do_handshake"},
 {ERR_PACK(0,SSL_F_SSL_GET_NEW_SESSION,0),       "SSL_GET_NEW_SESSION"},
+{ERR_PACK(0,SSL_F_SSL_GET_PREV_SESSION,0),      "SSL_GET_PREV_SESSION"},
 {ERR_PACK(0,SSL_F_SSL_GET_SERVER_SEND_CERT,0),  "SSL_GET_SERVER_SEND_CERT"},
 {ERR_PACK(0,SSL_F_SSL_GET_SIGN_PKEY,0), "SSL_GET_SIGN_PKEY"},
 {ERR_PACK(0,SSL_F_SSL_INIT_WBIO_BUFFER,0),      "SSL_INIT_WBIO_BUFFER"},
 {ERR_PACK(0,SSL_F_SSL_LOAD_CLIENT_CA_FILE,0),   "SSL_load_client_CA_file"},
 {ERR_PACK(0,SSL_F_SSL_NEW,0),   "SSL_new"},
+{ERR_PACK(0,SSL_F_SSL_READ,0),  "SSL_read"},
 {ERR_PACK(0,SSL_F_SSL_RSA_PRIVATE_DECRYPT,0),   "SSL_RSA_PRIVATE_DECRYPT"},
 {ERR_PACK(0,SSL_F_SSL_RSA_PUBLIC_ENCRYPT,0),    "SSL_RSA_PUBLIC_ENCRYPT"},
 {ERR_PACK(0,SSL_F_SSL_SESSION_NEW,0),   "SSL_SESSION_new"},
 {ERR_PACK(0,SSL_F_SSL_SESSION_PRINT_FP,0),      "SSL_SESSION_print_fp"},
+{ERR_PACK(0,SSL_F_SSL_SESS_CERT_NEW,0), "SSL_SESS_CERT_NEW"},
 {ERR_PACK(0,SSL_F_SSL_SET_CERT,0),      "SSL_SET_CERT"},
 {ERR_PACK(0,SSL_F_SSL_SET_FD,0),        "SSL_set_fd"},
 {ERR_PACK(0,SSL_F_SSL_SET_PKEY,0),      "SSL_SET_PKEY"},
+{ERR_PACK(0,SSL_F_SSL_SET_PURPOSE,0),   "SSL_set_purpose"},
 {ERR_PACK(0,SSL_F_SSL_SET_RFD,0),       "SSL_set_rfd"},
 {ERR_PACK(0,SSL_F_SSL_SET_SESSION,0),   "SSL_set_session"},
+{ERR_PACK(0,SSL_F_SSL_SET_SESSION_ID_CONTEXT,0),        "SSL_set_session_id_context"},
+{ERR_PACK(0,SSL_F_SSL_SET_TRUST,0),     "SSL_set_trust"},
 {ERR_PACK(0,SSL_F_SSL_SET_WFD,0),       "SSL_set_wfd"},
+{ERR_PACK(0,SSL_F_SSL_SHUTDOWN,0),      "SSL_shutdown"},
 {ERR_PACK(0,SSL_F_SSL_UNDEFINED_FUNCTION,0),    "SSL_UNDEFINED_FUNCTION"},
 {ERR_PACK(0,SSL_F_SSL_USE_CERTIFICATE,0),       "SSL_use_certificate"},
 {ERR_PACK(0,SSL_F_SSL_USE_CERTIFICATE_ASN1,0),  "SSL_use_certificate_ASN1"},
@@ -167,22 +198,23 @@ static ERR_STRING_DATA SSL_str_functs[]=
 {ERR_PACK(0,SSL_F_SSL_USE_RSAPRIVATEKEY,0),     "SSL_use_RSAPrivateKey"},
 {ERR_PACK(0,SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1,0),        "SSL_use_RSAPrivateKey_ASN1"},
 {ERR_PACK(0,SSL_F_SSL_USE_RSAPRIVATEKEY_FILE,0),        "SSL_use_RSAPrivateKey_file"},
+{ERR_PACK(0,SSL_F_SSL_VERIFY_CERT_CHAIN,0),     "SSL_VERIFY_CERT_CHAIN"},
 {ERR_PACK(0,SSL_F_SSL_WRITE,0), "SSL_write"},
 {ERR_PACK(0,SSL_F_TLS1_CHANGE_CIPHER_STATE,0),  "TLS1_CHANGE_CIPHER_STATE"},
 {ERR_PACK(0,SSL_F_TLS1_ENC,0),  "TLS1_ENC"},
 {ERR_PACK(0,SSL_F_TLS1_SETUP_KEY_BLOCK,0),      "TLS1_SETUP_KEY_BLOCK"},
 {ERR_PACK(0,SSL_F_WRITE_PENDING,0),     "WRITE_PENDING"},
-{0,NULL},
+{0,NULL}
         };
 
 static ERR_STRING_DATA SSL_str_reasons[]=
         {
 {SSL_R_APP_DATA_IN_HANDSHAKE             ,"app data in handshake"},
+{SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT,"attempt to reuse session in different context"},
 {SSL_R_BAD_ALERT_RECORD                  ,"bad alert record"},
 {SSL_R_BAD_AUTHENTICATION_TYPE           ,"bad authentication type"},
 {SSL_R_BAD_CHANGE_CIPHER_SPEC            ,"bad change cipher spec"},
 {SSL_R_BAD_CHECKSUM                      ,"bad checksum"},
-{SSL_R_BAD_CLIENT_REQUEST                ,"bad client request"},
 {SSL_R_BAD_DATA_RETURNED_BY_CALLBACK     ,"bad data returned by callback"},
 {SSL_R_BAD_DECOMPRESSION                 ,"bad decompression"},
 {SSL_R_BAD_DH_G_LENGTH                   ,"bad dh g length"},
@@ -190,6 +222,8 @@ static ERR_STRING_DATA SSL_str_reasons[]=
 {SSL_R_BAD_DH_P_LENGTH                   ,"bad dh p length"},
 {SSL_R_BAD_DIGEST_LENGTH                 ,"bad digest length"},
 {SSL_R_BAD_DSA_SIGNATURE                 ,"bad dsa signature"},
+{SSL_R_BAD_HELLO_REQUEST                 ,"bad hello request"},
+{SSL_R_BAD_LENGTH                        ,"bad length"},
 {SSL_R_BAD_MAC_DECODE                    ,"bad mac decode"},
 {SSL_R_BAD_MESSAGE_TYPE                  ,"bad message type"},
 {SSL_R_BAD_PACKET_LENGTH                 ,"bad packet length"},
@@ -219,25 +253,44 @@ static ERR_STRING_DATA SSL_str_reasons[]=
 {SSL_R_CIPHER_TABLE_SRC_ERROR            ,"cipher table src error"},
 {SSL_R_COMPRESSED_LENGTH_TOO_LONG        ,"compressed length too long"},
 {SSL_R_COMPRESSION_FAILURE               ,"compression failure"},
+{SSL_R_COMPRESSION_LIBRARY_ERROR         ,"compression library error"},
 {SSL_R_CONNECTION_ID_IS_DIFFERENT        ,"connection id is different"},
 {SSL_R_CONNECTION_TYPE_NOT_SET           ,"connection type not set"},
 {SSL_R_DATA_BETWEEN_CCS_AND_FINISHED     ,"data between ccs and finished"},
 {SSL_R_DATA_LENGTH_TOO_LONG              ,"data length too long"},
 {SSL_R_DECRYPTION_FAILED                 ,"decryption failed"},
+{SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC,"decryption failed or bad record mac"},
 {SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG   ,"dh public value length is wrong"},
 {SSL_R_DIGEST_CHECK_FAILED               ,"digest check failed"},
 {SSL_R_ENCRYPTED_LENGTH_TOO_LONG         ,"encrypted length too long"},
+{SSL_R_ERROR_GENERATING_TMP_RSA_KEY      ,"error generating tmp rsa key"},
 {SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST     ,"error in received cipher list"},
 {SSL_R_EXCESSIVE_MESSAGE_SIZE            ,"excessive message size"},
 {SSL_R_EXTRA_DATA_IN_MESSAGE             ,"extra data in message"},
 {SSL_R_GOT_A_FIN_BEFORE_A_CCS            ,"got a fin before a ccs"},
 {SSL_R_HTTPS_PROXY_REQUEST               ,"https proxy request"},
 {SSL_R_HTTP_REQUEST                      ,"http request"},
-{SSL_R_INTERNAL_ERROR                    ,"internal error"},
+{SSL_R_ILLEGAL_PADDING                   ,"illegal padding"},
 {SSL_R_INVALID_CHALLENGE_LENGTH          ,"invalid challenge length"},
+{SSL_R_INVALID_COMMAND                   ,"invalid command"},
+{SSL_R_INVALID_PURPOSE                   ,"invalid purpose"},
+{SSL_R_INVALID_TRUST                     ,"invalid trust"},
+{SSL_R_KRB5                              ,"krb5"},
+{SSL_R_KRB5_C_CC_PRINC                   ,"krb5 client cc principal (no tkt?)"},
+{SSL_R_KRB5_C_GET_CRED                   ,"krb5 client get cred"},
+{SSL_R_KRB5_C_INIT                       ,"krb5 client init"},
+{SSL_R_KRB5_C_MK_REQ                     ,"krb5 client mk_req (expired tkt?)"},
+{SSL_R_KRB5_S_BAD_TICKET                 ,"krb5 server bad ticket"},
+{SSL_R_KRB5_S_INIT                       ,"krb5 server init"},
+{SSL_R_KRB5_S_RD_REQ                     ,"krb5 server rd_req (keytab perms?)"},
+{SSL_R_KRB5_S_TKT_EXPIRED                ,"krb5 server tkt expired"},
+{SSL_R_KRB5_S_TKT_NYV                    ,"krb5 server tkt not yet valid"},
+{SSL_R_KRB5_S_TKT_SKEW                   ,"krb5 server tkt skew"},
 {SSL_R_LENGTH_MISMATCH                   ,"length mismatch"},
 {SSL_R_LENGTH_TOO_SHORT                  ,"length too short"},
+{SSL_R_LIBRARY_BUG                       ,"library bug"},
 {SSL_R_LIBRARY_HAS_NO_CIPHERS            ,"library has no ciphers"},
+{SSL_R_MESSAGE_TOO_LONG                  ,"message too long"},
 {SSL_R_MISSING_DH_DSA_CERT               ,"missing dh dsa cert"},
 {SSL_R_MISSING_DH_KEY                    ,"missing dh key"},
 {SSL_R_MISSING_DH_RSA_CERT               ,"missing dh rsa cert"},
@@ -264,15 +317,18 @@ static ERR_STRING_DATA SSL_str_reasons[]=
 {SSL_R_NO_CIPHER_MATCH                   ,"no cipher match"},
 {SSL_R_NO_CLIENT_CERT_RECEIVED           ,"no client cert received"},
 {SSL_R_NO_COMPRESSION_SPECIFIED          ,"no compression specified"},
+{SSL_R_NO_METHOD_SPECIFIED               ,"no method specified"},
 {SSL_R_NO_PRIVATEKEY                     ,"no privatekey"},
 {SSL_R_NO_PRIVATE_KEY_ASSIGNED           ,"no private key assigned"},
 {SSL_R_NO_PROTOCOLS_AVAILABLE            ,"no protocols available"},
 {SSL_R_NO_PUBLICKEY                      ,"no publickey"},
 {SSL_R_NO_SHARED_CIPHER                  ,"no shared cipher"},
+{SSL_R_NO_VERIFY_CALLBACK                ,"no verify callback"},
 {SSL_R_NULL_SSL_CTX                      ,"null ssl ctx"},
 {SSL_R_NULL_SSL_METHOD_PASSED            ,"null ssl method passed"},
 {SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED   ,"old session cipher not returned"},
 {SSL_R_PACKET_LENGTH_TOO_LONG            ,"packet length too long"},
+{SSL_R_PATH_TOO_LONG                     ,"path too long"},
 {SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE ,"peer did not return a certificate"},
 {SSL_R_PEER_ERROR                        ,"peer error"},
 {SSL_R_PEER_ERROR_CERTIFICATE            ,"peer error certificate"},
@@ -289,12 +345,15 @@ static ERR_STRING_DATA SSL_str_reasons[]=
 {SSL_R_READ_WRONG_PACKET_TYPE            ,"read wrong packet type"},
 {SSL_R_RECORD_LENGTH_MISMATCH            ,"record length mismatch"},
 {SSL_R_RECORD_TOO_LARGE                  ,"record too large"},
+{SSL_R_RECORD_TOO_SMALL                  ,"record too small"},
 {SSL_R_REQUIRED_CIPHER_MISSING           ,"required cipher missing"},
 {SSL_R_REUSE_CERT_LENGTH_NOT_ZERO        ,"reuse cert length not zero"},
 {SSL_R_REUSE_CERT_TYPE_NOT_ZERO          ,"reuse cert type not zero"},
 {SSL_R_REUSE_CIPHER_LIST_NOT_ZERO        ,"reuse cipher list not zero"},
+{SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED  ,"session id context uninitialized"},
 {SSL_R_SHORT_READ                        ,"short read"},
 {SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE,"signature for non signing certificate"},
+{SSL_R_SSL23_DOING_SESSION_ID_REUSE      ,"ssl23 doing session id reuse"},
 {SSL_R_SSL3_SESSION_ID_TOO_SHORT         ,"ssl3 session id too short"},
 {SSL_R_SSLV3_ALERT_BAD_CERTIFICATE       ,"sslv3 alert bad certificate"},
 {SSL_R_SSLV3_ALERT_BAD_RECORD_MAC        ,"sslv3 alert bad record mac"},
@@ -315,7 +374,23 @@ static ERR_STRING_DATA SSL_str_reasons[]=
 {SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION,"ssl ctx has no default ssl version"},
 {SSL_R_SSL_HANDSHAKE_FAILURE             ,"ssl handshake failure"},
 {SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS        ,"ssl library has no ciphers"},
+{SSL_R_SSL_SESSION_ID_CALLBACK_FAILED    ,"ssl session id callback failed"},
+{SSL_R_SSL_SESSION_ID_CONFLICT           ,"ssl session id conflict"},
+{SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG   ,"ssl session id context too long"},
+{SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH     ,"ssl session id has bad length"},
 {SSL_R_SSL_SESSION_ID_IS_DIFFERENT       ,"ssl session id is different"},
+{SSL_R_TLSV1_ALERT_ACCESS_DENIED         ,"tlsv1 alert access denied"},
+{SSL_R_TLSV1_ALERT_DECODE_ERROR          ,"tlsv1 alert decode error"},
+{SSL_R_TLSV1_ALERT_DECRYPTION_FAILED     ,"tlsv1 alert decryption failed"},
+{SSL_R_TLSV1_ALERT_DECRYPT_ERROR         ,"tlsv1 alert decrypt error"},
+{SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION    ,"tlsv1 alert export restriction"},
+{SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY ,"tlsv1 alert insufficient security"},
+{SSL_R_TLSV1_ALERT_INTERNAL_ERROR        ,"tlsv1 alert internal error"},
+{SSL_R_TLSV1_ALERT_NO_RENEGOTIATION      ,"tlsv1 alert no renegotiation"},
+{SSL_R_TLSV1_ALERT_PROTOCOL_VERSION      ,"tlsv1 alert protocol version"},
+{SSL_R_TLSV1_ALERT_RECORD_OVERFLOW       ,"tlsv1 alert record overflow"},
+{SSL_R_TLSV1_ALERT_UNKNOWN_CA            ,"tlsv1 alert unknown ca"},
+{SSL_R_TLSV1_ALERT_USER_CANCELLED        ,"tlsv1 alert user cancelled"},
 {SSL_R_TLS_CLIENT_CERT_REQ_WITH_ANON_CIPHER,"tls client cert req with anon cipher"},
 {SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST,"tls peer did not respond with certificate list"},
 {SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG,"tls rsa encrypted value length is wrong"},
@@ -330,6 +405,7 @@ static ERR_STRING_DATA SSL_str_reasons[]=
 {SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES ,"unable to load ssl3 sha1 routines"},
 {SSL_R_UNEXPECTED_MESSAGE                ,"unexpected message"},
 {SSL_R_UNEXPECTED_RECORD                 ,"unexpected record"},
+{SSL_R_UNINITIALIZED                     ,"uninitialized"},
 {SSL_R_UNKNOWN_ALERT_TYPE                ,"unknown alert type"},
 {SSL_R_UNKNOWN_CERTIFICATE_TYPE          ,"unknown certificate type"},
 {SSL_R_UNKNOWN_CIPHER_RETURNED           ,"unknown cipher returned"},
@@ -342,6 +418,7 @@ static ERR_STRING_DATA SSL_str_reasons[]=
 {SSL_R_UNKNOWN_STATE                     ,"unknown state"},
 {SSL_R_UNSUPPORTED_CIPHER                ,"unsupported cipher"},
 {SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM ,"unsupported compression algorithm"},
+{SSL_R_UNSUPPORTED_OPTION                ,"unsupported option"},
 {SSL_R_UNSUPPORTED_PROTOCOL              ,"unsupported protocol"},
 {SSL_R_UNSUPPORTED_SSL_VERSION           ,"unsupported ssl version"},
 {SSL_R_WRITE_BIO_NOT_SET                 ,"write bio not set"},
@@ -353,19 +430,20 @@ static ERR_STRING_DATA SSL_str_reasons[]=
 {SSL_R_WRONG_SSL_VERSION                 ,"wrong ssl version"},
 {SSL_R_WRONG_VERSION_NUMBER              ,"wrong version number"},
 {SSL_R_X509_LIB                          ,"x509 lib"},
-{0,NULL},
+{SSL_R_X509_VERIFICATION_SETUP_PROBLEMS  ,"x509 verification setup problems"},
+{0,NULL}
         };
 
 #endif
 
-void ERR_load_SSL_strings()
+void ERR_load_SSL_strings(void)
         {
         static int init=1;
 
-        if (init);
-                {;
+        if (init)
+                {
                 init=0;
-#ifndef NO_ERR
+#ifndef OPENSSL_NO_ERR
                 ERR_load_strings(ERR_LIB_SSL,SSL_str_functs);
                 ERR_load_strings(ERR_LIB_SSL,SSL_str_reasons);
 #endif
diff --git a/src/lib/libssl/ssl_err2.c b/src/lib/libssl/ssl_err2.c
index 0b91f7b8d2..ea95a5f983 100644
--- a/src/lib/libssl/ssl_err2.c
+++ b/src/lib/libssl/ssl_err2.c
@@ -57,12 +57,12 @@
  */
 
 #include <stdio.h>
-#include "err.h"
-#include "ssl.h"
+#include <openssl/err.h>
+#include <openssl/ssl.h>
 
-void SSL_load_error_strings()
+void SSL_load_error_strings(void)
         {
-#ifndef NO_ERR
+#ifndef OPENSSL_NO_ERR
         ERR_load_crypto_strings();
         ERR_load_SSL_strings();
 #endif
diff --git a/src/lib/libssl/ssl_lib.c b/src/lib/libssl/ssl_lib.c
index f562ec6b14..df307a80c5 100644
--- a/src/lib/libssl/ssl_lib.c
+++ b/src/lib/libssl/ssl_lib.c
@@ -1,4 +1,6 @@
-/* ssl/ssl_lib.c */
+/*! \file ssl/ssl_lib.c
+ *  \brief Version independent SSL functions.
+ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -55,52 +57,126 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
+/* ====================================================================
+ * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
 
+
+#ifdef REF_CHECK
+#  include <assert.h>
+#endif
 #include <stdio.h>
-#include "objects.h"
-#include "lhash.h"
+#include <openssl/objects.h>
+#include <openssl/lhash.h>
+#include <openssl/x509v3.h>
 #include "ssl_locl.h"
+#include "kssl_lcl.h"
 
-char *SSL_version_str="SSLeay 0.9.0b 29-Jun-1998";
-
-static STACK *ssl_meth=NULL;
-static STACK *ssl_ctx_meth=NULL;
-static int ssl_meth_num=0;
-static int ssl_ctx_meth_num=0;
+const char *SSL_version_str=OPENSSL_VERSION_TEXT;
 
-SSL3_ENC_METHOD ssl3_undef_enc_method={
-        ssl_undefined_function,
-        ssl_undefined_function,
-        ssl_undefined_function,
-        ssl_undefined_function,
-        ssl_undefined_function,
+OPENSSL_GLOBAL SSL3_ENC_METHOD ssl3_undef_enc_method={
+        /* evil casts, but these functions are only called if there's a library bug */
+        (int (*)(SSL *,int))ssl_undefined_function,
+        (int (*)(SSL *, unsigned char *, int))ssl_undefined_function,
         ssl_undefined_function,
+        (int (*)(SSL *, unsigned char *, unsigned char *, int))ssl_undefined_function,
+        (int (*)(SSL*, int))ssl_undefined_function,
+        (int (*)(SSL *, EVP_MD_CTX *, EVP_MD_CTX *, const char*, int, unsigned char *))ssl_undefined_function
         };
 
-void SSL_clear(s)
-SSL *s;
+int SSL_clear(SSL *s)
         {
-        int state;
 
-        if (s->method == NULL) return;
+        if (s->method == NULL)
+                {
+                SSLerr(SSL_F_SSL_CLEAR,SSL_R_NO_METHOD_SPECIFIED);
+                return(0);
+                }
+
+        if (ssl_clear_bad_session(s))
+                {
+                SSL_SESSION_free(s->session);
+                s->session=NULL;
+                }
 
         s->error=0;
         s->hit=0;
+        s->shutdown=0;
 
+#if 0 /* Disabled since version 1.10 of this file (early return not
+       * needed because SSL_clear is not called when doing renegotiation) */
         /* This is set if we are doing dynamic renegotiation so keep
          * the old cipher.  It is sort of a SSL_clear_lite :-) */
-        if (s->new_session) return;
+        if (s->new_session) return(1);
+#else
+        if (s->new_session)
+                {
+                SSLerr(SSL_F_SSL_CLEAR,ERR_R_INTERNAL_ERROR);
+                return 0;
+                }
+#endif
 
-        state=s->state; /* Keep to check if we throw away the session-id */
         s->type=0;
 
+        s->state=SSL_ST_BEFORE|((s->server)?SSL_ST_ACCEPT:SSL_ST_CONNECT);
+
         s->version=s->method->version;
+        s->client_version=s->version;
         s->rwstate=SSL_NOTHING;
-        s->state=SSL_ST_BEFORE;
         s->rstate=SSL_ST_READ_HEADER;
-        s->read_ahead=s->ctx->default_read_ahead;
-
-/*      s->shutdown=(SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN); */
+#if 0
+        s->read_ahead=s->ctx->read_ahead;
+#endif
 
         if (s->init_buf != NULL)
                 {
@@ -110,30 +186,34 @@ SSL *s;
 
         ssl_clear_cipher_ctx(s);
 
-        if (ssl_clear_bad_session(s))
-                {
-                SSL_SESSION_free(s->session);
-                s->session=NULL;
-                }
-
-        s->shutdown=(SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN);
         s->first_packet=0;
 
-        s->method->ssl_clear(s);
+#if 1
+        /* Check to see if we were changed into a different method, if
+         * so, revert back if we are not doing session-id reuse. */
+        if (!s->in_handshake && (s->session == NULL) && (s->method != s->ctx->method))
+                {
+                s->method->ssl_free(s);
+                s->method=s->ctx->method;
+                if (!s->method->ssl_new(s))
+                        return(0);
+                }
+        else
+#endif
+                s->method->ssl_clear(s);
+        return(1);
         }
 
-/* Used to change an SSL_CTXs default SSL method type */
-int SSL_CTX_set_ssl_version(ctx,meth)
-SSL_CTX *ctx;
-SSL_METHOD *meth;
+/** Used to change an SSL_CTXs default SSL method type */
+int SSL_CTX_set_ssl_version(SSL_CTX *ctx,SSL_METHOD *meth)
         {
-        STACK *sk;
+        STACK_OF(SSL_CIPHER) *sk;
 
         ctx->method=meth;
 
         sk=ssl_create_cipher_list(ctx->method,&(ctx->cipher_list),
                 &(ctx->cipher_list_by_id),SSL_DEFAULT_CIPHER_LIST);
-        if ((sk == NULL) || (sk_num(sk) <= 0))
+        if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= 0))
                 {
                 SSLerr(SSL_F_SSL_CTX_SET_SSL_VERSION,SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
                 return(0);
@@ -141,8 +221,7 @@ SSL_METHOD *meth;
         return(1);
         }
 
-SSL *SSL_new(ctx)
-SSL_CTX *ctx;
+SSL *SSL_new(SSL_CTX *ctx)
         {
         SSL *s;
 
@@ -157,20 +236,50 @@ SSL_CTX *ctx;
                 return(NULL);
                 }
 
-        s=(SSL *)Malloc(sizeof(SSL));
+        s=(SSL *)OPENSSL_malloc(sizeof(SSL));
         if (s == NULL) goto err;
         memset(s,0,sizeof(SSL));
 
-        if (ctx->default_cert != NULL)
-                {
-                CRYPTO_add(&ctx->default_cert->references,1,
-                        CRYPTO_LOCK_SSL_CERT);
-                s->cert=ctx->default_cert;
+#ifndef OPENSSL_NO_KRB5
+        s->kssl_ctx = kssl_ctx_new();
+#endif  /* OPENSSL_NO_KRB5 */
+
+        s->options=ctx->options;
+        s->mode=ctx->mode;
+        s->max_cert_list=ctx->max_cert_list;
+
+        if (ctx->cert != NULL)
+                {
+                /* Earlier library versions used to copy the pointer to
+                 * the CERT, not its contents; only when setting new
+                 * parameters for the per-SSL copy, ssl_cert_new would be
+                 * called (and the direct reference to the per-SSL_CTX
+                 * settings would be lost, but those still were indirectly
+                 * accessed for various purposes, and for that reason they
+                 * used to be known as s->ctx->default_cert).
+                 * Now we don't look at the SSL_CTX's CERT after having
+                 * duplicated it once. */
+
+                s->cert = ssl_cert_dup(ctx->cert);
+                if (s->cert == NULL)
+                        goto err;
                 }
         else
-                s->cert=NULL;
-        s->verify_mode=ctx->default_verify_mode;
+                s->cert=NULL; /* Cannot really happen (see SSL_CTX_new) */
+
+        s->read_ahead=ctx->read_ahead;
+        s->msg_callback=ctx->msg_callback;
+        s->msg_callback_arg=ctx->msg_callback_arg;
+        s->verify_mode=ctx->verify_mode;
+        s->verify_depth=ctx->verify_depth;
+        s->sid_ctx_length=ctx->sid_ctx_length;
+        memcpy(&s->sid_ctx,&ctx->sid_ctx,sizeof(s->sid_ctx));
         s->verify_callback=ctx->default_verify_callback;
+        s->generate_session_id=ctx->generate_session_id;
+        s->purpose = ctx->purpose;
+        s->trust = ctx->trust;
+        s->quiet_shutdown=ctx->quiet_shutdown;
+
         CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
         s->ctx=ctx;
 
@@ -179,30 +288,130 @@ SSL_CTX *ctx;
         s->method=ctx->method;
 
         if (!s->method->ssl_new(s))
-                {
-                SSL_CTX_free(ctx);
-                Free(s);
                 goto err;
-                }
 
-        s->quiet_shutdown=ctx->quiet_shutdown;
         s->references=1;
-        s->options=ctx->options;
+        s->server=(ctx->method->ssl_accept == ssl_undefined_function)?0:1;
+
         SSL_clear(s);
 
-        CRYPTO_new_ex_data(ssl_meth,(char *)s,&s->ex_data);
+        CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
 
         return(s);
 err:
+        if (s != NULL)
+                {
+                if (s->cert != NULL)
+                        ssl_cert_free(s->cert);
+                if (s->ctx != NULL)
+                        SSL_CTX_free(s->ctx); /* decrement reference count */
+                OPENSSL_free(s);
+                }
         SSLerr(SSL_F_SSL_NEW,ERR_R_MALLOC_FAILURE);
         return(NULL);
         }
 
-void SSL_free(s)
-SSL *s;
+int SSL_CTX_set_session_id_context(SSL_CTX *ctx,const unsigned char *sid_ctx,
+                                   unsigned int sid_ctx_len)
+    {
+    if(sid_ctx_len > SSL_MAX_SID_CTX_LENGTH)
+        {
+        SSLerr(SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT,SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
+        return 0;
+        }
+    ctx->sid_ctx_length=sid_ctx_len;
+    memcpy(ctx->sid_ctx,sid_ctx,sid_ctx_len);
+
+    return 1;
+    }
+
+int SSL_set_session_id_context(SSL *ssl,const unsigned char *sid_ctx,
+                               unsigned int sid_ctx_len)
+    {
+    if(sid_ctx_len > SSL_MAX_SID_CTX_LENGTH)
+        {
+        SSLerr(SSL_F_SSL_SET_SESSION_ID_CONTEXT,SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
+        return 0;
+        }
+    ssl->sid_ctx_length=sid_ctx_len;
+    memcpy(ssl->sid_ctx,sid_ctx,sid_ctx_len);
+
+    return 1;
+    }
+
+int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb)
+        {
+        CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
+        ctx->generate_session_id = cb;
+        CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
+        return 1;
+        }
+
+int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
+        {
+        CRYPTO_w_lock(CRYPTO_LOCK_SSL);
+        ssl->generate_session_id = cb;
+        CRYPTO_w_unlock(CRYPTO_LOCK_SSL);
+        return 1;
+        }
+
+int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
+                                unsigned int id_len)
+        {
+        /* A quick examination of SSL_SESSION_hash and SSL_SESSION_cmp shows how
+         * we can "construct" a session to give us the desired check - ie. to
+         * find if there's a session in the hash table that would conflict with
+         * any new session built out of this id/id_len and the ssl_version in
+         * use by this SSL. */
+        SSL_SESSION r, *p;
+        r.ssl_version = ssl->version;
+        r.session_id_length = id_len;
+        memcpy(r.session_id, id, id_len);
+        /* NB: SSLv2 always uses a fixed 16-byte session ID, so even if a
+         * callback is calling us to check the uniqueness of a shorter ID, it
+         * must be compared as a padded-out ID because that is what it will be
+         * converted to when the callback has finished choosing it. */
+        if((r.ssl_version == SSL2_VERSION) &&
+                        (id_len < SSL2_SSL_SESSION_ID_LENGTH))
+                {
+                memset(r.session_id + id_len, 0,
+                        SSL2_SSL_SESSION_ID_LENGTH - id_len);
+                r.session_id_length = SSL2_SSL_SESSION_ID_LENGTH;
+                }
+
+        CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
+        p = (SSL_SESSION *)lh_retrieve(ssl->ctx->sessions, &r);
+        CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
+        return (p != NULL);
+        }
+
+int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
+        {
+        return X509_PURPOSE_set(&s->purpose, purpose);
+        }
+
+int SSL_set_purpose(SSL *s, int purpose)
+        {
+        return X509_PURPOSE_set(&s->purpose, purpose);
+        }
+
+int SSL_CTX_set_trust(SSL_CTX *s, int trust)
+        {
+        return X509_TRUST_set(&s->trust, trust);
+        }
+
+int SSL_set_trust(SSL *s, int trust)
+        {
+        return X509_TRUST_set(&s->trust, trust);
+        }
+
+void SSL_free(SSL *s)
         {
         int i;
 
+        if(s == NULL)
+            return;
+
         i=CRYPTO_add(&s->references,-1,CRYPTO_LOCK_SSL);
 #ifdef REF_PRINT
         REF_PRINT("SSL",s);
@@ -216,7 +425,7 @@ SSL *s;
                 }
 #endif
 
-        CRYPTO_free_ex_data(ssl_meth,(char *)s,&s->ex_data);
+        CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
 
         if (s->bbio != NULL)
                 {
@@ -236,8 +445,8 @@ SSL *s;
         if (s->init_buf != NULL) BUF_MEM_free(s->init_buf);
 
         /* add extra stuff */
-        if (s->cipher_list != NULL) sk_free(s->cipher_list);
-        if (s->cipher_list_by_id != NULL) sk_free(s->cipher_list_by_id);
+        if (s->cipher_list != NULL) sk_SSL_CIPHER_free(s->cipher_list);
+        if (s->cipher_list_by_id != NULL) sk_SSL_CIPHER_free(s->cipher_list_by_id);
 
         /* Make the next call work :-) */
         if (s->session != NULL)
@@ -254,17 +463,14 @@ SSL *s;
         if (s->ctx) SSL_CTX_free(s->ctx);
 
         if (s->client_CA != NULL)
-                sk_pop_free(s->client_CA,X509_NAME_free);
+                sk_X509_NAME_pop_free(s->client_CA,X509_NAME_free);
 
         if (s->method != NULL) s->method->ssl_free(s);
 
-        Free((char *)s);
+        OPENSSL_free(s);
         }
 
-void SSL_set_bio(s, rbio,wbio)
-SSL *s;
-BIO *rbio;
-BIO *wbio;
+void SSL_set_bio(SSL *s,BIO *rbio,BIO *wbio)
         {
         /* If the output buffering BIO is still in place, remove it
          */
@@ -284,16 +490,18 @@ BIO *wbio;
         s->wbio=wbio;
         }
 
-BIO *SSL_get_rbio(s)
-SSL *s;
+BIO *SSL_get_rbio(SSL *s)
         { return(s->rbio); }
 
-BIO *SSL_get_wbio(s)
-SSL *s;
+BIO *SSL_get_wbio(SSL *s)
         { return(s->wbio); }
 
-int SSL_get_fd(s)
-SSL *s;
+int SSL_get_fd(SSL *s)
+        {
+        return(SSL_get_rfd(s));
+        }
+
+int SSL_get_rfd(SSL *s)
         {
         int ret= -1;
         BIO *b,*r;
@@ -305,10 +513,20 @@ SSL *s;
         return(ret);
         }
 
-#ifndef NO_SOCK
-int SSL_set_fd(s, fd)
-SSL *s;
-int fd;
+int SSL_get_wfd(SSL *s)
+        {
+        int ret= -1;
+        BIO *b,*r;
+
+        b=SSL_get_wbio(s);
+        r=BIO_find_type(b,BIO_TYPE_DESCRIPTOR);
+        if (r != NULL)
+                BIO_get_fd(r,&ret);
+        return(ret);
+        }
+
+#ifndef OPENSSL_NO_SOCK
+int SSL_set_fd(SSL *s,int fd)
         {
         int ret=0;
         BIO *bio=NULL;
@@ -327,9 +545,7 @@ err:
         return(ret);
         }
 
-int SSL_set_wfd(s, fd)
-SSL *s;
-int fd;
+int SSL_set_wfd(SSL *s,int fd)
         {
         int ret=0;
         BIO *bio=NULL;
@@ -351,9 +567,7 @@ err:
         return(ret);
         }
 
-int SSL_set_rfd(s, fd)
-SSL *s;
-int fd;
+int SSL_set_rfd(SSL *s,int fd)
         {
         int ret=0;
         BIO *bio=NULL;
@@ -379,61 +593,104 @@ err:
         }
 #endif
 
-int SSL_get_verify_mode(s)
-SSL *s;
+
+/* return length of latest Finished message we sent, copy to 'buf' */
+size_t SSL_get_finished(SSL *s, void *buf, size_t count)
+        {
+        size_t ret = 0;
+        
+        if (s->s3 != NULL)
+                {
+                ret = s->s3->tmp.finish_md_len;
+                if (count > ret)
+                        count = ret;
+                memcpy(buf, s->s3->tmp.finish_md, count);
+                }
+        return ret;
+        }
+
+/* return length of latest Finished message we expected, copy to 'buf' */
+size_t SSL_get_peer_finished(SSL *s, void *buf, size_t count)
+        {
+        size_t ret = 0;
+        
+        if (s->s3 != NULL)
+                {
+                ret = s->s3->tmp.peer_finish_md_len;
+                if (count > ret)
+                        count = ret;
+                memcpy(buf, s->s3->tmp.peer_finish_md, count);
+                }
+        return ret;
+        }
+
+
+int SSL_get_verify_mode(SSL *s)
         {
         return(s->verify_mode);
         }
 
-int (*SSL_get_verify_callback(s))()
-SSL *s;
+int SSL_get_verify_depth(SSL *s)
+        {
+        return(s->verify_depth);
+        }
+
+int (*SSL_get_verify_callback(SSL *s))(int,X509_STORE_CTX *)
         {
         return(s->verify_callback);
         }
 
-int SSL_CTX_get_verify_mode(ctx)
-SSL_CTX *ctx;
+int SSL_CTX_get_verify_mode(SSL_CTX *ctx)
         {
-        return(ctx->default_verify_mode);
+        return(ctx->verify_mode);
         }
 
-int (*SSL_CTX_get_verify_callback(ctx))()
-SSL_CTX *ctx;
+int SSL_CTX_get_verify_depth(SSL_CTX *ctx)
+        {
+        return(ctx->verify_depth);
+        }
+
+int (*SSL_CTX_get_verify_callback(SSL_CTX *ctx))(int,X509_STORE_CTX *)
         {
         return(ctx->default_verify_callback);
         }
 
-void SSL_set_verify(s, mode, callback)
-SSL *s;
-int mode;
-int (*callback)();
+void SSL_set_verify(SSL *s,int mode,
+                    int (*callback)(int ok,X509_STORE_CTX *ctx))
         {
         s->verify_mode=mode;
         if (callback != NULL)
                 s->verify_callback=callback;
         }
 
-void SSL_set_read_ahead(s, yes)
-SSL *s;
-int yes;
+void SSL_set_verify_depth(SSL *s,int depth)
+        {
+        s->verify_depth=depth;
+        }
+
+void SSL_set_read_ahead(SSL *s,int yes)
         {
         s->read_ahead=yes;
         }
 
-int SSL_get_read_ahead(s)
-SSL *s;
+int SSL_get_read_ahead(SSL *s)
         {
         return(s->read_ahead);
         }
 
-int SSL_pending(s)
-SSL *s;
+int SSL_pending(SSL *s)
         {
+        /* SSL_pending cannot work properly if read-ahead is enabled
+         * (SSL_[CTX_]ctrl(..., SSL_CTRL_SET_READ_AHEAD, 1, NULL)),
+         * and it is impossible to fix since SSL_pending cannot report
+         * errors that may be observed while scanning the new data.
+         * (Note that SSL_pending() is often used as a boolean value,
+         * so we'd better not return -1.)
+         */
         return(s->method->ssl_pending(s));
         }
 
-X509 *SSL_get_peer_certificate(s)
-SSL *s;
+X509 *SSL_get_peer_certificate(SSL *s)
         {
         X509 *r;
         
@@ -449,23 +706,24 @@ SSL *s;
         return(r);
         }
 
-STACK *SSL_get_peer_cert_chain(s)
-SSL *s;
+STACK_OF(X509) *SSL_get_peer_cert_chain(SSL *s)
         {
-        STACK *r;
+        STACK_OF(X509) *r;
         
-        if ((s == NULL) || (s->session == NULL) || (s->session->cert == NULL))
+        if ((s == NULL) || (s->session == NULL) || (s->session->sess_cert == NULL))
                 r=NULL;
         else
-                r=s->session->cert->cert_chain;
+                r=s->session->sess_cert->cert_chain;
 
+        /* If we are a client, cert_chain includes the peer's own
+         * certificate; if we are a server, it does not. */
+        
         return(r);
         }
 
 /* Now in theory, since the calling process own 't' it should be safe to
  * modify.  We need to be able to read f without being hassled */
-void SSL_copy_session_id(t,f)
-SSL *t,*f;
+void SSL_copy_session_id(SSL *t,SSL *f)
         {
         CERT *tmp;
 
@@ -490,30 +748,29 @@ SSL *t,*f;
         else
                 t->cert=NULL;
         if (tmp != NULL) ssl_cert_free(tmp);
+        SSL_set_session_id_context(t,f->sid_ctx,f->sid_ctx_length);
         }
 
 /* Fix this so it checks all the valid key/cert options */
-int SSL_CTX_check_private_key(ctx)
-SSL_CTX *ctx;
+int SSL_CTX_check_private_key(SSL_CTX *ctx)
         {
         if (    (ctx == NULL) ||
-                (ctx->default_cert == NULL) ||
-                (ctx->default_cert->key->x509 == NULL))
+                (ctx->cert == NULL) ||
+                (ctx->cert->key->x509 == NULL))
                 {
                 SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
                 return(0);
                 }
-        if      (ctx->default_cert->key->privatekey == NULL)
+        if      (ctx->cert->key->privatekey == NULL)
                 {
                 SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,SSL_R_NO_PRIVATE_KEY_ASSIGNED);
                 return(0);
                 }
-        return(X509_check_private_key(ctx->default_cert->key->x509, ctx->default_cert->key->privatekey));
+        return(X509_check_private_key(ctx->cert->key->x509, ctx->cert->key->privatekey));
         }
 
 /* Fix this function so that it takes an optional type parameter */
-int SSL_check_private_key(ssl)
-SSL *ssl;
+int SSL_check_private_key(SSL *ssl)
         {
         if (ssl == NULL)
                 {
@@ -521,7 +778,10 @@ SSL *ssl;
                 return(0);
                 }
         if (ssl->cert == NULL)
-                return(SSL_CTX_check_private_key(ssl->ctx));
+                {
+                SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
+                return 0;
+                }
         if (ssl->cert->key->x509 == NULL)
                 {
                 SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
@@ -536,29 +796,37 @@ SSL *ssl;
                 ssl->cert->key->privatekey));
         }
 
-int SSL_accept(s)
-SSL *s;
+int SSL_accept(SSL *s)
         {
+        if (s->handshake_func == 0)
+                /* Not properly initialized yet */
+                SSL_set_accept_state(s);
+
         return(s->method->ssl_accept(s));
         }
 
-int SSL_connect(s)
-SSL *s;
+int SSL_connect(SSL *s)
         {
+        if (s->handshake_func == 0)
+                /* Not properly initialized yet */
+                SSL_set_connect_state(s);
+
         return(s->method->ssl_connect(s));
         }
 
-long SSL_get_default_timeout(s)
-SSL *s;
+long SSL_get_default_timeout(SSL *s)
         {
         return(s->method->get_timeout());
         }
 
-int SSL_read(s,buf,num)
-SSL *s;
-char *buf;
-int num;
+int SSL_read(SSL *s,void *buf,int num)
         {
+        if (s->handshake_func == 0)
+                {
+                SSLerr(SSL_F_SSL_READ, SSL_R_UNINITIALIZED);
+                return -1;
+                }
+
         if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
                 {
                 s->rwstate=SSL_NOTHING;
@@ -567,11 +835,14 @@ int num;
         return(s->method->ssl_read(s,buf,num));
         }
 
-int SSL_peek(s,buf,num)
-SSL *s;
-char *buf;
-int num;
+int SSL_peek(SSL *s,void *buf,int num)
         {
+        if (s->handshake_func == 0)
+                {
+                SSLerr(SSL_F_SSL_READ, SSL_R_UNINITIALIZED);
+                return -1;
+                }
+
         if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
                 {
                 return(0);
@@ -579,11 +850,14 @@ int num;
         return(s->method->ssl_peek(s,buf,num));
         }
 
-int SSL_write(s,buf,num)
-SSL *s;
-char *buf;
-int num;
+int SSL_write(SSL *s,const void *buf,int num)
         {
+        if (s->handshake_func == 0)
+                {
+                SSLerr(SSL_F_SSL_WRITE, SSL_R_UNINITIALIZED);
+                return -1;
+                }
+
         if (s->shutdown & SSL_SENT_SHUTDOWN)
                 {
                 s->rwstate=SSL_NOTHING;
@@ -593,42 +867,176 @@ int num;
         return(s->method->ssl_write(s,buf,num));
         }
 
-int SSL_shutdown(s)
-SSL *s;
+int SSL_shutdown(SSL *s)
         {
+        /* Note that this function behaves differently from what one might
+         * expect.  Return values are 0 for no success (yet),
+         * 1 for success; but calling it once is usually not enough,
+         * even if blocking I/O is used (see ssl3_shutdown).
+         */
+
+        if (s->handshake_func == 0)
+                {
+                SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_UNINITIALIZED);
+                return -1;
+                }
+
         if ((s != NULL) && !SSL_in_init(s))
                 return(s->method->ssl_shutdown(s));
         else
                 return(1);
         }
 
-int SSL_renegotiate(s)
-SSL *s;
+int SSL_renegotiate(SSL *s)
         {
-        s->new_session=1;
+        if (s->new_session == 0)
+                {
+                s->new_session=1;
+                }
         return(s->method->ssl_renegotiate(s));
         }
 
-long SSL_ctrl(s,cmd,larg,parg)
-SSL *s;
-int cmd;
-long larg;
-char *parg;
+int SSL_renegotiate_pending(SSL *s)
+        {
+        /* becomes true when negotiation is requested;
+         * false again once a handshake has finished */
+        return (s->new_session != 0);
+        }
+
+long SSL_ctrl(SSL *s,int cmd,long larg,void *parg)
         {
-        return(s->method->ssl_ctrl(s,cmd,larg,parg));
+        long l;
+
+        switch (cmd)
+                {
+        case SSL_CTRL_GET_READ_AHEAD:
+                return(s->read_ahead);
+        case SSL_CTRL_SET_READ_AHEAD:
+                l=s->read_ahead;
+                s->read_ahead=larg;
+                return(l);
+
+        case SSL_CTRL_SET_MSG_CALLBACK_ARG:
+                s->msg_callback_arg = parg;
+                return 1;
+
+        case SSL_CTRL_OPTIONS:
+                return(s->options|=larg);
+        case SSL_CTRL_MODE:
+                return(s->mode|=larg);
+        case SSL_CTRL_GET_MAX_CERT_LIST:
+                return(s->max_cert_list);
+        case SSL_CTRL_SET_MAX_CERT_LIST:
+                l=s->max_cert_list;
+                s->max_cert_list=larg;
+                return(l);
+        default:
+                return(s->method->ssl_ctrl(s,cmd,larg,parg));
+                }
+        }
+
+long SSL_callback_ctrl(SSL *s, int cmd, void (*fp)())
+        {
+        switch(cmd)
+                {
+        case SSL_CTRL_SET_MSG_CALLBACK:
+                s->msg_callback = (void (*)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))(fp);
+                return 1;
+                
+        default:
+                return(s->method->ssl_callback_ctrl(s,cmd,fp));
+                }
         }
 
-long SSL_CTX_ctrl(ctx,cmd,larg,parg)
-SSL_CTX *ctx;
-int cmd;
-long larg;
-char *parg;
+struct lhash_st *SSL_CTX_sessions(SSL_CTX *ctx)
         {
-        return(ctx->method->ssl_ctx_ctrl(ctx,cmd,larg,parg));
+        return ctx->sessions;
         }
 
-int ssl_cipher_id_cmp(a,b)
-SSL_CIPHER *a,*b;
+long SSL_CTX_ctrl(SSL_CTX *ctx,int cmd,long larg,void *parg)
+        {
+        long l;
+
+        switch (cmd)
+                {
+        case SSL_CTRL_GET_READ_AHEAD:
+                return(ctx->read_ahead);
+        case SSL_CTRL_SET_READ_AHEAD:
+                l=ctx->read_ahead;
+                ctx->read_ahead=larg;
+                return(l);
+                
+        case SSL_CTRL_SET_MSG_CALLBACK_ARG:
+                ctx->msg_callback_arg = parg;
+                return 1;
+
+        case SSL_CTRL_GET_MAX_CERT_LIST:
+                return(ctx->max_cert_list);
+        case SSL_CTRL_SET_MAX_CERT_LIST:
+                l=ctx->max_cert_list;
+                ctx->max_cert_list=larg;
+                return(l);
+
+        case SSL_CTRL_SET_SESS_CACHE_SIZE:
+                l=ctx->session_cache_size;
+                ctx->session_cache_size=larg;
+                return(l);
+        case SSL_CTRL_GET_SESS_CACHE_SIZE:
+                return(ctx->session_cache_size);
+        case SSL_CTRL_SET_SESS_CACHE_MODE:
+                l=ctx->session_cache_mode;
+                ctx->session_cache_mode=larg;
+                return(l);
+        case SSL_CTRL_GET_SESS_CACHE_MODE:
+                return(ctx->session_cache_mode);
+
+        case SSL_CTRL_SESS_NUMBER:
+                return(ctx->sessions->num_items);
+        case SSL_CTRL_SESS_CONNECT:
+                return(ctx->stats.sess_connect);
+        case SSL_CTRL_SESS_CONNECT_GOOD:
+                return(ctx->stats.sess_connect_good);
+        case SSL_CTRL_SESS_CONNECT_RENEGOTIATE:
+                return(ctx->stats.sess_connect_renegotiate);
+        case SSL_CTRL_SESS_ACCEPT:
+                return(ctx->stats.sess_accept);
+        case SSL_CTRL_SESS_ACCEPT_GOOD:
+                return(ctx->stats.sess_accept_good);
+        case SSL_CTRL_SESS_ACCEPT_RENEGOTIATE:
+                return(ctx->stats.sess_accept_renegotiate);
+        case SSL_CTRL_SESS_HIT:
+                return(ctx->stats.sess_hit);
+        case SSL_CTRL_SESS_CB_HIT:
+                return(ctx->stats.sess_cb_hit);
+        case SSL_CTRL_SESS_MISSES:
+                return(ctx->stats.sess_miss);
+        case SSL_CTRL_SESS_TIMEOUTS:
+                return(ctx->stats.sess_timeout);
+        case SSL_CTRL_SESS_CACHE_FULL:
+                return(ctx->stats.sess_cache_full);
+        case SSL_CTRL_OPTIONS:
+                return(ctx->options|=larg);
+        case SSL_CTRL_MODE:
+                return(ctx->mode|=larg);
+        default:
+                return(ctx->method->ssl_ctx_ctrl(ctx,cmd,larg,parg));
+                }
+        }
+
+long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)())
+        {
+        switch(cmd)
+                {
+        case SSL_CTRL_SET_MSG_CALLBACK:
+                ctx->msg_callback = (void (*)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))(fp);
+                return 1;
+
+        default:
+                return(ctx->method->ssl_ctx_callback_ctrl(ctx,cmd,fp));
+                }
+        }
+
+int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
         {
         long l;
 
@@ -639,8 +1047,8 @@ SSL_CIPHER *a,*b;
                 return((l > 0)?1:-1);
         }
 
-int ssl_cipher_ptr_id_cmp(ap,bp)
-SSL_CIPHER **ap,**bp;
+int ssl_cipher_ptr_id_cmp(const SSL_CIPHER * const *ap,
+                        const SSL_CIPHER * const *bp)
         {
         long l;
 
@@ -651,10 +1059,9 @@ SSL_CIPHER **ap,**bp;
                 return((l > 0)?1:-1);
         }
 
-/* return a STACK of the ciphers available for the SSL and in order of
+/** return a STACK of the ciphers available for the SSL and in order of
  * preference */
-STACK *SSL_get_ciphers(s)
-SSL *s;
+STACK_OF(SSL_CIPHER) *SSL_get_ciphers(SSL *s)
         {
         if ((s != NULL) && (s->cipher_list != NULL))
                 {
@@ -668,10 +1075,9 @@ SSL *s;
         return(NULL);
         }
 
-/* return a STACK of the ciphers available for the SSL and in order of
+/** return a STACK of the ciphers available for the SSL and in order of
  * algorithm id */
-STACK *ssl_get_ciphers_by_id(s)
-SSL *s;
+STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s)
         {
         if ((s != NULL) && (s->cipher_list_by_id != NULL))
                 {
@@ -685,29 +1091,25 @@ SSL *s;
         return(NULL);
         }
 
-/* The old interface to get the same thing as SSL_get_ciphers() */
-char *SSL_get_cipher_list(s,n)
-SSL *s;
-int n;
+/** The old interface to get the same thing as SSL_get_ciphers() */
+const char *SSL_get_cipher_list(SSL *s,int n)
         {
         SSL_CIPHER *c;
-        STACK *sk;
+        STACK_OF(SSL_CIPHER) *sk;
 
         if (s == NULL) return(NULL);
         sk=SSL_get_ciphers(s);
-        if ((sk == NULL) || (sk_num(sk) <= n))
+        if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= n))
                 return(NULL);
-        c=(SSL_CIPHER *)sk_value(sk,n);
+        c=sk_SSL_CIPHER_value(sk,n);
         if (c == NULL) return(NULL);
         return(c->name);
         }
 
-/* specify the ciphers to be used by defaut by the SSL_CTX */
-int SSL_CTX_set_cipher_list(ctx,str)
-SSL_CTX *ctx;
-char *str;
+/** specify the ciphers to be used by default by the SSL_CTX */
+int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
         {
-        STACK *sk;
+        STACK_OF(SSL_CIPHER) *sk;
         
         sk=ssl_create_cipher_list(ctx->method,&ctx->cipher_list,
                 &ctx->cipher_list_by_id,str);
@@ -715,12 +1117,10 @@ char *str;
         return((sk == NULL)?0:1);
         }
 
-/* specify the ciphers to be used by the SSL */
-int SSL_set_cipher_list(s, str)
-SSL *s;
-char *str;
+/** specify the ciphers to be used by the SSL */
+int SSL_set_cipher_list(SSL *s,const char *str)
         {
-        STACK *sk;
+        STACK_OF(SSL_CIPHER) *sk;
         
         sk=ssl_create_cipher_list(s->ctx->method,&s->cipher_list,
                 &s->cipher_list_by_id,str);
@@ -729,13 +1129,11 @@ char *str;
         }
 
 /* works well for SSLv2, not so good for SSLv3 */
-char *SSL_get_shared_ciphers(s,buf,len)
-SSL *s;
-char *buf;
-int len;
+char *SSL_get_shared_ciphers(SSL *s,char *buf,int len)
         {
-        char *p,*cp;
-        STACK *sk;
+        char *p;
+        const char *cp;
+        STACK_OF(SSL_CIPHER) *sk;
         SSL_CIPHER *c;
         int i;
 
@@ -745,11 +1143,11 @@ int len;
 
         p=buf;
         sk=s->session->ciphers;
-        for (i=0; i<sk_num(sk); i++)
+        for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
                 {
                 /* Decrement for either the ':' or a '\0' */
                 len--;
-                c=(SSL_CIPHER *)sk_value(sk,i);
+                c=sk_SSL_CIPHER_value(sk,i);
                 for (cp=c->name; *cp; )
                         {
                         if (len-- == 0)
@@ -766,35 +1164,36 @@ int len;
         return(buf);
         }
 
-int ssl_cipher_list_to_bytes(s,sk,p)
-SSL *s;
-STACK *sk;
-unsigned char *p;
+int ssl_cipher_list_to_bytes(SSL *s,STACK_OF(SSL_CIPHER) *sk,unsigned char *p)
         {
         int i,j=0;
         SSL_CIPHER *c;
         unsigned char *q;
+#ifndef OPENSSL_NO_KRB5
+        int nokrb5 = !kssl_tgt_is_available(s->kssl_ctx);
+#endif /* OPENSSL_NO_KRB5 */
 
         if (sk == NULL) return(0);
         q=p;
 
-        for (i=0; i<sk_num(sk); i++)
+        for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
                 {
-                c=(SSL_CIPHER *)sk_value(sk,i);
+                c=sk_SSL_CIPHER_value(sk,i);
+#ifndef OPENSSL_NO_KRB5
+                if ((c->algorithms & SSL_KRB5) && nokrb5)
+                    continue;
+#endif /* OPENSSL_NO_KRB5 */                    
                 j=ssl_put_cipher_by_char(s,c,p);
                 p+=j;
                 }
         return(p-q);
         }
 
-STACK *ssl_bytes_to_cipher_list(s,p,num,skp)
-SSL *s;
-unsigned char *p;
-int num;
-STACK **skp;
+STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,unsigned char *p,int num,
+                                               STACK_OF(SSL_CIPHER) **skp)
         {
         SSL_CIPHER *c;
-        STACK *sk;
+        STACK_OF(SSL_CIPHER) *sk;
         int i,n;
 
         n=ssl_put_cipher_by_char(s,NULL,NULL);
@@ -804,11 +1203,11 @@ STACK **skp;
                 return(NULL);
                 }
         if ((skp == NULL) || (*skp == NULL))
-                sk=sk_new(NULL); /* change perhaps later */
+                sk=sk_SSL_CIPHER_new_null(); /* change perhaps later */
         else
                 {
                 sk= *skp;
-                sk_zero(sk);
+                sk_SSL_CIPHER_zero(sk);
                 }
 
         for (i=0; i<num; i+=n)
@@ -817,7 +1216,7 @@ STACK **skp;
                 p+=n;
                 if (c != NULL)
                         {
-                        if (!sk_push(sk,(char *)c))
+                        if (!sk_SSL_CIPHER_push(sk,c))
                                 {
                                 SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,ERR_R_MALLOC_FAILURE);
                                 goto err;
@@ -830,23 +1229,28 @@ STACK **skp;
         return(sk);
 err:
         if ((skp == NULL) || (*skp == NULL))
-                sk_free(sk);
+                sk_SSL_CIPHER_free(sk);
         return(NULL);
         }
 
-unsigned long SSL_SESSION_hash(a)
-SSL_SESSION *a;
+unsigned long SSL_SESSION_hash(SSL_SESSION *a)
         {
         unsigned long l;
 
-        l=      (a->session_id[0]     )|(a->session_id[1]<< 8L)|
-                (a->session_id[2]<<16L)|(a->session_id[3]<<24L);
+        l=(unsigned long)
+                ((unsigned int) a->session_id[0]     )|
+                ((unsigned int) a->session_id[1]<< 8L)|
+                ((unsigned long)a->session_id[2]<<16L)|
+                ((unsigned long)a->session_id[3]<<24L);
         return(l);
         }
 
-int SSL_SESSION_cmp(a, b)
-SSL_SESSION *a;
-SSL_SESSION *b;
+/* NB: If this function (or indeed the hash function which uses a sort of
+ * coarser function than this one) is changed, ensure
+ * SSL_CTX_has_matching_session_id() is checked accordingly. It relies on being
+ * able to construct an SSL_SESSION that will collide with any existing session
+ * with a matching session ID. */
+int SSL_SESSION_cmp(SSL_SESSION *a,SSL_SESSION *b)
         {
         if (a->ssl_version != b->ssl_version)
                 return(1);
@@ -855,17 +1259,29 @@ SSL_SESSION *b;
         return(memcmp(a->session_id,b->session_id,a->session_id_length));
         }
 
-SSL_CTX *SSL_CTX_new(meth)
-SSL_METHOD *meth;
+/* These wrapper functions should remain rather than redeclaring
+ * SSL_SESSION_hash and SSL_SESSION_cmp for void* types and casting each
+ * variable. The reason is that the functions aren't static, they're exposed via
+ * ssl.h. */
+static IMPLEMENT_LHASH_HASH_FN(SSL_SESSION_hash, SSL_SESSION *)
+static IMPLEMENT_LHASH_COMP_FN(SSL_SESSION_cmp, SSL_SESSION *)
+
+SSL_CTX *SSL_CTX_new(SSL_METHOD *meth)
         {
-        SSL_CTX *ret;
+        SSL_CTX *ret=NULL;
         
         if (meth == NULL)
                 {
                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_NULL_SSL_METHOD_PASSED);
                 return(NULL);
                 }
-        ret=(SSL_CTX *)Malloc(sizeof(SSL_CTX));
+
+        if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0)
+                {
+                SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
+                goto err;
+                }
+        ret=(SSL_CTX *)OPENSSL_malloc(sizeof(SSL_CTX));
         if (ret == NULL)
                 goto err;
 
@@ -882,21 +1298,12 @@ SSL_METHOD *meth;
         /* We take the system default */
         ret->session_timeout=meth->get_timeout();
 
-        ret->new_session_cb=NULL;
-        ret->remove_session_cb=NULL;
-        ret->get_session_cb=NULL;
-
-        ret->sess_connect=0;
-        ret->sess_connect_good=0;
-        ret->sess_accept=0;
-        ret->sess_accept_renegotiate=0;
-        ret->sess_connect_renegotiate=0;
-        ret->sess_accept_good=0;
-        ret->sess_miss=0;
-        ret->sess_timeout=0;
-        ret->sess_cache_full=0;
-        ret->sess_hit=0;
-        ret->sess_cb_hit=0;
+        ret->new_session_cb=0;
+        ret->remove_session_cb=0;
+        ret->get_session_cb=0;
+        ret->generate_session_id=0;
+
+        memset((char *)&ret->stats,0,sizeof(ret->stats));
 
         ret->references=1;
         ret->quiet_shutdown=0;
@@ -909,19 +1316,26 @@ SSL_METHOD *meth;
 
         ret->info_callback=NULL;
 
-        ret->app_verify_callback=NULL;
+        ret->app_verify_callback=0;
         ret->app_verify_arg=NULL;
 
-        ret->default_read_ahead=0;
-        ret->default_verify_mode=SSL_VERIFY_NONE;
+        ret->max_cert_list=SSL_MAX_CERT_LIST_DEFAULT;
+        ret->read_ahead=0;
+        ret->msg_callback=0;
+        ret->msg_callback_arg=NULL;
+        ret->verify_mode=SSL_VERIFY_NONE;
+        ret->verify_depth=-1; /* Don't impose a limit (but x509_lu.c does) */
+        ret->sid_ctx_length=0;
         ret->default_verify_callback=NULL;
-        if ((ret->default_cert=ssl_cert_new()) == NULL)
+        if ((ret->cert=ssl_cert_new()) == NULL)
                 goto err;
 
-        ret->default_passwd_callback=NULL;
-        ret->client_cert_cb=NULL;
+        ret->default_passwd_callback=0;
+        ret->default_passwd_callback_userdata=NULL;
+        ret->client_cert_cb=0;
 
-        ret->sessions=lh_new(SSL_SESSION_hash,SSL_SESSION_cmp);
+        ret->sessions=lh_new(LHASH_HASH_FN(SSL_SESSION_hash),
+                        LHASH_COMP_FN(SSL_SESSION_cmp));
         if (ret->sessions == NULL) goto err;
         ret->cert_store=X509_STORE_new();
         if (ret->cert_store == NULL) goto err;
@@ -929,7 +1343,8 @@ SSL_METHOD *meth;
         ssl_create_cipher_list(ret->method,
                 &ret->cipher_list,&ret->cipher_list_by_id,
                 SSL_DEFAULT_CIPHER_LIST);
-        if ((ret->cipher_list == NULL) || (sk_num(ret->cipher_list) <= 0))
+        if (ret->cipher_list == NULL
+            || sk_SSL_CIPHER_num(ret->cipher_list) <= 0)
                 {
                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_LIBRARY_HAS_NO_CIPHERS);
                 goto err2;
@@ -951,10 +1366,13 @@ SSL_METHOD *meth;
                 goto err2;
                 }
 
-        if ((ret->client_CA=sk_new_null()) == NULL)
+        if ((ret->client_CA=sk_X509_NAME_new_null()) == NULL)
                 goto err;
 
-        CRYPTO_new_ex_data(ssl_ctx_meth,(char *)ret,&ret->ex_data);
+        CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data);
+
+        ret->extra_certs=NULL;
+        ret->comp_methods=SSL_COMP_get_compression_methods();
 
         return(ret);
 err:
@@ -964,8 +1382,12 @@ err2:
         return(NULL);
         }
 
-void SSL_CTX_free(a)
-SSL_CTX *a;
+#if 0
+static void SSL_COMP_free(SSL_COMP *comp)
+    { OPENSSL_free(comp); }
+#endif
+
+void SSL_CTX_free(SSL_CTX *a)
         {
         int i;
 
@@ -983,7 +1405,7 @@ SSL_CTX *a;
                 abort(); /* ok */
                 }
 #endif
-        CRYPTO_free_ex_data(ssl_ctx_meth,(char *)a,&a->ex_data);
+        CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, a, &a->ex_data);
 
         if (a->sessions != NULL)
                 {
@@ -993,96 +1415,105 @@ SSL_CTX *a;
         if (a->cert_store != NULL)
                 X509_STORE_free(a->cert_store);
         if (a->cipher_list != NULL)
-                sk_free(a->cipher_list);
+                sk_SSL_CIPHER_free(a->cipher_list);
         if (a->cipher_list_by_id != NULL)
-                sk_free(a->cipher_list_by_id);
-        if (a->default_cert != NULL)
-                ssl_cert_free(a->default_cert);
+                sk_SSL_CIPHER_free(a->cipher_list_by_id);
+        if (a->cert != NULL)
+                ssl_cert_free(a->cert);
         if (a->client_CA != NULL)
-                sk_pop_free(a->client_CA,X509_NAME_free);
-        Free((char *)a);
+                sk_X509_NAME_pop_free(a->client_CA,X509_NAME_free);
+        if (a->extra_certs != NULL)
+                sk_X509_pop_free(a->extra_certs,X509_free);
+#if 0 /* This should never be done, since it removes a global database */
+        if (a->comp_methods != NULL)
+                sk_SSL_COMP_pop_free(a->comp_methods,SSL_COMP_free);
+#else
+        a->comp_methods = NULL;
+#endif
+        OPENSSL_free(a);
         }
 
-void SSL_CTX_set_default_passwd_cb(ctx,cb)
-SSL_CTX *ctx;
-int (*cb)();
+void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
         {
         ctx->default_passwd_callback=cb;
         }
 
-void SSL_CTX_set_cert_verify_cb(ctx,cb,arg)
-SSL_CTX *ctx;
-int (*cb)();
-char *arg;
+void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx,void *u)
+        {
+        ctx->default_passwd_callback_userdata=u;
+        }
+
+void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx, int (*cb)(X509_STORE_CTX *,void *), void *arg)
         {
         ctx->app_verify_callback=cb;
         ctx->app_verify_arg=arg;
         }
 
-void SSL_CTX_set_verify(ctx,mode,cb)
-SSL_CTX *ctx;
-int mode;
-int (*cb)();
+void SSL_CTX_set_verify(SSL_CTX *ctx,int mode,int (*cb)(int, X509_STORE_CTX *))
         {
-        ctx->default_verify_mode=mode;
+        ctx->verify_mode=mode;
         ctx->default_verify_callback=cb;
-        /* This needs cleaning up EAY EAY EAY */
-        X509_STORE_set_verify_cb_func(ctx->cert_store,cb);
         }
 
-void ssl_set_cert_masks(c)
-CERT *c;
+void SSL_CTX_set_verify_depth(SSL_CTX *ctx,int depth)
+        {
+        ctx->verify_depth=depth;
+        }
+
+void ssl_set_cert_masks(CERT *c, SSL_CIPHER *cipher)
         {
         CERT_PKEY *cpk;
         int rsa_enc,rsa_tmp,rsa_sign,dh_tmp,dh_rsa,dh_dsa,dsa_sign;
         int rsa_enc_export,dh_rsa_export,dh_dsa_export;
-        int rsa_tmp_export,dh_tmp_export;
+        int rsa_tmp_export,dh_tmp_export,kl;
         unsigned long mask,emask;
 
-        if ((c == NULL) || (c->valid)) return;
+        if (c == NULL) return;
 
-#ifndef NO_RSA
-        rsa_tmp=((c->rsa_tmp != NULL) || (c->rsa_tmp_cb != NULL))?1:0;
-        rsa_tmp_export=((c->rsa_tmp_cb != NULL) ||
-                (rsa_tmp && (RSA_size(c->rsa_tmp)*8 <= 512)))?1:0;
+        kl=SSL_C_EXPORT_PKEYLENGTH(cipher);
+
+#ifndef OPENSSL_NO_RSA
+        rsa_tmp=(c->rsa_tmp != NULL || c->rsa_tmp_cb != NULL);
+        rsa_tmp_export=(c->rsa_tmp_cb != NULL ||
+                (rsa_tmp && RSA_size(c->rsa_tmp)*8 <= kl));
 #else
         rsa_tmp=rsa_tmp_export=0;
 #endif
-#ifndef NO_DH
-        dh_tmp=((c->dh_tmp != NULL) || (c->dh_tmp_cb != NULL))?1:0;
-        dh_tmp_export=((c->dh_tmp_cb != NULL) ||
-                (dh_tmp && (DH_size(c->dh_tmp)*8 <= 512)))?1:0;
+#ifndef OPENSSL_NO_DH
+        dh_tmp=(c->dh_tmp != NULL || c->dh_tmp_cb != NULL);
+        dh_tmp_export=(c->dh_tmp_cb != NULL ||
+                (dh_tmp && DH_size(c->dh_tmp)*8 <= kl));
 #else
         dh_tmp=dh_tmp_export=0;
 #endif
 
         cpk= &(c->pkeys[SSL_PKEY_RSA_ENC]);
-        rsa_enc= ((cpk->x509 != NULL) && (cpk->privatekey != NULL))?1:0;
-        rsa_enc_export=(rsa_enc && (EVP_PKEY_size(cpk->privatekey)*8 <= 512))?1:0;
+        rsa_enc= (cpk->x509 != NULL && cpk->privatekey != NULL);
+        rsa_enc_export=(rsa_enc && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
         cpk= &(c->pkeys[SSL_PKEY_RSA_SIGN]);
-        rsa_sign=((cpk->x509 != NULL) && (cpk->privatekey != NULL))?1:0;
+        rsa_sign=(cpk->x509 != NULL && cpk->privatekey != NULL);
         cpk= &(c->pkeys[SSL_PKEY_DSA_SIGN]);
-        dsa_sign=((cpk->x509 != NULL) && (cpk->privatekey != NULL))?1:0;
+        dsa_sign=(cpk->x509 != NULL && cpk->privatekey != NULL);
         cpk= &(c->pkeys[SSL_PKEY_DH_RSA]);
-        dh_rsa=  ((cpk->x509 != NULL) && (cpk->privatekey != NULL))?1:0;
-        dh_rsa_export=(dh_rsa && (EVP_PKEY_size(cpk->privatekey)*8 <= 512))?1:0;
+        dh_rsa=  (cpk->x509 != NULL && cpk->privatekey != NULL);
+        dh_rsa_export=(dh_rsa && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
         cpk= &(c->pkeys[SSL_PKEY_DH_DSA]);
 /* FIX THIS EAY EAY EAY */
-        dh_dsa=  ((cpk->x509 != NULL) && (cpk->privatekey != NULL))?1:0;
-        dh_dsa_export=(dh_dsa && (EVP_PKEY_size(cpk->privatekey)*8 <= 512))?1:0;
+        dh_dsa=  (cpk->x509 != NULL && cpk->privatekey != NULL);
+        dh_dsa_export=(dh_dsa && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
 
         mask=0;
         emask=0;
 
 #ifdef CIPHER_DEBUG
-        printf("rt=%d dht=%d re=%d rs=%d ds=%d dhr=%d dhd=%d\n",
-                rsa_tmp,dh_tmp,
-                rsa_enc,rsa_sign,dsa_sign,dh_rsa,dh_dsa);
+        printf("rt=%d rte=%d dht=%d re=%d ree=%d rs=%d ds=%d dhr=%d dhd=%d\n",
+                rsa_tmp,rsa_tmp_export,dh_tmp,
+                rsa_enc,rsa_enc_export,rsa_sign,dsa_sign,dh_rsa,dh_dsa);
 #endif
 
         if (rsa_enc || (rsa_tmp && rsa_sign))
                 mask|=SSL_kRSA;
-        if (rsa_enc_export || (rsa_tmp_export && rsa_sign))
+        if (rsa_enc_export || (rsa_tmp_export && (rsa_sign || rsa_enc)))
                 emask|=SSL_kRSA;
 
 #if 0
@@ -1119,9 +1550,12 @@ CERT *c;
                 emask|=SSL_aDSS;
                 }
 
-#ifdef SSL_ALLOW_ADH
         mask|=SSL_aNULL;
         emask|=SSL_aNULL;
+
+#ifndef OPENSSL_NO_KRB5
+        mask|=SSL_kKRB5|SSL_aKRB5;
+        emask|=SSL_kKRB5|SSL_aKRB5;
 #endif
 
         c->mask=mask;
@@ -1130,18 +1564,17 @@ CERT *c;
         }
 
 /* THIS NEEDS CLEANING UP */
-X509 *ssl_get_server_send_cert(s)
-SSL *s;
+X509 *ssl_get_server_send_cert(SSL *s)
         {
         unsigned long alg,mask,kalg;
         CERT *c;
-        int i,export;
+        int i,is_export;
 
         c=s->cert;
-        ssl_set_cert_masks(c);
+        ssl_set_cert_masks(c, s->s3->tmp.new_cipher);
         alg=s->s3->tmp.new_cipher->algorithms;
-        export=(alg & SSL_EXPORT)?1:0;
-        mask=(export)?c->export_mask:c->mask;
+        is_export=SSL_C_IS_EXPORT(s->s3->tmp.new_cipher);
+        mask=is_export?c->export_mask:c->mask;
         kalg=alg&(SSL_MKEY_MASK|SSL_AUTH_MASK);
 
         if      (kalg & SSL_kDHr)
@@ -1157,18 +1590,21 @@ SSL *s;
                 else
                         i=SSL_PKEY_RSA_ENC;
                 }
+        else if (kalg & SSL_aKRB5)
+                {
+                /* VRS something else here? */
+                return(NULL);
+                }
         else /* if (kalg & SSL_aNULL) */
                 {
-                SSLerr(SSL_F_SSL_GET_SERVER_SEND_CERT,SSL_R_INTERNAL_ERROR);
+                SSLerr(SSL_F_SSL_GET_SERVER_SEND_CERT,ERR_R_INTERNAL_ERROR);
                 return(NULL);
                 }
         if (c->pkeys[i].x509 == NULL) return(NULL);
         return(c->pkeys[i].x509);
         }
 
-EVP_PKEY *ssl_get_sign_pkey(s,cipher)
-SSL *s;
-SSL_CIPHER *cipher;
+EVP_PKEY *ssl_get_sign_pkey(SSL *s,SSL_CIPHER *cipher)
         {
         unsigned long alg;
         CERT *c;
@@ -1190,14 +1626,12 @@ SSL_CIPHER *cipher;
                 }
         else /* if (alg & SSL_aNULL) */
                 {
-                SSLerr(SSL_F_SSL_GET_SIGN_PKEY,SSL_R_INTERNAL_ERROR);
+                SSLerr(SSL_F_SSL_GET_SIGN_PKEY,ERR_R_INTERNAL_ERROR);
                 return(NULL);
                 }
         }
 
-void ssl_update_cache(s,mode)
-SSL *s;
-int mode;
+void ssl_update_cache(SSL *s,int mode)
         {
         int i;
 
@@ -1205,9 +1639,10 @@ int mode;
          * and it would be rather hard to do anyway :-) */
         if (s->session->session_id_length == 0) return;
 
-        if ((s->ctx->session_cache_mode & mode)
-                && (!s->hit)
-                && SSL_CTX_add_session(s->ctx,s->session)
+        i=s->ctx->session_cache_mode;
+        if ((i & mode) && (!s->hit)
+                && ((i & SSL_SESS_CACHE_NO_INTERNAL_LOOKUP)
+                    || SSL_CTX_add_session(s->ctx,s->session))
                 && (s->ctx->new_session_cb != NULL))
                 {
                 CRYPTO_add(&s->session->references,1,CRYPTO_LOCK_SSL_SESSION);
@@ -1216,28 +1651,24 @@ int mode;
                 }
 
         /* auto flush every 255 connections */
-        i=s->ctx->session_cache_mode;
         if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) &&
                 ((i & mode) == mode))
                 {
                 if (  (((mode & SSL_SESS_CACHE_CLIENT)
-                        ?s->ctx->sess_connect_good
-                        :s->ctx->sess_accept_good) & 0xff) == 0xff)
+                        ?s->ctx->stats.sess_connect_good
+                        :s->ctx->stats.sess_accept_good) & 0xff) == 0xff)
                         {
                         SSL_CTX_flush_sessions(s->ctx,time(NULL));
                         }
                 }
         }
 
-SSL_METHOD *SSL_get_ssl_method(s)
-SSL *s;
+SSL_METHOD *SSL_get_ssl_method(SSL *s)
         {
         return(s->method);
         }
 
-int SSL_set_ssl_method(s,meth)
-SSL *s;
-SSL_METHOD *meth;
+int SSL_set_ssl_method(SSL *s,SSL_METHOD *meth)
         {
         int conn= -1;
         int ret=1;
@@ -1264,17 +1695,23 @@ SSL_METHOD *meth;
         return(ret);
         }
 
-int SSL_get_error(s,i)
-SSL *s;
-int i;
+int SSL_get_error(SSL *s,int i)
         {
         int reason;
+        unsigned long l;
         BIO *bio;
 
         if (i > 0) return(SSL_ERROR_NONE);
 
-        if (ERR_peek_error() != 0)
-                return(SSL_ERROR_SSL);
+        /* Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake
+         * etc, where we do encode the error */
+        if ((l=ERR_peek_error()) != 0)
+                {
+                if (ERR_GET_LIB(l) == ERR_LIB_SYS)
+                        return(SSL_ERROR_SYSCALL);
+                else
+                        return(SSL_ERROR_SSL);
+                }
 
         if ((i < 0) && SSL_want_read(s))
                 {
@@ -1282,12 +1719,23 @@ int i;
                 if (BIO_should_read(bio))
                         return(SSL_ERROR_WANT_READ);
                 else if (BIO_should_write(bio))
+                        /* This one doesn't make too much sense ... We never try
+                         * to write to the rbio, and an application program where
+                         * rbio and wbio are separate couldn't even know what it
+                         * should wait for.
+                         * However if we ever set s->rwstate incorrectly
+                         * (so that we have SSL_want_read(s) instead of
+                         * SSL_want_write(s)) and rbio and wbio *are* the same,
+                         * this test works around that bug; so it might be safer
+                         * to keep it. */
                         return(SSL_ERROR_WANT_WRITE);
                 else if (BIO_should_io_special(bio))
                         {
                         reason=BIO_get_retry_reason(bio);
                         if (reason == BIO_RR_CONNECT)
                                 return(SSL_ERROR_WANT_CONNECT);
+                        else if (reason == BIO_RR_ACCEPT)
+                                return(SSL_ERROR_WANT_ACCEPT);
                         else
                                 return(SSL_ERROR_SYSCALL); /* unknown */
                         }
@@ -1299,12 +1747,15 @@ int i;
                 if (BIO_should_write(bio))
                         return(SSL_ERROR_WANT_WRITE);
                 else if (BIO_should_read(bio))
+                        /* See above (SSL_want_read(s) with BIO_should_write(bio)) */
                         return(SSL_ERROR_WANT_READ);
                 else if (BIO_should_io_special(bio))
                         {
                         reason=BIO_get_retry_reason(bio);
                         if (reason == BIO_RR_CONNECT)
                                 return(SSL_ERROR_WANT_CONNECT);
+                        else if (reason == BIO_RR_ACCEPT)
+                                return(SSL_ERROR_WANT_ACCEPT);
                         else
                                 return(SSL_ERROR_SYSCALL);
                         }
@@ -1331,8 +1782,7 @@ int i;
         return(SSL_ERROR_SYSCALL);
         }
 
-int SSL_do_handshake(s)
-SSL *s;
+int SSL_do_handshake(SSL *s)
         {
         int ret=1;
 
@@ -1341,7 +1791,9 @@ SSL *s;
                 SSLerr(SSL_F_SSL_DO_HANDSHAKE,SSL_R_CONNECTION_TYPE_NOT_SET);
                 return(-1);
                 }
-        if (s->s3->renegotiate) ssl3_renegotiate_check(s);
+
+        s->method->ssl_renegotiate_check(s);
+
         if (SSL_in_init(s) || SSL_in_before(s))
                 {
                 ret=s->handshake_func(s);
@@ -1351,9 +1803,9 @@ SSL *s;
 
 /* For the next 2 functions, SSL_clear() sets shutdown and so
  * one of these calls will reset it */
-void SSL_set_accept_state(s)
-SSL *s;
+void SSL_set_accept_state(SSL *s)
         {
+        s->server=1;
         s->shutdown=0;
         s->state=SSL_ST_ACCEPT|SSL_ST_BEFORE;
         s->handshake_func=s->method->ssl_accept;
@@ -1361,9 +1813,9 @@ SSL *s;
         ssl_clear_cipher_ctx(s);
         }
 
-void SSL_set_connect_state(s)
-SSL *s;
+void SSL_set_connect_state(SSL *s)
         {
+        s->server=0;
         s->shutdown=0;
         s->state=SSL_ST_CONNECT|SSL_ST_BEFORE;
         s->handshake_func=s->method->ssl_connect;
@@ -1371,22 +1823,19 @@ SSL *s;
         ssl_clear_cipher_ctx(s);
         }
 
-int ssl_undefined_function(s)
-SSL *s;
+int ssl_undefined_function(SSL *s)
         {
         SSLerr(SSL_F_SSL_UNDEFINED_FUNCTION,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
         return(0);
         }
 
-SSL_METHOD *ssl_bad_method(ver)
-int ver;
+SSL_METHOD *ssl_bad_method(int ver)
         {
         SSLerr(SSL_F_SSL_BAD_METHOD,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
         return(NULL);
         }
 
-char *SSL_get_version(s)
-SSL *s;
+const char *SSL_get_version(SSL *s)
         {
         if (s->version == TLS1_VERSION)
                 return("TLSv1");
@@ -1398,30 +1847,67 @@ SSL *s;
                 return("unknown");
         }
 
-SSL *SSL_dup(s)
-SSL *s;
-        {
-        STACK *sk;
+SSL *SSL_dup(SSL *s)
+        {
+        STACK_OF(X509_NAME) *sk;
         X509_NAME *xn;
-        SSL *ret;
+        SSL *ret;
         int i;
                  
-        if ((ret=SSL_new(SSL_get_SSL_CTX(s))) == NULL) return(NULL);
-                          
-        /* This copies version, session-id, SSL_METHOD and 'cert' */
-        SSL_copy_session_id(ret,s);
+        if ((ret=SSL_new(SSL_get_SSL_CTX(s))) == NULL)
+            return(NULL);
+
+        ret->version = s->version;
+        ret->type = s->type;
+        ret->method = s->method;
+
+        if (s->session != NULL)
+                {
+                /* This copies session-id, SSL_METHOD, sid_ctx, and 'cert' */
+                SSL_copy_session_id(ret,s);
+                }
+        else
+                {
+                /* No session has been established yet, so we have to expect
+                 * that s->cert or ret->cert will be changed later --
+                 * they should not both point to the same object,
+                 * and thus we can't use SSL_copy_session_id. */
 
+                ret->method = s->method;
+                ret->method->ssl_new(ret);
+
+                if (s->cert != NULL)
+                        {
+                        if (ret->cert != NULL)
+                                {
+                                ssl_cert_free(ret->cert);
+                                }
+                        ret->cert = ssl_cert_dup(s->cert);
+                        if (ret->cert == NULL)
+                                goto err;
+                        }
+                                
+                SSL_set_session_id_context(ret,
+                        s->sid_ctx, s->sid_ctx_length);
+                }
+
+        ret->options=s->options;
+        ret->mode=s->mode;
+        SSL_set_max_cert_list(ret,SSL_get_max_cert_list(s));
         SSL_set_read_ahead(ret,SSL_get_read_ahead(s));
+        ret->msg_callback = s->msg_callback;
+        ret->msg_callback_arg = s->msg_callback_arg;
         SSL_set_verify(ret,SSL_get_verify_mode(s),
                 SSL_get_verify_callback(s));
+        SSL_set_verify_depth(ret,SSL_get_verify_depth(s));
+        ret->generate_session_id = s->generate_session_id;
 
         SSL_set_info_callback(ret,SSL_get_info_callback(s));
         
         ret->debug=s->debug;
-        ret->options=s->options;
 
         /* copy app data, a little dangerous perhaps */
-        if (!CRYPTO_dup_ex_data(ssl_meth,&ret->ex_data,&s->ex_data))
+        if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data))
                 goto err;
 
         /* setup rbio, and wbio */
@@ -1440,27 +1926,40 @@ SSL *s;
                 else
                         ret->wbio=ret->rbio;
                 }
+        ret->rwstate = s->rwstate;
+        ret->in_handshake = s->in_handshake;
+        ret->handshake_func = s->handshake_func;
+        ret->server = s->server;
+        ret->new_session = s->new_session;
+        ret->quiet_shutdown = s->quiet_shutdown;
+        ret->shutdown=s->shutdown;
+        ret->state=s->state; /* SSL_dup does not really work at any state, though */
+        ret->rstate=s->rstate;
+        ret->init_num = 0; /* would have to copy ret->init_buf, ret->init_msg, ret->init_num, ret->init_off */
+        ret->hit=s->hit;
+        ret->purpose=s->purpose;
+        ret->trust=s->trust;
 
         /* dup the cipher_list and cipher_list_by_id stacks */
         if (s->cipher_list != NULL)
                 {
-                if ((ret->cipher_list=sk_dup(s->cipher_list)) == NULL)
+                if ((ret->cipher_list=sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
                         goto err;
                 }
         if (s->cipher_list_by_id != NULL)
-                if ((ret->cipher_list_by_id=sk_dup(s->cipher_list_by_id))
+                if ((ret->cipher_list_by_id=sk_SSL_CIPHER_dup(s->cipher_list_by_id))
                         == NULL)
                         goto err;
 
         /* Dup the client_CA list */
         if (s->client_CA != NULL)
                 {
-                if ((sk=sk_dup(s->client_CA)) == NULL) goto err;
+                if ((sk=sk_X509_NAME_dup(s->client_CA)) == NULL) goto err;
                 ret->client_CA=sk;
-                for (i=0; i<sk_num(sk); i++)
+                for (i=0; i<sk_X509_NAME_num(sk); i++)
                         {
-                        xn=(X509_NAME *)sk_value(sk,i);
-                        if ((sk_value(sk,i)=(char *)X509_NAME_dup(xn)) == NULL)
+                        xn=sk_X509_NAME_value(sk,i);
+                        if (sk_X509_NAME_set(sk,i,X509_NAME_dup(xn)) == NULL)
                                 {
                                 X509_NAME_free(xn);
                                 goto err;
@@ -1468,10 +1967,6 @@ SSL *s;
                         }
                 }
 
-        ret->shutdown=s->shutdown;
-        ret->state=s->state;
-        ret->handshake_func=s->handshake_func;
-
         if (0)
                 {
 err:
@@ -1481,26 +1976,34 @@ err:
         return(ret);
         }
 
-void ssl_clear_cipher_ctx(s)
-SSL *s;
+void ssl_clear_cipher_ctx(SSL *s)
         {
-        if (s->enc_read_ctx != NULL)
-                {
-                EVP_CIPHER_CTX_cleanup(s->enc_read_ctx);
-                Free(s->enc_read_ctx);
-                s->enc_read_ctx=NULL;
-                }
-        if (s->enc_write_ctx != NULL)
-                {
-                EVP_CIPHER_CTX_cleanup(s->enc_write_ctx);
-                Free(s->enc_write_ctx);
-                s->enc_write_ctx=NULL;
-                }
+        if (s->enc_read_ctx != NULL)
+                {
+                EVP_CIPHER_CTX_cleanup(s->enc_read_ctx);
+                OPENSSL_free(s->enc_read_ctx);
+                s->enc_read_ctx=NULL;
+                }
+        if (s->enc_write_ctx != NULL)
+                {
+                EVP_CIPHER_CTX_cleanup(s->enc_write_ctx);
+                OPENSSL_free(s->enc_write_ctx);
+                s->enc_write_ctx=NULL;
+                }
+        if (s->expand != NULL)
+                {
+                COMP_CTX_free(s->expand);
+                s->expand=NULL;
+                }
+        if (s->compress != NULL)
+                {
+                COMP_CTX_free(s->compress);
+                s->compress=NULL;
+                }
         }
 
 /* Fix this function so that it takes an optional type parameter */
-X509 *SSL_get_certificate(s)
-SSL *s;
+X509 *SSL_get_certificate(SSL *s)
         {
         if (s->cert != NULL)
                 return(s->cert->key->x509);
@@ -1509,8 +2012,7 @@ SSL *s;
         }
 
 /* Fix this function so that it takes an optional type parameter */
-EVP_PKEY *SSL_get_privatekey(s)
-SSL *s;
+EVP_PKEY *SSL_get_privatekey(SSL *s)
         {
         if (s->cert != NULL)
                 return(s->cert->key->privatekey);
@@ -1518,17 +2020,14 @@ SSL *s;
                 return(NULL);
         }
 
-SSL_CIPHER *SSL_get_current_cipher(s)
-SSL *s;
+SSL_CIPHER *SSL_get_current_cipher(SSL *s)
         {
-        if ((s->session != NULL) && (s->session->cipher != NULL))
-                return(s->session->cipher);
-        return(NULL);
+        if ((s->session != NULL) && (s->session->cipher != NULL))
+                return(s->session->cipher);
+        return(NULL);
         }
 
-int ssl_init_wbio_buffer(s,push)
-SSL *s;
-int push;
+int ssl_init_wbio_buffer(SSL *s,int push)
         {
         BIO *bbio;
 
@@ -1544,7 +2043,7 @@ int push;
                 if (s->bbio == s->wbio)
                         s->wbio=BIO_pop(s->wbio);
                 }
-        BIO_reset(bbio);
+        (void)BIO_reset(bbio);
 /*      if (!BIO_set_write_buffer_size(bbio,16*1024)) */
         if (!BIO_set_read_buffer_size(bbio,1))
                 {
@@ -1563,159 +2062,230 @@ int push;
                 }
         return(1);
         }
+
+void ssl_free_wbio_buffer(SSL *s)
+        {
+        if (s->bbio == NULL) return;
+
+        if (s->bbio == s->wbio)
+                {
+                /* remove buffering */
+                s->wbio=BIO_pop(s->wbio);
+#ifdef REF_CHECK /* not the usual REF_CHECK, but this avoids adding one more preprocessor symbol */
+                assert(s->wbio != NULL);
+#endif  
+        }
+        BIO_free(s->bbio);
+        s->bbio=NULL;
+        }
         
-void SSL_CTX_set_quiet_shutdown(ctx,mode)
-SSL_CTX *ctx;
-int mode;
+void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx,int mode)
         {
         ctx->quiet_shutdown=mode;
         }
 
-int SSL_CTX_get_quiet_shutdown(ctx)
-SSL_CTX *ctx;
+int SSL_CTX_get_quiet_shutdown(SSL_CTX *ctx)
         {
         return(ctx->quiet_shutdown);
         }
 
-void SSL_set_quiet_shutdown(s,mode)
-SSL *s;
-int mode;
+void SSL_set_quiet_shutdown(SSL *s,int mode)
         {
         s->quiet_shutdown=mode;
         }
 
-int SSL_get_quiet_shutdown(s)
-SSL *s;
+int SSL_get_quiet_shutdown(SSL *s)
         {
         return(s->quiet_shutdown);
         }
 
-void SSL_set_shutdown(s,mode)
-SSL *s;
-int mode;
+void SSL_set_shutdown(SSL *s,int mode)
         {
         s->shutdown=mode;
         }
 
-int SSL_get_shutdown(s)
-SSL *s;
+int SSL_get_shutdown(SSL *s)
         {
         return(s->shutdown);
         }
 
-int SSL_version(s)
-SSL *s;
+int SSL_version(SSL *s)
         {
         return(s->version);
         }
 
-SSL_CTX *SSL_get_SSL_CTX(ssl)
-SSL *ssl;
+SSL_CTX *SSL_get_SSL_CTX(SSL *ssl)
         {
         return(ssl->ctx);
         }
 
-int SSL_CTX_set_default_verify_paths(ctx)
-SSL_CTX *ctx;
+#ifndef OPENSSL_NO_STDIO
+int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
         {
         return(X509_STORE_set_default_paths(ctx->cert_store));
         }
 
-int SSL_CTX_load_verify_locations(ctx,CAfile,CApath)
-SSL_CTX *ctx;
-char *CAfile;
-char *CApath;
+int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
+                const char *CApath)
         {
         return(X509_STORE_load_locations(ctx->cert_store,CAfile,CApath));
         }
+#endif
 
-void SSL_set_info_callback(ssl,cb)
-SSL *ssl;
-void (*cb)();
+void SSL_set_info_callback(SSL *ssl,
+                           void (*cb)(const SSL *ssl,int type,int val))
         {
         ssl->info_callback=cb;
         }
 
-void (*SSL_get_info_callback(ssl))()
-SSL *ssl;
+void (*SSL_get_info_callback(SSL *ssl))(const SSL *ssl,int type,int val)
         {
-        return(ssl->info_callback);
+        return ssl->info_callback;
         }
 
-int SSL_state(ssl)
-SSL *ssl;
+int SSL_state(SSL *ssl)
         {
         return(ssl->state);
         }
 
-void SSL_set_verify_result(ssl,arg)
-SSL *ssl;
-long arg;
+void SSL_set_verify_result(SSL *ssl,long arg)
         {
         ssl->verify_result=arg;
         }
 
-long SSL_get_verify_result(ssl)
-SSL *ssl;
+long SSL_get_verify_result(SSL *ssl)
         {
         return(ssl->verify_result);
         }
 
-int SSL_get_ex_new_index(argl,argp,new_func,dup_func,free_func)
-long argl;
-char *argp;
-int (*new_func)();
-int (*dup_func)();
-void (*free_func)();
-        {
-        ssl_meth_num++;
-        return(CRYPTO_get_ex_new_index(ssl_meth_num-1,
-                &ssl_meth,argl,argp,new_func,dup_func,free_func));
-        }
+int SSL_get_ex_new_index(long argl,void *argp,CRYPTO_EX_new *new_func,
+                         CRYPTO_EX_dup *dup_func,CRYPTO_EX_free *free_func)
+        {
+        return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL, argl, argp,
+                                new_func, dup_func, free_func);
+        }
 
-int SSL_set_ex_data(s,idx,arg)
-SSL *s;
-int idx;
-char *arg;
+int SSL_set_ex_data(SSL *s,int idx,void *arg)
         {
         return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
         }
 
-char *SSL_get_ex_data(s,idx)
-SSL *s;
-int idx;
+void *SSL_get_ex_data(SSL *s,int idx)
         {
         return(CRYPTO_get_ex_data(&s->ex_data,idx));
         }
 
-int SSL_CTX_get_ex_new_index(argl,argp,new_func,dup_func,free_func)
-long argl;
-char *argp;
-int (*new_func)();
-int (*dup_func)();
-void (*free_func)();
-        {
-        ssl_ctx_meth_num++;
-        return(CRYPTO_get_ex_new_index(ssl_ctx_meth_num-1,
-                &ssl_ctx_meth,argl,argp,new_func,dup_func,free_func));
-        }
+int SSL_CTX_get_ex_new_index(long argl,void *argp,CRYPTO_EX_new *new_func,
+                             CRYPTO_EX_dup *dup_func,CRYPTO_EX_free *free_func)
+        {
+        return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_CTX, argl, argp,
+                                new_func, dup_func, free_func);
+        }
 
-int SSL_CTX_set_ex_data(s,idx,arg)
-SSL_CTX *s;
-int idx;
-char *arg;
+int SSL_CTX_set_ex_data(SSL_CTX *s,int idx,void *arg)
         {
         return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
         }
 
-char *SSL_CTX_get_ex_data(s,idx)
-SSL_CTX *s;
-int idx;
+void *SSL_CTX_get_ex_data(SSL_CTX *s,int idx)
         {
         return(CRYPTO_get_ex_data(&s->ex_data,idx));
         }
 
-#if defined(_WINDLL) && defined(WIN16)
+int ssl_ok(SSL *s)
+        {
+        return(1);
+        }
+
+X509_STORE *SSL_CTX_get_cert_store(SSL_CTX *ctx)
+        {
+        return(ctx->cert_store);
+        }
+
+void SSL_CTX_set_cert_store(SSL_CTX *ctx,X509_STORE *store)
+        {
+        if (ctx->cert_store != NULL)
+                X509_STORE_free(ctx->cert_store);
+        ctx->cert_store=store;
+        }
+
+int SSL_want(SSL *s)
+        {
+        return(s->rwstate);
+        }
+
+/*!
+ * \brief Set the callback for generating temporary RSA keys.
+ * \param ctx the SSL context.
+ * \param cb the callback
+ */
+
+#ifndef OPENSSL_NO_RSA
+void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx,RSA *(*cb)(SSL *ssl,
+                                                          int is_export,
+                                                          int keylength))
+    {
+    SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_RSA_CB,(void (*)())cb);
+    }
+
+void SSL_set_tmp_rsa_callback(SSL *ssl,RSA *(*cb)(SSL *ssl,
+                                                  int is_export,
+                                                  int keylength))
+    {
+    SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_RSA_CB,(void (*)())cb);
+    }
+#endif
+
+#ifdef DOXYGEN
+/*!
+ * \brief The RSA temporary key callback function.
+ * \param ssl the SSL session.
+ * \param is_export \c TRUE if the temp RSA key is for an export ciphersuite.
+ * \param keylength if \c is_export is \c TRUE, then \c keylength is the size
+ * of the required key in bits.
+ * \return the temporary RSA key.
+ * \sa SSL_CTX_set_tmp_rsa_callback, SSL_set_tmp_rsa_callback
+ */
+
+RSA *cb(SSL *ssl,int is_export,int keylength)
+    {}
+#endif
+
+/*!
+ * \brief Set the callback for generating temporary DH keys.
+ * \param ctx the SSL context.
+ * \param dh the callback
+ */
+
+#ifndef OPENSSL_NO_DH
+void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,DH *(*dh)(SSL *ssl,int is_export,
+                                                        int keylength))
+        {
+        SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_DH_CB,(void (*)())dh);
+        }
+
+void SSL_set_tmp_dh_callback(SSL *ssl,DH *(*dh)(SSL *ssl,int is_export,
+                                                int keylength))
+        {
+        SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_DH_CB,(void (*)())dh);
+        }
+#endif
+
+
+void SSL_CTX_set_msg_callback(SSL_CTX *ctx, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))
+        {
+        SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)())cb);
+        }
+void SSL_set_msg_callback(SSL *ssl, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))
+        {
+        SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)())cb);
+        }
+
+
+
+#if defined(_WINDLL) && defined(OPENSSL_SYS_WIN16)
 #include "../crypto/bio/bss_file.c"
 #endif
 
+IMPLEMENT_STACK_OF(SSL_CIPHER)
+IMPLEMENT_STACK_OF(SSL_COMP)
diff --git a/src/lib/libssl/ssl_locl.h b/src/lib/libssl/ssl_locl.h
index b29517081b..17e9bef832 100644
--- a/src/lib/libssl/ssl_locl.h
+++ b/src/lib/libssl/ssl_locl.h
@@ -55,6 +55,59 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
+/* ====================================================================
+ * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
 
 #ifndef HEADER_SSL_LOCL_H
 #define HEADER_SSL_LOCL_H
@@ -65,15 +118,23 @@
 
 #include "e_os.h"
 
-#include "buffer.h"
-#include "bio.h"
-#include "crypto.h"
-#include "evp.h"
-#include "stack.h"
-#include "x509.h"
-#include "err.h"
-#include "ssl.h"
+#include <openssl/buffer.h>
+#include <openssl/comp.h>
+#include <openssl/bio.h>
+#include <openssl/crypto.h>
+#include <openssl/evp.h>
+#include <openssl/stack.h>
+#include <openssl/x509.h>
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+#include <openssl/symhacks.h>
+
+#ifdef OPENSSL_BUILD_SHLIBSSL
+# undef OPENSSL_EXTERN
+# define OPENSSL_EXTERN OPENSSL_EXPORT
+#endif
 
+#define PKCS1_CHECK
 
 #define c2l(c,l)        (l = ((unsigned long)(*((c)++)))     , \
                          l|=(((unsigned long)(*((c)++)))<< 8), \
@@ -126,18 +187,18 @@
                                 } \
                         }
 
-#define n2s(c,s)        (s =((unsigned int)(*((c)++)))<< 8, \
-                         s|=((unsigned int)(*((c)++))))
-#define s2n(s,c)        (*((c)++)=(unsigned char)(((s)>> 8)&0xff), \
-                         *((c)++)=(unsigned char)(((s)    )&0xff))
+#define n2s(c,s)        ((s=(((unsigned int)(c[0]))<< 8)| \
+                            (((unsigned int)(c[1]))    )),c+=2)
+#define s2n(s,c)        ((c[0]=(unsigned char)(((s)>> 8)&0xff), \
+                          c[1]=(unsigned char)(((s)    )&0xff)),c+=2)
 
-#define n2l3(c,l)       (l =((unsigned long)(*((c)++)))<<16, \
-                         l|=((unsigned long)(*((c)++)))<< 8, \
-                         l|=((unsigned long)(*((c)++))))
+#define n2l3(c,l)       ((l =(((unsigned long)(c[0]))<<16)| \
+                             (((unsigned long)(c[1]))<< 8)| \
+                             (((unsigned long)(c[2]))    )),c+=3)
 
-#define l2n3(l,c)       (*((c)++)=(unsigned char)(((l)>>16)&0xff), \
-                         *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
-                         *((c)++)=(unsigned char)(((l)    )&0xff))
+#define l2n3(l,c)       ((c[0]=(unsigned char)(((l)>>16)&0xff), \
+                          c[1]=(unsigned char)(((l)>> 8)&0xff), \
+                          c[2]=(unsigned char)(((l)    )&0xff)),c+=3)
 
 /* LOCAL STUFF */
 
@@ -153,60 +214,128 @@
 #define DEC32(a)        ((a)=((a)-1)&0xffffffffL)
 #define MAX_MAC_SIZE    20 /* up from 16 for SSLv3 */
 
-#define SSL_MKEY_MASK           0x0000001FL
+/*
+ * Define the Bitmasks for SSL_CIPHER.algorithms.
+ * This bits are used packed as dense as possible. If new methods/ciphers
+ * etc will be added, the bits a likely to change, so this information
+ * is for internal library use only, even though SSL_CIPHER.algorithms
+ * can be publicly accessed.
+ * Use the according functions for cipher management instead.
+ *
+ * The bit mask handling in the selection and sorting scheme in
+ * ssl_create_cipher_list() has only limited capabilities, reflecting
+ * that the different entities within are mutually exclusive:
+ * ONLY ONE BIT PER MASK CAN BE SET AT A TIME.
+ */
+#define SSL_MKEY_MASK           0x0000003FL
 #define SSL_kRSA                0x00000001L /* RSA key exchange */
 #define SSL_kDHr                0x00000002L /* DH cert RSA CA cert */
 #define SSL_kDHd                0x00000004L /* DH cert DSA CA cert */
 #define SSL_kFZA                0x00000008L
 #define SSL_kEDH                0x00000010L /* tmp DH key no DH cert */
+#define SSL_kKRB5               0x00000020L /* Kerberos5 key exchange */
 #define SSL_EDH                 (SSL_kEDH|(SSL_AUTH_MASK^SSL_aNULL))
 
-#define SSL_AUTH_MASK           0x000003e0L
-#define SSL_aRSA                0x00000020L /* Authenticate with RSA */
-#define SSL_aDSS                0x00000040L /* Authenticate with DSS */
+#define SSL_AUTH_MASK           0x00000FC0L
+#define SSL_aRSA                0x00000040L /* Authenticate with RSA */
+#define SSL_aDSS                0x00000080L /* Authenticate with DSS */
 #define SSL_DSS                 SSL_aDSS
-#define SSL_aFZA                0x00000080L
-#define SSL_aNULL               0x00000100L /* no Authenticate, ADH */
-#define SSL_aDH                 0x00000200L /* no Authenticate, ADH */
+#define SSL_aFZA                0x00000100L
+#define SSL_aNULL               0x00000200L /* no Authenticate, ADH */
+#define SSL_aDH                 0x00000400L /* no Authenticate, ADH */
+#define SSL_aKRB5               0x00000800L /* Authenticate with KRB5 */
 
 #define SSL_NULL                (SSL_eNULL)
 #define SSL_ADH                 (SSL_kEDH|SSL_aNULL)
 #define SSL_RSA                 (SSL_kRSA|SSL_aRSA)
 #define SSL_DH                  (SSL_kDHr|SSL_kDHd|SSL_kEDH)
 #define SSL_FZA                 (SSL_aFZA|SSL_kFZA|SSL_eFZA)
-
-#define SSL_ENC_MASK            0x0001Fc00L
-#define SSL_DES                 0x00000400L
-#define SSL_3DES                0x00000800L
-#define SSL_RC4                 0x00001000L
-#define SSL_RC2                 0x00002000L
-#define SSL_IDEA                0x00004000L
-#define SSL_eFZA                0x00008000L
-#define SSL_eNULL               0x00010000L
-
-#define SSL_MAC_MASK            0x00060000L
-#define SSL_MD5                 0x00020000L
-#define SSL_SHA1                0x00040000L
+#define SSL_KRB5                (SSL_kKRB5|SSL_aKRB5)
+
+#define SSL_ENC_MASK            0x0087F000L
+#define SSL_DES                 0x00001000L
+#define SSL_3DES                0x00002000L
+#define SSL_RC4                 0x00004000L
+#define SSL_RC2                 0x00008000L
+#define SSL_IDEA                0x00010000L
+#define SSL_eFZA                0x00020000L
+#define SSL_eNULL               0x00040000L
+#define SSL_AES                 0x00800000L
+
+#define SSL_MAC_MASK            0x00180000L
+#define SSL_MD5                 0x00080000L
+#define SSL_SHA1                0x00100000L
 #define SSL_SHA                 (SSL_SHA1)
 
-#define SSL_EXP_MASK            0x00300000L
-#define SSL_EXP                 0x00100000L
-#define SSL_NOT_EXP             0x00200000L
-#define SSL_EXPORT              SSL_EXP
+#define SSL_SSL_MASK            0x00600000L
+#define SSL_SSLV2               0x00200000L
+#define SSL_SSLV3               0x00400000L
+#define SSL_TLSV1               SSL_SSLV3       /* for now */
 
-#define SSL_SSL_MASK            0x00c00000L
-#define SSL_SSLV2               0x00400000L
-#define SSL_SSLV3               0x00800000L
+/* we have used 007fffff - 9 bits left to go */
+
+/*
+ * Export and cipher strength information. For each cipher we have to decide
+ * whether it is exportable or not. This information is likely to change
+ * over time, since the export control rules are no static technical issue.
+ *
+ * Independent of the export flag the cipher strength is sorted into classes.
+ * SSL_EXP40 was denoting the 40bit US export limit of past times, which now
+ * is at 56bit (SSL_EXP56). If the exportable cipher class is going to change
+ * again (eg. to 64bit) the use of "SSL_EXP*" becomes blurred even more,
+ * since SSL_EXP64 could be similar to SSL_LOW.
+ * For this reason SSL_MICRO and SSL_MINI macros are included to widen the
+ * namespace of SSL_LOW-SSL_HIGH to lower values. As development of speed
+ * and ciphers goes, another extension to SSL_SUPER and/or SSL_ULTRA would
+ * be possible.
+ */
+#define SSL_EXP_MASK            0x00000003L
+#define SSL_NOT_EXP             0x00000001L
+#define SSL_EXPORT              0x00000002L
+
+#define SSL_STRONG_MASK         0x0000007cL
+#define SSL_EXP40               0x00000004L
+#define SSL_MICRO               (SSL_EXP40)
+#define SSL_EXP56               0x00000008L
+#define SSL_MINI                (SSL_EXP56)
+#define SSL_LOW                 0x00000010L
+#define SSL_MEDIUM              0x00000020L
+#define SSL_HIGH                0x00000040L
+
+/* we have used 0000007f - 25 bits left to go */
+
+/*
+ * Macros to check the export status and cipher strength for export ciphers.
+ * Even though the macros for EXPORT and EXPORT40/56 have similar names,
+ * their meaning is different:
+ * *_EXPORT macros check the 'exportable' status.
+ * *_EXPORT40/56 macros are used to check whether a certain cipher strength
+ *          is given.
+ * Since the SSL_IS_EXPORT* and SSL_EXPORT* macros depend on the correct
+ * algorithm structure element to be passed (algorithms, algo_strength) and no
+ * typechecking can be done as they are all of type unsigned long, their
+ * direct usage is discouraged.
+ * Use the SSL_C_* macros instead.
+ */
+#define SSL_IS_EXPORT(a)        ((a)&SSL_EXPORT)
+#define SSL_IS_EXPORT56(a)      ((a)&SSL_EXP56)
+#define SSL_IS_EXPORT40(a)      ((a)&SSL_EXP40)
+#define SSL_C_IS_EXPORT(c)      SSL_IS_EXPORT((c)->algo_strength)
+#define SSL_C_IS_EXPORT56(c)    SSL_IS_EXPORT56((c)->algo_strength)
+#define SSL_C_IS_EXPORT40(c)    SSL_IS_EXPORT40((c)->algo_strength)
+
+#define SSL_EXPORT_KEYLENGTH(a,s)       (SSL_IS_EXPORT40(s) ? 5 : \
+                                 ((a)&SSL_ENC_MASK) == SSL_DES ? 8 : 7)
+#define SSL_EXPORT_PKEYLENGTH(a) (SSL_IS_EXPORT40(a) ? 512 : 1024)
+#define SSL_C_EXPORT_KEYLENGTH(c)       SSL_EXPORT_KEYLENGTH((c)->algorithms, \
+                                (c)->algo_strength)
+#define SSL_C_EXPORT_PKEYLENGTH(c)      SSL_EXPORT_PKEYLENGTH((c)->algo_strength)
 
-#define SSL_STRONG_MASK         0x07000000L
-#define SSL_LOW                 0x01000000L
-#define SSL_MEDIUM              0x02000000L
-#define SSL_HIGH                0x04000000L
 
-/* we have used 0fffffff - 4 bits left to go */
 #define SSL_ALL                 0xffffffffL
 #define SSL_ALL_CIPHERS         (SSL_MKEY_MASK|SSL_AUTH_MASK|SSL_ENC_MASK|\
-                                SSL_MAC_MASK|SSL_EXP_MASK)
+                                SSL_MAC_MASK)
+#define SSL_ALL_STRENGTHS       (SSL_EXP_MASK|SSL_STRONG_MASK)
 
 /* Mostly for SSLv3 */
 #define SSL_PKEY_RSA_ENC        0
@@ -233,44 +362,59 @@
 typedef struct cert_pkey_st
         {
         X509 *x509;
-/*      EVP_PKEY *publickey; *//* when extracted */
         EVP_PKEY *privatekey;
         } CERT_PKEY;
 
 typedef struct cert_st
         {
-        int cert_type;
-
-#ifdef undef
-        X509 *x509;
-        EVP_PKEY *publickey; /* when extracted */
-        EVP_PKEY *privatekey;
-
-        pkeys[SSL_PKEY_RSA_ENC].x509
-/*      pkeys[SSL_PKEY_RSA_ENC].publickey */
-        pkeys[SSL_PKEY_RSA_ENC].privatekey
-#endif
-
         /* Current active set */
-        CERT_PKEY *key;
-
+        CERT_PKEY *key; /* ALWAYS points to an element of the pkeys array
+                         * Probably it would make more sense to store
+                         * an index, not a pointer. */
+ 
         /* The following masks are for the key and auth
          * algorithms that are supported by the certs below */
         int valid;
         unsigned long mask;
         unsigned long export_mask;
-
+#ifndef OPENSSL_NO_RSA
         RSA *rsa_tmp;
+        RSA *(*rsa_tmp_cb)(SSL *ssl,int is_export,int keysize);
+#endif
+#ifndef OPENSSL_NO_DH
         DH *dh_tmp;
-        RSA *(*rsa_tmp_cb)();
-        DH *(*dh_tmp_cb)();
-        CERT_PKEY pkeys[SSL_PKEY_NUM];
+        DH *(*dh_tmp_cb)(SSL *ssl,int is_export,int keysize);
+#endif
 
-        STACK *cert_chain;
+        CERT_PKEY pkeys[SSL_PKEY_NUM];
 
-        int references;
+        int references; /* >1 only if SSL_copy_session_id is used */
         } CERT;
 
+
+typedef struct sess_cert_st
+        {
+        STACK_OF(X509) *cert_chain; /* as received from peer (not for SSL2) */
+
+        /* The 'peer_...' members are used only by clients. */
+        int peer_cert_type;
+
+        CERT_PKEY *peer_key; /* points to an element of peer_pkeys (never NULL!) */
+        CERT_PKEY peer_pkeys[SSL_PKEY_NUM];
+        /* Obviously we don't have the private keys of these,
+         * so maybe we shouldn't even use the CERT_PKEY type here. */
+
+#ifndef OPENSSL_NO_RSA
+        RSA *peer_rsa_tmp; /* not used for SSL 2 */
+#endif
+#ifndef OPENSSL_NO_DH
+        DH *peer_dh_tmp; /* not used for SSL 2 */
+#endif
+
+        int references; /* actually always 1 at the moment */
+        } SESS_CERT;
+
+
 /*#define MAC_DEBUG     */
 
 /*#define ERR_DEBUG     */
@@ -282,12 +426,7 @@ typedef struct cert_st
 /*#define RSA_DEBUG     */ 
 /*#define IDEA_DEBUG    */ 
 
-#ifndef NOPROTO
 #define FP_ICC  (int (*)(const void *,const void *))
-#else
-#define FP_ICC
-#endif
-
 #define ssl_put_cipher_by_char(ssl,ciph,ptr) \
                 ((ssl)->method->put_cipher_by_char((ciph),(ptr)))
 #define ssl_get_cipher_by_char(ssl,ptr) \
@@ -295,29 +434,41 @@ typedef struct cert_st
 
 /* This is for the SSLv3/TLSv1.0 differences in crypto/hash stuff
  * It is a bit of a mess of functions, but hell, think of it as
- * an opaque strucute :-) */
+ * an opaque structure :-) */
 typedef struct ssl3_enc_method
         {
-        int (*enc)();
-        int (*mac)();
-        int (*setup_key_block)();
-        int (*generate_master_secret)();
-        int (*change_cipher_state)();
-        int (*final_finish_mac)();
+        int (*enc)(SSL *, int);
+        int (*mac)(SSL *, unsigned char *, int);
+        int (*setup_key_block)(SSL *);
+        int (*generate_master_secret)(SSL *, unsigned char *, unsigned char *, int);
+        int (*change_cipher_state)(SSL *, int);
+        int (*final_finish_mac)(SSL *, EVP_MD_CTX *, EVP_MD_CTX *, const char *, int, unsigned char *);
         int finish_mac_length;
-        int (*cert_verify_mac)();
-        unsigned char client_finished[20];
-        int client_finished_len;
-        unsigned char server_finished[20];
-        int server_finished_len;
-        int (*alert_value)();
+        int (*cert_verify_mac)(SSL *, EVP_MD_CTX *, unsigned char *);
+        const char *client_finished_label;
+        int client_finished_label_len;
+        const char *server_finished_label;
+        int server_finished_label_len;
+        int (*alert_value)(int);
         } SSL3_ENC_METHOD;
 
-extern SSL3_ENC_METHOD ssl3_undef_enc_method;
-extern SSL_CIPHER ssl2_ciphers[];
-extern SSL_CIPHER ssl3_ciphers[];
+/* Used for holding the relevant compression methods loaded into SSL_CTX */
+typedef struct ssl3_comp_st
+        {
+        int comp_id;    /* The identifier byte for this compression type */
+        char *name;     /* Text name used for the compression type */
+        COMP_METHOD *method; /* The method :-) */
+        } SSL3_COMP;
+
+OPENSSL_EXTERN SSL3_ENC_METHOD ssl3_undef_enc_method;
+OPENSSL_EXTERN SSL_CIPHER ssl2_ciphers[];
+OPENSSL_EXTERN SSL_CIPHER ssl3_ciphers[];
+
+#ifdef OPENSSL_SYS_VMS
+#undef SSL_COMP_get_compression_methods
+#define SSL_COMP_get_compression_methods        SSL_COMP_get_compress_methods
+#endif
 
-#ifndef NOPROTO
 
 SSL_METHOD *ssl_bad_method(int ver);
 SSL_METHOD *sslv2_base_method(void);
@@ -327,33 +478,42 @@ SSL_METHOD *sslv3_base_method(void);
 void ssl_clear_cipher_ctx(SSL *s);
 int ssl_clear_bad_session(SSL *s);
 CERT *ssl_cert_new(void);
+CERT *ssl_cert_dup(CERT *cert);
+int ssl_cert_inst(CERT **o);
 void ssl_cert_free(CERT *c);
-int ssl_set_cert_type(CERT *c, int type);
+SESS_CERT *ssl_sess_cert_new(void);
+void ssl_sess_cert_free(SESS_CERT *sc);
+int ssl_set_peer_cert_type(SESS_CERT *c, int type);
 int ssl_get_new_session(SSL *s, int session);
 int ssl_get_prev_session(SSL *s, unsigned char *session,int len);
-int ssl_cipher_id_cmp(SSL_CIPHER *a,SSL_CIPHER *b);
-int ssl_cipher_ptr_id_cmp(SSL_CIPHER **ap,SSL_CIPHER **bp);
-STACK *ssl_bytes_to_cipher_list(SSL *s,unsigned char *p,int num,STACK **skp);
-int ssl_cipher_list_to_bytes(SSL *s,STACK *sk,unsigned char *p);
-STACK *ssl_create_cipher_list(SSL_METHOD *meth,STACK **pref,
-        STACK **sorted,char *str);
+int ssl_cipher_id_cmp(const SSL_CIPHER *a,const SSL_CIPHER *b);
+int ssl_cipher_ptr_id_cmp(const SSL_CIPHER * const *ap,
+                        const SSL_CIPHER * const *bp);
+STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,unsigned char *p,int num,
+                                               STACK_OF(SSL_CIPHER) **skp);
+int ssl_cipher_list_to_bytes(SSL *s,STACK_OF(SSL_CIPHER) *sk,unsigned char *p);
+STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(const SSL_METHOD *meth,
+                                             STACK_OF(SSL_CIPHER) **pref,
+                                             STACK_OF(SSL_CIPHER) **sorted,
+                                             const char *rule_str);
 void ssl_update_cache(SSL *s, int mode);
-int ssl_cipher_get_evp(SSL_CIPHER *c, EVP_CIPHER **enc, EVP_MD **md);
-int ssl_verify_cert_chain(SSL *s,STACK *sk);
+int ssl_cipher_get_evp(SSL_SESSION *s,const EVP_CIPHER **enc,const EVP_MD **md,
+                       SSL_COMP **comp);
+int ssl_verify_cert_chain(SSL *s,STACK_OF(X509) *sk);
 int ssl_undefined_function(SSL *s);
 X509 *ssl_get_server_send_cert(SSL *);
 EVP_PKEY *ssl_get_sign_pkey(SSL *,SSL_CIPHER *);
 int ssl_cert_type(X509 *x,EVP_PKEY *pkey);
-void ssl_set_cert_masks(CERT *c);
-STACK *ssl_get_ciphers_by_id(SSL *s);
+void ssl_set_cert_masks(CERT *c, SSL_CIPHER *cipher);
+STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s);
 int ssl_verify_alarm_type(long type);
 
 int ssl2_enc_init(SSL *s, int client);
 void ssl2_generate_key_material(SSL *s);
 void ssl2_enc(SSL *s,int send_data);
 void ssl2_mac(SSL *s,unsigned char *mac,int send_data);
-SSL_CIPHER *ssl2_get_cipher_by_char(unsigned char *p);
-int ssl2_put_cipher_by_char(SSL_CIPHER *c,unsigned char *p);
+SSL_CIPHER *ssl2_get_cipher_by_char(const unsigned char *p);
+int ssl2_put_cipher_by_char(const SSL_CIPHER *c,unsigned char *p);
 int ssl2_part_read(SSL *s, unsigned long f, int i);
 int ssl2_do_write(SSL *s);
 int ssl2_set_certificate(SSL *s, int type, int len, unsigned char *data);
@@ -365,17 +525,19 @@ int	ssl2_new(SSL *s);
 void    ssl2_free(SSL *s);
 int     ssl2_accept(SSL *s);
 int     ssl2_connect(SSL *s);
-int     ssl2_read(SSL *s, char *buf, int len);
-int     ssl2_peek(SSL *s, char *buf, int len);
-int     ssl2_write(SSL *s, char *buf, int len);
+int     ssl2_read(SSL *s, void *buf, int len);
+int     ssl2_peek(SSL *s, void *buf, int len);
+int     ssl2_write(SSL *s, const void *buf, int len);
 int     ssl2_shutdown(SSL *s);
 void    ssl2_clear(SSL *s);
-long    ssl2_ctrl(SSL *s,int cmd, long larg, char *parg);
-long    ssl2_ctx_ctrl(SSL_CTX *s,int cmd, long larg, char *parg);
+long    ssl2_ctrl(SSL *s,int cmd, long larg, void *parg);
+long    ssl2_ctx_ctrl(SSL_CTX *s,int cmd, long larg, void *parg);
+long    ssl2_callback_ctrl(SSL *s,int cmd, void (*fp)());
+long    ssl2_ctx_callback_ctrl(SSL_CTX *s,int cmd, void (*fp)());
 int     ssl2_pending(SSL *s);
 
-SSL_CIPHER *ssl3_get_cipher_by_char(unsigned char *p);
-int ssl3_put_cipher_by_char(SSL_CIPHER *c,unsigned char *p);
+SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p);
+int ssl3_put_cipher_by_char(const SSL_CIPHER *c,unsigned char *p);
 void ssl3_init_finished_mac(SSL *s);
 int ssl3_send_server_certificate(SSL *s);
 int ssl3_get_finished(SSL *s,int state_a,int state_b);
@@ -389,35 +551,37 @@ int ssl3_generate_master_secret(SSL *s, unsigned char *out,
         unsigned char *p, int len);
 int ssl3_get_req_cert_type(SSL *s,unsigned char *p);
 long ssl3_get_message(SSL *s, int st1, int stn, int mt, long max, int *ok);
-int ssl3_send_finished(SSL *s, int a, int b, unsigned char *sender,int slen);
+int ssl3_send_finished(SSL *s, int a, int b, const char *sender,int slen);
 int ssl3_num_ciphers(void);
 SSL_CIPHER *ssl3_get_cipher(unsigned int u);
 int ssl3_renegotiate(SSL *ssl); 
 int ssl3_renegotiate_check(SSL *ssl); 
 int ssl3_dispatch_alert(SSL *s);
-int ssl3_read_bytes(SSL *s, int type, char *buf, int len);
-int ssl3_part_read(SSL *s, int i);
-int ssl3_write_bytes(SSL *s, int type, char *buf, int len);
-int ssl3_final_finish_mac(SSL *s, EVP_MD_CTX *ctx1,EVP_MD_CTX *ctx2,
-        unsigned char *sender, int slen,unsigned char *p);
+int ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek);
+int ssl3_write_bytes(SSL *s, int type, const void *buf, int len);
+int ssl3_final_finish_mac(SSL *s, EVP_MD_CTX *ctx1, EVP_MD_CTX *ctx2,
+        const char *sender, int slen,unsigned char *p);
 int ssl3_cert_verify_mac(SSL *s, EVP_MD_CTX *in, unsigned char *p);
-void ssl3_finish_mac(SSL *s, unsigned char *buf, int len);
+void ssl3_finish_mac(SSL *s, const unsigned char *buf, int len);
 int ssl3_enc(SSL *s, int send_data);
 int ssl3_mac(SSL *ssl, unsigned char *md, int send_data);
 unsigned long ssl3_output_cert_chain(SSL *s, X509 *x);
-SSL_CIPHER *ssl3_choose_cipher(SSL *ssl,STACK *have,STACK *pref);
+SSL_CIPHER *ssl3_choose_cipher(SSL *ssl,STACK_OF(SSL_CIPHER) *clnt,
+                               STACK_OF(SSL_CIPHER) *srvr);
 int     ssl3_setup_buffers(SSL *s);
 int     ssl3_new(SSL *s);
 void    ssl3_free(SSL *s);
 int     ssl3_accept(SSL *s);
 int     ssl3_connect(SSL *s);
-int     ssl3_read(SSL *s, char *buf, int len);
-int     ssl3_peek(SSL *s,char *buf, int len);
-int     ssl3_write(SSL *s, char *buf, int len);
+int     ssl3_read(SSL *s, void *buf, int len);
+int     ssl3_peek(SSL *s, void *buf, int len);
+int     ssl3_write(SSL *s, const void *buf, int len);
 int     ssl3_shutdown(SSL *s);
 void    ssl3_clear(SSL *s);
-long    ssl3_ctrl(SSL *s,int cmd, long larg, char *parg);
-long    ssl3_ctx_ctrl(SSL_CTX *s,int cmd, long larg, char *parg);
+long    ssl3_ctrl(SSL *s,int cmd, long larg, void *parg);
+long    ssl3_ctx_ctrl(SSL_CTX *s,int cmd, long larg, void *parg);
+long    ssl3_callback_ctrl(SSL *s,int cmd, void (*fp)());
+long    ssl3_ctx_callback_ctrl(SSL_CTX *s,int cmd, void (*fp)());
 int     ssl3_pending(SSL *s);
 
 int ssl23_accept(SSL *s);
@@ -428,131 +592,28 @@ int ssl23_write_bytes(SSL *s);
 int tls1_new(SSL *s);
 void tls1_free(SSL *s);
 void tls1_clear(SSL *s);
-long tls1_ctrl(SSL *s,int cmd, long larg, char *parg);
+long tls1_ctrl(SSL *s,int cmd, long larg, void *parg);
+long tls1_callback_ctrl(SSL *s,int cmd, void (*fp)());
 SSL_METHOD *tlsv1_base_method(void );
 
-
 int ssl_init_wbio_buffer(SSL *s, int push);
+void ssl_free_wbio_buffer(SSL *s);
 
 int tls1_change_cipher_state(SSL *s, int which);
 int tls1_setup_key_block(SSL *s);
 int tls1_enc(SSL *s, int snd);
 int tls1_final_finish_mac(SSL *s, EVP_MD_CTX *in1_ctx, EVP_MD_CTX *in2_ctx,
-        unsigned char *str, int slen, unsigned char *p);
+        const char *str, int slen, unsigned char *p);
 int tls1_cert_verify_mac(SSL *s, EVP_MD_CTX *in, unsigned char *p);
 int tls1_mac(SSL *ssl, unsigned char *md, int snd);
 int tls1_generate_master_secret(SSL *s, unsigned char *out,
         unsigned char *p, int len);
 int tls1_alert_code(int code);
 int ssl3_alert_code(int code);
+int ssl_ok(SSL *s);
 
+SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n);
+STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void);
 
-#else
-
-SSL_METHOD *ssl_bad_method();
-SSL_METHOD *sslv2_base_method();
-SSL_METHOD *sslv23_base_method();
-SSL_METHOD *sslv3_base_method();
-
-void ssl_clear_cipher_ctx();
-int ssl_clear_bad_session();
-CERT *ssl_cert_new();
-void ssl_cert_free();
-int ssl_set_cert_type();
-int ssl_get_new_session();
-int ssl_get_prev_session();
-int ssl_cipher_id_cmp();
-int ssl_cipher_ptr_id_cmp();
-STACK *ssl_bytes_to_cipher_list();
-int ssl_cipher_list_to_bytes();
-STACK *ssl_create_cipher_list();
-void ssl_update_cache();
-int ssl_session_get_ciphers();
-int ssl_verify_cert_chain();
-int ssl_undefined_function();
-X509 *ssl_get_server_send_cert();
-EVP_PKEY *ssl_get_sign_pkey();
-int ssl_cert_type();
-void ssl_set_cert_masks();
-STACK *ssl_get_ciphers_by_id();
-int ssl_verify_alarm_type();
-
-int ssl2_enc_init();
-void ssl2_generate_key_material();
-void ssl2_enc();
-void ssl2_mac();
-SSL_CIPHER *ssl2_get_cipher_by_char();
-int ssl2_put_cipher_by_char();
-int ssl2_part_read();
-int ssl2_do_write();
-int ssl2_set_certificate();
-void ssl2_return_error();
-void ssl2_write_error();
-int ssl2_num_ciphers();
-SSL_CIPHER *ssl2_get_cipher();
-int     ssl2_new();
-void    ssl2_free();
-int     ssl2_accept();
-int     ssl2_connect();
-int     ssl2_read();
-int     ssl2_peek();
-int     ssl2_write();
-int     ssl2_shutdown();
-void    ssl2_clear();
-long    ssl2_ctrl();
-long    ssl2_ctx_ctrl();
-int     ssl2_pending();
-
-SSL_CIPHER *ssl3_get_cipher_by_char();
-int ssl3_put_cipher_by_char();
-void ssl3_init_finished_mac();
-int ssl3_send_server_certificate();
-int ssl3_get_finished();
-int ssl3_setup_key_block();
-int ssl3_send_change_cipher_spec();
-int ssl3_change_cipher_state();
-void ssl3_cleanup_key_block();
-int ssl3_do_write();
-void ssl3_send_alert();
-int ssl3_generate_master_secret();
-int ssl3_get_req_cert_type();
-long ssl3_get_message();
-int ssl3_send_finished();
-int ssl3_num_ciphers();
-SSL_CIPHER *ssl3_get_cipher();
-int ssl3_renegotiate();
-int ssl3_renegotiate_check();
-int ssl3_dispatch_alert();
-int ssl3_read_bytes();
-int ssl3_part_read();
-int ssl3_write_bytes();
-int ssl3_final_finish_mac();
-void ssl3_finish_mac();
-int ssl3_enc();
-int ssl3_mac();
-unsigned long ssl3_output_cert_chain();
-SSL_CIPHER *ssl3_choose_cipher();
-int     ssl3_setup_buffers();
-int     ssl3_new();
-void    ssl3_free();
-int     ssl3_accept();
-int     ssl3_connect();
-int     ssl3_read();
-int     ssl3_peek();
-int     ssl3_write();
-int     ssl3_shutdown();
-void    ssl3_clear();
-long    ssl3_ctrl();
-long    ssl3_ctx_ctrl();
-int     ssl3_pending();
-
-int ssl23_accept();
-int ssl23_connect();
-int ssl23_read_bytes();
-int ssl23_write_bytes();
-
-int ssl_init_wbio_buffer();
-
-#endif
 
 #endif
diff --git a/src/lib/libssl/ssl_rsa.c b/src/lib/libssl/ssl_rsa.c
index 140475e5fb..1cf8e20934 100644
--- a/src/lib/libssl/ssl_rsa.c
+++ b/src/lib/libssl/ssl_rsa.c
@@ -57,53 +57,32 @@
  */
 
 #include <stdio.h>
-#include "bio.h"
-#include "objects.h"
-#include "evp.h"
-#include "x509.h"
-#include "pem.h"
+#include <openssl/bio.h>
+#include <openssl/objects.h>
+#include <openssl/evp.h>
+#include <openssl/x509.h>
+#include <openssl/pem.h>
 #include "ssl_locl.h"
 
-#ifndef NOPROTO
 static int ssl_set_cert(CERT *c, X509 *x509);
 static int ssl_set_pkey(CERT *c, EVP_PKEY *pkey);
-#else
-static int ssl_set_cert();
-static int ssl_set_pkey();
-#endif
-
-int SSL_use_certificate(ssl, x)
-SSL *ssl;
-X509 *x;
+int SSL_use_certificate(SSL *ssl, X509 *x)
         {
-        CERT *c;
-
         if (x == NULL)
                 {
                 SSLerr(SSL_F_SSL_USE_CERTIFICATE,ERR_R_PASSED_NULL_PARAMETER);
                 return(0);
                 }
-        if ((ssl->cert == NULL) || (ssl->cert == ssl->ctx->default_cert))
+        if (!ssl_cert_inst(&ssl->cert))
                 {
-                c=ssl_cert_new();
-                if (c == NULL)
-                        {
-                        SSLerr(SSL_F_SSL_USE_CERTIFICATE,ERR_R_MALLOC_FAILURE);
-                        return(0);
-                        }
-                if (ssl->cert != NULL) ssl_cert_free(ssl->cert);
-                ssl->cert=c;
+                SSLerr(SSL_F_SSL_USE_CERTIFICATE,ERR_R_MALLOC_FAILURE);
+                return(0);
                 }
-        c=ssl->cert;
-
-        return(ssl_set_cert(c,x));
+        return(ssl_set_cert(ssl->cert,x));
         }
 
-#ifndef NO_STDIO
-int SSL_use_certificate_file(ssl, file, type)
-SSL *ssl;
-char *file;
-int type;
+#ifndef OPENSSL_NO_STDIO
+int SSL_use_certificate_file(SSL *ssl, const char *file, int type)
         {
         int j;
         BIO *in;
@@ -130,7 +109,7 @@ int type;
         else if (type == SSL_FILETYPE_PEM)
                 {
                 j=ERR_R_PEM_LIB;
-                x=PEM_read_bio_X509(in,NULL,ssl->ctx->default_passwd_callback);
+                x=PEM_read_bio_X509(in,NULL,ssl->ctx->default_passwd_callback,ssl->ctx->default_passwd_callback_userdata);
                 }
         else
                 {
@@ -152,10 +131,7 @@ end:
         }
 #endif
 
-int SSL_use_certificate_ASN1(ssl, len, d)
-SSL *ssl;
-int len;
-unsigned char *d;
+int SSL_use_certificate_ASN1(SSL *ssl, unsigned char *d, int len)
         {
         X509 *x;
         int ret;
@@ -172,12 +148,9 @@ unsigned char *d;
         return(ret);
         }
 
-#ifndef NO_RSA
-int SSL_use_RSAPrivateKey(ssl, rsa)
-SSL *ssl;
-RSA *rsa;
+#ifndef OPENSSL_NO_RSA
+int SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa)
         {
-        CERT *c;
         EVP_PKEY *pkey;
         int ret;
 
@@ -186,37 +159,27 @@ RSA *rsa;
                 SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY,ERR_R_PASSED_NULL_PARAMETER);
                 return(0);
                 }
-
-        if ((ssl->cert == NULL) || (ssl->cert == ssl->ctx->default_cert))
-                {
-                c=ssl_cert_new();
-                if (c == NULL)
-                        {
-                        SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY,ERR_R_MALLOC_FAILURE);
-                        return(0);
-                        }
-                if (ssl->cert != NULL) ssl_cert_free(ssl->cert);
-                ssl->cert=c;
+        if (!ssl_cert_inst(&ssl->cert))
+                {
+                SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY,ERR_R_MALLOC_FAILURE);
+                return(0);
                 }
-        c=ssl->cert;
         if ((pkey=EVP_PKEY_new()) == NULL)
                 {
                 SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY,ERR_R_EVP_LIB);
                 return(0);
                 }
 
-        CRYPTO_add(&rsa->references,1,CRYPTO_LOCK_RSA);
+        RSA_up_ref(rsa);
         EVP_PKEY_assign_RSA(pkey,rsa);
 
-        ret=ssl_set_pkey(c,pkey);
+        ret=ssl_set_pkey(ssl->cert,pkey);
         EVP_PKEY_free(pkey);
         return(ret);
         }
 #endif
 
-static int ssl_set_pkey(c,pkey)
-CERT *c;
-EVP_PKEY *pkey;
+static int ssl_set_pkey(CERT *c, EVP_PKEY *pkey)
         {
         int i,ok=0,bad=0;
 
@@ -229,7 +192,13 @@ EVP_PKEY *pkey;
 
         if (c->pkeys[i].x509 != NULL)
                 {
-#ifndef NO_RSA
+                EVP_PKEY *pktmp;
+                pktmp = X509_get_pubkey(c->pkeys[i].x509);
+                EVP_PKEY_copy_parameters(pktmp,pkey);
+                EVP_PKEY_free(pktmp);
+                ERR_clear_error();
+
+#ifndef OPENSSL_NO_RSA
                 /* Don't check the public/private key, this is mostly
                  * for smart cards. */
                 if ((pkey->type == EVP_PKEY_RSA) &&
@@ -282,12 +251,9 @@ EVP_PKEY *pkey;
         return(1);
         }
 
-#ifndef NO_RSA
-#ifndef NO_STDIO
-int SSL_use_RSAPrivateKey_file(ssl, file, type)
-SSL *ssl;
-char *file;
-int type;
+#ifndef OPENSSL_NO_RSA
+#ifndef OPENSSL_NO_STDIO
+int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type)
         {
         int j,ret=0;
         BIO *in;
@@ -314,7 +280,7 @@ int type;
                 {
                 j=ERR_R_PEM_LIB;
                 rsa=PEM_read_bio_RSAPrivateKey(in,NULL,
-                        ssl->ctx->default_passwd_callback);
+                        ssl->ctx->default_passwd_callback,ssl->ctx->default_passwd_callback_userdata);
                 }
         else
                 {
@@ -334,13 +300,10 @@ end:
         }
 #endif
 
-int SSL_use_RSAPrivateKey_ASN1(ssl,d,len)
-SSL *ssl;
-unsigned char *d;
-long len;
+int SSL_use_RSAPrivateKey_ASN1(SSL *ssl, unsigned char *d, long len)
         {
         int ret;
-        unsigned char *p;
+        const unsigned char *p;
         RSA *rsa;
 
         p=d;
@@ -354,13 +317,10 @@ long len;
         RSA_free(rsa);
         return(ret);
         }
-#endif /* !NO_RSA */
+#endif /* !OPENSSL_NO_RSA */
 
-int SSL_use_PrivateKey(ssl, pkey)
-SSL *ssl;
-EVP_PKEY *pkey;
+int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey)
         {
-        CERT *c;
         int ret;
 
         if (pkey == NULL)
@@ -368,29 +328,17 @@ EVP_PKEY *pkey;
                 SSLerr(SSL_F_SSL_USE_PRIVATEKEY,ERR_R_PASSED_NULL_PARAMETER);
                 return(0);
                 }
-
-        if ((ssl->cert == NULL) || (ssl->cert == ssl->ctx->default_cert))
-                {
-                c=ssl_cert_new();
-                if (c == NULL)
-                        {
-                        SSLerr(SSL_F_SSL_USE_PRIVATEKEY,ERR_R_MALLOC_FAILURE);
-                        return(0);
-                        }
-                if (ssl->cert != NULL) ssl_cert_free(ssl->cert);
-                ssl->cert=c;
+        if (!ssl_cert_inst(&ssl->cert))
+                {
+                SSLerr(SSL_F_SSL_USE_PRIVATEKEY,ERR_R_MALLOC_FAILURE);
+                return(0);
                 }
-        c=ssl->cert;
-
-        ret=ssl_set_pkey(c,pkey);
+        ret=ssl_set_pkey(ssl->cert,pkey);
         return(ret);
         }
 
-#ifndef NO_STDIO
-int SSL_use_PrivateKey_file(ssl, file, type)
-SSL *ssl;
-char *file;
-int type;
+#ifndef OPENSSL_NO_STDIO
+int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type)
         {
         int j,ret=0;
         BIO *in;
@@ -412,7 +360,7 @@ int type;
                 {
                 j=ERR_R_PEM_LIB;
                 pkey=PEM_read_bio_PrivateKey(in,NULL,
-                        ssl->ctx->default_passwd_callback);
+                        ssl->ctx->default_passwd_callback,ssl->ctx->default_passwd_callback_userdata);
                 }
         else
                 {
@@ -432,11 +380,7 @@ end:
         }
 #endif
 
-int SSL_use_PrivateKey_ASN1(type,ssl,d,len)
-int type;
-SSL *ssl;
-unsigned char *d;
-long len;
+int SSL_use_PrivateKey_ASN1(int type, SSL *ssl, unsigned char *d, long len)
         {
         int ret;
         unsigned char *p;
@@ -454,36 +398,22 @@ long len;
         return(ret);
         }
 
-int SSL_CTX_use_certificate(ctx, x)
-SSL_CTX *ctx;
-X509 *x;
+int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x)
         {
-        CERT *c;
-
         if (x == NULL)
                 {
                 SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE,ERR_R_PASSED_NULL_PARAMETER);
                 return(0);
                 }
-
-        if (ctx->default_cert == NULL)
+        if (!ssl_cert_inst(&ctx->cert))
                 {
-                c=ssl_cert_new();
-                if (c == NULL)
-                        {
-                        SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE,ERR_R_MALLOC_FAILURE);
-                        return(0);
-                        }
-                ctx->default_cert=c;
+                SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE,ERR_R_MALLOC_FAILURE);
+                return(0);
                 }
-        c=ctx->default_cert;
-
-        return(ssl_set_cert(c,x));
+        return(ssl_set_cert(ctx->cert, x));
         }
 
-static int ssl_set_cert(c,x)
-CERT *c;
-X509 *x;
+static int ssl_set_cert(CERT *c, X509 *x)
         {
         EVP_PKEY *pkey;
         int i,ok=0,bad=0;
@@ -499,11 +429,25 @@ X509 *x;
         if (i < 0)
                 {
                 SSLerr(SSL_F_SSL_SET_CERT,SSL_R_UNKNOWN_CERTIFICATE_TYPE);
+                EVP_PKEY_free(pkey);
                 return(0);
                 }
 
         if (c->pkeys[i].privatekey != NULL)
                 {
+                EVP_PKEY_copy_parameters(pkey,c->pkeys[i].privatekey);
+                ERR_clear_error();
+
+#ifndef OPENSSL_NO_RSA
+                /* Don't check the public/private key, this is mostly
+                 * for smart cards. */
+                if ((c->pkeys[i].privatekey->type == EVP_PKEY_RSA) &&
+                        (RSA_flags(c->pkeys[i].privatekey->pkey.rsa) &
+                         RSA_METHOD_FLAG_NO_CHECK))
+                         ok=1;
+                else
+#endif
+                {
                 if (!X509_check_private_key(x,c->pkeys[i].privatekey))
                         {
                         if ((i == SSL_PKEY_DH_RSA) || (i == SSL_PKEY_DH_DSA))
@@ -527,10 +471,12 @@ X509 *x;
                         }
                 else
                         ok=1;
+                } /* OPENSSL_NO_RSA */
                 }
         else
                 ok=1;
 
+        EVP_PKEY_free(pkey);
         if (bad)
                 {
                 EVP_PKEY_free(c->pkeys[i].privatekey);
@@ -547,11 +493,8 @@ X509 *x;
         return(1);
         }
 
-#ifndef NO_STDIO
-int SSL_CTX_use_certificate_file(ctx, file, type)
-SSL_CTX *ctx;
-char *file;
-int type;
+#ifndef OPENSSL_NO_STDIO
+int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file, int type)
         {
         int j;
         BIO *in;
@@ -578,7 +521,7 @@ int type;
         else if (type == SSL_FILETYPE_PEM)
                 {
                 j=ERR_R_PEM_LIB;
-                x=PEM_read_bio_X509(in,NULL,ctx->default_passwd_callback);
+                x=PEM_read_bio_X509(in,NULL,ctx->default_passwd_callback,ctx->default_passwd_callback_userdata);
                 }
         else
                 {
@@ -600,10 +543,7 @@ end:
         }
 #endif
 
-int SSL_CTX_use_certificate_ASN1(ctx, len, d)
-SSL_CTX *ctx;
-int len;
-unsigned char *d;
+int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len, unsigned char *d)
         {
         X509 *x;
         int ret;
@@ -620,13 +560,10 @@ unsigned char *d;
         return(ret);
         }
 
-#ifndef NO_RSA
-int SSL_CTX_use_RSAPrivateKey(ctx, rsa)
-SSL_CTX *ctx;
-RSA *rsa;
+#ifndef OPENSSL_NO_RSA
+int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa)
         {
         int ret;
-        CERT *c;
         EVP_PKEY *pkey;
 
         if (rsa == NULL)
@@ -634,37 +571,27 @@ RSA *rsa;
                 SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY,ERR_R_PASSED_NULL_PARAMETER);
                 return(0);
                 }
-        if (ctx->default_cert == NULL)
+        if (!ssl_cert_inst(&ctx->cert))
                 {
-                c=ssl_cert_new();
-                if (c == NULL)
-                        {
-                        SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY,ERR_R_MALLOC_FAILURE);
-                        return(0);
-                        }
-                ctx->default_cert=c;
+                SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY,ERR_R_MALLOC_FAILURE);
+                return(0);
                 }
-        c=ctx->default_cert;
-
         if ((pkey=EVP_PKEY_new()) == NULL)
                 {
                 SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY,ERR_R_EVP_LIB);
                 return(0);
                 }
 
-        CRYPTO_add(&rsa->references,1,CRYPTO_LOCK_RSA);
+        RSA_up_ref(rsa);
         EVP_PKEY_assign_RSA(pkey,rsa);
 
-        ret=ssl_set_pkey(c,pkey);
+        ret=ssl_set_pkey(ctx->cert, pkey);
         EVP_PKEY_free(pkey);
         return(ret);
         }
 
-#ifndef NO_STDIO
-int SSL_CTX_use_RSAPrivateKey_file(ctx, file, type)
-SSL_CTX *ctx;
-char *file;
-int type;
+#ifndef OPENSSL_NO_STDIO
+int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file, int type)
         {
         int j,ret=0;
         BIO *in;
@@ -691,7 +618,7 @@ int type;
                 {
                 j=ERR_R_PEM_LIB;
                 rsa=PEM_read_bio_RSAPrivateKey(in,NULL,
-                        ctx->default_passwd_callback);
+                        ctx->default_passwd_callback,ctx->default_passwd_callback_userdata);
                 }
         else
                 {
@@ -711,13 +638,10 @@ end:
         }
 #endif
 
-int SSL_CTX_use_RSAPrivateKey_ASN1(ctx,d,len)
-SSL_CTX *ctx;
-unsigned char *d;
-long len;
+int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, unsigned char *d, long len)
         {
         int ret;
-        unsigned char *p;
+        const unsigned char *p;
         RSA *rsa;
 
         p=d;
@@ -731,40 +655,25 @@ long len;
         RSA_free(rsa);
         return(ret);
         }
-#endif /* !NO_RSA */
+#endif /* !OPENSSL_NO_RSA */
 
-int SSL_CTX_use_PrivateKey(ctx, pkey)
-SSL_CTX *ctx;
-EVP_PKEY *pkey;
+int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey)
         {
-        CERT *c;
-
         if (pkey == NULL)
                 {
                 SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY,ERR_R_PASSED_NULL_PARAMETER);
                 return(0);
                 }
-                
-        if (ctx->default_cert == NULL)
+        if (!ssl_cert_inst(&ctx->cert))
                 {
-                c=ssl_cert_new();
-                if (c == NULL)
-                        {
-                        SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY,ERR_R_MALLOC_FAILURE);
-                        return(0);
-                        }
-                ctx->default_cert=c;
+                SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY,ERR_R_MALLOC_FAILURE);
+                return(0);
                 }
-        c=ctx->default_cert;
-
-        return(ssl_set_pkey(c,pkey));
+        return(ssl_set_pkey(ctx->cert,pkey));
         }
 
-#ifndef NO_STDIO
-int SSL_CTX_use_PrivateKey_file(ctx, file, type)
-SSL_CTX *ctx;
-char *file;
-int type;
+#ifndef OPENSSL_NO_STDIO
+int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type)
         {
         int j,ret=0;
         BIO *in;
@@ -786,7 +695,7 @@ int type;
                 {
                 j=ERR_R_PEM_LIB;
                 pkey=PEM_read_bio_PrivateKey(in,NULL,
-                        ctx->default_passwd_callback);
+                        ctx->default_passwd_callback,ctx->default_passwd_callback_userdata);
                 }
         else
                 {
@@ -806,11 +715,8 @@ end:
         }
 #endif
 
-int SSL_CTX_use_PrivateKey_ASN1(type,ctx,d,len)
-int type;
-SSL_CTX *ctx;
-unsigned char *d;
-long len;
+int SSL_CTX_use_PrivateKey_ASN1(int type, SSL_CTX *ctx, unsigned char *d,
+             long len)
         {
         int ret;
         unsigned char *p;
@@ -829,3 +735,81 @@ long len;
         }
 
 
+#ifndef OPENSSL_NO_STDIO
+/* Read a file that contains our certificate in "PEM" format,
+ * possibly followed by a sequence of CA certificates that should be
+ * sent to the peer in the Certificate message.
+ */
+int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file)
+        {
+        BIO *in;
+        int ret=0;
+        X509 *x=NULL;
+
+        in=BIO_new(BIO_s_file_internal());
+        if (in == NULL)
+                {
+                SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE,ERR_R_BUF_LIB);
+                goto end;
+                }
+
+        if (BIO_read_filename(in,file) <= 0)
+                {
+                SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE,ERR_R_SYS_LIB);
+                goto end;
+                }
+
+        x=PEM_read_bio_X509(in,NULL,ctx->default_passwd_callback,ctx->default_passwd_callback_userdata);
+        if (x == NULL)
+                {
+                SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE,ERR_R_PEM_LIB);
+                goto end;
+                }
+
+        ret=SSL_CTX_use_certificate(ctx,x);
+        if (ERR_peek_error() != 0)
+                ret = 0;  /* Key/certificate mismatch doesn't imply ret==0 ... */
+        if (ret)
+                {
+                /* If we could set up our certificate, now proceed to
+                 * the CA certificates.
+                 */
+                X509 *ca;
+                int r;
+                unsigned long err;
+                
+                if (ctx->extra_certs != NULL) 
+                        {
+                        sk_X509_pop_free(ctx->extra_certs, X509_free);
+                        ctx->extra_certs = NULL;
+                        }
+
+                while ((ca = PEM_read_bio_X509(in,NULL,ctx->default_passwd_callback,ctx->default_passwd_callback_userdata))
+                        != NULL)
+                        {
+                        r = SSL_CTX_add_extra_chain_cert(ctx, ca);
+                        if (!r) 
+                                {
+                                X509_free(ca);
+                                ret = 0;
+                                goto end;
+                                }
+                        /* Note that we must not free r if it was successfully
+                         * added to the chain (while we must free the main
+                         * certificate, since its reference count is increased
+                         * by SSL_CTX_use_certificate). */
+                        }
+                /* When the while loop ends, it's usually just EOF. */
+                err = ERR_peek_last_error();
+                if (ERR_GET_LIB(err) == ERR_LIB_PEM && ERR_GET_REASON(err) == PEM_R_NO_START_LINE)
+                        (void)ERR_get_error();
+                else 
+                        ret = 0; /* some real error */
+                }
+
+end:
+        if (x != NULL) X509_free(x);
+        if (in != NULL) BIO_free(in);
+        return(ret);
+        }
+#endif
diff --git a/src/lib/libssl/ssl_sess.c b/src/lib/libssl/ssl_sess.c
index 8212600e40..6424f775e2 100644
--- a/src/lib/libssl/ssl_sess.c
+++ b/src/lib/libssl/ssl_sess.c
@@ -57,60 +57,57 @@
  */
 
 #include <stdio.h>
-#include "lhash.h"
-#include "rand.h"
+#include <openssl/lhash.h>
+#include <openssl/rand.h>
 #include "ssl_locl.h"
 
-#ifndef NOPROTO
 static void SSL_SESSION_list_remove(SSL_CTX *ctx, SSL_SESSION *s);
 static void SSL_SESSION_list_add(SSL_CTX *ctx,SSL_SESSION *s);
-#else
-static void SSL_SESSION_list_remove();
-static void SSL_SESSION_list_add();
-#endif
-
-static ssl_session_num=0;
-static STACK *ssl_session_meth=NULL;
+static int remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck);
 
-SSL_SESSION *SSL_get_session(ssl)
-SSL *ssl;
+SSL_SESSION *SSL_get_session(SSL *ssl)
+/* aka SSL_get0_session; gets 0 objects, just returns a copy of the pointer */
         {
         return(ssl->session);
         }
 
-int SSL_SESSION_get_ex_new_index(argl,argp,new_func,dup_func,free_func)
-long argl;
-char *argp;
-int (*new_func)();
-int (*dup_func)();
-void (*free_func)();
-        {
-        ssl_session_num++;
-        return(CRYPTO_get_ex_new_index(ssl_session_num-1,
-                &ssl_session_meth,
-                argl,argp,new_func,dup_func,free_func));
-        }
-
-int SSL_SESSION_set_ex_data(s,idx,arg)
-SSL_SESSION *s;
-int idx;
-char *arg;
+SSL_SESSION *SSL_get1_session(SSL *ssl)
+/* variant of SSL_get_session: caller really gets something */
+        {
+        SSL_SESSION *sess;
+        /* Need to lock this all up rather than just use CRYPTO_add so that
+         * somebody doesn't free ssl->session between when we check it's
+         * non-null and when we up the reference count. */
+        CRYPTO_r_lock(CRYPTO_LOCK_SSL_SESSION);
+        sess = ssl->session;
+        if(sess)
+                sess->references++;
+        CRYPTO_r_unlock(CRYPTO_LOCK_SSL_SESSION);
+        return(sess);
+        }
+
+int SSL_SESSION_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
+             CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
+        {
+        return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_SESSION, argl, argp,
+                        new_func, dup_func, free_func);
+        }
+
+int SSL_SESSION_set_ex_data(SSL_SESSION *s, int idx, void *arg)
         {
         return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
         }
 
-char *SSL_SESSION_get_ex_data(s,idx)
-SSL_SESSION *s;
-int idx;
+void *SSL_SESSION_get_ex_data(SSL_SESSION *s, int idx)
         {
         return(CRYPTO_get_ex_data(&s->ex_data,idx));
         }
 
-SSL_SESSION *SSL_SESSION_new()
+SSL_SESSION *SSL_SESSION_new(void)
         {
         SSL_SESSION *ss;
 
-        ss=(SSL_SESSION *)Malloc(sizeof(SSL_SESSION));
+        ss=(SSL_SESSION *)OPENSSL_malloc(sizeof(SSL_SESSION));
         if (ss == NULL)
                 {
                 SSLerr(SSL_F_SSL_SESSION_NEW,ERR_R_MALLOC_FAILURE);
@@ -118,26 +115,64 @@ SSL_SESSION *SSL_SESSION_new()
                 }
         memset(ss,0,sizeof(SSL_SESSION));
 
+        ss->verify_result = 1; /* avoid 0 (= X509_V_OK) just in case */
         ss->references=1;
         ss->timeout=60*5+4; /* 5 minute timeout by default */
         ss->time=time(NULL);
         ss->prev=NULL;
         ss->next=NULL;
-        CRYPTO_new_ex_data(ssl_session_meth,(char *)ss,&ss->ex_data);
+        ss->compress_meth=0;
+        CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, ss, &ss->ex_data);
         return(ss);
         }
 
-int ssl_get_new_session(s, session)
-SSL *s;
-int session;
+/* Even with SSLv2, we have 16 bytes (128 bits) of session ID space. SSLv3/TLSv1
+ * has 32 bytes (256 bits). As such, filling the ID with random gunk repeatedly
+ * until we have no conflict is going to complete in one iteration pretty much
+ * "most" of the time (btw: understatement). So, if it takes us 10 iterations
+ * and we still can't avoid a conflict - well that's a reasonable point to call
+ * it quits. Either the RAND code is broken or someone is trying to open roughly
+ * very close to 2^128 (or 2^256) SSL sessions to our server. How you might
+ * store that many sessions is perhaps a more interesting question ... */
+
+#define MAX_SESS_ID_ATTEMPTS 10
+static int def_generate_session_id(const SSL *ssl, unsigned char *id,
+                                unsigned int *id_len)
+{
+        unsigned int retry = 0;
+        do
+                RAND_pseudo_bytes(id, *id_len);
+        while(SSL_has_matching_session_id(ssl, id, *id_len) &&
+                (++retry < MAX_SESS_ID_ATTEMPTS));
+        if(retry < MAX_SESS_ID_ATTEMPTS)
+                return 1;
+        /* else - woops a session_id match */
+        /* XXX We should also check the external cache --
+         * but the probability of a collision is negligible, and
+         * we could not prevent the concurrent creation of sessions
+         * with identical IDs since we currently don't have means
+         * to atomically check whether a session ID already exists
+         * and make a reservation for it if it does not
+         * (this problem applies to the internal cache as well).
+         */
+        return 0;
+}
+
+int ssl_get_new_session(SSL *s, int session)
         {
+        /* This gets used by clients and servers. */
+
+        unsigned int tmp;
         SSL_SESSION *ss=NULL;
+        GEN_SESSION_CB cb = def_generate_session_id;
 
         if ((ss=SSL_SESSION_new()) == NULL) return(0);
 
         /* If the context has a default timeout, use it */
-        if (s->ctx->session_timeout != 0)
+        if (s->ctx->session_timeout == 0)
                 ss->timeout=SSL_get_default_timeout(s);
+        else
+                ss->timeout=s->ctx->session_timeout;
 
         if (s->session != NULL)
                 {
@@ -147,7 +182,7 @@ int session;
 
         if (session)
                 {
-                if (s->version == SSL2_CLIENT_VERSION)
+                if (s->version == SSL2_VERSION)
                         {
                         ss->ssl_version=SSL2_VERSION;
                         ss->session_id_length=SSL2_SSL_SESSION_ID_LENGTH;
@@ -168,18 +203,46 @@ int session;
                         SSL_SESSION_free(ss);
                         return(0);
                         }
-
-                for (;;)
+                /* Choose which callback will set the session ID */
+                CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
+                if(s->generate_session_id)
+                        cb = s->generate_session_id;
+                else if(s->ctx->generate_session_id)
+                        cb = s->ctx->generate_session_id;
+                CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
+                /* Choose a session ID */
+                tmp = ss->session_id_length;
+                if(!cb(s, ss->session_id, &tmp))
+                        {
+                        /* The callback failed */
+                        SSLerr(SSL_F_SSL_GET_NEW_SESSION,
+                                SSL_R_SSL_SESSION_ID_CALLBACK_FAILED);
+                        SSL_SESSION_free(ss);
+                        return(0);
+                        }
+                /* Don't allow the callback to set the session length to zero.
+                 * nor set it higher than it was. */
+                if(!tmp || (tmp > ss->session_id_length))
+                        {
+                        /* The callback set an illegal length */
+                        SSLerr(SSL_F_SSL_GET_NEW_SESSION,
+                                SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH);
+                        SSL_SESSION_free(ss);
+                        return(0);
+                        }
+                /* If the session length was shrunk and we're SSLv2, pad it */
+                if((tmp < ss->session_id_length) && (s->version == SSL2_VERSION))
+                        memset(ss->session_id + tmp, 0, ss->session_id_length - tmp);
+                else
+                        ss->session_id_length = tmp;
+                /* Finally, check for a conflict */
+                if(SSL_has_matching_session_id(s, ss->session_id,
+                                                ss->session_id_length))
                         {
-                        SSL_SESSION *r;
-
-                        RAND_bytes(ss->session_id,ss->session_id_length);
-                        CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
-                        r=(SSL_SESSION *)lh_retrieve(s->ctx->sessions,
-                                (char *)ss);
-                        CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
-                        if (r == NULL) break;
-                        /* else - woops a session_id match */
+                        SSLerr(SSL_F_SSL_GET_NEW_SESSION,
+                                SSL_R_SSL_SESSION_ID_CONFLICT);
+                        SSL_SESSION_free(ss);
+                        return(0);
                         }
                 }
         else
@@ -187,58 +250,100 @@ int session;
                 ss->session_id_length=0;
                 }
 
+        memcpy(ss->sid_ctx,s->sid_ctx,s->sid_ctx_length);
+        ss->sid_ctx_length=s->sid_ctx_length;
         s->session=ss;
         ss->ssl_version=s->version;
+        ss->verify_result = X509_V_OK;
 
         return(1);
         }
 
-int ssl_get_prev_session(s,session_id,len)
-SSL *s;
-unsigned char *session_id;
-int len;
+int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len)
         {
+        /* This is used only by servers. */
+
         SSL_SESSION *ret=NULL,data;
+        int fatal = 0;
 
-        /* conn_init();*/
         data.ssl_version=s->version;
         data.session_id_length=len;
         if (len > SSL_MAX_SSL_SESSION_ID_LENGTH)
-                return(0);
-        memcpy(data.session_id,session_id,len);;
+                goto err;
+        memcpy(data.session_id,session_id,len);
 
         if (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_LOOKUP))
                 {
                 CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
-                ret=(SSL_SESSION *)lh_retrieve(s->ctx->sessions,(char *)&data);
+                ret=(SSL_SESSION *)lh_retrieve(s->ctx->sessions,&data);
+                if (ret != NULL)
+                    /* don't allow other threads to steal it: */
+                    CRYPTO_add(&ret->references,1,CRYPTO_LOCK_SSL_SESSION);
                 CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
                 }
 
         if (ret == NULL)
                 {
                 int copy=1;
-
-                s->ctx->sess_miss++;
+        
+                s->ctx->stats.sess_miss++;
                 ret=NULL;
-                if ((s->ctx->get_session_cb != NULL) &&
-                        ((ret=s->ctx->get_session_cb(s,session_id,len,&copy))
-                                != NULL))
+                if (s->ctx->get_session_cb != NULL
+                    && (ret=s->ctx->get_session_cb(s,session_id,len,&copy))
+                       != NULL)
                         {
-                        s->ctx->sess_cb_hit++;
+                        s->ctx->stats.sess_cb_hit++;
+
+                        /* Increment reference count now if the session callback
+                         * asks us to do so (note that if the session structures
+                         * returned by the callback are shared between threads,
+                         * it must handle the reference count itself [i.e. copy == 0],
+                         * or things won't be thread-safe). */
+                        if (copy)
+                                CRYPTO_add(&ret->references,1,CRYPTO_LOCK_SSL_SESSION);
 
                         /* The following should not return 1, otherwise,
                          * things are very strange */
                         SSL_CTX_add_session(s->ctx,ret);
-                        /* auto free it */
-                        if (!copy)
-                                SSL_SESSION_free(ret);
                         }
-                if (ret == NULL) return(0);
+                if (ret == NULL)
+                        goto err;
+                }
+
+        /* Now ret is non-NULL, and we own one of its reference counts. */
+
+        if((s->verify_mode&SSL_VERIFY_PEER)
+           && (!s->sid_ctx_length || ret->sid_ctx_length != s->sid_ctx_length
+               || memcmp(ret->sid_ctx,s->sid_ctx,ret->sid_ctx_length)))
+            {
+                /* We've found the session named by the client, but we don't
+                 * want to use it in this context. */
+                
+                if (s->sid_ctx_length == 0)
+                        {
+                        /* application should have used SSL[_CTX]_set_session_id_context
+                         * -- we could tolerate this and just pretend we never heard
+                         * of this session, but then applications could effectively
+                         * disable the session cache by accident without anyone noticing */
+
+                        SSLerr(SSL_F_SSL_GET_PREV_SESSION,SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED);
+                        fatal = 1;
+                        goto err;
+                        }
+                else
+                        {
+#if 0 /* The client cannot always know when a session is not appropriate,
+           * so we shouldn't generate an error message. */
+
+                        SSLerr(SSL_F_SSL_GET_PREV_SESSION,SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT);
+#endif
+                        goto err; /* treat like cache miss */
+                        }
                 }
 
         if (ret->cipher == NULL)
                 {
-                char buf[5],*p;
+                unsigned char buf[5],*p;
                 unsigned long l;
 
                 p=buf;
@@ -249,25 +354,28 @@ int len;
                 else 
                         ret->cipher=ssl_get_cipher_by_char(s,&(buf[1]));
                 if (ret->cipher == NULL)
-                        return(0);
+                        goto err;
                 }
 
+
+#if 0 /* This is way too late. */
+
         /* If a thread got the session, then 'swaped', and another got
-         * it and then due to a time-out decided to 'Free' it we could
+         * it and then due to a time-out decided to 'OPENSSL_free' it we could
          * be in trouble.  So I'll increment it now, then double decrement
          * later - am I speaking rubbish?. */
         CRYPTO_add(&ret->references,1,CRYPTO_LOCK_SSL_SESSION);
+#endif
 
         if ((long)(ret->time+ret->timeout) < (long)time(NULL)) /* timeout */
                 {
-                s->ctx->sess_timeout++;
+                s->ctx->stats.sess_timeout++;
                 /* remove it from the cache */
                 SSL_CTX_remove_session(s->ctx,ret);
-                SSL_SESSION_free(ret);          /* again to actually Free it */
-                return(0);
+                goto err;
                 }
 
-        s->ctx->sess_hit++;
+        s->ctx->stats.sess_hit++;
 
         /* ret->time=time(NULL); */ /* rezero timeout? */
         /* again, just leave the session 
@@ -276,37 +384,64 @@ int len;
         if (s->session != NULL)
                 SSL_SESSION_free(s->session);
         s->session=ret;
+        s->verify_result = s->session->verify_result;
         return(1);
+
+ err:
+        if (ret != NULL)
+                SSL_SESSION_free(ret);
+        if (fatal)
+                return -1;
+        else
+                return 0;
         }
 
-int SSL_CTX_add_session(ctx,c)
-SSL_CTX *ctx;
-SSL_SESSION *c;
+int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c)
         {
         int ret=0;
         SSL_SESSION *s;
 
-        /* conn_init(); */
+        /* add just 1 reference count for the SSL_CTX's session cache
+         * even though it has two ways of access: each session is in a
+         * doubly linked list and an lhash */
         CRYPTO_add(&c->references,1,CRYPTO_LOCK_SSL_SESSION);
+        /* if session c is in already in cache, we take back the increment later */
 
         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
-        s=(SSL_SESSION *)lh_insert(ctx->sessions,(char *)c);
+        s=(SSL_SESSION *)lh_insert(ctx->sessions,c);
         
-        /* Put on the end of the queue unless it is already in the cache */
+        /* s != NULL iff we already had a session with the given PID.
+         * In this case, s == c should hold (then we did not really modify
+         * ctx->sessions), or we're in trouble. */
+        if (s != NULL && s != c)
+                {
+                /* We *are* in trouble ... */
+                SSL_SESSION_list_remove(ctx,s);
+                SSL_SESSION_free(s);
+                /* ... so pretend the other session did not exist in cache
+                 * (we cannot handle two SSL_SESSION structures with identical
+                 * session ID in the same cache, which could happen e.g. when
+                 * two threads concurrently obtain the same session from an external
+                 * cache) */
+                s = NULL;
+                }
+
+        /* Put at the head of the queue unless it is already in the cache */
         if (s == NULL)
                 SSL_SESSION_list_add(ctx,c);
 
-        /* If the same session if is being 're-added', Free the old
-         * one when the last person stops using it.
-         * This will also work if it is alread in the cache.
-         * The references will go up and then down :-) */
         if (s != NULL)
                 {
-                SSL_SESSION_free(s);
+                /* existing cache entry -- decrement previously incremented reference
+                 * count because it already takes into account the cache */
+
+                SSL_SESSION_free(s); /* s == c */
                 ret=0;
                 }
         else
                 {
+                /* new cache entry -- remove old ones if cache has become too large */
+                
                 ret=1;
 
                 if (SSL_CTX_sess_get_cache_size(ctx) > 0)
@@ -314,11 +449,11 @@ SSL_SESSION *c;
                         while (SSL_CTX_sess_number(ctx) >
                                 SSL_CTX_sess_get_cache_size(ctx))
                                 {
-                                if (!SSL_CTX_remove_session(ctx,
-                                        ctx->session_cache_tail))
+                                if (!remove_session_lock(ctx,
+                                        ctx->session_cache_tail, 0))
                                         break;
                                 else
-                                        ctx->sess_cache_full++;
+                                        ctx->stats.sess_cache_full++;
                                 }
                         }
                 }
@@ -326,24 +461,27 @@ SSL_SESSION *c;
         return(ret);
         }
 
-int SSL_CTX_remove_session(ctx,c)
-SSL_CTX *ctx;
-SSL_SESSION *c;
+int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c)
+{
+        return remove_session_lock(ctx, c, 1);
+}
+
+static int remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck)
         {
         SSL_SESSION *r;
         int ret=0;
 
         if ((c != NULL) && (c->session_id_length != 0))
                 {
-                CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
-                r=(SSL_SESSION *)lh_delete(ctx->sessions,(char *)c);
-                if (r != NULL)
+                if(lck) CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
+                if ((r = (SSL_SESSION *)lh_retrieve(ctx->sessions,c)) == c)
                         {
                         ret=1;
+                        r=(SSL_SESSION *)lh_delete(ctx->sessions,c);
                         SSL_SESSION_list_remove(ctx,c);
                         }
 
-                CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
+                if(lck) CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
 
                 if (ret)
                         {
@@ -358,11 +496,13 @@ SSL_SESSION *c;
         return(ret);
         }
 
-void SSL_SESSION_free(ss)
-SSL_SESSION *ss;
+void SSL_SESSION_free(SSL_SESSION *ss)
         {
         int i;
 
+        if(ss == NULL)
+            return;
+
         i=CRYPTO_add(&ss->references,-1,CRYPTO_LOCK_SSL_SESSION);
 #ifdef REF_PRINT
         REF_PRINT("SSL_SESSION",ss);
@@ -376,21 +516,19 @@ SSL_SESSION *ss;
                 }
 #endif
 
-        CRYPTO_free_ex_data(ssl_session_meth,(char *)ss,&ss->ex_data);
+        CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, ss, &ss->ex_data);
 
         memset(ss->key_arg,0,SSL_MAX_KEY_ARG_LENGTH);
         memset(ss->master_key,0,SSL_MAX_MASTER_KEY_LENGTH);
         memset(ss->session_id,0,SSL_MAX_SSL_SESSION_ID_LENGTH);
-        if (ss->cert != NULL) ssl_cert_free(ss->cert);
+        if (ss->sess_cert != NULL) ssl_sess_cert_free(ss->sess_cert);
         if (ss->peer != NULL) X509_free(ss->peer);
-        if (ss->ciphers != NULL) sk_free(ss->ciphers);
+        if (ss->ciphers != NULL) sk_SSL_CIPHER_free(ss->ciphers);
         memset(ss,0,sizeof(*ss));
-        Free(ss);
+        OPENSSL_free(ss);
         }
 
-int SSL_set_session(s, session)
-SSL *s;
-SSL_SESSION *session;
+int SSL_set_session(SSL *s, SSL_SESSION *session)
         {
         int ret=0;
         SSL_METHOD *meth;
@@ -410,14 +548,29 @@ SSL_SESSION *session;
                         {
                         if (!SSL_set_ssl_method(s,meth))
                                 return(0);
-                        session->timeout=SSL_get_default_timeout(s);
+                        if (s->ctx->session_timeout == 0)
+                                session->timeout=SSL_get_default_timeout(s);
+                        else
+                                session->timeout=s->ctx->session_timeout;
                         }
 
+#ifndef OPENSSL_NO_KRB5
+                if (s->kssl_ctx && !s->kssl_ctx->client_princ &&
+                    session->krb5_client_princ_len > 0)
+                {
+                    s->kssl_ctx->client_princ = (char *)malloc(session->krb5_client_princ_len + 1);
+                    memcpy(s->kssl_ctx->client_princ,session->krb5_client_princ,
+                            session->krb5_client_princ_len);
+                    s->kssl_ctx->client_princ[session->krb5_client_princ_len] = '\0';
+                }
+#endif /* OPENSSL_NO_KRB5 */
+
                 /* CRYPTO_w_lock(CRYPTO_LOCK_SSL);*/
                 CRYPTO_add(&session->references,1,CRYPTO_LOCK_SSL_SESSION);
                 if (s->session != NULL)
                         SSL_SESSION_free(s->session);
                 s->session=session;
+                s->verify_result = s->session->verify_result;
                 /* CRYPTO_w_unlock(CRYPTO_LOCK_SSL);*/
                 ret=1;
                 }
@@ -428,42 +581,59 @@ SSL_SESSION *session;
                         SSL_SESSION_free(s->session);
                         s->session=NULL;
                         }
+
+                meth=s->ctx->method;
+                if (meth != s->method)
+                        {
+                        if (!SSL_set_ssl_method(s,meth))
+                                return(0);
+                        }
+                ret=1;
                 }
         return(ret);
         }
 
-long SSL_SESSION_set_timeout(s,t)
-SSL_SESSION *s;
-long t;
+long SSL_SESSION_set_timeout(SSL_SESSION *s, long t)
         {
         if (s == NULL) return(0);
         s->timeout=t;
         return(1);
         }
 
-long SSL_SESSION_get_timeout(s)
-SSL_SESSION *s;
+long SSL_SESSION_get_timeout(SSL_SESSION *s)
         {
         if (s == NULL) return(0);
         return(s->timeout);
         }
 
-long SSL_SESSION_get_time(s)
-SSL_SESSION *s;
+long SSL_SESSION_get_time(SSL_SESSION *s)
         {
         if (s == NULL) return(0);
         return(s->time);
         }
 
-long SSL_SESSION_set_time(s,t)
-SSL_SESSION *s;
-long t;
+long SSL_SESSION_set_time(SSL_SESSION *s, long t)
         {
         if (s == NULL) return(0);
         s->time=t;
         return(t);
         }
 
+long SSL_CTX_set_timeout(SSL_CTX *s, long t)
+        {
+        long l;
+        if (s == NULL) return(0);
+        l=s->session_timeout;
+        s->session_timeout=t;
+        return(l);
+        }
+
+long SSL_CTX_get_timeout(SSL_CTX *s)
+        {
+        if (s == NULL) return(0);
+        return(s->session_timeout);
+        }
+
 typedef struct timeout_param_st
         {
         SSL_CTX *ctx;
@@ -471,15 +641,13 @@ typedef struct timeout_param_st
         LHASH *cache;
         } TIMEOUT_PARAM;
 
-static void timeout(s,p)
-SSL_SESSION *s;
-TIMEOUT_PARAM *p;
+static void timeout(SSL_SESSION *s, TIMEOUT_PARAM *p)
         {
         if ((p->time == 0) || (p->time > (s->time+s->timeout))) /* timeout */
                 {
                 /* The reason we don't call SSL_CTX_remove_session() is to
                  * save on locking overhead */
-                lh_delete(p->cache,(char *)s);
+                lh_delete(p->cache,s);
                 SSL_SESSION_list_remove(p->ctx,s);
                 s->not_resumable=1;
                 if (p->ctx->remove_session_cb != NULL)
@@ -488,27 +656,26 @@ TIMEOUT_PARAM *p;
                 }
         }
 
-void SSL_CTX_flush_sessions(s,t)
-SSL_CTX *s;
-long t;
+static IMPLEMENT_LHASH_DOALL_ARG_FN(timeout, SSL_SESSION *, TIMEOUT_PARAM *)
+
+void SSL_CTX_flush_sessions(SSL_CTX *s, long t)
         {
         unsigned long i;
         TIMEOUT_PARAM tp;
 
         tp.ctx=s;
-        tp.cache=SSL_CTX_sessions(s);
+        tp.cache=s->sessions;
         if (tp.cache == NULL) return;
         tp.time=t;
         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
         i=tp.cache->down_load;
         tp.cache->down_load=0;
-        lh_doall_arg(tp.cache,(void (*)())timeout,(char *)&tp);
+        lh_doall_arg(tp.cache, LHASH_DOALL_ARG_FN(timeout), &tp);
         tp.cache->down_load=i;
         CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
         }
 
-int ssl_clear_bad_session(s)
-SSL *s;
+int ssl_clear_bad_session(SSL *s)
         {
         if (    (s->session != NULL) &&
                 !(s->shutdown & SSL_SENT_SHUTDOWN) &&
@@ -522,9 +689,7 @@ SSL *s;
         }
 
 /* locked by SSL_CTX in the calling function */
-static void SSL_SESSION_list_remove(ctx,s)
-SSL_CTX *ctx;
-SSL_SESSION *s;
+static void SSL_SESSION_list_remove(SSL_CTX *ctx, SSL_SESSION *s)
         {
         if ((s->next == NULL) || (s->prev == NULL)) return;
 
@@ -557,9 +722,7 @@ SSL_SESSION *s;
         s->prev=s->next=NULL;
         }
 
-static void SSL_SESSION_list_add(ctx,s)
-SSL_CTX *ctx;
-SSL_SESSION *s;
+static void SSL_SESSION_list_add(SSL_CTX *ctx, SSL_SESSION *s)
         {
         if ((s->next != NULL) && (s->prev != NULL))
                 SSL_SESSION_list_remove(ctx,s);
diff --git a/src/lib/libssl/ssl_stat.c b/src/lib/libssl/ssl_stat.c
index a1daf25dd4..b16d253081 100644
--- a/src/lib/libssl/ssl_stat.c
+++ b/src/lib/libssl/ssl_stat.c
@@ -59,23 +59,22 @@
 #include <stdio.h>
 #include "ssl_locl.h"
 
-char *SSL_state_string_long(s)
-SSL *s;
+const char *SSL_state_string_long(const SSL *s)
         {
-        char *str;
+        const char *str;
 
         switch (s->state)
                 {
-case SSL_ST_BEFORE: str="before SSL initalisation"; break;
-case SSL_ST_ACCEPT: str="before accept initalisation"; break;
-case SSL_ST_CONNECT: str="before connect initalisation"; break;
+case SSL_ST_BEFORE: str="before SSL initialization"; break;
+case SSL_ST_ACCEPT: str="before accept initialization"; break;
+case SSL_ST_CONNECT: str="before connect initialization"; break;
 case SSL_ST_OK: str="SSL negotiation finished successfully"; break;
 case SSL_ST_RENEGOTIATE:        str="SSL renegotiate ciphers"; break;
-case SSL_ST_BEFORE|SSL_ST_CONNECT: str="before/connect initalisation"; break;
-case SSL_ST_OK|SSL_ST_CONNECT: str="ok/connect SSL initalisation"; break;
-case SSL_ST_BEFORE|SSL_ST_ACCEPT: str="before/accept initalisation"; break;
-case SSL_ST_OK|SSL_ST_ACCEPT: str="ok/accept SSL initalisation"; break;
-#ifndef NO_SSL2
+case SSL_ST_BEFORE|SSL_ST_CONNECT: str="before/connect initialization"; break;
+case SSL_ST_OK|SSL_ST_CONNECT: str="ok/connect SSL initialization"; break;
+case SSL_ST_BEFORE|SSL_ST_ACCEPT: str="before/accept initialization"; break;
+case SSL_ST_OK|SSL_ST_ACCEPT: str="ok/accept SSL initialization"; break;
+#ifndef OPENSSL_NO_SSL2
 case SSL2_ST_CLIENT_START_ENCRYPTION: str="SSLv2 client start encryption"; break;
 case SSL2_ST_SERVER_START_ENCRYPTION: str="SSLv2 server start encryption"; break;
 case SSL2_ST_SEND_CLIENT_HELLO_A: str="SSLv2 write client hello A"; break;
@@ -116,7 +115,7 @@ case SSL2_ST_X509_GET_SERVER_CERTIFICATE: str="SSLv2 X509 read server certificat
 case SSL2_ST_X509_GET_CLIENT_CERTIFICATE: str="SSLv2 X509 read client certificate"; break;
 #endif
 
-#ifndef NO_SSL3
+#ifndef OPENSSL_NO_SSL3
 /* SSLv3 additions */
 case SSL3_ST_CW_CLNT_HELLO_A:   str="SSLv3 write client hello A"; break;
 case SSL3_ST_CW_CLNT_HELLO_B:   str="SSLv3 write client hello B"; break;
@@ -132,10 +131,12 @@ case SSL3_ST_CR_SRVR_DONE_A:	str="SSLv3 read server done A"; break;
 case SSL3_ST_CR_SRVR_DONE_B:    str="SSLv3 read server done B"; break;
 case SSL3_ST_CW_CERT_A:         str="SSLv3 write client certificate A"; break;
 case SSL3_ST_CW_CERT_B:         str="SSLv3 write client certificate B"; break;
+case SSL3_ST_CW_CERT_C:         str="SSLv3 write client certificate C"; break;
+case SSL3_ST_CW_CERT_D:         str="SSLv3 write client certificate D"; break;
 case SSL3_ST_CW_KEY_EXCH_A:     str="SSLv3 write client key exchange A"; break;
 case SSL3_ST_CW_KEY_EXCH_B:     str="SSLv3 write client key exchange B"; break;
 case SSL3_ST_CW_CERT_VRFY_A:    str="SSLv3 write certificate verify A"; break;
-case SSL3_ST_CW_CERT_VRFY_B:    str="SSLv3 write certificate verify A"; break;
+case SSL3_ST_CW_CERT_VRFY_B:    str="SSLv3 write certificate verify B"; break;
 
 case SSL3_ST_CW_CHANGE_A:
 case SSL3_ST_SW_CHANGE_A:       str="SSLv3 write change cipher spec A"; break;
@@ -144,7 +145,7 @@ case SSL3_ST_SW_CHANGE_B:	str="SSLv3 write change cipher spec B"; break;
 case SSL3_ST_CW_FINISHED_A:     
 case SSL3_ST_SW_FINISHED_A:     str="SSLv3 write finished A"; break;
 case SSL3_ST_CW_FINISHED_B:     
-case SSL3_ST_SW_FINISHED_B:     str="SSLv3 write finished A"; break;
+case SSL3_ST_SW_FINISHED_B:     str="SSLv3 write finished B"; break;
 case SSL3_ST_CR_CHANGE_A:       
 case SSL3_ST_SR_CHANGE_A:       str="SSLv3 read change cipher spec A"; break;
 case SSL3_ST_CR_CHANGE_B:       
@@ -181,8 +182,8 @@ case SSL3_ST_SR_CERT_VRFY_A:	str="SSLv3 read certificate verify A"; break;
 case SSL3_ST_SR_CERT_VRFY_B:    str="SSLv3 read certificate verify B"; break;
 #endif
 
-#if !defined(NO_SSL2) && !defined(NO_SSL3)
-/* SSLv2/v3 compatablitity states */
+#if !defined(OPENSSL_NO_SSL2) && !defined(OPENSSL_NO_SSL3)
+/* SSLv2/v3 compatibility states */
 /* client */
 case SSL23_ST_CW_CLNT_HELLO_A:  str="SSLv2/v3 write client hello A"; break;
 case SSL23_ST_CW_CLNT_HELLO_B:  str="SSLv2/v3 write client hello B"; break;
@@ -198,10 +199,9 @@ default:	str="unknown state"; break;
         return(str);
         }
 
-char *SSL_rstate_string_long(s)
-SSL *s;
+const char *SSL_rstate_string_long(const SSL *s)
         {
-        char *str;
+        const char *str;
 
         switch (s->rstate)
                 {
@@ -213,10 +213,9 @@ SSL *s;
         return(str);
         }
 
-char *SSL_state_string(s)
-SSL *s;
+const char *SSL_state_string(const SSL *s)
         {
-        char *str;
+        const char *str;
 
         switch (s->state)
                 {
@@ -224,7 +223,7 @@ case SSL_ST_BEFORE:				str="PINIT "; break;
 case SSL_ST_ACCEPT:                             str="AINIT "; break;
 case SSL_ST_CONNECT:                            str="CINIT "; break;
 case SSL_ST_OK:                                 str="SSLOK "; break;
-#ifndef NO_SSL2
+#ifndef OPENSSL_NO_SSL2
 case SSL2_ST_CLIENT_START_ENCRYPTION:           str="2CSENC"; break;
 case SSL2_ST_SERVER_START_ENCRYPTION:           str="2SSENC"; break;
 case SSL2_ST_SEND_CLIENT_HELLO_A:               str="2SCH_A"; break;
@@ -265,7 +264,7 @@ case SSL2_ST_X509_GET_SERVER_CERTIFICATE:	str="2X9GSC"; break;
 case SSL2_ST_X509_GET_CLIENT_CERTIFICATE:       str="2X9GCC"; break;
 #endif
 
-#ifndef NO_SSL3
+#ifndef OPENSSL_NO_SSL3
 /* SSLv3 additions */
 case SSL3_ST_SW_FLUSH:
 case SSL3_ST_CW_FLUSH:                          str="3FLUSH"; break;
@@ -283,6 +282,8 @@ case SSL3_ST_CR_SRVR_DONE_A:			str="3RSD_A"; break;
 case SSL3_ST_CR_SRVR_DONE_B:                    str="3RSD_B"; break;
 case SSL3_ST_CW_CERT_A:                         str="3WCC_A"; break;
 case SSL3_ST_CW_CERT_B:                         str="3WCC_B"; break;
+case SSL3_ST_CW_CERT_C:                         str="3WCC_C"; break;
+case SSL3_ST_CW_CERT_D:                         str="3WCC_D"; break;
 case SSL3_ST_CW_KEY_EXCH_A:                     str="3WCKEA"; break;
 case SSL3_ST_CW_KEY_EXCH_B:                     str="3WCKEB"; break;
 case SSL3_ST_CW_CERT_VRFY_A:                    str="3WCV_A"; break;
@@ -329,8 +330,8 @@ case SSL3_ST_SR_CERT_VRFY_A:			str="3RCV_A"; break;
 case SSL3_ST_SR_CERT_VRFY_B:                    str="3RCV_B"; break;
 #endif
 
-#if !defined(NO_SSL2) && !defined(NO_SSL3)
-/* SSLv2/v3 compatablitity states */
+#if !defined(OPENSSL_NO_SSL2) && !defined(OPENSSL_NO_SSL3)
+/* SSLv2/v3 compatibility states */
 /* client */
 case SSL23_ST_CW_CLNT_HELLO_A:                  str="23WCHA"; break;
 case SSL23_ST_CW_CLNT_HELLO_B:                  str="23WCHB"; break;
@@ -346,8 +347,7 @@ default:					str="UNKWN "; break;
         return(str);
         }
 
-char *SSL_alert_type_string_long(value)
-int value;
+const char *SSL_alert_type_string_long(int value)
         {
         value>>=8;
         if (value == SSL3_AL_WARNING)
@@ -358,8 +358,7 @@ int value;
                 return("unknown");
         }
 
-char *SSL_alert_type_string(value)
-int value;
+const char *SSL_alert_type_string(int value)
         {
         value>>=8;
         if (value == SSL3_AL_WARNING)
@@ -370,10 +369,9 @@ int value;
                 return("U");
         }
 
-char *SSL_alert_desc_string(value)
-int value;
+const char *SSL_alert_desc_string(int value)
         {
-        char *str;
+        const char *str;
 
         switch (value & 0xff)
                 {
@@ -389,15 +387,26 @@ int value;
         case SSL3_AD_CERTIFICATE_EXPIRED:       str="CE"; break;
         case SSL3_AD_CERTIFICATE_UNKNOWN:       str="CU"; break;
         case SSL3_AD_ILLEGAL_PARAMETER:         str="IP"; break;
+        case TLS1_AD_DECRYPTION_FAILED:         str="DC"; break;
+        case TLS1_AD_RECORD_OVERFLOW:           str="RO"; break;
+        case TLS1_AD_UNKNOWN_CA:                str="CA"; break;
+        case TLS1_AD_ACCESS_DENIED:             str="AD"; break;
+        case TLS1_AD_DECODE_ERROR:              str="DE"; break;
+        case TLS1_AD_DECRYPT_ERROR:             str="CY"; break;
+        case TLS1_AD_EXPORT_RESTRICTION:        str="ER"; break;
+        case TLS1_AD_PROTOCOL_VERSION:          str="PV"; break;
+        case TLS1_AD_INSUFFICIENT_SECURITY:     str="IS"; break;
+        case TLS1_AD_INTERNAL_ERROR:            str="IE"; break;
+        case TLS1_AD_USER_CANCELLED:            str="US"; break;
+        case TLS1_AD_NO_RENEGOTIATION:          str="NR"; break;
         default:                                str="UK"; break;
                 }
         return(str);
         }
 
-char *SSL_alert_desc_string_long(value)
-int value;
+const char *SSL_alert_desc_string_long(int value)
         {
-        char *str;
+        const char *str;
 
         switch (value & 0xff)
                 {
@@ -405,7 +414,7 @@ int value;
                 str="close notify";
                 break;
         case SSL3_AD_UNEXPECTED_MESSAGE:
-                str="unexected_message";
+                str="unexpected_message";
                 break;
         case SSL3_AD_BAD_RECORD_MAC:
                 str="bad record mac";
@@ -432,20 +441,55 @@ int value;
                 str="certificate expired";
                 break;
         case SSL3_AD_CERTIFICATE_UNKNOWN:
-                str="certifcate unknown";
+                str="certificate unknown";
                 break;
         case SSL3_AD_ILLEGAL_PARAMETER:
                 str="illegal parameter";
                 break;
+        case TLS1_AD_DECRYPTION_FAILED:
+                str="decryption failed";
+                break;
+        case TLS1_AD_RECORD_OVERFLOW:
+                str="record overflow";
+                break;
+        case TLS1_AD_UNKNOWN_CA:
+                str="unknown CA";
+                break;
+        case TLS1_AD_ACCESS_DENIED:
+                str="access denied";
+                break;
+        case TLS1_AD_DECODE_ERROR:
+                str="decode error";
+                break;
+        case TLS1_AD_DECRYPT_ERROR:
+                str="decrypt error";
+                break;
+        case TLS1_AD_EXPORT_RESTRICTION:
+                str="export restriction";
+                break;
+        case TLS1_AD_PROTOCOL_VERSION:
+                str="protocol version";
+                break;
+        case TLS1_AD_INSUFFICIENT_SECURITY:
+                str="insufficient security";
+                break;
+        case TLS1_AD_INTERNAL_ERROR:
+                str="internal error";
+                break;
+        case TLS1_AD_USER_CANCELLED:
+                str="user canceled";
+                break;
+        case TLS1_AD_NO_RENEGOTIATION:
+                str="no renegotiation";
+                break;
         default: str="unknown"; break;
                 }
         return(str);
         }
 
-char *SSL_rstate_string(s)
-SSL *s;
+const char *SSL_rstate_string(const SSL *s)
         {
-        char *str;
+        const char *str;
 
         switch (s->rstate)
                 {
diff --git a/src/lib/libssl/ssl_txt.c b/src/lib/libssl/ssl_txt.c
index ce60e1a6dd..40b76b1b26 100644
--- a/src/lib/libssl/ssl_txt.c
+++ b/src/lib/libssl/ssl_txt.c
@@ -57,35 +57,31 @@
  */
 
 #include <stdio.h>
-#include "buffer.h"
+#include <openssl/buffer.h>
 #include "ssl_locl.h"
 
-#ifndef NO_FP_API
-int SSL_SESSION_print_fp(fp, x)
-FILE *fp;
-SSL_SESSION *x;
-        {
-        BIO *b;
-        int ret;
+#ifndef OPENSSL_NO_FP_API
+int SSL_SESSION_print_fp(FILE *fp, SSL_SESSION *x)
+        {
+        BIO *b;
+        int ret;
 
-        if ((b=BIO_new(BIO_s_file_internal())) == NULL)
+        if ((b=BIO_new(BIO_s_file_internal())) == NULL)
                 {
                 SSLerr(SSL_F_SSL_SESSION_PRINT_FP,ERR_R_BUF_LIB);
-                return(0);
+                return(0);
                 }
-        BIO_set_fp(b,fp,BIO_NOCLOSE);
-        ret=SSL_SESSION_print(b,x);
-        BIO_free(b);
-        return(ret);
-        }
+        BIO_set_fp(b,fp,BIO_NOCLOSE);
+        ret=SSL_SESSION_print(b,x);
+        BIO_free(b);
+        return(ret);
+        }
 #endif
 
-int SSL_SESSION_print(bp,x)
-BIO *bp;
-SSL_SESSION *x;
+int SSL_SESSION_print(BIO *bp, SSL_SESSION *x)
         {
-        int i;
-        char str[128],*s;
+        unsigned int i;
+        char *s;
 
         if (x == NULL) goto err;
         if (BIO_puts(bp,"SSL-Session:\n") <= 0) goto err;
@@ -97,30 +93,41 @@ SSL_SESSION *x;
                 s="TLSv1";
         else
                 s="unknown";
-        sprintf(str,"    Protocol  : %s\n",s);
-        if (BIO_puts(bp,str) <= 0) goto err;
+        if (BIO_printf(bp,"    Protocol  : %s\n",s) <= 0) goto err;
 
         if (x->cipher == NULL)
                 {
                 if (((x->cipher_id) & 0xff000000) == 0x02000000)
-                        sprintf(str,"    Cipher    : %06lX\n",x->cipher_id&0xffffff);
+                        {
+                        if (BIO_printf(bp,"    Cipher    : %06lX\n",x->cipher_id&0xffffff) <= 0)
+                                goto err;
+                        }
                 else
-                        sprintf(str,"    Cipher    : %04lX\n",x->cipher_id&0xffff);
+                        {
+                        if (BIO_printf(bp,"    Cipher    : %04lX\n",x->cipher_id&0xffff) <= 0)
+                                goto err;
+                        }
                 }
         else
-                sprintf(str,"    Cipher    : %s\n",(x->cipher == NULL)?"unknown":x->cipher->name);
-        if (BIO_puts(bp,str) <= 0) goto err;
+                {
+                if (BIO_printf(bp,"    Cipher    : %s\n",((x->cipher == NULL)?"unknown":x->cipher->name)) <= 0)
+                        goto err;
+                }
         if (BIO_puts(bp,"    Session-ID: ") <= 0) goto err;
-        for (i=0; i<(int)x->session_id_length; i++)
+        for (i=0; i<x->session_id_length; i++)
+                {
+                if (BIO_printf(bp,"%02X",x->session_id[i]) <= 0) goto err;
+                }
+        if (BIO_puts(bp,"\n    Session-ID-ctx: ") <= 0) goto err;
+        for (i=0; i<x->sid_ctx_length; i++)
                 {
-                sprintf(str,"%02X",x->session_id[i]);
-                if (BIO_puts(bp,str) <= 0) goto err;
+                if (BIO_printf(bp,"%02X",x->sid_ctx[i]) <= 0)
+                        goto err;
                 }
         if (BIO_puts(bp,"\n    Master-Key: ") <= 0) goto err;
-        for (i=0; i<(int)x->master_key_length; i++)
+        for (i=0; i<(unsigned int)x->master_key_length; i++)
                 {
-                sprintf(str,"%02X",x->master_key[i]);
-                if (BIO_puts(bp,str) <= 0) goto err;
+                if (BIO_printf(bp,"%02X",x->master_key[i]) <= 0) goto err;
                 }
         if (BIO_puts(bp,"\n    Key-Arg   : ") <= 0) goto err;
         if (x->key_arg_length == 0)
@@ -128,22 +135,49 @@ SSL_SESSION *x;
                 if (BIO_puts(bp,"None") <= 0) goto err;
                 }
         else
-                for (i=0; i<(int)x->key_arg_length; i++)
+                for (i=0; i<x->key_arg_length; i++)
                         {
-                        sprintf(str,"%02X",x->key_arg[i]);
-                        if (BIO_puts(bp,str) <= 0) goto err;
+                        if (BIO_printf(bp,"%02X",x->key_arg[i]) <= 0) goto err;
                         }
+#ifndef OPENSSL_NO_KRB5
+       if (BIO_puts(bp,"\n    Krb5 Principal: ") <= 0) goto err;
+            if (x->krb5_client_princ_len == 0)
+            {
+                if (BIO_puts(bp,"None") <= 0) goto err;
+                }
+        else
+                for (i=0; i<x->krb5_client_princ_len; i++)
+                        {
+                        if (BIO_printf(bp,"%02X",x->krb5_client_princ[i]) <= 0) goto err;
+                        }
+#endif /* OPENSSL_NO_KRB5 */
+        if (x->compress_meth != 0)
+                {
+                SSL_COMP *comp;
+
+                ssl_cipher_get_evp(x,NULL,NULL,&comp);
+                if (comp == NULL)
+                        {
+                        if (BIO_printf(bp,"\n   Compression: %d",x->compress_meth) <= 0) goto err;
+                        }
+                else
+                        {
+                        if (BIO_printf(bp,"\n   Compression: %d (%s)", comp->id,comp->method->name) <= 0) goto err;
+                        }
+                }       
         if (x->time != 0L)
                 {
-                sprintf(str,"\n    Start Time: %ld",x->time);
-                if (BIO_puts(bp,str) <= 0) goto err;
+                if (BIO_printf(bp, "\n    Start Time: %ld",x->time) <= 0) goto err;
                 }
         if (x->timeout != 0L)
                 {
-                sprintf(str,"\n    Timeout   : %ld (sec)",x->timeout);
-                if (BIO_puts(bp,str) <= 0) goto err;
+                if (BIO_printf(bp, "\n    Timeout   : %ld (sec)",x->timeout) <= 0) goto err;
                 }
         if (BIO_puts(bp,"\n") <= 0) goto err;
+
+        if (BIO_puts(bp, "    Verify return code: ") <= 0) goto err;
+        if (BIO_printf(bp, "%ld (%s)\n", x->verify_result,
+                X509_verify_cert_error_string(x->verify_result)) <= 0) goto err;
                 
         return(1);
 err:
diff --git a/src/lib/libssl/t1_clnt.c b/src/lib/libssl/t1_clnt.c
index 986d2436e2..9745630a00 100644
--- a/src/lib/libssl/t1_clnt.c
+++ b/src/lib/libssl/t1_clnt.c
@@ -57,14 +57,14 @@
  */
 
 #include <stdio.h>
-#include "buffer.h"
-#include "rand.h"
-#include "objects.h"
-#include "evp.h"
+#include <openssl/buffer.h>
+#include <openssl/rand.h>
+#include <openssl/objects.h>
+#include <openssl/evp.h>
 #include "ssl_locl.h"
 
-static SSL_METHOD *tls1_get_client_method(ver)
-int ver;
+static SSL_METHOD *tls1_get_client_method(int ver);
+static SSL_METHOD *tls1_get_client_method(int ver)
         {
         if (ver == TLS1_VERSION)
                 return(TLSv1_client_method());
@@ -72,18 +72,18 @@ int ver;
                 return(NULL);
         }
 
-SSL_METHOD *TLSv1_client_method()
+SSL_METHOD *TLSv1_client_method(void)
         {
         static int init=1;
         static SSL_METHOD TLSv1_client_data;
 
         if (init)
                 {
-                init=0;
                 memcpy((char *)&TLSv1_client_data,(char *)tlsv1_base_method(),
                         sizeof(SSL_METHOD));
                 TLSv1_client_data.ssl_connect=ssl3_connect;
                 TLSv1_client_data.get_ssl_method=tls1_get_client_method;
+                init=0;
                 }
         return(&TLSv1_client_data);
         }
diff --git a/src/lib/libssl/t1_enc.c b/src/lib/libssl/t1_enc.c
index fbdd3bffb5..b80525f3ba 100644
--- a/src/lib/libssl/t1_enc.c
+++ b/src/lib/libssl/t1_enc.c
@@ -55,20 +55,70 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
+/* ====================================================================
+ * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
 
 #include <stdio.h>
-#include "evp.h"
-#include "hmac.h"
+#include <openssl/comp.h>
+#include <openssl/evp.h>
+#include <openssl/hmac.h>
 #include "ssl_locl.h"
+#include <openssl/md5.h>
 
-static void tls1_P_hash(md,sec,sec_len,seed,seed_len,out,olen)
-EVP_MD *md;
-unsigned char *sec;
-int sec_len;
-unsigned char *seed;
-int seed_len;
-unsigned char *out;
-int olen;
+static void tls1_P_hash(const EVP_MD *md, const unsigned char *sec,
+                        int sec_len, unsigned char *seed, int seed_len,
+                        unsigned char *out, int olen)
         {
         int chunk,n;
         unsigned int j;
@@ -79,16 +129,20 @@ int olen;
         
         chunk=EVP_MD_size(md);
 
-        HMAC_Init(&ctx,sec,sec_len,md);
+        HMAC_CTX_init(&ctx);
+        HMAC_CTX_init(&ctx_tmp);
+        HMAC_Init_ex(&ctx,sec,sec_len,md, NULL);
+        HMAC_Init_ex(&ctx_tmp,sec,sec_len,md, NULL);
         HMAC_Update(&ctx,seed,seed_len);
         HMAC_Final(&ctx,A1,&A1_len);
 
         n=0;
         for (;;)
                 {
-                HMAC_Init(&ctx,NULL,0,NULL); /* re-init */
+                HMAC_Init_ex(&ctx,NULL,0,NULL,NULL); /* re-init */
+                HMAC_Init_ex(&ctx_tmp,NULL,0,NULL,NULL); /* re-init */
                 HMAC_Update(&ctx,A1,A1_len);
-                memcpy(&ctx_tmp,&ctx,sizeof(ctx)); /* Copy for A2 */ /* not needed for last one */
+                HMAC_Update(&ctx_tmp,A1,A1_len);
                 HMAC_Update(&ctx,seed,seed_len);
 
                 if (olen > chunk)
@@ -105,24 +159,18 @@ int olen;
                         break;
                         }
                 }
-        HMAC_cleanup(&ctx);
-        HMAC_cleanup(&ctx_tmp);
+        HMAC_CTX_cleanup(&ctx);
+        HMAC_CTX_cleanup(&ctx_tmp);
         memset(A1,0,sizeof(A1));
         }
 
-static void tls1_PRF(md5,sha1,label,label_len,sec,slen,out1,out2,olen)
-EVP_MD *md5;
-EVP_MD *sha1;
-unsigned char *label;
-int label_len;
-unsigned char *sec;
-int slen;
-unsigned char *out1;
-unsigned char *out2;
-int olen;
+static void tls1_PRF(const EVP_MD *md5, const EVP_MD *sha1,
+                     unsigned char *label, int label_len,
+                     const unsigned char *sec, int slen, unsigned char *out1,
+                     unsigned char *out2, int olen)
         {
         int len,i;
-        unsigned char *S1,*S2;
+        const unsigned char *S1,*S2;
 
         len=slen/2;
         S1=sec;
@@ -137,10 +185,8 @@ int olen;
                 out1[i]^=out2[i];
         }
 
-static void tls1_generate_key_block(s,km,tmp,num)
-SSL *s;
-unsigned char *km,*tmp;
-int num;
+static void tls1_generate_key_block(SSL *s, unsigned char *km,
+             unsigned char *tmp, int num)
         {
         unsigned char *p;
         unsigned char buf[SSL3_RANDOM_SIZE*2+
@@ -155,15 +201,25 @@ int num;
         memcpy(p,s->s3->client_random,SSL3_RANDOM_SIZE);
         p+=SSL3_RANDOM_SIZE;
 
-        tls1_PRF(s->ctx->md5,s->ctx->sha1,buf,p-buf,
-                s->session->master_key,s->session->master_key_length,
-                km,tmp,num);
+        tls1_PRF(s->ctx->md5,s->ctx->sha1,buf,(int)(p-buf),
+                 s->session->master_key,s->session->master_key_length,
+                 km,tmp,num);
+#ifdef KSSL_DEBUG
+        printf("tls1_generate_key_block() ==> %d byte master_key =\n\t",
+                s->session->master_key_length);
+        {
+        int i;
+        for (i=0; i < s->session->master_key_length; i++)
+                {
+                printf("%02X", s->session->master_key[i]);
+                }
+        printf("\n");  }
+#endif    /* KSSL_DEBUG */
         }
 
-int tls1_change_cipher_state(s,which)
-SSL *s;
-int which;
+int tls1_change_cipher_state(SSL *s, int which)
         {
+        static const unsigned char empty[]="";
         unsigned char *p,*key_block,*mac_secret;
         unsigned char *exp_label,buf[TLS_MD_MAX_CONST_SIZE+
                 SSL3_RANDOM_SIZE*2];
@@ -174,47 +230,103 @@ int which;
         unsigned char *ms,*key,*iv,*er1,*er2;
         int client_write;
         EVP_CIPHER_CTX *dd;
-        EVP_CIPHER *c;
-        SSL_COMPRESSION *comp;
-        EVP_MD *m;
-        int exp,n,i,j,k,exp_label_len;
+        const EVP_CIPHER *c;
+        const SSL_COMP *comp;
+        const EVP_MD *m;
+        int is_export,n,i,j,k,exp_label_len,cl;
+        int reuse_dd = 0;
 
-        exp=(s->s3->tmp.new_cipher->algorithms & SSL_EXPORT)?1:0;
+        is_export=SSL_C_IS_EXPORT(s->s3->tmp.new_cipher);
         c=s->s3->tmp.new_sym_enc;
         m=s->s3->tmp.new_hash;
         comp=s->s3->tmp.new_compression;
         key_block=s->s3->tmp.key_block;
 
+#ifdef KSSL_DEBUG
+        printf("tls1_change_cipher_state(which= %d) w/\n", which);
+        printf("\talg= %ld, comp= %p\n", s->s3->tmp.new_cipher->algorithms,
+                comp);
+        printf("\tevp_cipher == %p ==? &d_cbc_ede_cipher3\n", c);
+        printf("\tevp_cipher: nid, blksz= %d, %d, keylen=%d, ivlen=%d\n",
+                c->nid,c->block_size,c->key_len,c->iv_len);
+        printf("\tkey_block: len= %d, data= ", s->s3->tmp.key_block_length);
+        {
+        int i;
+        for (i=0; i<s->s3->tmp.key_block_length; i++)
+                printf("%02x", key_block[i]);  printf("\n");
+        }
+#endif  /* KSSL_DEBUG */
+
         if (which & SSL3_CC_READ)
                 {
-                if ((s->enc_read_ctx == NULL) &&
-                        ((s->enc_read_ctx=(EVP_CIPHER_CTX *)
-                        Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
+                if (s->enc_read_ctx != NULL)
+                        reuse_dd = 1;
+                else if ((s->enc_read_ctx=OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL)
                         goto err;
                 dd= s->enc_read_ctx;
                 s->read_hash=m;
-                s->read_compression=comp;
+                if (s->expand != NULL)
+                        {
+                        COMP_CTX_free(s->expand);
+                        s->expand=NULL;
+                        }
+                if (comp != NULL)
+                        {
+                        s->expand=COMP_CTX_new(comp->method);
+                        if (s->expand == NULL)
+                                {
+                                SSLerr(SSL_F_TLS1_CHANGE_CIPHER_STATE,SSL_R_COMPRESSION_LIBRARY_ERROR);
+                                goto err2;
+                                }
+                        if (s->s3->rrec.comp == NULL)
+                                s->s3->rrec.comp=(unsigned char *)
+                                        OPENSSL_malloc(SSL3_RT_MAX_ENCRYPTED_LENGTH);
+                        if (s->s3->rrec.comp == NULL)
+                                goto err;
+                        }
                 memset(&(s->s3->read_sequence[0]),0,8);
                 mac_secret= &(s->s3->read_mac_secret[0]);
                 }
         else
                 {
+                if (s->enc_write_ctx != NULL)
+                        reuse_dd = 1;
+                else if ((s->enc_write_ctx=OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL)
+                        goto err;
                 if ((s->enc_write_ctx == NULL) &&
                         ((s->enc_write_ctx=(EVP_CIPHER_CTX *)
-                        Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
+                        OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
                         goto err;
                 dd= s->enc_write_ctx;
                 s->write_hash=m;
-                s->write_compression=comp;
+                if (s->compress != NULL)
+                        {
+                        COMP_CTX_free(s->compress);
+                        s->compress=NULL;
+                        }
+                if (comp != NULL)
+                        {
+                        s->compress=COMP_CTX_new(comp->method);
+                        if (s->compress == NULL)
+                                {
+                                SSLerr(SSL_F_TLS1_CHANGE_CIPHER_STATE,SSL_R_COMPRESSION_LIBRARY_ERROR);
+                                goto err2;
+                                }
+                        }
                 memset(&(s->s3->write_sequence[0]),0,8);
                 mac_secret= &(s->s3->write_mac_secret[0]);
                 }
 
+        if (reuse_dd)
+                EVP_CIPHER_CTX_cleanup(dd);
         EVP_CIPHER_CTX_init(dd);
 
         p=s->s3->tmp.key_block;
         i=EVP_MD_size(m);
-        j=(exp)?5:EVP_CIPHER_key_length(c);
+        cl=EVP_CIPHER_key_length(c);
+        j=is_export ? (cl < SSL_C_EXPORT_KEYLENGTH(s->s3->tmp.new_cipher) ?
+                       cl : SSL_C_EXPORT_KEYLENGTH(s->s3->tmp.new_cipher)) : cl;
+        /* Was j=(exp)?5:EVP_CIPHER_key_length(c); */
         k=EVP_CIPHER_iv_length(c);
         er1= &(s->s3->client_random[0]);
         er2= &(s->s3->server_random[0]);
@@ -241,7 +353,7 @@ int which;
 
         if (n > s->s3->tmp.key_block_length)
                 {
-                SSLerr(SSL_F_TLS1_CHANGE_CIPHER_STATE,SSL_R_INTERNAL_ERROR);
+                SSLerr(SSL_F_TLS1_CHANGE_CIPHER_STATE,ERR_R_INTERNAL_ERROR);
                 goto err2;
                 }
 
@@ -250,7 +362,7 @@ int which;
 printf("which = %04X\nmac key=",which);
 { int z; for (z=0; z<i; z++) printf("%02X%c",ms[z],((z+1)%16)?' ':'\n'); }
 #endif
-        if (exp)
+        if (is_export)
                 {
                 /* In here I set both the read and write key/iv to the
                  * same value since only the correct one will be used :-).
@@ -262,8 +374,8 @@ printf("which = %04X\nmac key=",which);
                 p+=SSL3_RANDOM_SIZE;
                 memcpy(p,s->s3->server_random,SSL3_RANDOM_SIZE);
                 p+=SSL3_RANDOM_SIZE;
-                tls1_PRF(s->ctx->md5,s->ctx->sha1,buf,p-buf,key,j,
-                        tmp1,tmp2,EVP_CIPHER_key_length(c));
+                tls1_PRF(s->ctx->md5,s->ctx->sha1,buf,(int)(p-buf),key,j,
+                         tmp1,tmp2,EVP_CIPHER_key_length(c));
                 key=tmp1;
 
                 if (k > 0)
@@ -276,8 +388,8 @@ printf("which = %04X\nmac key=",which);
                         p+=SSL3_RANDOM_SIZE;
                         memcpy(p,s->s3->server_random,SSL3_RANDOM_SIZE);
                         p+=SSL3_RANDOM_SIZE;
-                        tls1_PRF(s->ctx->md5,s->ctx->sha1,
-                                buf,p-buf,"",0,iv1,iv2,k*2);
+                        tls1_PRF(s->ctx->md5,s->ctx->sha1,buf,p-buf,empty,0,
+                                 iv1,iv2,k*2);
                         if (client_write)
                                 iv=iv1;
                         else
@@ -286,8 +398,18 @@ printf("which = %04X\nmac key=",which);
                 }
 
         s->session->key_arg_length=0;
+#ifdef KSSL_DEBUG
+        {
+        int i;
+        printf("EVP_CipherInit_ex(dd,c,key=,iv=,which)\n");
+        printf("\tkey= "); for (i=0; i<c->key_len; i++) printf("%02x", key[i]);
+        printf("\n");
+        printf("\t iv= "); for (i=0; i<c->iv_len; i++) printf("%02x", iv[i]);
+        printf("\n");
+        }
+#endif  /* KSSL_DEBUG */
 
-        EVP_CipherInit(dd,c,key,iv,(which & SSL3_CC_WRITE));
+        EVP_CipherInit_ex(dd,c,NULL,key,iv,(which & SSL3_CC_WRITE));
 #ifdef TLS_DEBUG
 printf("which = %04X\nkey=",which);
 { int z; for (z=0; z<EVP_CIPHER_key_length(c); z++) printf("%02X%c",key[z],((z+1)%16)?' ':'\n'); }
@@ -307,18 +429,22 @@ err2:
         return(0);
         }
 
-int tls1_setup_key_block(s)
-SSL *s;
+int tls1_setup_key_block(SSL *s)
         {
         unsigned char *p1,*p2;
-        EVP_CIPHER *c;
-        EVP_MD *hash;
-        int num,exp;
+        const EVP_CIPHER *c;
+        const EVP_MD *hash;
+        int num;
+        SSL_COMP *comp;
+
+#ifdef KSSL_DEBUG
+        printf ("tls1_setup_key_block()\n");
+#endif  /* KSSL_DEBUG */
 
         if (s->s3->tmp.key_block_length != 0)
                 return(1);
 
-        if (!ssl_cipher_get_evp(s->session->cipher,&c,&hash))
+        if (!ssl_cipher_get_evp(s->session,&c,&hash,&comp))
                 {
                 SSLerr(SSL_F_TLS1_SETUP_KEY_BLOCK,SSL_R_CIPHER_OR_HASH_UNAVAILABLE);
                 return(0);
@@ -327,16 +453,14 @@ SSL *s;
         s->s3->tmp.new_sym_enc=c;
         s->s3->tmp.new_hash=hash;
 
-        exp=(s->session->cipher->algorithms & SSL_EXPORT)?1:0;
-
         num=EVP_CIPHER_key_length(c)+EVP_MD_size(hash)+EVP_CIPHER_iv_length(c);
         num*=2;
 
         ssl3_cleanup_key_block(s);
 
-        if ((p1=(unsigned char *)Malloc(num)) == NULL)
+        if ((p1=(unsigned char *)OPENSSL_malloc(num)) == NULL)
                 goto err;
-        if ((p2=(unsigned char *)Malloc(num)) == NULL)
+        if ((p2=(unsigned char *)OPENSSL_malloc(num)) == NULL)
                 goto err;
 
         s->s3->tmp.key_block_length=num;
@@ -353,28 +477,33 @@ printf("pre-master\n");
 #endif
         tls1_generate_key_block(s,p1,p2,num);
         memset(p2,0,num);
-        Free(p2);
+        OPENSSL_free(p2);
 #ifdef TLS_DEBUG
 printf("\nkey block\n");
 { int z; for (z=0; z<num; z++) printf("%02X%c",p1[z],((z+1)%16)?' ':'\n'); }
 #endif
 
+        /* enable vulnerability countermeasure for CBC ciphers with
+         * known-IV problem (http://www.openssl.org/~bodo/tls-cbc.txt) */
+        s->s3->need_empty_fragments = 1;
+#ifndef NO_RC4
+        if ((s->session->cipher != NULL) && ((s->session->cipher->algorithms & SSL_ENC_MASK) == SSL_RC4))
+                s->s3->need_empty_fragments = 0;
+#endif
+                
         return(1);
 err:
         SSLerr(SSL_F_TLS1_SETUP_KEY_BLOCK,ERR_R_MALLOC_FAILURE);
         return(0);
         }
 
-int tls1_enc(s,send)
-SSL *s;
-int send;
+int tls1_enc(SSL *s, int send)
         {
         SSL3_RECORD *rec;
         EVP_CIPHER_CTX *ds;
         unsigned long l;
         int bs,i,ii,j,k,n=0;
-        EVP_CIPHER *enc;
-        SSL_COMPRESSION *comp;
+        const EVP_CIPHER *enc;
 
         if (send)
                 {
@@ -383,12 +512,9 @@ int send;
                 ds=s->enc_write_ctx;
                 rec= &(s->s3->wrec);
                 if (s->enc_write_ctx == NULL)
-                        { enc=NULL; comp=NULL; }
+                        enc=NULL;
                 else
-                        {
                         enc=EVP_CIPHER_CTX_cipher(s->enc_write_ctx);
-                        comp=s->write_compression;
-                        }
                 }
         else
                 {
@@ -397,18 +523,19 @@ int send;
                 ds=s->enc_read_ctx;
                 rec= &(s->s3->rrec);
                 if (s->enc_read_ctx == NULL)
-                        { enc=NULL; comp=NULL; }
+                        enc=NULL;
                 else
-                        {
                         enc=EVP_CIPHER_CTX_cipher(s->enc_read_ctx);
-                        comp=s->read_compression;
-                        }
                 }
 
+#ifdef KSSL_DEBUG
+        printf("tls1_enc(%d)\n", send);
+#endif    /* KSSL_DEBUG */
+
         if ((s->session == NULL) || (ds == NULL) ||
-                ((enc == NULL) && (comp == NULL)))
+                (enc == NULL))
                 {
-                memcpy(rec->data,rec->input,rec->length);
+                memmove(rec->data,rec->input,rec->length);
                 rec->input=rec->data;
                 }
         else
@@ -435,11 +562,48 @@ int send;
                         rec->length+=i;
                         }
 
+#ifdef KSSL_DEBUG
+                {
+                unsigned long ui;
+                printf("EVP_Cipher(ds=%p,rec->data=%p,rec->input=%p,l=%ld) ==>\n",
+                        ds,rec->data,rec->input,l);
+                printf("\tEVP_CIPHER_CTX: %d buf_len, %d key_len [%d %d], %d iv_len\n",
+                        ds->buf_len, ds->cipher->key_len,
+                        DES_KEY_SZ, DES_SCHEDULE_SZ,
+                        ds->cipher->iv_len);
+                printf("\t\tIV: ");
+                for (i=0; i<ds->cipher->iv_len; i++) printf("%02X", ds->iv[i]);
+                printf("\n");
+                printf("\trec->input=");
+                for (ui=0; ui<l; ui++) printf(" %02x", rec->input[ui]);
+                printf("\n");
+                }
+#endif  /* KSSL_DEBUG */
+
+                if (!send)
+                        {
+                        if (l == 0 || l%bs != 0)
+                                {
+                                SSLerr(SSL_F_TLS1_ENC,SSL_R_BLOCK_CIPHER_PAD_IS_WRONG);
+                                ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_DECRYPTION_FAILED);
+                                return 0;
+                                }
+                        }
+                
                 EVP_Cipher(ds,rec->data,rec->input,l);
 
+#ifdef KSSL_DEBUG
+                {
+                unsigned long i;
+                printf("\trec->data=");
+                for (i=0; i<l; i++)
+                        printf(" %02x", rec->data[i]);  printf("\n");
+                }
+#endif  /* KSSL_DEBUG */
+
                 if ((bs != 1) && !send)
                         {
-                        ii=i=rec->data[l-1];
+                        ii=i=rec->data[l-1]; /* padding_length */
                         i++;
                         if (s->options&SSL_OP_TLS_BLOCK_PADDING_BUG)
                                 {
@@ -450,19 +614,22 @@ int send;
                                 if (s->s3->flags & TLS1_FLAGS_TLS_PADDING_BUG)
                                         i--;
                                 }
+                        /* TLS 1.0 does not bound the number of padding bytes by the block size.
+                         * All of them must have value 'padding_length'. */
                         if (i > (int)rec->length)
                                 {
-                                SSLerr(SSL_F_TLS1_ENC,SSL_R_BLOCK_CIPHER_PAD_IS_WRONG);
-                                ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_DECRYPTION_FAILED);
-                                return(0);
+                                /* Incorrect padding. SSLerr() and ssl3_alert are done
+                                 * by caller: we don't want to reveal whether this is
+                                 * a decryption error or a MAC verification failure
+                                 * (see http://www.openssl.org/~bodo/tls-cbc.txt) */
+                                return -1;
                                 }
                         for (j=(int)(l-i); j<(int)l; j++)
                                 {
                                 if (rec->data[j] != ii)
                                         {
-                                        SSLerr(SSL_F_TLS1_ENC,SSL_R_DECRYPTION_FAILED);
-                                        ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_DECRYPTION_FAILED);
-                                        return(0);
+                                        /* Incorrect padding */
+                                        return -1;
                                         }
                                 }
                         rec->length-=i;
@@ -471,25 +638,20 @@ int send;
         return(1);
         }
 
-int tls1_cert_verify_mac(s,in_ctx,out)
-SSL *s;
-EVP_MD_CTX *in_ctx;
-unsigned char *out;
+int tls1_cert_verify_mac(SSL *s, EVP_MD_CTX *in_ctx, unsigned char *out)
         {
         unsigned int ret;
         EVP_MD_CTX ctx;
 
-        memcpy(&ctx,in_ctx,sizeof(EVP_MD_CTX));
-        EVP_DigestFinal(&ctx,out,&ret);
+        EVP_MD_CTX_init(&ctx);
+        EVP_MD_CTX_copy_ex(&ctx,in_ctx);
+        EVP_DigestFinal_ex(&ctx,out,&ret);
+        EVP_MD_CTX_cleanup(&ctx);
         return((int)ret);
         }
 
-int tls1_final_finish_mac(s,in1_ctx,in2_ctx,str,slen,out)
-SSL *s;
-EVP_MD_CTX *in1_ctx,*in2_ctx;
-unsigned char *str;
-int slen;
-unsigned char *out;
+int tls1_final_finish_mac(SSL *s, EVP_MD_CTX *in1_ctx, EVP_MD_CTX *in2_ctx,
+             const char *str, int slen, unsigned char *out)
         {
         unsigned int i;
         EVP_MD_CTX ctx;
@@ -500,29 +662,27 @@ unsigned char *out;
         memcpy(q,str,slen);
         q+=slen;
 
-        memcpy(&ctx,in1_ctx,sizeof(EVP_MD_CTX));
-        EVP_DigestFinal(&ctx,q,&i);
+        EVP_MD_CTX_init(&ctx);
+        EVP_MD_CTX_copy_ex(&ctx,in1_ctx);
+        EVP_DigestFinal_ex(&ctx,q,&i);
         q+=i;
-        memcpy(&ctx,in2_ctx,sizeof(EVP_MD_CTX));
-        EVP_DigestFinal(&ctx,q,&i);
+        EVP_MD_CTX_copy_ex(&ctx,in2_ctx);
+        EVP_DigestFinal_ex(&ctx,q,&i);
         q+=i;
 
-        tls1_PRF(s->ctx->md5,s->ctx->sha1,buf,q-buf,
+        tls1_PRF(s->ctx->md5,s->ctx->sha1,buf,(int)(q-buf),
                 s->session->master_key,s->session->master_key_length,
                 out,buf2,12);
-        memset(&ctx,0,sizeof(EVP_MD_CTX));
+        EVP_MD_CTX_cleanup(&ctx);
 
         return((int)12);
         }
 
-int tls1_mac(ssl,md,send)
-SSL *ssl;
-unsigned char *md;
-int send;
+int tls1_mac(SSL *ssl, unsigned char *md, int send)
         {
         SSL3_RECORD *rec;
         unsigned char *mac_sec,*seq;
-        EVP_MD *hash;
+        const EVP_MD *hash;
         unsigned int md_size;
         int i;
         HMAC_CTX hmac;
@@ -552,41 +712,47 @@ int send;
         buf[4]=rec->length&0xff;
 
         /* I should fix this up TLS TLS TLS TLS TLS XXXXXXXX */
-        HMAC_Init(&hmac,mac_sec,EVP_MD_size(hash),hash);
+        HMAC_CTX_init(&hmac);
+        HMAC_Init_ex(&hmac,mac_sec,EVP_MD_size(hash),hash,NULL);
         HMAC_Update(&hmac,seq,8);
         HMAC_Update(&hmac,buf,5);
         HMAC_Update(&hmac,rec->input,rec->length);
         HMAC_Final(&hmac,md,&md_size);
+        HMAC_CTX_cleanup(&hmac);
 
 #ifdef TLS_DEBUG
 printf("sec=");
-{int z; for (z=0; z<md_size; z++) printf("%02X ",mac_sec[z]); printf("\n"); }
+{unsigned int z; for (z=0; z<md_size; z++) printf("%02X ",mac_sec[z]); printf("\n"); }
 printf("seq=");
 {int z; for (z=0; z<8; z++) printf("%02X ",seq[z]); printf("\n"); }
 printf("buf=");
 {int z; for (z=0; z<5; z++) printf("%02X ",buf[z]); printf("\n"); }
 printf("rec=");
-{int z; for (z=0; z<rec->length; z++) printf("%02X ",buf[z]); printf("\n"); }
+{unsigned int z; for (z=0; z<rec->length; z++) printf("%02X ",buf[z]); printf("\n"); }
 #endif
 
         for (i=7; i>=0; i--)
-                if (++seq[i]) break; 
+                {
+                ++seq[i];
+                if (seq[i] != 0) break; 
+                }
 
 #ifdef TLS_DEBUG
-{int z; for (z=0; z<md_size; z++) printf("%02X ",md[z]); printf("\n"); }
+{unsigned int z; for (z=0; z<md_size; z++) printf("%02X ",md[z]); printf("\n"); }
 #endif
         return(md_size);
         }
 
-int tls1_generate_master_secret(s,out,p,len)
-SSL *s;
-unsigned char *out;
-unsigned char *p;
-int len;
+int tls1_generate_master_secret(SSL *s, unsigned char *out, unsigned char *p,
+             int len)
         {
         unsigned char buf[SSL3_RANDOM_SIZE*2+TLS_MD_MASTER_SECRET_CONST_SIZE];
         unsigned char buff[SSL_MAX_MASTER_KEY_LENGTH];
 
+#ifdef KSSL_DEBUG
+        printf ("tls1_generate_master_secret(%p,%p, %p, %d)\n", s,out, p,len);
+#endif  /* KSSL_DEBUG */
+
         /* Setup the stuff to munge */
         memcpy(buf,TLS_MD_MASTER_SECRET_CONST,
                 TLS_MD_MASTER_SECRET_CONST_SIZE);
@@ -597,11 +763,13 @@ int len;
         tls1_PRF(s->ctx->md5,s->ctx->sha1,
                 buf,TLS_MD_MASTER_SECRET_CONST_SIZE+SSL3_RANDOM_SIZE*2,p,len,
                 s->session->master_key,buff,SSL3_MASTER_SECRET_SIZE);
+#ifdef KSSL_DEBUG
+        printf ("tls1_generate_master_secret() complete\n");
+#endif  /* KSSL_DEBUG */
         return(SSL3_MASTER_SECRET_SIZE);
         }
 
-int tls1_alert_code(code)
-int code;
+int tls1_alert_code(int code)
         {
         switch (code)
                 {
@@ -623,11 +791,11 @@ int code;
         case SSL_AD_ACCESS_DENIED:      return(TLS1_AD_ACCESS_DENIED);
         case SSL_AD_DECODE_ERROR:       return(TLS1_AD_DECODE_ERROR);
         case SSL_AD_DECRYPT_ERROR:      return(TLS1_AD_DECRYPT_ERROR);
-        case SSL_AD_EXPORT_RESTRICION:  return(TLS1_AD_EXPORT_RESTRICION);
+        case SSL_AD_EXPORT_RESTRICTION: return(TLS1_AD_EXPORT_RESTRICTION);
         case SSL_AD_PROTOCOL_VERSION:   return(TLS1_AD_PROTOCOL_VERSION);
         case SSL_AD_INSUFFICIENT_SECURITY:return(TLS1_AD_INSUFFICIENT_SECURITY);
         case SSL_AD_INTERNAL_ERROR:     return(TLS1_AD_INTERNAL_ERROR);
-        case SSL_AD_USER_CANCLED:       return(TLS1_AD_USER_CANCLED);
+        case SSL_AD_USER_CANCELLED:     return(TLS1_AD_USER_CANCELLED);
         case SSL_AD_NO_RENEGOTIATION:   return(TLS1_AD_NO_RENEGOTIATION);
         default:                        return(-1);
                 }
diff --git a/src/lib/libssl/t1_lib.c b/src/lib/libssl/t1_lib.c
index f9fbfa414c..ca6c03d5af 100644
--- a/src/lib/libssl/t1_lib.c
+++ b/src/lib/libssl/t1_lib.c
@@ -57,16 +57,12 @@
  */
 
 #include <stdio.h>
-#include "objects.h"
+#include <openssl/objects.h>
 #include "ssl_locl.h"
 
-char *tls1_version_str="TLSv1 part of SSLeay 0.9.0b 29-Jun-1998";
+const char *tls1_version_str="TLSv1" OPENSSL_VERSION_PTEXT;
 
-#ifndef NO_PROTO
 static long tls1_default_timeout(void);
-#else
-static long tls1_default_timeout();
-#endif
 
 static SSL3_ENC_METHOD TLSv1_enc_data={
         tls1_enc,
@@ -94,6 +90,7 @@ static SSL_METHOD TLSv1_data= {
         ssl3_write,
         ssl3_shutdown,
         ssl3_renegotiate,
+        ssl3_renegotiate_check,
         ssl3_ctrl,
         ssl3_ctx_ctrl,
         ssl3_get_cipher_by_char,
@@ -104,47 +101,48 @@ static SSL_METHOD TLSv1_data= {
         ssl_bad_method,
         tls1_default_timeout,
         &TLSv1_enc_data,
+        ssl_undefined_function,
+        ssl3_callback_ctrl,
+        ssl3_ctx_callback_ctrl,
         };
 
-static long tls1_default_timeout()
+static long tls1_default_timeout(void)
         {
         /* 2 hours, the 24 hours mentioned in the TLSv1 spec
          * is way too long for http, the cache would over fill */
         return(60*60*2);
         }
 
-SSL_METHOD *tlsv1_base_method()
+SSL_METHOD *tlsv1_base_method(void)
         {
         return(&TLSv1_data);
         }
 
-int tls1_new(s)
-SSL *s;
+int tls1_new(SSL *s)
         {
         if (!ssl3_new(s)) return(0);
         s->method->ssl_clear(s);
         return(1);
         }
 
-void tls1_free(s)
-SSL *s;
+void tls1_free(SSL *s)
         {
         ssl3_free(s);
         }
 
-void tls1_clear(s)
-SSL *s;
+void tls1_clear(SSL *s)
         {
         ssl3_clear(s);
         s->version=TLS1_VERSION;
         }
 
 #if 0
-long tls1_ctrl(s,cmd,larg,parg)
-SSL *s;
-int cmd;
-long larg;
-char *parg;
+long tls1_ctrl(SSL *s, int cmd, long larg, char *parg)
+        {
+        return(0);
+        }
+
+long tls1_callback_ctrl(SSL *s, int cmd, void *(*fp)())
         {
         return(0);
         }
diff --git a/src/lib/libssl/t1_meth.c b/src/lib/libssl/t1_meth.c
index 512c2078e7..9bb36a7d1c 100644
--- a/src/lib/libssl/t1_meth.c
+++ b/src/lib/libssl/t1_meth.c
@@ -57,11 +57,11 @@
  */
 
 #include <stdio.h>
-#include "objects.h"
+#include <openssl/objects.h>
 #include "ssl_locl.h"
 
-static SSL_METHOD *tls1_get_method(ver)
-int ver;
+static SSL_METHOD *tls1_get_method(int ver);
+static SSL_METHOD *tls1_get_method(int ver)
         {
         if (ver == TLS1_VERSION)
                 return(TLSv1_method());
@@ -69,19 +69,19 @@ int ver;
                 return(NULL);
         }
 
-SSL_METHOD *TLSv1_method()
+SSL_METHOD *TLSv1_method(void)
         {
         static int init=1;
         static SSL_METHOD TLSv1_data;
 
         if (init)
                 {
-                init=0;
                 memcpy((char *)&TLSv1_data,(char *)tlsv1_base_method(),
                         sizeof(SSL_METHOD));
                 TLSv1_data.ssl_connect=ssl3_connect;
                 TLSv1_data.ssl_accept=ssl3_accept;
                 TLSv1_data.get_ssl_method=tls1_get_method;
+                init=0;
                 }
         return(&TLSv1_data);
         }
diff --git a/src/lib/libssl/t1_srvr.c b/src/lib/libssl/t1_srvr.c
index 8cf0addcd9..996b7ca8e2 100644
--- a/src/lib/libssl/t1_srvr.c
+++ b/src/lib/libssl/t1_srvr.c
@@ -57,15 +57,15 @@
  */
 
 #include <stdio.h>
-#include "buffer.h"
-#include "rand.h"
-#include "objects.h"
-#include "evp.h"
-#include "x509.h"
+#include <openssl/buffer.h>
+#include <openssl/rand.h>
+#include <openssl/objects.h>
+#include <openssl/evp.h>
+#include <openssl/x509.h>
 #include "ssl_locl.h"
 
-static SSL_METHOD *tls1_get_server_method(ver)
-int ver;
+static SSL_METHOD *tls1_get_server_method(int ver);
+static SSL_METHOD *tls1_get_server_method(int ver)
         {
         if (ver == TLS1_VERSION)
                 return(TLSv1_server_method());
@@ -73,18 +73,18 @@ int ver;
                 return(NULL);
         }
 
-SSL_METHOD *TLSv1_server_method()
+SSL_METHOD *TLSv1_server_method(void)
         {
         static int init=1;
         static SSL_METHOD TLSv1_server_data;
 
         if (init)
                 {
-                init=0;
                 memcpy((char *)&TLSv1_server_data,(char *)tlsv1_base_method(),
                         sizeof(SSL_METHOD));
                 TLSv1_server_data.ssl_accept=ssl3_accept;
                 TLSv1_server_data.get_ssl_method=tls1_get_server_method;
+                init=0;
                 }
         return(&TLSv1_server_data);
         }
diff --git a/src/lib/libssl/test/methtest.c b/src/lib/libssl/test/methtest.c
index 630d29dc91..06ccb3b310 100644
--- a/src/lib/libssl/test/methtest.c
+++ b/src/lib/libssl/test/methtest.c
@@ -58,10 +58,10 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "rsa.h"
-#include "x509.h"
+#include <openssl/rsa.h>
+#include <openssl/x509.h>
 #include "meth.h"
-#include "err.h"
+#include <openssl/err.h>
 
 int main(argc,argv)
 int argc;
diff --git a/src/lib/libssl/test/tcrl b/src/lib/libssl/test/tcrl
index 859fba452f..acaf8f3c47 100644
--- a/src/lib/libssl/test/tcrl
+++ b/src/lib/libssl/test/tcrl
@@ -3,7 +3,7 @@
 PATH=../apps:$PATH
 export PATH
 
-cmd='../apps/ssleay crl'
+cmd='../apps/openssl crl'
 
 if [ "$1"x != "x" ]; then
         t=$1
diff --git a/src/lib/libssl/test/testca b/src/lib/libssl/test/testca
index a28402f9ca..88c186b6ab 100644
--- a/src/lib/libssl/test/testca
+++ b/src/lib/libssl/test/testca
@@ -23,7 +23,7 @@ if [ $? != 0 ]; then
 fi
 
 
-SSLEAY_CONFIG="-config ../apps/ssleay.cnf"
+SSLEAY_CONFIG="-config ../apps/openssl.cnf"
 export SSLEAY_CONFIG
 $SH ../apps/CA.sh -sign  <<EOF
 y
diff --git a/src/lib/libssl/test/testenc b/src/lib/libssl/test/testenc
index 42db56c2be..0656c7f525 100644
--- a/src/lib/libssl/test/testenc
+++ b/src/lib/libssl/test/testenc
@@ -2,7 +2,7 @@
 
 testsrc=Makefile.ssl
 test=./p
-cmd=../apps/ssleay
+cmd=../apps/openssl
 
 cat $testsrc >$test;
 
@@ -27,15 +27,7 @@ else
         /bin/rm $test.cipher $test.clear
 fi
 
-for i in rc4 \
-        des-cfb des-ede-cfb des-ede3-cfb \
-        des-ofb des-ede-ofb des-ede3-ofb \
-        des-ecb des-ede des-ede3 desx \
-        des-cbc des-ede-cbc des-ede3-cbc \
-        idea-ecb idea-cfb idea-ofb idea-cbc \
-        rc2-ecb rc2-cfb rc2-ofb rc2-cbc \
-        bf-ecb bf-cfb bf-ofb bf-cbc rc4 \
-        cast5-ecb cast5-cfb cast5-ofb cast5-cbc
+for i in `$cmd list-cipher-commands`
 do
         echo $i
         $cmd $i -bufsize 113 -e -k test < $test > $test.$i.cipher
diff --git a/src/lib/libssl/test/testgen b/src/lib/libssl/test/testgen
index 12a4ca4cea..6a4b6b9221 100644
--- a/src/lib/libssl/test/testgen
+++ b/src/lib/libssl/test/testgen
@@ -11,17 +11,25 @@ export PATH
 
 echo "generating certificate request"
 
-echo "There should be a 2 sequences of .'s and some +'s."
-echo "There should not be more that at most 80 per line"
+echo "string to make the random number generator think it has entropy" >> ./.rnd
+
+if ../apps/openssl no-rsa; then
+  req_new='-newkey dsa:../apps/dsa512.pem'
+else
+  req_new='-new'
+  echo "There should be a 2 sequences of .'s and some +'s."
+  echo "There should not be more that at most 80 per line"
+fi
+
 echo "This could take some time."
 
-../apps/ssleay req -config test.cnf -new -out testreq.pem
+../apps/openssl req -config test.cnf $req_new -out testreq.pem
 if [ $? != 0 ]; then
 echo problems creating request
 exit 1
 fi
 
-../apps/ssleay req -verify -in testreq.pem -noout
+../apps/openssl req -config test.cnf -verify -in testreq.pem -noout
 if [ $? != 0 ]; then
 echo signature on req is wrong
 exit 1
diff --git a/src/lib/libssl/test/testp7.pem b/src/lib/libssl/test/testp7.pem
index b3b6dba830..e5b7866c31 100644
--- a/src/lib/libssl/test/testp7.pem
+++ b/src/lib/libssl/test/testp7.pem
@@ -1,46 +1,46 @@
 -----BEGIN PKCS7-----
-MIAGCSqGSIb3DQEHAqCAMIIIBwIBATEAMIAGCSqGSIb3DQEHAQAAoIIGPDCCBHIw
-ggQcoAMCAQICEHkvjiX1iVGQMenF9HgIjI8wDQYJKoZIhvcNAQEEBQAwYjERMA8G
-A1UEBxMISW50ZXJuZXQxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTQwMgYDVQQL
-EytWZXJpU2lnbiBDbGFzcyAxIENBIC0gSW5kaXZpZHVhbCBTdWJzY3JpYmVyMB4X
-DTk2MDcxOTAwMDAwMFoXDTk3MDMzMDIzNTk1OVowgdUxETAPBgNVBAcTCEludGVy
-bmV0MRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE0MDIGA1UECxMrVmVyaVNpZ24g
-Q2xhc3MgMSBDQSAtIEluZGl2aWR1YWwgU3Vic2NyaWJlcjEoMCYGA1UECxMfRGln
-aXRhbCBJRCBDbGFzcyAxIC0gU01JTUUgVGVzdDFHMEUGA1UECxM+d3d3LnZlcmlz
-aWduLmNvbS9yZXBvc2l0b3J5L0NQUy0xLjAgSW5jLiBieSBSZWYuLExJQUIuTFRE
-KGMpOTYwWzANBgkqhkiG9w0BAQEFAANKADBHAkAOy7xxCAIkOfuIA2LyRpxgKlDO
-Rl8htdXYhF5iBGUx1GYaK6KF+bK/CCI0l4j2OfWGFBUrwGoWqxTNcWgTfMzRAgMB
-AAGjggI5MIICNTAJBgNVHRMEAjAAMIICJgYDVR0DBIICHTCCAhkwggIVMIICEQYL
-YIZIAYb4RQEHAQEwggIAFoIBq1RoaXMgY2VydGlmaWNhdGUgaW5jb3Jwb3JhdGVz
-IGJ5IHJlZmVyZW5jZSwgYW5kIGl0cyB1c2UgaXMgc3RyaWN0bHkgc3ViamVjdCB0
-bywgdGhlIFZlcmlTaWduIENlcnRpZmljYXRpb24gUHJhY3RpY2UgU3RhdGVtZW50
-IChDUFMpLCBhdmFpbGFibGUgYXQ6IGh0dHBzOi8vd3d3LnZlcmlzaWduLmNvbS9D
-UFMtMS4wOyBieSBFLW1haWwgYXQgQ1BTLXJlcXVlc3RzQHZlcmlzaWduLmNvbTsg
-b3IgYnkgbWFpbCBhdCBWZXJpU2lnbiwgSW5jLiwgMjU5MyBDb2FzdCBBdmUuLCBN
-b3VudGFpbiBWaWV3LCBDQSA5NDA0MyBVU0EgVGVsLiArMSAoNDE1KSA5NjEtODgz
-MCBDb3B5cmlnaHQgKGMpIDE5OTYgVmVyaVNpZ24sIEluYy4gIEFsbCBSaWdodHMg
-UmVzZXJ2ZWQuIENFUlRBSU4gV0FSUkFOVElFUyBESVNDTEFJTUVEIGFuZCBMSUFC
-SUxJVFkgTElNSVRFRC6gDgYMYIZIAYb4RQEHAQEBoQ4GDGCGSAGG+EUBBwEBAjAv
-MC0WK2h0dHBzOi8vd3d3LnZlcmlzaWduLmNvbS9yZXBvc2l0b3J5L0NQUy0xLgMw
-DQYJKoZIhvcNAQEEBQADQQDAmA7km/3iJWEsWN9Z2WU2gmZAknx45WnDKHxMa3Bf
-gNsh6BLk/ngkJKjNKTDR13XVHqEPUY1flbjATZputw1GMIIBwjCCAWygAwIBAgIQ
-fAmE6tW5ERSQWDneu3KfSTANBgkqhkiG9w0BAQIFADA+MQswCQYDVQQGEwJVUzEX
-MBUGA1UEChMOVmVyaVNpZ24sIEluYy4xFjAUBgNVBAsTDVRFU1QgUm9vdCBQQ0Ew
-HhcNOTYwNzE3MDAwMDAwWhcNOTcwNzE3MjM1OTU5WjBiMREwDwYDVQQHEwhJbnRl
-cm5ldDEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xNDAyBgNVBAsTK1ZlcmlTaWdu
-IENsYXNzIDEgQ0EgLSBJbmRpdmlkdWFsIFN1YnNjcmliZXIwXDANBgkqhkiG9w0B
-AQEFAANLADBIAkEA7Fc6zYJw4WwCWa1ni3fYNbzGSQNluuw990024GusjLfhEk1h
-MsIUukTT/n8yxoO7rYp4x+LS+tHF2tBtuxg7CwIDAQABoyIwIDALBgNVHQ8EBAMC
-AQYwEQYJYIZIAYb4QgEBBAQDAgIEMA0GCSqGSIb3DQEBAgUAA0EAFKem0cJGg9nd
-TAbP5o1HIEyNn11ZlvLU5v1Hejs1MKQt72IMm4jjgOH+pjguXW8lB6yzrK4oVOO2
-UNCaNQ1H26GCAa0wgeYwgZEwDQYJKoZIhvcNAQECBQAwYjERMA8GA1UEBxMISW50
+MIIIGAYJKoZIhvcNAQcCoIIICTCCCAUCAQExADALBgkqhkiG9w0BBwGgggY8MIIE
+cjCCBBygAwIBAgIQeS+OJfWJUZAx6cX0eAiMjzANBgkqhkiG9w0BAQQFADBiMREw
+DwYDVQQHEwhJbnRlcm5ldDEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xNDAyBgNV
+BAsTK1ZlcmlTaWduIENsYXNzIDEgQ0EgLSBJbmRpdmlkdWFsIFN1YnNjcmliZXIw
+HhcNOTYwNzE5MDAwMDAwWhcNOTcwMzMwMjM1OTU5WjCB1TERMA8GA1UEBxMISW50
 ZXJuZXQxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTQwMgYDVQQLEytWZXJpU2ln
-biBDbGFzcyAxIENBIC0gSW5kaXZpZHVhbCBTdWJzY3JpYmVyFw05NjA3MTcxNzU5
-MjlaFw05NzA3MTgwMDAwMDBaMA0GCSqGSIb3DQEBAgUAA0EAubVWYTsWsQmste9f
-+UgMw8BkjDlM25fwQLrCfmmnLxjewey10kSROypUaJLb+r4oRALc0fG9XfZsaiiI
-gotQHjCBwTBtMA0GCSqGSIb3DQEBAgUAMD4xCzAJBgNVBAYTAlVTMRcwFQYDVQQK
-Ew5WZXJpU2lnbiwgSW5jLjEWMBQGA1UECxMNVEVTVCBSb290IFBDQRcNOTYwNzE3
-MTc0NDA5WhcNOTgwNzE3MDAwMDAwWjANBgkqhkiG9w0BAQIFAANBAHitA0/xAukC
-jHzeh1AMT/l2oC68N+yFb+aJPHBBMxc6gG2MaKjBNwb5hcXUllMlExONA3ju10f7
-owIq3s3wx10xAAAAAAA=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 -----END PKCS7-----
diff --git a/src/lib/libssl/test/testsid.pem b/src/lib/libssl/test/testsid.pem
index cd8617be2e..7ffd008f66 100644
--- a/src/lib/libssl/test/testsid.pem
+++ b/src/lib/libssl/test/testsid.pem
@@ -1,5 +1,5 @@
 -----BEGIN SSL SESSION PARAMETERS-----
-MIIBxwIBAQIBAgQDAQCABBCi11xa5qkOP8xrr02K/NQCBBBkIYQZM0Bt95W0EHNV
+MIIB1gIBAQIBAgQDAQCABBCi11xa5qkOP8xrr02K/NQCBBBkIYQZM0Bt95W0EHNV
 bA58oQYCBDIBr7WiBAICASyjggGGMIIBgjCCASwCAQMwDQYJKoZIhvcNAQEEBQAw
 ODELMAkGA1UEBhMCQVUxDDAKBgNVBAgTA1FMRDEbMBkGA1UEAxMSU1NMZWF5L3Jz
 YSB0ZXN0IENBMB4XDTk1MTAwOTIzMzEzNFoXDTk4MDcwNTIzMzEzNFowYDELMAkG
@@ -8,5 +8,5 @@ LjELMAkGA1UECxMCQ1MxGzAZBgNVBAMTElNTTGVheSBkZW1vIGNsaWVudDBcMA0G
 CSqGSIb3DQEBAQUAA0sAMEgCQQC4pcXEL1lgVA+B5Q3TcuW/O3LZHoA73IYm8oFD
 TezgCDhL2RTMn+seKWF36UtJKRIOBU9jZHCVVd0Me5ls6BEjAgMBAAEwDQYJKoZI
 hvcNAQEEBQADQQBoIpOcwUY1qlVF7j3ROSGvUsbvByOBFmYWkIBgsCqR+9qo1A7L
-CrWF5i8LWt/vLwAHaxWNx2YuBJMFyuK81fTv
+CrWF5i8LWt/vLwAHaxWNx2YuBJMFyuK81fTvpA0EC3Rlc3Rjb250ZXh0
 -----END SSL SESSION PARAMETERS-----
diff --git a/src/lib/libssl/test/testss b/src/lib/libssl/test/testss
index a5aecf4694..8d3557f356 100644
--- a/src/lib/libssl/test/testss
+++ b/src/lib/libssl/test/testss
@@ -1,9 +1,10 @@
 #!/bin/sh
 
-digest='-mdc2'
-reqcmd="../apps/ssleay req"
-x509cmd="../apps/ssleay x509 $digest"
-verifycmd="../apps/ssleay verify"
+digest='-md5'
+reqcmd="../apps/openssl req"
+x509cmd="../apps/openssl x509 $digest"
+verifycmd="../apps/openssl verify"
+dummycnf="../apps/openssl.cnf"
 
 CAkey="keyCA.ss"
 CAcert="certCA.ss"
@@ -18,7 +19,16 @@ Ucert="certU.ss"
 
 echo
 echo "make a certificate request using 'req'"
-$reqcmd -config $CAconf -out $CAreq -keyout $CAkey -new #>err.ss
+
+echo "string to make the random number generator think it has entropy" >> ./.rnd
+
+if ../apps/openssl no-rsa; then
+  req_new='-newkey dsa:../apps/dsa512.pem'
+else
+  req_new='-new'
+fi
+
+$reqcmd -config $CAconf -out $CAreq -keyout $CAkey $req_new #>err.ss
 if [ $? != 0 ]; then
         echo "error using 'req' to generate a certificate request"
         exit 1
@@ -39,13 +49,13 @@ if [ $? != 0 ]; then
         exit 1
 fi
 
-$reqcmd -verify -in $CAreq -noout
+$reqcmd -config $dummycnf -verify -in $CAreq -noout
 if [ $? != 0 ]; then
         echo first generated request is invalid
         exit 1
 fi
 
-$reqcmd -verify -in $CAreq2 -noout
+$reqcmd -config $dummycnf -verify -in $CAreq2 -noout
 if [ $? != 0 ]; then
         echo second generated request is invalid
         exit 1
@@ -59,7 +69,7 @@ fi
 
 echo
 echo "make another certificate request using 'req'"
-$reqcmd -config $Uconf -out $Ureq -keyout $Ukey -new >err.ss
+$reqcmd -config $Uconf -out $Ureq -keyout $Ukey $req_new >err.ss
 if [ $? != 0 ]; then
         echo "error using 'req' to generate a certificate request"
         exit 1
diff --git a/src/lib/libssl/test/testssl b/src/lib/libssl/test/testssl
index f115adb8e1..ba5e41c861 100644
--- a/src/lib/libssl/test/testssl
+++ b/src/lib/libssl/test/testssl
@@ -1,40 +1,137 @@
 #!/bin/sh
 
+if [ "$1" = "" ]; then
+  key=../apps/server.pem
+else
+  key="$1"
+fi
+if [ "$2" = "" ]; then
+  cert=../apps/server.pem
+else
+  cert="$2"
+fi
+ssltest="./ssltest -key $key -cert $cert -c_key $key -c_cert $cert"
+
+if ../apps/openssl x509 -in $cert -text -noout | fgrep 'DSA Public Key' >/dev/null; then
+  dsa_cert=YES
+else
+  dsa_cert=NO
+fi
+
+if [ "$3" = "" ]; then
+  CA="-CApath ../certs"
+else
+  CA="-CAfile $3"
+fi
+
+if [ "$4" = "" ]; then
+  extra=""
+else
+  extra="$4"
+fi
+
+#############################################################################
+
 echo test sslv2
-./ssltest -ssl2 || exit 1
+$ssltest -ssl2 $extra || exit 1
 
 echo test sslv2 with server authentication
-./ssltest -ssl2 -server_auth -CApath ../certs || exit 1
+$ssltest -ssl2 -server_auth $CA $extra || exit 1
 
-echo test sslv2 with client authentication
-./ssltest -ssl2 -client_auth -CApath ../certs || exit 1
+if [ $dsa_cert = NO ]; then
+  echo test sslv2 with client authentication
+  $ssltest -ssl2 -client_auth $CA $extra || exit 1
 
-echo test sslv2 with both client and server authentication
-./ssltest -ssl2 -server_auth -client_auth -CApath ../certs || exit 1
+  echo test sslv2 with both client and server authentication
+  $ssltest -ssl2 -server_auth -client_auth $CA $extra || exit 1
+fi
 
 echo test sslv3
-./ssltest -ssl3 || exit 1
+$ssltest -ssl3 $extra || exit 1
 
 echo test sslv3 with server authentication
-./ssltest -ssl3 -server_auth -CApath ../certs || exit 1
+$ssltest -ssl3 -server_auth $CA $extra || exit 1
 
 echo test sslv3 with client authentication
-./ssltest -ssl3 -client_auth -CApath ../certs || exit 1
+$ssltest -ssl3 -client_auth $CA $extra || exit 1
 
 echo test sslv3 with both client and server authentication
-./ssltest -ssl3 -server_auth -client_auth -CApath ../certs || exit 1
+$ssltest -ssl3 -server_auth -client_auth $CA $extra || exit 1
 
 echo test sslv2/sslv3
-./ssltest || exit 1
+$ssltest $extra || exit 1
 
 echo test sslv2/sslv3 with server authentication
-./ssltest -server_auth -CApath ../certs || exit 1
+$ssltest -server_auth $CA $extra || exit 1
 
 echo test sslv2/sslv3 with client authentication
-./ssltest -client_auth -CApath ../certs || exit 1
+$ssltest -client_auth $CA $extra || exit 1
 
 echo test sslv2/sslv3 with both client and server authentication
-./ssltest -server_auth -client_auth -CApath ../certs || exit 1
+$ssltest -server_auth -client_auth $CA $extra || exit 1
 
-exit 0
+echo test sslv2 via BIO pair
+$ssltest -bio_pair -ssl2 $extra || exit 1
+
+echo test sslv2 with server authentication via BIO pair
+$ssltest -bio_pair -ssl2 -server_auth $CA $extra || exit 1
+
+if [ $dsa_cert = NO ]; then
+  echo test sslv2 with client authentication via BIO pair
+  $ssltest -bio_pair -ssl2 -client_auth $CA $extra || exit 1
+
+  echo test sslv2 with both client and server authentication via BIO pair
+  $ssltest -bio_pair -ssl2 -server_auth -client_auth $CA $extra || exit 1
+fi
+
+echo test sslv3 via BIO pair
+$ssltest -bio_pair -ssl3 $extra || exit 1
+
+echo test sslv3 with server authentication via BIO pair
+$ssltest -bio_pair -ssl3 -server_auth $CA $extra || exit 1
+
+echo test sslv3 with client authentication via BIO pair
+$ssltest -bio_pair -ssl3 -client_auth $CA $extra || exit 1
+
+echo test sslv3 with both client and server authentication via BIO pair
+$ssltest -bio_pair -ssl3 -server_auth -client_auth $CA $extra || exit 1
 
+echo test sslv2/sslv3 via BIO pair
+$ssltest $extra || exit 1
+
+if [ $dsa_cert = NO ]; then
+  echo test sslv2/sslv3 w/o DHE via BIO pair
+  $ssltest -bio_pair -no_dhe $extra || exit 1
+fi
+
+echo test sslv2/sslv3 with 1024bit DHE via BIO pair
+$ssltest -bio_pair -dhe1024dsa -v $extra || exit 1
+
+echo test sslv2/sslv3 with server authentication
+$ssltest -bio_pair -server_auth $CA $extra || exit 1
+
+echo test sslv2/sslv3 with client authentication via BIO pair
+$ssltest -bio_pair -client_auth $CA $extra || exit 1
+
+echo test sslv2/sslv3 with both client and server authentication via BIO pair
+$ssltest -bio_pair -server_auth -client_auth $CA $extra || exit 1
+
+echo test sslv2/sslv3 with both client and server authentication via BIO pair and app verify
+$ssltest -bio_pair -server_auth -client_auth -app_verify $CA $extra || exit 1
+
+#############################################################################
+
+echo test tls1 with 1024bit anonymous DH, multiple handshakes
+$ssltest -v -bio_pair -tls1 -cipher ADH -dhe1024dsa -num 10 -f -time $extra || exit 1
+
+if ../apps/openssl no-rsa; then
+  echo skipping RSA tests
+else
+  echo test tls1 with 1024bit RSA, no DHE, multiple handshakes
+  ./ssltest -v -bio_pair -tls1 -cert ../apps/server2.pem -no_dhe -num 10 -f -time $extra || exit 1
+
+  echo test tls1 with 1024bit RSA, 1024bit DHE, multiple handshakes
+  ./ssltest -v -bio_pair -tls1 -cert ../apps/server2.pem -dhe1024dsa -num 10 -f -time $extra || exit 1
+fi
+
+exit 0
diff --git a/src/lib/libssl/test/tpkcs7 b/src/lib/libssl/test/tpkcs7
index ea1f005dac..15bbba42c0 100644
--- a/src/lib/libssl/test/tpkcs7
+++ b/src/lib/libssl/test/tpkcs7
@@ -3,7 +3,7 @@
 PATH=../apps:$PATH
 export PATH
 
-cmd='../apps/ssleay pkcs7'
+cmd='../apps/openssl pkcs7'
 
 if [ "$1"x != "x" ]; then
         t=$1
diff --git a/src/lib/libssl/test/tpkcs7d b/src/lib/libssl/test/tpkcs7d
index c8f18fb09c..46e5aa2bd6 100644
--- a/src/lib/libssl/test/tpkcs7d
+++ b/src/lib/libssl/test/tpkcs7d
@@ -3,7 +3,7 @@
 PATH=../apps:$PATH
 export PATH
 
-cmd='../apps/ssleay pkcs7'
+cmd='../apps/openssl pkcs7'
 
 if [ "$1"x != "x" ]; then
         t=$1
@@ -11,7 +11,7 @@ else
         t=pkcs7-1.pem
 fi
 
-echo testing pkcs7 conversions
+echo "testing pkcs7 conversions (2)"
 cp $t fff.p
 
 echo "p -> d"
diff --git a/src/lib/libssl/test/treq b/src/lib/libssl/test/treq
index e5f1d8cc41..9f5eb7eea5 100644
--- a/src/lib/libssl/test/treq
+++ b/src/lib/libssl/test/treq
@@ -3,7 +3,7 @@
 PATH=../apps:$PATH
 export PATH
 
-cmd='../apps/ssleay req'
+cmd='../apps/openssl req -config ../apps/openssl.cnf'
 
 if [ "$1"x != "x" ]; then
         t=$1
@@ -11,6 +11,11 @@ else
         t=testreq.pem
 fi
 
+if $cmd -in $t -inform p -noout -text | fgrep 'Unknown Public Key'; then
+  echo "skipping req conversion test for $t"
+  exit 0
+fi
+
 echo testing req conversions
 cp $t fff.p
 
diff --git a/src/lib/libssl/test/trsa b/src/lib/libssl/test/trsa
index e5b8fe0448..bd6c07650a 100644
--- a/src/lib/libssl/test/trsa
+++ b/src/lib/libssl/test/trsa
@@ -3,7 +3,12 @@
 PATH=../apps:$PATH
 export PATH
 
-cmd='../apps/ssleay rsa'
+if ../apps/openssl no-rsa; then
+  echo skipping rsa conversion test
+  exit 0
+fi
+
+cmd='../apps/openssl rsa'
 
 if [ "$1"x != "x" ]; then
         t=$1
diff --git a/src/lib/libssl/test/tsid b/src/lib/libssl/test/tsid
index 8c7e9b1387..9e0854516c 100644
--- a/src/lib/libssl/test/tsid
+++ b/src/lib/libssl/test/tsid
@@ -3,7 +3,7 @@
 PATH=../apps:$PATH
 export PATH
 
-cmd='../apps/ssleay sess_id'
+cmd='../apps/openssl sess_id'
 
 if [ "$1"x != "x" ]; then
         t=$1
diff --git a/src/lib/libssl/test/tx509 b/src/lib/libssl/test/tx509
index f8d1f82cdd..35169f3a43 100644
--- a/src/lib/libssl/test/tx509
+++ b/src/lib/libssl/test/tx509
@@ -3,7 +3,7 @@
 PATH=../apps:$PATH
 export PATH
 
-cmd='../apps/ssleay x509'
+cmd='../apps/openssl x509'
 
 if [ "$1"x != "x" ]; then
         t=$1
diff --git a/src/lib/libssl/tls1.h b/src/lib/libssl/tls1.h
index 60978613ef..88ec5fb527 100644
--- a/src/lib/libssl/tls1.h
+++ b/src/lib/libssl/tls1.h
@@ -59,12 +59,14 @@
 #ifndef HEADER_TLS1_H 
 #define HEADER_TLS1_H 
 
-#include "buffer.h"
+#include <openssl/buffer.h>
 
 #ifdef  __cplusplus
 extern "C" {
 #endif
 
+#define TLS1_ALLOW_EXPERIMENTAL_CIPHERSUITES    1
+
 #define TLS1_VERSION                    0x0301
 #define TLS1_VERSION_MAJOR              0x03
 #define TLS1_VERSION_MINOR              0x01
@@ -75,13 +77,71 @@ extern "C" {
 #define TLS1_AD_ACCESS_DENIED           49      /* fatal */
 #define TLS1_AD_DECODE_ERROR            50      /* fatal */
 #define TLS1_AD_DECRYPT_ERROR           51
-#define TLS1_AD_EXPORT_RESTRICION       60      /* fatal */
+#define TLS1_AD_EXPORT_RESTRICTION      60      /* fatal */
 #define TLS1_AD_PROTOCOL_VERSION        70      /* fatal */
 #define TLS1_AD_INSUFFICIENT_SECURITY   71      /* fatal */
 #define TLS1_AD_INTERNAL_ERROR          80      /* fatal */
-#define TLS1_AD_USER_CANCLED            90
+#define TLS1_AD_USER_CANCELLED          90
 #define TLS1_AD_NO_RENEGOTIATION        100
 
+/* Additional TLS ciphersuites from draft-ietf-tls-56-bit-ciphersuites-00.txt
+ * (available if TLS1_ALLOW_EXPERIMENTAL_CIPHERSUITES is defined, see
+ * s3_lib.c).  We actually treat them like SSL 3.0 ciphers, which we probably
+ * shouldn't. */
+#define TLS1_CK_RSA_EXPORT1024_WITH_RC4_56_MD5          0x03000060
+#define TLS1_CK_RSA_EXPORT1024_WITH_RC2_CBC_56_MD5      0x03000061
+#define TLS1_CK_RSA_EXPORT1024_WITH_DES_CBC_SHA         0x03000062
+#define TLS1_CK_DHE_DSS_EXPORT1024_WITH_DES_CBC_SHA     0x03000063
+#define TLS1_CK_RSA_EXPORT1024_WITH_RC4_56_SHA          0x03000064
+#define TLS1_CK_DHE_DSS_EXPORT1024_WITH_RC4_56_SHA      0x03000065
+#define TLS1_CK_DHE_DSS_WITH_RC4_128_SHA                0x03000066
+
+  /* AES ciphersuites from draft ietf-tls-ciphersuite-03.txt */
+
+#define TLS1_CK_RSA_WITH_AES_128_SHA                    0x0300002F
+#define TLS1_CK_DH_DSS_WITH_AES_128_SHA                 0x03000030
+#define TLS1_CK_DH_RSA_WITH_AES_128_SHA                 0x03000031
+#define TLS1_CK_DHE_DSS_WITH_AES_128_SHA                0x03000032
+#define TLS1_CK_DHE_RSA_WITH_AES_128_SHA                0x03000033
+#define TLS1_CK_ADH_WITH_AES_128_SHA                    0x03000034
+
+#define TLS1_CK_RSA_WITH_AES_256_SHA                    0x03000035
+#define TLS1_CK_DH_DSS_WITH_AES_256_SHA                 0x03000036
+#define TLS1_CK_DH_RSA_WITH_AES_256_SHA                 0x03000037
+#define TLS1_CK_DHE_DSS_WITH_AES_256_SHA                0x03000038
+#define TLS1_CK_DHE_RSA_WITH_AES_256_SHA                0x03000039
+#define TLS1_CK_ADH_WITH_AES_256_SHA                    0x0300003A
+
+/* XXX
+ * Inconsistency alert:
+ * The OpenSSL names of ciphers with ephemeral DH here include the string
+ * "DHE", while elsewhere it has always been "EDH".
+ * (The alias for the list of all such ciphers also is "EDH".)
+ * The specifications speak of "EDH"; maybe we should allow both forms
+ * for everything. */
+#define TLS1_TXT_RSA_EXPORT1024_WITH_RC4_56_MD5         "EXP1024-RC4-MD5"
+#define TLS1_TXT_RSA_EXPORT1024_WITH_RC2_CBC_56_MD5     "EXP1024-RC2-CBC-MD5"
+#define TLS1_TXT_RSA_EXPORT1024_WITH_DES_CBC_SHA        "EXP1024-DES-CBC-SHA"
+#define TLS1_TXT_DHE_DSS_EXPORT1024_WITH_DES_CBC_SHA    "EXP1024-DHE-DSS-DES-CBC-SHA"
+#define TLS1_TXT_RSA_EXPORT1024_WITH_RC4_56_SHA         "EXP1024-RC4-SHA"
+#define TLS1_TXT_DHE_DSS_EXPORT1024_WITH_RC4_56_SHA     "EXP1024-DHE-DSS-RC4-SHA"
+#define TLS1_TXT_DHE_DSS_WITH_RC4_128_SHA               "DHE-DSS-RC4-SHA"
+  /* AES ciphersuites from draft-ietf-tls-ciphersuite-06.txt */
+#define TLS1_TXT_RSA_WITH_AES_128_SHA                   "AESdraft128-SHA"
+#define TLS1_TXT_DH_DSS_WITH_AES_128_SHA                "DH-DSS-AESdraft128-SHA"
+#define TLS1_TXT_DH_RSA_WITH_AES_128_SHA                "DH-RSA-AESdraft128-SHA"
+#define TLS1_TXT_DHE_DSS_WITH_AES_128_SHA               "DHE-DSS-AESdraft128-SHA"
+#define TLS1_TXT_DHE_RSA_WITH_AES_128_SHA               "DHE-RSA-AESdraft128-SHA"
+#define TLS1_TXT_ADH_WITH_AES_128_SHA                   "ADH-AESdraft128-SHA"
+
+#define TLS1_TXT_RSA_WITH_AES_256_SHA                   "AESdraft256-SHA"
+#define TLS1_TXT_DH_DSS_WITH_AES_256_SHA                "DH-DSS-AESdraft256-SHA"
+#define TLS1_TXT_DH_RSA_WITH_AES_256_SHA                "DH-RSA-AESdraft256-SHA"
+#define TLS1_TXT_DHE_DSS_WITH_AES_256_SHA               "DHE-DSS-AESdraft256-SHA"
+#define TLS1_TXT_DHE_RSA_WITH_AES_256_SHA               "DHE-RSA-AESdraft256-SHA"
+#define TLS1_TXT_ADH_WITH_AES_256_SHA                   "ADH-AESdraft256-SHA"
+
+
 #define TLS_CT_RSA_SIGN                 1
 #define TLS_CT_DSS_SIGN                 2
 #define TLS_CT_RSA_FIXED_DH             3
@@ -108,6 +168,25 @@ extern "C" {
 #define TLS_MD_MASTER_SECRET_CONST              "master secret"
 #define TLS_MD_MASTER_SECRET_CONST_SIZE         13
 
+#ifdef CHARSET_EBCDIC
+#undef TLS_MD_CLIENT_FINISH_CONST
+#define TLS_MD_CLIENT_FINISH_CONST    "\x63\x6c\x69\x65\x6e\x74\x20\x66\x69\x6e\x69\x73\x68\x65\x64"  /*client finished*/
+#undef TLS_MD_SERVER_FINISH_CONST
+#define TLS_MD_SERVER_FINISH_CONST    "\x73\x65\x72\x76\x65\x72\x20\x66\x69\x6e\x69\x73\x68\x65\x64"  /*server finished*/
+#undef TLS_MD_SERVER_WRITE_KEY_CONST
+#define TLS_MD_SERVER_WRITE_KEY_CONST "\x73\x65\x72\x76\x65\x72\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"  /*server write key*/
+#undef TLS_MD_KEY_EXPANSION_CONST
+#define TLS_MD_KEY_EXPANSION_CONST    "\x6b\x65\x79\x20\x65\x78\x70\x61\x6e\x73\x69\x6f\x6e"  /*key expansion*/
+#undef TLS_MD_CLIENT_WRITE_KEY_CONST
+#define TLS_MD_CLIENT_WRITE_KEY_CONST "\x63\x6c\x69\x65\x6e\x74\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"  /*client write key*/
+#undef TLS_MD_SERVER_WRITE_KEY_CONST
+#define TLS_MD_SERVER_WRITE_KEY_CONST "\x73\x65\x72\x76\x65\x72\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"  /*server write key*/
+#undef TLS_MD_IV_BLOCK_CONST
+#define TLS_MD_IV_BLOCK_CONST         "\x49\x56\x20\x62\x6c\x6f\x63\x6b"  /*IV block*/
+#undef TLS_MD_MASTER_SECRET_CONST
+#define TLS_MD_MASTER_SECRET_CONST    "\x6d\x61\x73\x74\x65\x72\x20\x73\x65\x63\x72\x65\x74"  /*master secret*/
+#endif
+
 #ifdef  __cplusplus
 }
 #endif