X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Flibldap%2Ftls.c;h=2070e28d80da407566d3d95f0a001809996f71f2;hb=f8e5ed25e96805959f9a385212d7bad2a1c5eff3;hp=a00ad4525f3eb08363ec4174f16c806453394113;hpb=15c83bef9da518054baa1362a16308145c6fb9e5;p=openldap

diff --git a/libraries/libldap/tls.c b/libraries/libldap/tls.c
index a00ad4525f..2070e28d80 100644
--- a/libraries/libldap/tls.c
+++ b/libraries/libldap/tls.c
@@ -1,6 +1,6 @@
 /* $OpenLDAP$ */
 /*
- * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  *
  * tls.c - Handle tls/ssl using SSLeay or OpenSSL.
@@ -8,8 +8,6 @@
 
 #include "portable.h"
 
-#ifdef HAVE_TLS
-
 #include <stdio.h>
 
 #include <ac/stdlib.h>
@@ -18,15 +16,21 @@
 #include <ac/string.h>
 #include <ac/time.h>
 #include <ac/unistd.h>
+#include <ac/param.h>
 
 #include "ldap-int.h"
 
+#ifdef HAVE_TLS
+
 #ifdef LDAP_R_COMPILE
 #include <ldap_pvt_thread.h>
 #endif
 
 #ifdef HAVE_OPENSSL_SSL_H
 #include <openssl/ssl.h>
+#include <openssl/x509v3.h>
+#include <openssl/err.h>
+#include <openssl/rand.h>
 #elif defined( HAVE_SSL_H )
 #include <ssl.h>
 #endif
@@ -38,33 +42,26 @@ static char *tls_opt_cacertfile = NULL;
 static char *tls_opt_cacertdir = NULL;
 static int  tls_opt_require_cert = 0;
 static char *tls_opt_ciphersuite = NULL;
+static char *tls_opt_randfile = NULL;
 
-#define HAS_TLS( sb ) ((sb)->sb_io==&tls_io)
+#define HAS_TLS( sb )	ber_sockbuf_ctrl( sb, LBER_SB_OPT_HAS_IO, \
+				(void *)&ldap_pvt_sockbuf_io_tls )
 
-static int tls_setup( Sockbuf *sb, void *arg );
-static int tls_remove( Sockbuf *sb );
-static ber_slen_t tls_read( Sockbuf *sb, void *buf, ber_len_t len );
-static ber_slen_t tls_write( Sockbuf *sb, void *buf, ber_len_t len );
-static int tls_close( Sockbuf *sb );
-static int tls_report_error( void );
-
-static Sockbuf_IO tls_io=
-{
-   tls_setup,
-   tls_remove,
-   tls_read,
-   tls_write,
-   tls_close
-};
+static void tls_report_error( void );
 
 static void tls_info_cb( SSL *ssl, int where, int ret );
 static int tls_verify_cb( int ok, X509_STORE_CTX *ctx );
 static RSA * tls_tmp_rsa_cb( SSL *ssl, int is_export, int key_length );
-static DH * tls_tmp_dh_cb( SSL *ssl, int is_export, int key_length );
 static STACK_OF(X509_NAME) * get_ca_list( char * bundle, char * dir );
 
+#if 0	/* Currently this is not used by anyone */
+static DH * tls_tmp_dh_cb( SSL *ssl, int is_export, int key_length );
+#endif
+
 static SSL_CTX *tls_def_ctx = NULL;
 
+static int tls_seed_PRNG( const char *randfile );
+
 #ifdef LDAP_R_COMPILE
 /*
  * provide mutexes for the SSLeay library.
@@ -74,9 +71,9 @@ static ldap_pvt_thread_mutex_t	tls_mutexes[CRYPTO_NUM_LOCKS];
 static void tls_locking_cb( int mode, int type, const char *file, int line )
 {
 	if ( mode & CRYPTO_LOCK ) {
-		ldap_pvt_thread_mutex_lock( tls_mutexes+type );
+		ldap_pvt_thread_mutex_lock( &tls_mutexes[type] );
 	} else {
-		ldap_pvt_thread_mutex_unlock( tls_mutexes+type );
+		ldap_pvt_thread_mutex_unlock( &tls_mutexes[type] );
 	}
 }
 
@@ -91,7 +88,7 @@ static void tls_init_threads( void )
 	int i;
 
 	for( i=0; i< CRYPTO_NUM_LOCKS ; i++ ) {
-		ldap_pvt_thread_mutex_init( tls_mutexes+i );
+		ldap_pvt_thread_mutex_init( &tls_mutexes[i] );
 	}
 	CRYPTO_set_locking_callback( tls_locking_cb );
 	/* FIXME: the thread id should be added somehow... */
