comp_methods in a SSL_CTX points at an internal database. Do *not*

[openssl.git] / ssl / ssl_lib.c

diff --git a/ssl/ssl_lib.c b/ssl/ssl_lib.c
index 9b02b6a3438f8d5f3ee80361988195551525ac5a..621d101a9ed56e83a0f77a25b5f12703e9fe7adc 100644 (file)
--- a/ssl/ssl_lib.c
+++ b/ssl/ssl_lib.c
@@ -58,6 +58,8 @@
  * [including the GNU Public Licence.]
  */
 
+
+#include <assert.h>
 #include <stdio.h>
 #include <openssl/objects.h>
 #include <openssl/lhash.h>
@@ -117,7 +119,9 @@ int SSL_clear(SSL *s)
        s->client_version=s->version;
        s->rwstate=SSL_NOTHING;
        s->rstate=SSL_ST_READ_HEADER;
+#if 0
        s->read_ahead=s->ctx->read_ahead;
+#endif
 
        if (s->init_buf != NULL)
                {
@@ -183,7 +187,7 @@ SSL *SSL_new(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));
 
@@ -227,6 +231,7 @@ SSL *SSL_new(SSL_CTX *ctx)
        s->server=(ctx->method->ssl_accept == ssl_undefined_function)?0:1;
        s->options=ctx->options;
        s->mode=ctx->mode;
+       s->read_ahead=ctx->read_ahead; /* used to happen in SSL_clear */
        SSL_clear(s);
 
        CRYPTO_new_ex_data(ssl_meth,s,&s->ex_data);
@@ -239,7 +244,7 @@ err:
                        ssl_cert_free(s->cert);
                if (s->ctx != NULL)
                        SSL_CTX_free(s->ctx); /* decrement reference count */
-               Free(s);
+               OPENSSL_free(s);
                }
        SSLerr(SSL_F_SSL_NEW,ERR_R_MALLOC_FAILURE);
        return(NULL);
@@ -375,7 +380,7 @@ void SSL_free(SSL *s)
 
        if (s->method != NULL) s->method->ssl_free(s);
 
-       Free(s);
+       OPENSSL_free(s);
        }
 
 void SSL_set_bio(SSL *s,BIO *rbio,BIO *wbio)
@@ -571,6 +576,13 @@ int SSL_get_read_ahead(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));
        }
 
@@ -599,6 +611,9 @@ STACK_OF(X509) *SSL_get_peer_cert_chain(SSL *s)
        else
                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);
        }
 
@@ -798,6 +813,11 @@ long SSL_callback_ctrl(SSL *s, int cmd, void (*fp)())
                }
        }
 
+struct lhash_st *SSL_CTX_sessions(SSL_CTX *ctx)
+       {
+       return ctx->sessions;
+       }
+
 long SSL_CTX_ctrl(SSL_CTX *ctx,int cmd,long larg,char *parg)
        {
        long l;
@@ -866,7 +886,7 @@ long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)())
                }
        }
 
-int ssl_cipher_id_cmp(SSL_CIPHER *a,SSL_CIPHER *b)
+int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
        {
        long l;
 
@@ -877,7 +897,8 @@ int ssl_cipher_id_cmp(SSL_CIPHER *a,SSL_CIPHER *b)
                return((l > 0)?1:-1);
        }
 
-int ssl_cipher_ptr_id_cmp(SSL_CIPHER **ap,SSL_CIPHER **bp)
+int ssl_cipher_ptr_id_cmp(const SSL_CIPHER * const *ap,
+                       const SSL_CIPHER * const *bp)
        {
        long l;
 
@@ -1025,7 +1046,7 @@ STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,unsigned char *p,int num,
                return(NULL);
                }
        if ((skp == NULL) || (*skp == NULL))
-               sk=sk_SSL_CIPHER_new(NULL); /* change perhaps later */
+               sk=sk_SSL_CIPHER_new_null(); /* change perhaps later */
        else
                {
                sk= *skp;
@@ -1091,7 +1112,7 @@ SSL_CTX *SSL_CTX_new(SSL_METHOD *meth)
                SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
                goto err;
                }
-       ret=(SSL_CTX *)Malloc(sizeof(SSL_CTX));
+       ret=(SSL_CTX *)OPENSSL_malloc(sizeof(SSL_CTX));
        if (ret == NULL)
                goto err;
 
@@ -1187,7 +1208,7 @@ err2:
        }
 
 static void SSL_COMP_free(SSL_COMP *comp)
-    { Free(comp); }
+    { OPENSSL_free(comp); }
 
 void SSL_CTX_free(SSL_CTX *a)
        {
@@ -1226,9 +1247,13 @@ void SSL_CTX_free(SSL_CTX *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);
-       Free(a);
+#else
+       a->comp_methods = NULL;
+#endif
+       OPENSSL_free(a);
        }
 
 void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
@@ -1529,6 +1554,8 @@ int SSL_get_error(SSL *s,int i)
                        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 */
                        }
@@ -1547,6 +1574,8 @@ int SSL_get_error(SSL *s,int i)
                        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);
                        }
@@ -1751,13 +1780,13 @@ 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);
+               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);
-               Free(s->enc_write_ctx);
+               OPENSSL_free(s->enc_write_ctx);
                s->enc_write_ctx=NULL;
                }
        if (s->expand != NULL)
@@ -1835,19 +1864,16 @@ int ssl_init_wbio_buffer(SSL *s,int push)
 
 void ssl_free_wbio_buffer(SSL *s)
        {
-       BIO *under;
-
        if (s->bbio == NULL) return;
 
        if (s->bbio == s->wbio)
                {
                /* remove buffering */
-               under=BIO_pop(s->wbio);
-               if (under != NULL)
-                       s->wbio=under;
-               else
-                       abort(); /* ok */
-               }
+               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;
        }