X-Git-Url: https://git.openssl.org/?a=blobdiff_plain;f=ssl%2Fssl_lib.c;h=365b3ce0e43b74e7ae4bd85186b2fe1cc81b739b;hb=a40f6dce871e8e020ca16713cc19798fcc141ed1;hp=18564170cc423c8a7a6ac754d3997615c8a90767;hpb=ff71222024503178ecc38bdc4b53ef420614a948;p=openssl.git

diff --git a/ssl/ssl_lib.c b/ssl/ssl_lib.c
index 18564170cc..365b3ce0e4 100644
--- a/ssl/ssl_lib.c
+++ b/ssl/ssl_lib.c
@@ -70,7 +70,7 @@ static STACK *ssl_ctx_meth=NULL;
 static int ssl_meth_num=0;
 static int ssl_ctx_meth_num=0;
 
-SSL3_ENC_METHOD ssl3_undef_enc_method={
+OPENSSL_GLOBAL SSL3_ENC_METHOD ssl3_undef_enc_method={
 	ssl_undefined_function,
 	ssl_undefined_function,
 	ssl_undefined_function,
@@ -215,6 +215,7 @@ SSL *SSL_new(SSL_CTX *ctx)
 	s->references=1;
 	s->server=(ctx->method->ssl_accept == ssl_undefined_function)?0:1;
 	s->options=ctx->options;
+	s->mode=ctx->mode;
 	SSL_clear(s);
 
 	CRYPTO_new_ex_data(ssl_meth,(char *)s,&s->ex_data);
@@ -657,6 +658,12 @@ int SSL_write(SSL *s,const char *buf,int num)
 
 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);
@@ -689,6 +696,8 @@ long SSL_ctrl(SSL *s,int cmd,long larg,char *parg)
 		return(l);
 	case SSL_CTRL_OPTIONS:
 		return(s->options|=larg);
+	case SSL_CTRL_MODE:
+		return(s->mode|=larg);
 	default:
 		return(s->method->ssl_ctrl(s,cmd,larg,parg));
 		}
@@ -746,6 +755,8 @@ long SSL_CTX_ctrl(SSL_CTX *ctx,int cmd,long larg,char *parg)
 		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));
 		}
@@ -1021,6 +1032,7 @@ SSL_CTX *SSL_CTX_new(SSL_METHOD *meth)
 		goto err;
 
 	ret->default_passwd_callback=NULL;
+	ret->default_passwd_callback_userdata=NULL;
 	ret->client_cert_cb=NULL;
 
 	ret->sessions=lh_new(SSL_SESSION_hash,SSL_SESSION_cmp);
@@ -1115,12 +1127,17 @@ void SSL_CTX_free(SSL_CTX *a)
 	Free((char *)a);
 	}
 
-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)
 	{
 	ctx->default_passwd_callback=cb;
 	}
 
-void SSL_CTX_set_cert_verify_cb(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)(),char *arg)
 	{
 	ctx->app_verify_callback=cb;
 	ctx->app_verify_arg=arg;
@@ -1244,13 +1261,13 @@ 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, s->s3->tmp.new_cipher);
 	alg=s->s3->tmp.new_cipher->algorithms;
-	export=SSL_IS_EXPORT(alg);
-	mask=export?c->export_mask:c->mask;
+	is_export=SSL_IS_EXPORT(alg);
+	mask=is_export?c->export_mask:c->mask;
 	kalg=alg&(SSL_MKEY_MASK|SSL_AUTH_MASK);
 
 	if 	(kalg & SSL_kDHr)
@@ -1390,6 +1407,15 @@ int SSL_get_error(SSL *s,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))
 			{
@@ -1407,6 +1433,7 @@ int SSL_get_error(SSL *s,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))
 			{
@@ -1505,17 +1532,40 @@ char *SSL_get_version(SSL *s)
 	}
 
 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 (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)
+			{
+			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);
+		}
 
 	SSL_set_read_ahead(ret,SSL_get_read_ahead(s));
 	SSL_set_verify(ret,SSL_get_verify_mode(s),
@@ -1591,18 +1641,18 @@ err:
 
 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);
+		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->expand != NULL)
 		{
 		COMP_CTX_free(s->expand);
@@ -1635,9 +1685,9 @@ EVP_PKEY *SSL_get_privatekey(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(SSL *s,int push)
@@ -1656,7 +1706,7 @@ int ssl_init_wbio_buffer(SSL *s,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))
 		{
@@ -1775,11 +1825,11 @@ long SSL_get_verify_result(SSL *ssl)
 
 int SSL_get_ex_new_index(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_set_ex_data(SSL *s,int idx,void *arg)
 	{
@@ -1793,11 +1843,11 @@ void *SSL_get_ex_data(SSL *s,int idx)
 
 int SSL_CTX_get_ex_new_index(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_set_ex_data(SSL_CTX *s,int idx,void *arg)
 	{
@@ -1838,13 +1888,14 @@ int SSL_want(SSL *s)
  */
 
 #ifndef NO_RSA
-void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx,RSA *(*cb)(SSL *ssl,int export,
+void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx,RSA *(*cb)(SSL *ssl,
+							  int is_export,
 							  int keylength))
     { SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_RSA_CB,0,(char *)cb); }
 #endif
 
 #ifndef NO_RSA
-void SSL_set_tmp_rsa_callback(SSL *ssl,RSA *(*cb)(SSL *ssl,int export,
+void SSL_set_tmp_rsa_callback(SSL *ssl,RSA *(*cb)(SSL *ssl,int is_export,
 							  int keylength))
     { SSL_ctrl(ssl,SSL_CTRL_SET_TMP_RSA_CB,0,(char *)cb); }
 #endif
@@ -1853,14 +1904,14 @@ void SSL_set_tmp_rsa_callback(SSL *ssl,RSA *(*cb)(SSL *ssl,int export,
 /*!
  * \brief The RSA temporary key callback function.
  * \param ssl the SSL session.
- * \param export \c TRUE if the temp RSA key is for an export ciphersuite.
- * \param keylength if \c export is \c TRUE, then \c keylength is the size of
- * the required key in bits.
+ * \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 export,int keylength)
+RSA *cb(SSL *ssl,int is_export,int keylength)
     {}
 #endif
 
@@ -1871,11 +1922,11 @@ RSA *cb(SSL *ssl,int export,int keylength)
  */
 
 #ifndef NO_DH
-void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,DH *(*dh)(SSL *ssl,int export,
+void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,DH *(*dh)(SSL *ssl,int is_export,
 							int keylength))
     { SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_DH_CB,0,(char *)dh); }
 
-void SSL_set_tmp_dh_callback(SSL *ssl,DH *(*dh)(SSL *ssl,int export,
+void SSL_set_tmp_dh_callback(SSL *ssl,DH *(*dh)(SSL *ssl,int is_export,
 							int keylength))
     { SSL_ctrl(ssl,SSL_CTRL_SET_TMP_DH_CB,0,(char *)dh); }
 #endif