@@ -101,20 +98,25 @@ static void tls_init_threads( void )
 #endif /* LDAP_R_COMPILE */
 
 /*
- * Initialize tls system. Should be called only once.
+ * Initialize TLS subsystem. Should be called only once.
  */
 int
 ldap_pvt_tls_init( void )
 {
 	static int tls_initialized = 0;
 
-	if ( tls_initialized )
-		return -1;
+	if ( tls_initialized ) return 0;
+	tls_initialized = 1;
+
+	(void) tls_seed_PRNG( tls_opt_randfile );
+
 #ifdef LDAP_R_COMPILE
 	tls_init_threads();
 #endif
+
 	SSL_load_error_strings();
 	SSLeay_add_ssl_algorithms();
+
 	/* FIXME: mod_ssl does this */
 	X509V3_add_standard_extensions();
 	return 0;
@@ -200,9 +202,11 @@ ldap_pvt_tls_init_def_ctx( void )
 		if ( tls_opt_trace ) {
 			SSL_CTX_set_info_callback( tls_def_ctx, tls_info_cb );
 		}
-		SSL_CTX_set_verify( tls_def_ctx, (tls_opt_require_cert) ?
+		SSL_CTX_set_verify( tls_def_ctx,
+			tls_opt_require_cert ?
 			(SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT) :
-			SSL_VERIFY_PEER, tls_verify_cb );
+			SSL_VERIFY_NONE,
+			tls_verify_cb );
 		SSL_CTX_set_tmp_rsa_callback( tls_def_ctx, tls_tmp_rsa_cb );
 		/* SSL_CTX_set_tmp_dh_callback( tls_def_ctx, tls_tmp_dh_cb ); */
 	}
@@ -211,6 +215,10 @@ ldap_pvt_tls_init_def_ctx( void )
 #endif
 	return 0;
 error_exit:
+	if ( tls_def_ctx != NULL ) {
+		SSL_CTX_free( tls_def_ctx );
+		tls_def_ctx = NULL;
+	}
 #ifdef LDAP_R_COMPILE
 	ldap_pvt_thread_mutex_unlock( &tls_def_ctx_mutex );
 #endif
@@ -233,9 +241,8 @@ get_ca_list( char * bundle, char * dir )
 }
 
 static SSL *
-alloc_handle( Sockbuf *sb, void *ctx_arg )
+alloc_handle( void *ctx_arg )
 {
-	int	err;
 	SSL_CTX	*ctx;
 	SSL	*ssl;
 
@@ -256,18 +263,277 @@ alloc_handle( Sockbuf *sb, void *ctx_arg )
 	if ( tls_opt_trace ) {
 		SSL_set_info_callback( ssl, tls_info_cb );
 	}
-	sb->sb_iodata = ssl;
-	SSL_set_fd( ssl, ber_pvt_sb_get_desc( sb ) );
 	return ssl;
 }
 
-static void
-update_flags( Sockbuf *sb, SSL * ssl )
+static int
+update_flags( Sockbuf *sb, SSL * ssl, int rc )
 {
-	sb->sb_trans_needs_read  = (SSL_want_read(ssl) ? 1 : 0);
-	sb->sb_trans_needs_write = (SSL_want_write(ssl) ? 1 : 0);
+	int err = SSL_get_error(ssl, rc);
+
+	sb->sb_trans_needs_read  = 0;
+	sb->sb_trans_needs_write = 0;
+	if (err == SSL_ERROR_WANT_READ)
+	{
+	    sb->sb_trans_needs_read  = 1;
+	    return 1;
+	} else if (err == SSL_ERROR_WANT_WRITE)
+	{
+	    sb->sb_trans_needs_write = 1;
+	    return 1;
+	} else if (err == SSL_ERROR_WANT_CONNECT)
+	{
+	    return 1;
+	}
+	return 0;
 }
 
+/*
+ * TLS support for LBER Sockbufs
+ */
+
+struct tls_data {
+	SSL			*ssl;
+	Sockbuf_IO_Desc		*sbiod;
+};
+
+extern BIO_METHOD ldap_pvt_sb_bio_method;
+
+static int
+sb_tls_setup( Sockbuf_IO_Desc *sbiod, void *arg )
+{
+	struct tls_data		*p;
+	BIO			*bio;
+
+	assert( sbiod != NULL );
+
+	p = LBER_MALLOC( sizeof( *p ) );
+	if ( p == NULL )
+		return -1;
+	
+	p->ssl = (SSL *)arg;
+	p->sbiod = sbiod;
+	bio = BIO_new( &ldap_pvt_sb_bio_method );
+	bio->ptr = (void *)p;
+	SSL_set_bio( p->ssl, bio, bio );
+	sbiod->sbiod_pvt = p;
+	return 0;
+}
+
+static int
+sb_tls_remove( Sockbuf_IO_Desc *sbiod )
+{
+	struct tls_data		*p;
+	
+	assert( sbiod != NULL );
+	assert( sbiod->sbiod_pvt != NULL );
+
+	p = (struct tls_data *)sbiod->sbiod_pvt;
+	SSL_free( p->ssl );
+	LBER_FREE( sbiod->sbiod_pvt );
+	sbiod->sbiod_pvt = NULL;
+	return 0;
+}
+
+static int
+sb_tls_close( Sockbuf_IO_Desc *sbiod )
+{
+	struct tls_data		*p;
+	
+	assert( sbiod != NULL );
+	assert( sbiod->sbiod_pvt != NULL );
+
+	p = (struct tls_data *)sbiod->sbiod_pvt;
+	SSL_shutdown( p->ssl );
+	return 0;
+}
+
+static int
+sb_tls_ctrl( Sockbuf_IO_Desc *sbiod, int opt, void *arg )
+{
+	struct tls_data		*p;
+	
+	assert( sbiod != NULL );
+	assert( sbiod->sbiod_pvt != NULL );
+
+	p = (struct tls_data *)sbiod->sbiod_pvt;
+	
+	if ( opt == LBER_SB_OPT_GET_SSL ) {
+		*((SSL **)arg) = p->ssl;
+		return 1;
+	}
+	
+	return LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg );
+}
+
+static ber_slen_t
+sb_tls_read( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
+{
+	struct tls_data		*p;
+	ber_slen_t		ret;
+	int			err;
+
+	assert( sbiod != NULL );
+	assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
+
+	p = (struct tls_data *)sbiod->sbiod_pvt;
+
+	ret = SSL_read( p->ssl, (char *)buf, len );
+#ifdef HAVE_WINSOCK
+	errno = WSAGetLastError();
+#endif
+	err = SSL_get_error( p->ssl, ret );
+	if (err == SSL_ERROR_WANT_READ ) {
+		sbiod->sbiod_sb->sb_trans_needs_read = 1;
+#ifdef WIN32
+		errno = EWOULDBLOCK;
+#endif
+	}
+	else
+		sbiod->sbiod_sb->sb_trans_needs_read = 0;
+	return ret;
+}
+
+static ber_slen_t
+sb_tls_write( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
+{
+	struct tls_data		*p;
+	ber_slen_t		ret;
+	int			err;
+
+	assert( sbiod != NULL );
+	assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
+
+	p = (struct tls_data *)sbiod->sbiod_pvt;
+
+	ret = SSL_write( p->ssl, (char *)buf, len );
+#ifdef HAVE_WINSOCK
+	errno = WSAGetLastError();
+#endif
+	err = SSL_get_error( p->ssl, ret );
+	if (err == SSL_ERROR_WANT_WRITE ) {
+		sbiod->sbiod_sb->sb_trans_needs_write = 1;
+#ifdef WIN32
+		errno = EWOULDBLOCK;
+#endif
+	}
+	else
+		sbiod->sbiod_sb->sb_trans_needs_write = 0;
+	return ret;
+}
+
+Sockbuf_IO ldap_pvt_sockbuf_io_tls =
+{
+	sb_tls_setup,		/* sbi_setup */
+	sb_tls_remove,		/* sbi_remove */
+	sb_tls_ctrl,		/* sbi_ctrl */
+	sb_tls_read,		/* sbi_read */
+	sb_tls_write,		/* sbi_write */
+	sb_tls_close		/* sbi_close */
+};
+
+static int
+sb_tls_bio_create( BIO *b ) {
+	b->init = 1;
+	b->num = 0;
+	b->ptr = NULL;
+	b->flags = 0;
+	return 1;
+}
+
+static int
+sb_tls_bio_destroy( BIO *b )
+{
+	if ( b == NULL )
+		return 0;
+
+	b->ptr = NULL;		/* sb_tls_remove() will free it */
+	b->init = 0;
+	b->flags = 0;
+	return 1;
+}
+
+static int
+sb_tls_bio_read( BIO *b, char *buf, int len )
+{
+	struct tls_data		*p;
+	int			ret;
+		
+	if ( buf == NULL || len <= 0 )
+		return 0;
+
+	p = (struct tls_data *)b->ptr;
+
+	if ( p == NULL || p->sbiod == NULL )
+		return 0;
+
+	ret = LBER_SBIOD_READ_NEXT( p->sbiod, buf, len );
+
+	BIO_clear_retry_flags( b );
+	if ( ret < 0 && errno == EWOULDBLOCK )
+		BIO_set_retry_read( b );
+
+	return ret;
+}
+
+static int
+sb_tls_bio_write( BIO *b, char *buf, int len )
+{
+	struct tls_data		*p;
+	int			ret;
+	
+	if ( buf == NULL || len <= 0 )
+		return 0;
+	
+	p = (struct tls_data *)b->ptr;
+
+	if ( p == NULL || p->sbiod == NULL )
+		return 0;
+
+	ret = LBER_SBIOD_WRITE_NEXT( p->sbiod, buf, len );
+
+	BIO_clear_retry_flags( b );
+	if ( ret < 0 && errno == EWOULDBLOCK )
+		BIO_set_retry_write( b );
+
+	return ret;
+}
+
+static long
+sb_tls_bio_ctrl( BIO *b, int cmd, long num, char *ptr )
+{
+	if ( cmd == BIO_CTRL_FLUSH ) {
+		/* The OpenSSL library needs this */
+		return 1;
+	}
+	return 0;
+}
+
+static int
+sb_tls_bio_gets( BIO *b, char *buf, int len )
+{
+	return -1;
+}
+
+static int
+sb_tls_bio_puts( BIO *b, char *str )
+{
+	return sb_tls_bio_write( b, str, strlen( str ) );
+}
+	
+BIO_METHOD ldap_pvt_sb_bio_method =
+{
+	( 100 | 0x400 ),		/* it's a source/sink BIO */
+	"sockbuf glue",
+	sb_tls_bio_write,
+	sb_tls_bio_read,
+	sb_tls_bio_puts,
+	sb_tls_bio_gets,
+	sb_tls_bio_ctrl,
+	sb_tls_bio_create,
+	sb_tls_bio_destroy
+};
+
 /*
  * Call this to do a TLS connect on a sockbuf. ctx_arg can be
  * a SSL_CTX * or NULL, in which case the default ctx is used.
@@ -282,38 +548,44 @@ update_flags( Sockbuf *sb, SSL * ssl )
  */
 
 int
-ldap_pvt_tls_connect( Sockbuf *sb, void *ctx_arg )
+ldap_pvt_tls_connect( LDAP *ld, Sockbuf *sb, void *ctx_arg )
 {
 	int	err;
 	SSL	*ssl;
 
 	if ( HAS_TLS( sb ) ) {
-		ssl = (SSL *) sb->sb_iodata;
+		ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_SSL, (void *)&ssl );
 	} else {
-		ssl = alloc_handle( sb, ctx_arg );
+		ssl = alloc_handle( ctx_arg );
 		if ( ssl == NULL )
 			return -1;
-		ber_pvt_sb_clear_io( sb );
-		ber_pvt_sb_set_io( sb, &tls_io, (void *)ssl );
+#ifdef LDAP_DEBUG
+		ber_sockbuf_add_io( sb, &ber_sockbuf_io_debug,
+			LBER_SBIOD_LEVEL_TRANSPORT, (void *)"tls_" );
+#endif
+		ber_sockbuf_add_io( sb, &ldap_pvt_sockbuf_io_tls,
+			LBER_SBIOD_LEVEL_TRANSPORT, (void *)ssl );
 	}
 
 	err = SSL_connect( ssl );
 
-	if ( err <= 0 ) {
-		if (
-#ifdef EWOULDBLOCK
-		    (errno==EWOULDBLOCK) ||
+#ifdef HAVE_WINSOCK
+	errno = WSAGetLastError();
 #endif
-#ifdef EAGAIN
-		    (errno==EAGAIN) ||
-#endif
-		    (0)) {
-			update_flags( sb, ssl );
+	if ( err <= 0 ) {
+		if ( update_flags( sb, ssl, err ))
 			return 1;
+		if ((err = ERR_peek_error())) {
+			char buf[256];
+			ld->ld_error = LDAP_STRDUP(ERR_error_string(err, buf));
 		}
 		Debug( LDAP_DEBUG_ANY,"TLS: can't connect.\n",0,0,0);
-		ber_pvt_sb_clear_io( sb );
-		ber_pvt_sb_set_io( sb, &ber_pvt_sb_io_tcp, NULL );
+		ber_sockbuf_remove_io( sb, &ldap_pvt_sockbuf_io_tls,
+			LBER_SBIOD_LEVEL_TRANSPORT );
+#ifdef LDAP_DEBUG
+		ber_sockbuf_remove_io( sb, &ber_sockbuf_io_debug,
+			LBER_SBIOD_LEVEL_TRANSPORT );
+#endif
 		return -1;
 	}
 	return 0;
@@ -330,43 +602,120 @@ ldap_pvt_tls_accept( Sockbuf *sb, void *ctx_arg )
 	SSL	*ssl;
 
 	if ( HAS_TLS( sb ) ) {
-		ssl = (SSL *) sb->sb_iodata;
+		ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_SSL, (void *)&ssl );
 	} else {
-		ssl = alloc_handle( sb, ctx_arg );
+		ssl = alloc_handle( ctx_arg );
 		if ( ssl == NULL )
 			return -1;
-		ber_pvt_sb_clear_io( sb );
-		ber_pvt_sb_set_io( sb, &tls_io, (void *)ssl );
+#ifdef LDAP_DEBUG
+		ber_sockbuf_add_io( sb, &ber_sockbuf_io_debug,
+			LBER_SBIOD_LEVEL_TRANSPORT, (void *)"tls_" );
+#endif
+		ber_sockbuf_add_io( sb, &ldap_pvt_sockbuf_io_tls,
+			LBER_SBIOD_LEVEL_TRANSPORT, (void *)ssl );
 	}
 
 	err = SSL_accept( ssl );
 
+#ifdef HAVE_WINSOCK
+	errno = WSAGetLastError();
+#endif
 	if ( err <= 0 ) {
-		if ( !SSL_want_nothing( ssl ) ) {
-			update_flags( sb, ssl );
+		if ( update_flags( sb, ssl, err ))
 			return 1;
-		}
 		Debug( LDAP_DEBUG_ANY,"TLS: can't accept.\n",0,0,0 );
 		tls_report_error();
-		ber_pvt_sb_clear_io( sb );
-		ber_pvt_sb_set_io( sb, &ber_pvt_sb_io_tcp, NULL );
+		ber_sockbuf_remove_io( sb, &ldap_pvt_sockbuf_io_tls,
+			LBER_SBIOD_LEVEL_TRANSPORT );
+#ifdef LDAP_DEBUG
+		ber_sockbuf_remove_io( sb, &ber_sockbuf_io_debug,
+			LBER_SBIOD_LEVEL_TRANSPORT );
+#endif
 		return -1;
 	}
+
 	return 0;
 }
 
+int
+ldap_pvt_tls_inplace ( Sockbuf *sb )
+{
+	if ( HAS_TLS( sb ) )
+		return(1);
+	return(0);
+}
+
+void *
+ldap_pvt_tls_sb_handle( Sockbuf *sb )
+{
+	void			*p;
+	
+	if (HAS_TLS( sb )) {
+		ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_SSL, (void *)&p );
+		return p;
+	}
+
+	return NULL;
+}
+
+void *
+ldap_pvt_tls_get_handle( LDAP *ld )
+{
+	return ldap_pvt_tls_sb_handle( ld->ld_sb );
+}
+
+int
+ldap_pvt_tls_get_strength( void *s )
+{
+    SSL_CIPHER *c;
+
+    c = SSL_get_current_cipher((SSL *)s);
+    return SSL_CIPHER_get_bits(c, NULL);
+}
+
+
 const char *
-ldap_pvt_tls_get_peer( LDAP *ld )
+ldap_pvt_tls_get_peer( void *s )
 {
+    X509 *x;
+    X509_NAME *xn;
+    char buf[2048], *p;
+
+    x = SSL_get_peer_certificate((SSL *)s);
+
+    if (!x)
+    	return NULL;
+    
+    xn = X509_get_subject_name(x);
+    p = LDAP_STRDUP(X509_NAME_oneline(xn, buf, sizeof(buf)));
+    X509_free(x);
+    return p;
 }
 
 const char *
-ldap_pvt_tls_get_peer_issuer( LDAP *ld )
+ldap_pvt_tls_get_peer_issuer( void *s )
 {
+#if 0	/* currently unused; see ldap_pvt_tls_get_peer() if needed */
+    X509 *x;
+    X509_NAME *xn;
+    char buf[2048], *p;
+
+    x = SSL_get_peer_certificate((SSL *)s);
+
+    if (!x)
+    	return NULL;
+    
+    xn = X509_get_issuer_name(x);
+    p = LDAP_STRDUP(X509_NAME_oneline(xn, buf, sizeof(buf)));
+    X509_free(x);
+    return p;
+#else
+    return NULL;
+#endif
 }
 
 int
-ldap_pvt_tls_config( struct ldapoptions *lo, int option, const char *arg )
+ldap_int_tls_config( struct ldapoptions *lo, int option, const char *arg )
 {
 	int i;
 
@@ -375,6 +724,7 @@ ldap_pvt_tls_config( struct ldapoptions *lo, int option, const char *arg )
 	case LDAP_OPT_X_TLS_CACERTDIR:
 	case LDAP_OPT_X_TLS_CERTFILE:
 	case LDAP_OPT_X_TLS_KEYFILE:
+	case LDAP_OPT_X_TLS_RANDOM_FILE:
 		return ldap_pvt_tls_set_option( NULL, option, (void *) arg );
 	case LDAP_OPT_X_TLS_REQUIRE_CERT:
 		i = ( ( strcasecmp( arg, "on" ) == 0 ) ||
@@ -396,9 +746,9 @@ ldap_pvt_tls_config( struct ldapoptions *lo, int option, const char *arg )
 		if (i >= 0)
 			return ldap_pvt_tls_set_option( lo, option, &i );
 		return -1;
-	default:
-		return -1;
 	}
+
+	return -1;
 }
 
 int
@@ -410,9 +760,9 @@ ldap_pvt_tls_get_option( struct ldapoptions *lo, int option, void *arg )
 		break;
 	case LDAP_OPT_X_TLS_CERT:
 		if ( lo == NULL )
-			arg = (void *) tls_def_ctx;
+			*(void **)arg = (void *) tls_def_ctx;
 		else
-			arg = lo->ldo_tls_ctx;
+			*(void **)arg = lo->ldo_tls_ctx;
 		break;
 	case LDAP_OPT_X_TLS_CACERTFILE:
 		*(char **)arg = tls_opt_cacertfile ?
@@ -433,6 +783,9 @@ ldap_pvt_tls_get_option( struct ldapoptions *lo, int option, void *arg )
 	case LDAP_OPT_X_TLS_REQUIRE_CERT:
 		*(int *)arg = tls_opt_require_cert;
 		break;
+	case LDAP_OPT_X_TLS_RANDOM_FILE:
+		*(char **)arg = tls_opt_randfile;
+		break;
 	default:
 		return -1;
 	}
@@ -450,97 +803,79 @@ ldap_pvt_tls_set_option( struct ldapoptions *lo, int option, void *arg )
 		case LDAP_OPT_X_TLS_ALLOW:
 		case LDAP_OPT_X_TLS_TRY:
 		case LDAP_OPT_X_TLS_HARD:
-			if (lo != NULL)
+			if (lo != NULL) {
 				lo->ldo_tls_mode = *(int *)arg;
+			}
+
 			return 0;
-		default:
-			return -1;
 		}
-		break;
+		return -1;
+
 	case LDAP_OPT_X_TLS_CERT:
-		if ( lo == NULL )
+		if ( lo == NULL ) {
 			tls_def_ctx = (SSL_CTX *) arg;
-		else
+
+		} else {
 			lo->ldo_tls_ctx = arg;
-		break;
+		}
+		return 0;
 	}
-	if ( lo != NULL )
+
+	if ( lo != NULL ) {
 		return -1;
+	}
+
 	switch( option ) {
 	case LDAP_OPT_X_TLS_CACERTFILE:
-		if ( tls_opt_cacertfile ) free( tls_opt_cacertfile );
+		if ( tls_opt_cacertfile ) LDAP_FREE( tls_opt_cacertfile );
 		tls_opt_cacertfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
 		break;
 	case LDAP_OPT_X_TLS_CACERTDIR:
-		if ( tls_opt_cacertdir ) free( tls_opt_cacertdir );
+		if ( tls_opt_cacertdir ) LDAP_FREE( tls_opt_cacertdir );
 		tls_opt_cacertdir = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
 		break;
 	case LDAP_OPT_X_TLS_CERTFILE:
-		if ( tls_opt_certfile ) free( tls_opt_certfile );
+		if ( tls_opt_certfile ) LDAP_FREE( tls_opt_certfile );
 		tls_opt_certfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
 		break;
 	case LDAP_OPT_X_TLS_KEYFILE:
-		if ( tls_opt_keyfile ) free( tls_opt_keyfile );
+		if ( tls_opt_keyfile ) LDAP_FREE( tls_opt_keyfile );
 		tls_opt_keyfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
 		break;
 	case LDAP_OPT_X_TLS_REQUIRE_CERT:
 		tls_opt_require_cert = * (int *) arg;
 		break;
 	case LDAP_OPT_X_TLS_CIPHER_SUITE:
-		if ( tls_opt_ciphersuite ) free( tls_opt_ciphersuite );
+		if ( tls_opt_ciphersuite ) LDAP_FREE( tls_opt_ciphersuite );
 		tls_opt_ciphersuite = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
 		break;
+	case LDAP_OPT_X_TLS_RANDOM_FILE:
+		if (tls_opt_randfile ) LDAP_FREE (tls_opt_randfile );
+		tls_opt_randfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
+		break;
 	default:
 		return -1;
 	}
 	return 0;
 }
 
-static int
-tls_setup( Sockbuf *sb, void *arg )
-{
-	sb->sb_iodata = arg;
-	return 0;
-}
-
-static int
-tls_remove( Sockbuf *sb )
-{
-	SSL_free( (SSL *) sb->sb_iodata );
-	return 0;
-}
-
-static ber_slen_t
-tls_write( Sockbuf *sb, void *buf, ber_len_t sz )
+int
+ldap_pvt_tls_start ( LDAP *ld, Sockbuf *sb, void *ctx_arg )
 {
-	int ret = SSL_write( (SSL *)sb->sb_iodata, buf, sz );
-
-	update_flags(sb, (SSL *)sb->sb_iodata );
-#ifdef WIN32
-	if (sb->sb_trans_needs_write)
-		errno = EWOULDBLOCK;
-#endif
-	return ret;
-}
+	(void) ldap_pvt_tls_init();
 
-static ber_slen_t
-tls_read( Sockbuf *sb, void *buf, ber_len_t sz )
-{
-	int ret = SSL_read( (SSL *)sb->sb_iodata, buf, sz );
+	/*
+	 * Fortunately, the lib uses blocking io...
+	 */
+	if ( ldap_pvt_tls_connect( ld, sb, ctx_arg ) < 0 ) {
+		return LDAP_CONNECT_ERROR;
+	}
 
-	update_flags(sb, (SSL *)sb->sb_iodata );
-#ifdef WIN32
-	if (sb->sb_trans_needs_read)
-		errno = EWOULDBLOCK;
-#endif
-	return ret;
-}
+	/* FIXME: hostname of server must be compared with name in
+	 * certificate....
+	 */
 
-static int
-tls_close( Sockbuf *sb )
-{
-	tcp_close( ber_pvt_sb_get_desc( sb ) );
-	return 0;
+	return LDAP_SUCCESS;
 }
 
 /* Derived from openssl/apps/s_cb.c */
@@ -613,15 +948,15 @@ tls_verify_cb( int ok, X509_STORE_CTX *ctx )
 	       sname ? sname : "-unknown-",
 	       iname ? iname : "-unknown-" );
 	if ( sname )
-		free ( sname );
+		CRYPTO_free ( sname );
 	if ( iname )
-		free ( iname );
+		CRYPTO_free ( iname );
 
-	return 1;
+	return ok;
 }
 
 /* Inspired by ERR_print_errors in OpenSSL */
-static int
+static void
 tls_report_error( void )
 {
         unsigned long l;
@@ -645,19 +980,97 @@ tls_tmp_rsa_cb( SSL *ssl, int is_export, int key_length )
 	tmp_rsa = RSA_generate_key( key_length, RSA_F4, NULL, NULL );
 
 	if ( !tmp_rsa ) {
-		Debug( LDAP_DEBUG_ANY, "TLS: Failed to generate temporary %d-bit %s RSA key\n",
-		       key_length, is_export ? "export" : "domestic", 0 );
+		Debug( LDAP_DEBUG_ANY,
+			"TLS: Failed to generate temporary %d-bit %s RSA key\n",
+			key_length, is_export ? "export" : "domestic", 0 );
 		return NULL;
 	}
 	return tmp_rsa;
 }
 
+static int
+tls_seed_PRNG( const char *randfile )
+{
+#ifndef URANDOM_DEVICE
+	/* no /dev/urandom (or equiv) */
+	char buffer[MAXPATHLEN];
+
+	if (randfile == NULL) {
+		/* The seed file is $RANDFILE if defined, otherwise $HOME/.rnd.
+		 * If $HOME is not set or buffer too small to hold the pathname,
+		 * an error occurs.    - From RAND_file_name() man page.
+		 * The fact is that when $HOME is NULL, .rnd is used.
+		 */
+		randfile = RAND_file_name( buffer, sizeof( buffer ) );
+
+	} else if (RAND_egd(randfile) > 0) {
+		/* EGD socket */
+		return 0;
+	}
+
+	if (randfile == NULL) {
+		Debug( LDAP_DEBUG_ANY,
+			"TLS: Use configuration file or $RANDFILE to define seed PRNG\n",
+			0, 0, 0);
+		return -1;
+	}
+
+	RAND_load_file(randfile, -1);
+
+	if (RAND_status() == 0) {
+		Debug( LDAP_DEBUG_ANY,
+			"TLS: PRNG not been seeded with enough data\n",
+			0, 0, 0);
+		return -1;
+	}
+#endif
+
+	return 0;
+}
+
+#if 0
 static DH *
 tls_tmp_dh_cb( SSL *ssl, int is_export, int key_length )
 {
 	return NULL;
 }
+#endif
+#endif
 
+int
+ldap_start_tls_s ( LDAP *ld,
+	LDAPControl **serverctrls,
+	LDAPControl **clientctrls )
+{
+#ifdef HAVE_TLS
+	int rc;
+	char *rspoid = NULL;
+	struct berval *rspdata = NULL;
+
+	/* XXYYZ: this initiates operaton only on default connection! */
+
+	if ( ldap_pvt_tls_inplace( ld->ld_sb ) != 0 ) {
+		return LDAP_LOCAL_ERROR;
+	}
+
+	rc = ldap_extended_operation_s( ld, LDAP_EXOP_START_TLS,
+		NULL, serverctrls, clientctrls, &rspoid, &rspdata );
+	if ( rc != LDAP_SUCCESS ) {
+		return rc;
+	}
+
+	if ( rspoid != NULL ) {
+		LDAP_FREE(rspoid);
+	}
+
+	if ( rspdata != NULL ) {
+		ber_bvfree( rspdata );
+	}
+
+	rc = ldap_pvt_tls_start( ld, ld->ld_sb, ld->ld_options.ldo_tls_ctx );
+	return rc;
 #else
-static int dummy;
+	return LDAP_NOT_SUPPORTED;
 #endif
+}
+