git.sur5r.net Git - openldap/blob - libraries/libldap/tls.c

   1 /* tls.c - Handle tls/ssl using SSLeay or OpenSSL. */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 1998-2006 The OpenLDAP Foundation.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  12  * A copy of this license is available in the file LICENSE in the
  13  * top-level directory of the distribution or, alternatively, at
  14  * <http://www.OpenLDAP.org/license.html>.
  15  */
  16
  17 #include "portable.h"
  18 #include "ldap_config.h"
  19
  20 #include <stdio.h>
  21
  22 #include <ac/stdlib.h>
  23 #include <ac/errno.h>
  24 #include <ac/socket.h>
  25 #include <ac/string.h>
  26 #include <ac/ctype.h>
  27 #include <ac/time.h>
  28 #include <ac/unistd.h>
  29 #include <ac/param.h>
  30 #include <ac/dirent.h>
  31
  32 #include "ldap-int.h"
  33
  34 #ifdef HAVE_TLS
  35
  36 #ifdef LDAP_R_COMPILE
  37 #include <ldap_pvt_thread.h>
  38 #endif
  39
  40 #ifdef HAVE_OPENSSL_SSL_H
  41 #include <openssl/ssl.h>
  42 #include <openssl/x509v3.h>
  43 #include <openssl/err.h>
  44 #include <openssl/rand.h>
  45 #include <openssl/safestack.h>
  46 #elif defined( HAVE_SSL_H )
  47 #include <ssl.h>
  48 #endif
  49
  50 static int  tls_opt_trace = 1;
  51 static char *tls_opt_randfile = NULL;
  52
  53 #define HAS_TLS( sb )   ber_sockbuf_ctrl( sb, LBER_SB_OPT_HAS_IO, \
  54                                 (void *)&sb_tls_sbio )
  55
  56 static void tls_report_error( void );
  57
  58 static void tls_info_cb( const SSL *ssl, int where, int ret );
  59 static int tls_verify_cb( int ok, X509_STORE_CTX *ctx );
  60 static int tls_verify_ok( int ok, X509_STORE_CTX *ctx );
  61 static RSA * tls_tmp_rsa_cb( SSL *ssl, int is_export, int key_length );
  62 static STACK_OF(X509_NAME) * get_ca_list( char * bundle, char * dir );
  63
  64 static DH * tls_tmp_dh_cb( SSL *ssl, int is_export, int key_length );
  65
  66 typedef struct dhplist {
  67         struct dhplist *next;
  68         int keylength;
  69         DH *param;
  70 } dhplist;
  71
  72 static dhplist *dhparams;
  73
  74 static int tls_seed_PRNG( const char *randfile );
  75
  76 #ifdef LDAP_R_COMPILE
  77 /*
  78  * provide mutexes for the SSLeay library.
  79  */
  80 static ldap_pvt_thread_mutex_t  tls_mutexes[CRYPTO_NUM_LOCKS];
  81
  82 static void tls_locking_cb( int mode, int type, const char *file, int line )
  83 {
  84         if ( mode & CRYPTO_LOCK ) {
  85                 ldap_pvt_thread_mutex_lock( &tls_mutexes[type] );
  86         } else {
  87                 ldap_pvt_thread_mutex_unlock( &tls_mutexes[type] );
  88         }
  89 }
  90
  91 /*
  92  * an extra mutex for the default ctx.
  93  */
  94
  95 static ldap_pvt_thread_mutex_t tls_def_ctx_mutex;
  96
  97 static void tls_init_threads( void )
  98 {
  99         int i;
 100
 101         for( i=0; i< CRYPTO_NUM_LOCKS ; i++ ) {
 102                 ldap_pvt_thread_mutex_init( &tls_mutexes[i] );
 103         }
 104         CRYPTO_set_locking_callback( tls_locking_cb );
 105         /* FIXME: the thread id should be added somehow... */
 106
 107         ldap_pvt_thread_mutex_init( &tls_def_ctx_mutex );
 108 }
 109 #endif /* LDAP_R_COMPILE */
 110
 111 void
 112 ldap_int_tls_destroy( struct ldapoptions *lo )
 113 {
 114         SSL_CTX_free( lo->ldo_tls_ctx );
 115         lo->ldo_tls_ctx = NULL;
 116
 117         if ( lo->ldo_tls_certfile ) {
 118                 LDAP_FREE( lo->ldo_tls_certfile );
 119                 lo->ldo_tls_certfile = NULL;
 120         }
 121         if ( lo->ldo_tls_keyfile ) {
 122                 LDAP_FREE( lo->ldo_tls_keyfile );
 123                 lo->ldo_tls_keyfile = NULL;
 124         }
 125         if ( lo->ldo_tls_dhfile ) {
 126                 LDAP_FREE( lo->ldo_tls_dhfile );
 127                 lo->ldo_tls_dhfile = NULL;
 128         }
 129         if ( lo->ldo_tls_cacertfile ) {
 130                 LDAP_FREE( lo->ldo_tls_cacertfile );
 131                 lo->ldo_tls_cacertfile = NULL;
 132         }
 133         if ( lo->ldo_tls_cacertdir ) {
 134                 LDAP_FREE( lo->ldo_tls_cacertdir );
 135                 lo->ldo_tls_cacertdir = NULL;
 136         }
 137         if ( lo->ldo_tls_ciphersuite ) {
 138                 LDAP_FREE( lo->ldo_tls_ciphersuite );
 139                 lo->ldo_tls_ciphersuite = NULL;
 140         }
 141 }
 142
 143 /*
 144  * Tear down the TLS subsystem. Should only be called once.
 145  */
 146 void
 147 ldap_pvt_tls_destroy( void )
 148 {
 149         EVP_cleanup();
 150         ERR_remove_state(0);
 151         ERR_free_strings();
 152
 153         if ( tls_opt_randfile ) {
 154                 LDAP_FREE( tls_opt_randfile );
 155                 tls_opt_randfile = NULL;
 156         }
 157 }
 158
 159 /*
 160  * Initialize TLS subsystem. Should be called only once.
 161  */
 162 int
 163 ldap_pvt_tls_init( void )
 164 {
 165         static int tls_initialized = 0;
 166
 167         if ( tls_initialized++ ) return 0;
 168
 169 #ifdef HAVE_EBCDIC
 170         {
 171                 char *file = LDAP_STRDUP( tls_opt_randfile );
 172                 if ( file ) __atoe( file );
 173                 (void) tls_seed_PRNG( file );
 174                 LDAP_FREE( file );
 175         }
 176 #else
 177         (void) tls_seed_PRNG( tls_opt_randfile );
 178 #endif
 179
 180 #ifdef LDAP_R_COMPILE
 181         tls_init_threads();
 182 #endif
 183
 184         SSL_load_error_strings();
 185         SSLeay_add_ssl_algorithms();
 186
 187         /* FIXME: mod_ssl does this */
 188         X509V3_add_standard_extensions();
 189         return 0;
 190 }
 191
 192 /*
 193  * initialize a new TLS context
 194  */
 195 static int
 196 ldap_int_tls_init_ctx( struct ldapoptions *lo, int is_server )
 197 {
 198         STACK_OF(X509_NAME) *calist;
 199         int i, rc = 0;
 200         char *ciphersuite = lo->ldo_tls_ciphersuite;
 201         char *cacertfile = lo->ldo_tls_cacertfile;
 202         char *cacertdir = lo->ldo_tls_cacertdir;
 203         char *certfile = lo->ldo_tls_certfile;
 204         char *keyfile = lo->ldo_tls_keyfile;
 205         char *dhfile = lo->ldo_tls_dhfile;
 206
 207         if ( lo->ldo_tls_ctx )
 208                 return 0;
 209
 210         if ( is_server && !certfile && !keyfile && !cacertfile && !cacertdir ) {
 211                 /* minimum configuration not provided */
 212                 return LDAP_NOT_SUPPORTED;
 213         }
 214
 215 #ifdef HAVE_EBCDIC
 216         /* This ASCII/EBCDIC handling is a real pain! */
 217         if ( ciphersuite ) {
 218                 ciphersuite = LDAP_STRDUP( ciphersuite );
 219                 __atoe( ciphersuite );
 220         }
 221         if ( cacertfile ) {
 222                 cacertfile = LDAP_STRDUP( cacertfile );
 223                 __atoe( cacertfile );
 224         }
 225         if ( cacertdir ) {
 226                 cacertdir = LDAP_STRDUP( cacertdir );
 227                 __atoe( cacertdir );
 228         }
 229         if ( certfile ) {
 230                 certfile = LDAP_STRDUP( certfile );
 231                 __atoe( certfile );
 232         }
 233         if ( keyfile ) {
 234                 keyfile = LDAP_STRDUP( keyfile );
 235                 __atoe( keyfile );
 236         }
 237         if ( dhfile ) {
 238                 dhfile = LDAP_STRDUP( dhfile );
 239                 __atoe( dhfile );
 240         }
 241 #endif
 242         lo->ldo_tls_ctx = SSL_CTX_new( SSLv23_method() );
 243         if ( lo->ldo_tls_ctx == NULL ) {
 244                 Debug( LDAP_DEBUG_ANY,
 245                    "TLS: could not allocate default ctx (%lu).\n",
 246                         ERR_peek_error(),0,0);
 247                 rc = -1;
 248                 goto error_exit;
 249         }
 250
 251         if ( is_server ) {
 252                 SSL_CTX_set_session_id_context( lo->ldo_tls_ctx,
 253                         (const unsigned char *) "OpenLDAP", sizeof("OpenLDAP")-1 );
 254         }
 255
 256         if ( lo->ldo_tls_ciphersuite &&
 257                 !SSL_CTX_set_cipher_list( lo->ldo_tls_ctx, ciphersuite ) )
 258         {
 259                 Debug( LDAP_DEBUG_ANY,
 260                            "TLS: could not set cipher list %s.\n",
 261                            lo->ldo_tls_ciphersuite, 0, 0 );
 262                 tls_report_error();
 263                 rc = -1;
 264                 goto error_exit;
 265         }
 266
 267         if (lo->ldo_tls_cacertfile != NULL || lo->ldo_tls_cacertdir != NULL) {
 268                 if ( !SSL_CTX_load_verify_locations( lo->ldo_tls_ctx,
 269                                 cacertfile, cacertdir ) ||
 270                         !SSL_CTX_set_default_verify_paths( lo->ldo_tls_ctx ) )
 271                 {
 272                         Debug( LDAP_DEBUG_ANY, "TLS: "
 273                                 "could not load verify locations (file:`%s',dir:`%s').\n",
 274                                 lo->ldo_tls_cacertfile ? lo->ldo_tls_cacertfile : "",
 275                                 lo->ldo_tls_cacertdir ? lo->ldo_tls_cacertdir : "",
 276                                 0 );
 277                         tls_report_error();
 278                         rc = -1;
 279                         goto error_exit;
 280                 }
 281
 282                 if ( is_server ) {
 283                         /* List of CA names to send to a client */
 284                         calist = get_ca_list( cacertfile, cacertdir );
 285                         if ( !calist ) {
 286                                 Debug( LDAP_DEBUG_ANY, "TLS: "
 287                                         "could not load client CA list (file:`%s',dir:`%s').\n",
 288                                         lo->ldo_tls_cacertfile ? lo->ldo_tls_cacertfile : "",
 289                                         lo->ldo_tls_cacertdir ? lo->ldo_tls_cacertdir : "",
 290                                         0 );
 291                                 tls_report_error();
 292                                 rc = -1;
 293                                 goto error_exit;
 294                         }
 295
 296                         SSL_CTX_set_client_CA_list( lo->ldo_tls_ctx, calist );
 297                 }
 298         }
 299
 300         if ( lo->ldo_tls_certfile &&
 301                 !SSL_CTX_use_certificate_file( lo->ldo_tls_ctx,
 302                         certfile, SSL_FILETYPE_PEM ) )
 303         {
 304                 Debug( LDAP_DEBUG_ANY,
 305                         "TLS: could not use certificate `%s'.\n",
 306                         lo->ldo_tls_certfile,0,0);
 307                 tls_report_error();
 308                 rc = -1;
 309                 goto error_exit;
 310         }
 311
 312         /* Key validity is checked automatically if cert has already been set */
 313         if ( lo->ldo_tls_keyfile &&
 314                 !SSL_CTX_use_PrivateKey_file( lo->ldo_tls_ctx,
 315                         keyfile, SSL_FILETYPE_PEM ) )
 316         {
 317                 Debug( LDAP_DEBUG_ANY,
 318                         "TLS: could not use key file `%s'.\n",
 319                         lo->ldo_tls_keyfile,0,0);
 320                 tls_report_error();
 321                 rc = -1;
 322                 goto error_exit;
 323         }
 324
 325         if ( lo->ldo_tls_dhfile ) {
 326                 DH *dh = NULL;
 327                 BIO *bio;
 328                 dhplist *p;
 329
 330                 if (( bio=BIO_new_file( dhfile,"r" )) == NULL ) {
 331                         Debug( LDAP_DEBUG_ANY,
 332                                 "TLS: could not use DH parameters file `%s'.\n",
 333                                 lo->ldo_tls_dhfile,0,0);
 334                         tls_report_error();
 335                         rc = -1;
 336                         goto error_exit;
 337                 }
 338                 while (( dh=PEM_read_bio_DHparams( bio, NULL, NULL, NULL ))) {
 339                         p = LDAP_MALLOC( sizeof(dhplist) );
 340                         if ( p != NULL ) {
 341                                 p->keylength = DH_size( dh ) * 8;
 342                                 p->param = dh;
 343                                 p->next = dhparams;
 344                                 dhparams = p;
 345                         }
 346                 }
 347                 BIO_free( bio );
 348         }
 349
 350         if ( tls_opt_trace ) {
 351                 SSL_CTX_set_info_callback( (SSL_CTX *)lo->ldo_tls_ctx, tls_info_cb );
 352         }
 353
 354         i = SSL_VERIFY_NONE;
 355         if ( lo->ldo_tls_require_cert ) {
 356                 i = SSL_VERIFY_PEER;
 357                 if ( lo->ldo_tls_require_cert == LDAP_OPT_X_TLS_DEMAND ||
 358                          lo->ldo_tls_require_cert == LDAP_OPT_X_TLS_HARD ) {
 359                         i |= SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
 360                 }
 361         }
 362
 363         SSL_CTX_set_verify( lo->ldo_tls_ctx, i,
 364                 lo->ldo_tls_require_cert == LDAP_OPT_X_TLS_ALLOW ?
 365                 tls_verify_ok : tls_verify_cb );
 366         SSL_CTX_set_tmp_rsa_callback( lo->ldo_tls_ctx, tls_tmp_rsa_cb );
 367         if ( lo->ldo_tls_dhfile ) {
 368                 SSL_CTX_set_tmp_dh_callback( lo->ldo_tls_ctx, tls_tmp_dh_cb );
 369         }
 370 #ifdef HAVE_OPENSSL_CRL
 371         if ( lo->ldo_tls_crlcheck ) {
 372                 X509_STORE *x509_s = SSL_CTX_get_cert_store( lo->ldo_tls_ctx );
 373                 if ( lo->ldo_tls_crlcheck == LDAP_OPT_X_TLS_CRL_PEER ) {
 374                         X509_STORE_set_flags( x509_s, X509_V_FLAG_CRL_CHECK );
 375                 } else if ( lo->ldo_tls_crlcheck == LDAP_OPT_X_TLS_CRL_ALL ) {
 376                         X509_STORE_set_flags( x509_s,
 377                                         X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL  );
 378                 }
 379         }
 380 #endif
 381
 382 error_exit:
 383         if ( rc == -1 && lo->ldo_tls_ctx != NULL ) {
 384                 SSL_CTX_free( lo->ldo_tls_ctx );
 385                 lo->ldo_tls_ctx = NULL;
 386         }
 387 #ifdef HAVE_EBCDIC
 388         LDAP_FREE( ciphersuite );
 389         LDAP_FREE( cacertfile );
 390         LDAP_FREE( cacertdir );
 391         LDAP_FREE( certfile );
 392         LDAP_FREE( keyfile );
 393         LDAP_FREE( dhfile );
 394 #endif
 395         return rc;
 396 }
 397
 398 /*
 399  * initialize the default context
 400  */
 401 int
 402 ldap_pvt_tls_init_def_ctx( int is_server )
 403 {
 404         struct ldapoptions *lo = LDAP_INT_GLOBAL_OPT();
 405         int rc;
 406 #ifdef LDAP_R_COMPILE
 407         ldap_pvt_thread_mutex_lock( &tls_def_ctx_mutex );
 408 #endif
 409         rc = ldap_int_tls_init_ctx( lo, is_server );
 410 #ifdef LDAP_R_COMPILE
 411         ldap_pvt_thread_mutex_unlock( &tls_def_ctx_mutex );
 412 #endif
 413 }
 414
 415 static STACK_OF(X509_NAME) *
 416 get_ca_list( char * bundle, char * dir )
 417 {
 418         STACK_OF(X509_NAME) *ca_list = NULL;
 419
 420         if ( bundle ) {
 421                 ca_list = SSL_load_client_CA_file( bundle );
 422         }
 423 #if defined(HAVE_DIRENT_H) || defined(dirent)
 424         if ( dir ) {
 425                 int freeit = 0;
 426
 427                 if ( !ca_list ) {
 428                         ca_list = sk_X509_NAME_new_null();
 429                         freeit = 1;
 430                 }
 431                 if ( !SSL_add_dir_cert_subjects_to_stack( ca_list, dir ) &&
 432                         freeit ) {
 433                         sk_X509_NAME_free( ca_list );
 434                         ca_list = NULL;
 435                 }
 436         }
 437 #endif
 438         return ca_list;
 439 }
 440
 441 static SSL *
 442 alloc_handle( void *ctx_arg, int is_server )
 443 {
 444         SSL_CTX *ctx;
 445         SSL     *ssl;
 446
 447         if ( ctx_arg ) {
 448                 ctx = (SSL_CTX *) ctx_arg;
 449         } else {
 450                 struct ldapoptions *lo = LDAP_INT_GLOBAL_OPT();
 451                 if ( ldap_pvt_tls_init_def_ctx( is_server ) < 0 ) return NULL;
 452                 ctx = lo->ldo_tls_ctx;
 453         }
 454
 455         ssl = SSL_new( ctx );
 456         if ( ssl == NULL ) {
 457                 Debug( LDAP_DEBUG_ANY,"TLS: can't create ssl handle.\n",0,0,0);
 458                 return NULL;
 459         }
 460         return ssl;
 461 }
 462
 463 static int
 464 update_flags( Sockbuf *sb, SSL * ssl, int rc )
 465 {
 466         int err = SSL_get_error(ssl, rc);
 467
 468         sb->sb_trans_needs_read  = 0;
 469         sb->sb_trans_needs_write = 0;
 470
 471         if (err == SSL_ERROR_WANT_READ) {
 472                 sb->sb_trans_needs_read  = 1;
 473                 return 1;
 474
 475         } else if (err == SSL_ERROR_WANT_WRITE) {
 476                 sb->sb_trans_needs_write = 1;
 477                 return 1;
 478
 479         } else if (err == SSL_ERROR_WANT_CONNECT) {
 480                 return 1;
 481         }
 482         return 0;
 483 }
 484
 485 /*
 486  * TLS support for LBER Sockbufs
 487  */
 488
 489 struct tls_data {
 490         SSL                     *ssl;
 491         Sockbuf_IO_Desc         *sbiod;
 492 };
 493
 494 static BIO_METHOD sb_tls_bio_method;
 495
 496 static int
 497 sb_tls_setup( Sockbuf_IO_Desc *sbiod, void *arg )
 498 {
 499         struct tls_data         *p;
 500         BIO                     *bio;
 501
 502         assert( sbiod != NULL );
 503
 504         p = LBER_MALLOC( sizeof( *p ) );
 505         if ( p == NULL ) {
 506                 return -1;
 507         }
 508
 509         p->ssl = (SSL *)arg;
 510         p->sbiod = sbiod;
 511         bio = BIO_new( &sb_tls_bio_method );
 512         bio->ptr = (void *)p;
 513         SSL_set_bio( p->ssl, bio, bio );
 514         sbiod->sbiod_pvt = p;
 515         return 0;
 516 }
 517
 518 static int
 519 sb_tls_remove( Sockbuf_IO_Desc *sbiod )
 520 {
 521         struct tls_data         *p;
 522
 523         assert( sbiod != NULL );
 524         assert( sbiod->sbiod_pvt != NULL );
 525
 526         p = (struct tls_data *)sbiod->sbiod_pvt;
 527         SSL_free( p->ssl );
 528         LBER_FREE( sbiod->sbiod_pvt );
 529         sbiod->sbiod_pvt = NULL;
 530         return 0;
 531 }
 532
 533 static int
 534 sb_tls_close( Sockbuf_IO_Desc *sbiod )
 535 {
 536         struct tls_data         *p;
 537
 538         assert( sbiod != NULL );
 539         assert( sbiod->sbiod_pvt != NULL );
 540
 541         p = (struct tls_data *)sbiod->sbiod_pvt;
 542         SSL_shutdown( p->ssl );
 543         return 0;
 544 }
 545
 546 static int
 547 sb_tls_ctrl( Sockbuf_IO_Desc *sbiod, int opt, void *arg )
 548 {
 549         struct tls_data         *p;
 550
 551         assert( sbiod != NULL );
 552         assert( sbiod->sbiod_pvt != NULL );
 553
 554         p = (struct tls_data *)sbiod->sbiod_pvt;
 555
 556         if ( opt == LBER_SB_OPT_GET_SSL ) {
 557                 *((SSL **)arg) = p->ssl;
 558                 return 1;
 559
 560         } else if ( opt == LBER_SB_OPT_DATA_READY ) {
 561                 if( SSL_pending( p->ssl ) > 0 ) {
 562                         return 1;
 563                 }
 564         }
 565
 566         return LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg );
 567 }
 568
 569 static ber_slen_t
 570 sb_tls_read( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
 571 {
 572         struct tls_data         *p;
 573         ber_slen_t              ret;
 574         int                     err;
 575
 576         assert( sbiod != NULL );
 577         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 578
 579         p = (struct tls_data *)sbiod->sbiod_pvt;
 580
 581         ret = SSL_read( p->ssl, (char *)buf, len );
 582 #ifdef HAVE_WINSOCK
 583         errno = WSAGetLastError();
 584 #endif
 585         err = SSL_get_error( p->ssl, ret );
 586         if (err == SSL_ERROR_WANT_READ ) {
 587                 sbiod->sbiod_sb->sb_trans_needs_read = 1;
 588                 errno = EWOULDBLOCK;
 589         }
 590         else
 591                 sbiod->sbiod_sb->sb_trans_needs_read = 0;
 592         return ret;
 593 }
 594
 595 static ber_slen_t
 596 sb_tls_write( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
 597 {
 598         struct tls_data         *p;
 599         ber_slen_t              ret;
 600         int                     err;
 601
 602         assert( sbiod != NULL );
 603         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 604
 605         p = (struct tls_data *)sbiod->sbiod_pvt;
 606
 607         ret = SSL_write( p->ssl, (char *)buf, len );
 608 #ifdef HAVE_WINSOCK
 609         errno = WSAGetLastError();
 610 #endif
 611         err = SSL_get_error( p->ssl, ret );
 612         if (err == SSL_ERROR_WANT_WRITE ) {
 613                 sbiod->sbiod_sb->sb_trans_needs_write = 1;
 614                 errno = EWOULDBLOCK;
 615
 616         } else {
 617                 sbiod->sbiod_sb->sb_trans_needs_write = 0;
 618         }
 619         return ret;
 620 }
 621
 622 static Sockbuf_IO sb_tls_sbio =
 623 {
 624         sb_tls_setup,           /* sbi_setup */
 625         sb_tls_remove,          /* sbi_remove */
 626         sb_tls_ctrl,            /* sbi_ctrl */
 627         sb_tls_read,            /* sbi_read */
 628         sb_tls_write,           /* sbi_write */
 629         sb_tls_close            /* sbi_close */
 630 };
 631
 632 static int
 633 sb_tls_bio_create( BIO *b ) {
 634         b->init = 1;
 635         b->num = 0;
 636         b->ptr = NULL;
 637         b->flags = 0;
 638         return 1;
 639 }
 640
 641 static int
 642 sb_tls_bio_destroy( BIO *b )
 643 {
 644         if ( b == NULL ) return 0;
 645
 646         b->ptr = NULL;          /* sb_tls_remove() will free it */
 647         b->init = 0;
 648         b->flags = 0;
 649         return 1;
 650 }
 651
 652 static int
 653 sb_tls_bio_read( BIO *b, char *buf, int len )
 654 {
 655         struct tls_data         *p;
 656         int                     ret;
 657
 658         if ( buf == NULL || len <= 0 ) return 0;
 659
 660         p = (struct tls_data *)b->ptr;
 661
 662         if ( p == NULL || p->sbiod == NULL ) {
 663                 return 0;
 664         }
 665
 666         ret = LBER_SBIOD_READ_NEXT( p->sbiod, buf, len );
 667
 668         BIO_clear_retry_flags( b );
 669         if ( ret < 0 ) {
 670                 int err = errno;
 671                 if ( err == EAGAIN || err == EWOULDBLOCK ) {
 672                         BIO_set_retry_read( b );
 673                 }
 674         }
 675
 676         return ret;
 677 }
 678
 679 static int
 680 sb_tls_bio_write( BIO *b, const char *buf, int len )
 681 {
 682         struct tls_data         *p;
 683         int                     ret;
 684
 685         if ( buf == NULL || len <= 0 ) return 0;
 686
 687         p = (struct tls_data *)b->ptr;
 688
 689         if ( p == NULL || p->sbiod == NULL ) {
 690                 return 0;
 691         }
 692
 693         ret = LBER_SBIOD_WRITE_NEXT( p->sbiod, (char *)buf, len );
 694
 695         BIO_clear_retry_flags( b );
 696         if ( ret < 0 ) {
 697                 int err = errno;
 698                 if ( err == EAGAIN || err == EWOULDBLOCK ) {
 699                         BIO_set_retry_write( b );
 700                 }
 701         }
 702
 703         return ret;
 704 }
 705
 706 static long
 707 sb_tls_bio_ctrl( BIO *b, int cmd, long num, void *ptr )
 708 {
 709         if ( cmd == BIO_CTRL_FLUSH ) {
 710                 /* The OpenSSL library needs this */
 711                 return 1;
 712         }
 713         return 0;
 714 }
 715
 716 static int
 717 sb_tls_bio_gets( BIO *b, char *buf, int len )
 718 {
 719         return -1;
 720 }
 721
 722 static int
 723 sb_tls_bio_puts( BIO *b, const char *str )
 724 {
 725         return sb_tls_bio_write( b, str, strlen( str ) );
 726 }
 727
 728 static BIO_METHOD sb_tls_bio_method =
 729 {
 730         ( 100 | 0x400 ),                /* it's a source/sink BIO */
 731         "sockbuf glue",
 732         sb_tls_bio_write,
 733         sb_tls_bio_read,
 734         sb_tls_bio_puts,
 735         sb_tls_bio_gets,
 736         sb_tls_bio_ctrl,
 737         sb_tls_bio_create,
 738         sb_tls_bio_destroy
 739 };
 740
 741 /*
 742  * Call this to do a TLS connect on a sockbuf. ctx_arg can be
 743  * a SSL_CTX * or NULL, in which case the default ctx is used.
 744  *
 745  * Return value:
 746  *
 747  *  0 - Success. Connection is ready for communication.
 748  * <0 - Error. Can't create a TLS stream.
 749  * >0 - Partial success.
 750  *        Do a select (using information from lber_pvt_sb_needs_{read,write}
 751  *              and call again.
 752  */
 753
 754 static int
 755 ldap_int_tls_connect( LDAP *ld, LDAPConn *conn )
 756 {
 757         Sockbuf *sb = conn->lconn_sb;
 758         int     err;
 759         SSL     *ssl;
 760
 761         if ( HAS_TLS( sb ) ) {
 762                 ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_SSL, (void *)&ssl );
 763
 764         } else {
 765                 struct ldapoptions *lo;
 766                 SSL_CTX *ctx;
 767
 768                 ctx = ld->ld_options.ldo_tls_ctx;
 769
 770                 ssl = alloc_handle( ctx, 0 );
 771
 772                 if ( ssl == NULL ) return -1;
 773
 774 #ifdef LDAP_DEBUG
 775                 ber_sockbuf_add_io( sb, &ber_sockbuf_io_debug,
 776                         LBER_SBIOD_LEVEL_TRANSPORT, (void *)"tls_" );
 777 #endif
 778                 ber_sockbuf_add_io( sb, &sb_tls_sbio,
 779                         LBER_SBIOD_LEVEL_TRANSPORT, (void *)ssl );
 780
 781                 lo = LDAP_INT_GLOBAL_OPT();
 782                 if( ctx == NULL ) {
 783                         ctx = lo->ldo_tls_ctx;
 784                         ld->ld_options.ldo_tls_ctx = ctx;
 785                         CRYPTO_add( &ctx->references, 1, CRYPTO_LOCK_SSL_CTX );
 786                 }
 787                 if ( ld->ld_options.ldo_tls_connect_cb )
 788                         ld->ld_options.ldo_tls_connect_cb( ld, ssl, ctx,
 789                         ld->ld_options.ldo_tls_connect_arg );
 790                 if ( lo && lo->ldo_tls_connect_cb && lo->ldo_tls_connect_cb !=
 791                         ld->ld_options.ldo_tls_connect_cb )
 792                         lo->ldo_tls_connect_cb( ld, ssl, ctx, lo->ldo_tls_connect_arg );
 793         }
 794
 795         err = SSL_connect( ssl );
 796
 797 #ifdef HAVE_WINSOCK
 798         errno = WSAGetLastError();
 799 #endif
 800
 801         if ( err <= 0 ) {
 802                 if ( update_flags( sb, ssl, err )) {
 803                         return 1;
 804                 }
 805
 806                 if ((err = ERR_peek_error())) {
 807                         char buf[256];
 808
 809                         if ( ld->ld_error ) {
 810                                 LDAP_FREE( ld->ld_error );
 811                         }
 812                         ld->ld_error = LDAP_STRDUP(ERR_error_string(err, buf));
 813 #ifdef HAVE_EBCDIC
 814                         if ( ld->ld_error ) __etoa(ld->ld_error);
 815 #endif
 816                 }
 817
 818                 Debug( LDAP_DEBUG_ANY,"TLS: can't connect.\n",0,0,0);
 819
 820                 ber_sockbuf_remove_io( sb, &sb_tls_sbio,
 821                         LBER_SBIOD_LEVEL_TRANSPORT );
 822 #ifdef LDAP_DEBUG
 823                 ber_sockbuf_remove_io( sb, &ber_sockbuf_io_debug,
 824                         LBER_SBIOD_LEVEL_TRANSPORT );
 825 #endif
 826                 return -1;
 827         }
 828
 829         return 0;
 830 }
 831
 832 /*
 833  * Call this to do a TLS accept on a sockbuf.
 834  * Everything else is the same as with tls_connect.
 835  */
 836 int
 837 ldap_pvt_tls_accept( Sockbuf *sb, void *ctx_arg )
 838 {
 839         int     err;
 840         SSL     *ssl;
 841
 842         if ( HAS_TLS( sb ) ) {
 843                 ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_SSL, (void *)&ssl );
 844
 845         } else {
 846                 ssl = alloc_handle( ctx_arg, 1 );
 847                 if ( ssl == NULL ) return -1;
 848
 849 #ifdef LDAP_DEBUG
 850                 ber_sockbuf_add_io( sb, &ber_sockbuf_io_debug,
 851                         LBER_SBIOD_LEVEL_TRANSPORT, (void *)"tls_" );
 852 #endif
 853                 ber_sockbuf_add_io( sb, &sb_tls_sbio,
 854                         LBER_SBIOD_LEVEL_TRANSPORT, (void *)ssl );
 855         }
 856
 857         err = SSL_accept( ssl );
 858
 859 #ifdef HAVE_WINSOCK
 860         errno = WSAGetLastError();
 861 #endif
 862         if ( err <= 0 ) {
 863                 if ( update_flags( sb, ssl, err )) return 1;
 864
 865                 Debug( LDAP_DEBUG_ANY,"TLS: can't accept.\n",0,0,0 );
 866
 867                 tls_report_error();
 868                 ber_sockbuf_remove_io( sb, &sb_tls_sbio,
 869                         LBER_SBIOD_LEVEL_TRANSPORT );
 870 #ifdef LDAP_DEBUG
 871                 ber_sockbuf_remove_io( sb, &ber_sockbuf_io_debug,
 872                         LBER_SBIOD_LEVEL_TRANSPORT );
 873 #endif
 874                 return -1;
 875         }
 876
 877         return 0;
 878 }
 879
 880 int
 881 ldap_pvt_tls_inplace ( Sockbuf *sb )
 882 {
 883         return HAS_TLS( sb ) ? 1 : 0;
 884 }
 885
 886 int
 887 ldap_tls_inplace( LDAP *ld )
 888 {
 889         Sockbuf         *sb = NULL;
 890
 891         if ( ld->ld_defconn && ld->ld_defconn->lconn_sb ) {
 892                 sb = ld->ld_defconn->lconn_sb;
 893
 894         } else if ( ld->ld_sb ) {
 895                 sb = ld->ld_sb;
 896
 897         } else {
 898                 return 0;
 899         }
 900
 901         return ldap_pvt_tls_inplace( sb );
 902 }
 903
 904 static X509 *
 905 tls_get_cert( SSL *s )
 906 {
 907         /* If peer cert was bad, treat as if no cert was given */
 908         if (SSL_get_verify_result(s)) {
 909                 /* If we can send an alert, do so */
 910                 if (SSL_version(s) != SSL2_VERSION) {
 911                         ssl3_send_alert(s,SSL3_AL_WARNING,SSL3_AD_BAD_CERTIFICATE);
 912                 }
 913                 return NULL;
 914         }
 915         return SSL_get_peer_certificate(s);
 916 }
 917
 918 int
 919 ldap_pvt_tls_get_peer_dn( void *s, struct berval *dn,
 920         LDAPDN_rewrite_dummy *func, unsigned flags )
 921 {
 922         X509 *x;
 923         X509_NAME *xn;
 924         int rc;
 925
 926         x = tls_get_cert((SSL *)s);
 927
 928         if (!x) return LDAP_INVALID_CREDENTIALS;
 929
 930         xn = X509_get_subject_name(x);
 931         rc = ldap_X509dn2bv(xn, dn, (LDAPDN_rewrite_func *)func, flags);
 932         X509_free(x);
 933         return rc;
 934 }
 935
 936 char *
 937 ldap_pvt_tls_get_peer_hostname( void *s )
 938 {
 939         X509 *x;
 940         X509_NAME *xn;
 941         char buf[2048], *p;
 942         int ret;
 943
 944         x = tls_get_cert((SSL *)s);
 945         if (!x) return NULL;
 946
 947         xn = X509_get_subject_name(x);
 948
 949         ret = X509_NAME_get_text_by_NID(xn, NID_commonName, buf, sizeof(buf));
 950         if( ret == -1 ) {
 951                 X509_free(x);
 952                 return NULL;
 953         }
 954
 955         p = LDAP_STRDUP(buf);
 956         X509_free(x);
 957         return p;
 958 }
 959
 960 /* what kind of hostname were we given? */
 961 #define IS_DNS  0
 962 #define IS_IP4  1
 963 #define IS_IP6  2
 964
 965 int
 966 ldap_pvt_tls_check_hostname( LDAP *ld, void *s, const char *name_in )
 967 {
 968         int i, ret = LDAP_LOCAL_ERROR;
 969         X509 *x;
 970         const char *name;
 971         char *ptr;
 972         int ntype = IS_DNS;
 973 #ifdef LDAP_PF_INET6
 974         struct in6_addr addr;
 975 #else
 976         struct in_addr addr;
 977 #endif
 978
 979         if( ldap_int_hostname &&
 980                 ( !name_in || !strcasecmp( name_in, "localhost" ) ) )
 981         {
 982                 name = ldap_int_hostname;
 983         } else {
 984                 name = name_in;
 985         }
 986
 987         x = tls_get_cert((SSL *)s);
 988         if (!x) {
 989                 Debug( LDAP_DEBUG_ANY,
 990                         "TLS: unable to get peer certificate.\n",
 991                         0, 0, 0 );
 992                 /* If this was a fatal condition, things would have
 993                  * aborted long before now.
 994                  */
 995                 return LDAP_SUCCESS;
 996         }
 997
 998 #ifdef LDAP_PF_INET6
 999         if (name[0] == '[' && strchr(name, ']')) {
1000                 char *n2 = ldap_strdup(name+1);
1001                 *strchr(n2, ']') = 2;
1002                 if (inet_pton(AF_INET6, n2, &addr))
1003                         ntype = IS_IP6;
1004                 LDAP_FREE(n2);
1005         } else
1006 #endif
1007         if ((ptr = strrchr(name, '.')) && isdigit((unsigned char)ptr[1])) {
1008                 if (inet_aton(name, (struct in_addr *)&addr)) ntype = IS_IP4;
1009         }
1010
1011         i = X509_get_ext_by_NID(x, NID_subject_alt_name, -1);
1012         if (i >= 0) {
1013                 X509_EXTENSION *ex;
1014                 STACK_OF(GENERAL_NAME) *alt;
1015
1016                 ex = X509_get_ext(x, i);
1017                 alt = X509V3_EXT_d2i(ex);
1018                 if (alt) {
1019                         int n, len1 = 0, len2 = 0;
1020                         char *domain = NULL;
1021                         GENERAL_NAME *gn;
1022
1023                         if (ntype == IS_DNS) {
1024                                 len1 = strlen(name);
1025                                 domain = strchr(name, '.');
1026                                 if (domain) {
1027                                         len2 = len1 - (domain-name);
1028                                 }
1029                         }
1030                         n = sk_GENERAL_NAME_num(alt);
1031                         for (i=0; i<n; i++) {
1032                                 char *sn;
1033                                 int sl;
1034                                 gn = sk_GENERAL_NAME_value(alt, i);
1035                                 if (gn->type == GEN_DNS) {
1036                                         if (ntype != IS_DNS) continue;
1037
1038                                         sn = (char *) ASN1_STRING_data(gn->d.ia5);
1039                                         sl = ASN1_STRING_length(gn->d.ia5);
1040
1041                                         /* ignore empty */
1042                                         if (sl == 0) continue;
1043
1044                                         /* Is this an exact match? */
1045                                         if ((len1 == sl) && !strncasecmp(name, sn, len1)) {
1046                                                 break;
1047                                         }
1048
1049                                         /* Is this a wildcard match? */
1050                                         if (domain && (sn[0] == '*') && (sn[1] == '.') &&
1051                                                 (len2 == sl-1) && !strncasecmp(domain, &sn[1], len2))
1052                                         {
1053                                                 break;
1054                                         }
1055
1056                                 } else if (gn->type == GEN_IPADD) {
1057                                         if (ntype == IS_DNS) continue;
1058
1059                                         sn = (char *) ASN1_STRING_data(gn->d.ia5);
1060                                         sl = ASN1_STRING_length(gn->d.ia5);
1061
1062 #ifdef LDAP_PF_INET6
1063                                         if (ntype == IS_IP6 && sl != sizeof(struct in6_addr)) {
1064                                                 continue;
1065                                         } else
1066 #endif
1067                                         if (ntype == IS_IP4 && sl != sizeof(struct in_addr)) {
1068                                                 continue;
1069                                         }
1070                                         if (!memcmp(sn, &addr, sl)) {
1071                                                 break;
1072                                         }
1073                                 }
1074                         }
1075
1076                         GENERAL_NAMES_free(alt);
1077                         if (i < n) {    /* Found a match */
1078                                 ret = LDAP_SUCCESS;
1079                         }
1080                 }
1081         }
1082
1083         if (ret != LDAP_SUCCESS) {
1084                 X509_NAME *xn;
1085                 char buf[2048];
1086                 buf[0] = '\0';
1087
1088                 xn = X509_get_subject_name(x);
1089                 if( X509_NAME_get_text_by_NID( xn, NID_commonName,
1090                         buf, sizeof(buf)) == -1)
1091                 {
1092                         Debug( LDAP_DEBUG_ANY,
1093                                 "TLS: unable to get common name from peer certificate.\n",
1094                                 0, 0, 0 );
1095                         ret = LDAP_CONNECT_ERROR;
1096                         if ( ld->ld_error ) {
1097                                 LDAP_FREE( ld->ld_error );
1098                         }
1099                         ld->ld_error = LDAP_STRDUP(
1100                                 _("TLS: unable to get CN from peer certificate"));
1101
1102                 } else if (strcasecmp(name, buf) == 0 ) {
1103                         ret = LDAP_SUCCESS;
1104
1105                 } else if (( buf[0] == '*' ) && ( buf[1] == '.' )) {
1106                         char *domain = strchr(name, '.');
1107                         if( domain ) {
1108                                 size_t dlen = 0;
1109                                 size_t sl;
1110
1111                                 sl = strlen(name);
1112                                 dlen = sl - (domain-name);
1113                                 sl = strlen(buf);
1114
1115                                 /* Is this a wildcard match? */
1116                                 if ((dlen == sl-1) && !strncasecmp(domain, &buf[1], dlen)) {
1117                                         ret = LDAP_SUCCESS;
1118                                 }
1119                         }
1120                 }
1121
1122                 if( ret == LDAP_LOCAL_ERROR ) {
1123                         Debug( LDAP_DEBUG_ANY, "TLS: hostname (%s) does not match "
1124                                 "common name in certificate (%s).\n",
1125                                 name, buf, 0 );
1126                         ret = LDAP_CONNECT_ERROR;
1127                         if ( ld->ld_error ) {
1128                                 LDAP_FREE( ld->ld_error );
1129                         }
1130                         ld->ld_error = LDAP_STRDUP(
1131                                 _("TLS: hostname does not match CN in peer certificate"));
1132                 }
1133         }
1134         X509_free(x);
1135         return ret;
1136 }
1137
1138 const char *
1139 ldap_pvt_tls_get_peer_issuer( void *s )
1140 {
1141 #if 0   /* currently unused; see ldap_pvt_tls_get_peer_dn() if needed */
1142         X509 *x;
1143         X509_NAME *xn;
1144         char buf[2048], *p;
1145
1146         x = SSL_get_peer_certificate((SSL *)s);
1147
1148         if (!x) return NULL;
1149
1150         xn = X509_get_issuer_name(x);
1151         p = LDAP_STRDUP(X509_NAME_oneline(xn, buf, sizeof(buf)));
1152         X509_free(x);
1153         return p;
1154 #else
1155         return NULL;
1156 #endif
1157 }
1158
1159 int
1160 ldap_int_tls_config( LDAP *ld, int option, const char *arg )
1161 {
1162         int i;
1163
1164         switch( option ) {
1165         case LDAP_OPT_X_TLS_CACERTFILE:
1166         case LDAP_OPT_X_TLS_CACERTDIR:
1167         case LDAP_OPT_X_TLS_CERTFILE:
1168         case LDAP_OPT_X_TLS_KEYFILE:
1169         case LDAP_OPT_X_TLS_RANDOM_FILE:
1170         case LDAP_OPT_X_TLS_CIPHER_SUITE:
1171         case LDAP_OPT_X_TLS_DHFILE:
1172                 return ldap_pvt_tls_set_option( ld, option, (void *) arg );
1173
1174         case LDAP_OPT_X_TLS_REQUIRE_CERT:
1175         case LDAP_OPT_X_TLS:
1176                 i = -1;
1177                 if ( strcasecmp( arg, "never" ) == 0 ) {
1178                         i = LDAP_OPT_X_TLS_NEVER ;
1179
1180                 } else if ( strcasecmp( arg, "demand" ) == 0 ) {
1181                         i = LDAP_OPT_X_TLS_DEMAND ;
1182
1183                 } else if ( strcasecmp( arg, "allow" ) == 0 ) {
1184                         i = LDAP_OPT_X_TLS_ALLOW ;
1185
1186                 } else if ( strcasecmp( arg, "try" ) == 0 ) {
1187                         i = LDAP_OPT_X_TLS_TRY ;
1188
1189                 } else if ( ( strcasecmp( arg, "hard" ) == 0 ) ||
1190                         ( strcasecmp( arg, "on" ) == 0 ) ||
1191                         ( strcasecmp( arg, "yes" ) == 0) ||
1192                         ( strcasecmp( arg, "true" ) == 0 ) )
1193                 {
1194                         i = LDAP_OPT_X_TLS_HARD ;
1195                 }
1196
1197                 if (i >= 0) {
1198                         return ldap_pvt_tls_set_option( ld, option, &i );
1199                 }
1200                 return -1;
1201 #ifdef HAVE_OPENSSL_CRL
1202         case LDAP_OPT_X_TLS_CRLCHECK:
1203                 i = -1;
1204                 if ( strcasecmp( arg, "none" ) == 0 ) {
1205                         i = LDAP_OPT_X_TLS_CRL_NONE ;
1206                 } else if ( strcasecmp( arg, "peer" ) == 0 ) {
1207                         i = LDAP_OPT_X_TLS_CRL_PEER ;
1208                 } else if ( strcasecmp( arg, "all" ) == 0 ) {
1209                         i = LDAP_OPT_X_TLS_CRL_ALL ;
1210                 }
1211                 if (i >= 0) {
1212                         return ldap_pvt_tls_set_option( ld, option, &i );
1213                 }
1214                 return -1;
1215 #endif
1216         }
1217         return -1;
1218 }
1219
1220 int
1221 ldap_pvt_tls_get_option( LDAP *ld, int option, void *arg )
1222 {
1223         struct ldapoptions *lo;
1224
1225         if( ld != NULL ) {
1226                 assert( LDAP_VALID( ld ) );
1227
1228                 if( !LDAP_VALID( ld ) ) {
1229                         return LDAP_OPT_ERROR;
1230                 }
1231
1232                 lo = &ld->ld_options;
1233
1234         } else {
1235                 /* Get pointer to global option structure */
1236                 lo = LDAP_INT_GLOBAL_OPT();
1237                 if ( lo == NULL ) {
1238                         return LDAP_NO_MEMORY;
1239                 }
1240         }
1241
1242         switch( option ) {
1243         case LDAP_OPT_X_TLS:
1244                 *(int *)arg = lo->ldo_tls_mode;
1245                 break;
1246         case LDAP_OPT_X_TLS_CTX:
1247                 *(void **)arg = lo->ldo_tls_ctx;
1248                 if ( lo->ldo_tls_ctx ) {
1249                         SSL_CTX *ctx = lo->ldo_tls_ctx;
1250                         CRYPTO_add( &ctx->references, 1, CRYPTO_LOCK_SSL_CTX );
1251                 }
1252                 break;
1253         case LDAP_OPT_X_TLS_CACERTFILE:
1254                 *(char **)arg = lo->ldo_tls_cacertfile ?
1255                         LDAP_STRDUP( lo->ldo_tls_cacertfile ) : NULL;
1256                 break;
1257         case LDAP_OPT_X_TLS_CACERTDIR:
1258                 *(char **)arg = lo->ldo_tls_cacertdir ?
1259                         LDAP_STRDUP( lo->ldo_tls_cacertdir ) : NULL;
1260                 break;
1261         case LDAP_OPT_X_TLS_CERTFILE:
1262                 *(char **)arg = lo->ldo_tls_certfile ?
1263                         LDAP_STRDUP( lo->ldo_tls_certfile ) : NULL;
1264                 break;
1265         case LDAP_OPT_X_TLS_KEYFILE:
1266                 *(char **)arg = lo->ldo_tls_keyfile ?
1267                         LDAP_STRDUP( lo->ldo_tls_keyfile ) : NULL;
1268                 break;
1269         case LDAP_OPT_X_TLS_DHFILE:
1270                 *(char **)arg = lo->ldo_tls_dhfile ?
1271                         LDAP_STRDUP( lo->ldo_tls_dhfile ) : NULL;
1272                 break;
1273         case LDAP_OPT_X_TLS_REQUIRE_CERT:
1274                 *(int *)arg = lo->ldo_tls_require_cert;
1275                 break;
1276 #ifdef HAVE_OPENSSL_CRL
1277         case LDAP_OPT_X_TLS_CRLCHECK:
1278                 *(int *)arg = lo->ldo_tls_crlcheck;
1279                 break;
1280 #endif
1281         case LDAP_OPT_X_TLS_RANDOM_FILE:
1282                 *(char **)arg = tls_opt_randfile ?
1283                         LDAP_STRDUP( tls_opt_randfile ) : NULL;
1284                 break;
1285         case LDAP_OPT_X_TLS_SSL_CTX: {
1286                 void *retval = 0;
1287                 if ( ld != NULL ) {
1288                         LDAPConn *conn = ld->ld_defconn;
1289                         if ( conn != NULL ) {
1290                                 Sockbuf *sb = conn->lconn_sb;
1291                                 retval = ldap_pvt_tls_sb_ctx( sb );
1292                         }
1293                 }
1294                 *(void **)arg = retval;
1295                 break;
1296         }
1297         case LDAP_OPT_X_TLS_CONNECT_CB:
1298                 *(LDAP_TLS_CONNECT_CB **)arg = lo->ldo_tls_connect_cb;
1299                 break;
1300         case LDAP_OPT_X_TLS_CONNECT_ARG:
1301                 *(void **)arg = lo->ldo_tls_connect_arg;
1302                 break;
1303         default:
1304                 return -1;
1305         }
1306         return 0;
1307 }
1308
1309 int
1310 ldap_pvt_tls_set_option( LDAP *ld, int option, void *arg )
1311 {
1312         struct ldapoptions *lo;
1313
1314         if( ld != NULL ) {
1315                 assert( LDAP_VALID( ld ) );
1316
1317                 if( !LDAP_VALID( ld ) ) {
1318                         return LDAP_OPT_ERROR;
1319                 }
1320
1321                 lo = &ld->ld_options;
1322
1323         } else {
1324                 /* Get pointer to global option structure */
1325                 lo = LDAP_INT_GLOBAL_OPT();
1326                 if ( lo == NULL ) {
1327                         return LDAP_NO_MEMORY;
1328                 }
1329         }
1330
1331         switch( option ) {
1332         case LDAP_OPT_X_TLS:
1333                 if ( !arg ) return -1;
1334
1335                 switch( *(int *) arg ) {
1336                 case LDAP_OPT_X_TLS_NEVER:
1337                 case LDAP_OPT_X_TLS_DEMAND:
1338                 case LDAP_OPT_X_TLS_ALLOW:
1339                 case LDAP_OPT_X_TLS_TRY:
1340                 case LDAP_OPT_X_TLS_HARD:
1341                         if (lo != NULL) {
1342                                 lo->ldo_tls_mode = *(int *)arg;
1343                         }
1344
1345                         return 0;
1346                 }
1347                 return -1;
1348
1349         case LDAP_OPT_X_TLS_CTX:
1350                 lo->ldo_tls_ctx = arg;
1351                 return 0;
1352         case LDAP_OPT_X_TLS_CONNECT_CB:
1353                 lo->ldo_tls_connect_cb = (LDAP_TLS_CONNECT_CB *)arg;
1354                 return 0;
1355         case LDAP_OPT_X_TLS_CONNECT_ARG:
1356                 lo->ldo_tls_connect_arg = arg;
1357                 return 0;
1358         case LDAP_OPT_X_TLS_CACERTFILE:
1359                 if ( lo->ldo_tls_cacertfile ) LDAP_FREE( lo->ldo_tls_cacertfile );
1360                 lo->ldo_tls_cacertfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1361                 return 0;
1362         case LDAP_OPT_X_TLS_CACERTDIR:
1363                 if ( lo->ldo_tls_cacertdir ) LDAP_FREE( lo->ldo_tls_cacertdir );
1364                 lo->ldo_tls_cacertdir = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1365                 return 0;
1366         case LDAP_OPT_X_TLS_CERTFILE:
1367                 if ( lo->ldo_tls_certfile ) LDAP_FREE( lo->ldo_tls_certfile );
1368                 lo->ldo_tls_certfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1369                 return 0;
1370         case LDAP_OPT_X_TLS_KEYFILE:
1371                 if ( lo->ldo_tls_keyfile ) LDAP_FREE( lo->ldo_tls_keyfile );
1372                 lo->ldo_tls_keyfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1373                 return 0;
1374         case LDAP_OPT_X_TLS_DHFILE:
1375                 if ( lo->ldo_tls_dhfile ) LDAP_FREE( lo->ldo_tls_dhfile );
1376                 lo->ldo_tls_dhfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1377                 return 0;
1378         case LDAP_OPT_X_TLS_REQUIRE_CERT:
1379                 if ( !arg ) return -1;
1380                 switch( *(int *) arg ) {
1381                 case LDAP_OPT_X_TLS_NEVER:
1382                 case LDAP_OPT_X_TLS_DEMAND:
1383                 case LDAP_OPT_X_TLS_ALLOW:
1384                 case LDAP_OPT_X_TLS_TRY:
1385                 case LDAP_OPT_X_TLS_HARD:
1386                         lo->ldo_tls_require_cert = * (int *) arg;
1387                         return 0;
1388                 }
1389                 return -1;
1390 #ifdef HAVE_OPENSSL_CRL
1391         case LDAP_OPT_X_TLS_CRLCHECK:
1392                 if ( !arg ) return -1;
1393                 switch( *(int *) arg ) {
1394                 case LDAP_OPT_X_TLS_CRL_NONE:
1395                 case LDAP_OPT_X_TLS_CRL_PEER:
1396                 case LDAP_OPT_X_TLS_CRL_ALL:
1397                         lo->ldo_tls_crlcheck = * (int *) arg;
1398                         return 0;
1399                 }
1400                 return -1;
1401 #endif
1402         case LDAP_OPT_X_TLS_CIPHER_SUITE:
1403                 if ( lo->ldo_tls_ciphersuite ) LDAP_FREE( lo->ldo_tls_ciphersuite );
1404                 lo->ldo_tls_ciphersuite = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1405                 return 0;
1406
1407         case LDAP_OPT_X_TLS_RANDOM_FILE:
1408                 if ( ld != NULL )
1409                         return -1;
1410                 if (tls_opt_randfile ) LDAP_FREE (tls_opt_randfile );
1411                 tls_opt_randfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1412                 break;
1413
1414         case LDAP_OPT_X_TLS_NEWCTX:
1415                 if ( !arg ) return -1;
1416                 lo->ldo_tls_ctx = NULL;
1417                 return ldap_int_tls_init_ctx( lo, *(int *)arg );
1418         default:
1419                 return -1;
1420         }
1421         return 0;
1422 }
1423
1424 int
1425 ldap_int_tls_start ( LDAP *ld, LDAPConn *conn, LDAPURLDesc *srv )
1426 {
1427         Sockbuf *sb = conn->lconn_sb;
1428         char *host;
1429         void *ssl;
1430
1431         if( srv ) {
1432                 host = srv->lud_host;
1433         } else {
1434                 host = conn->lconn_server->lud_host;
1435         }
1436
1437         /* avoid NULL host */
1438         if( host == NULL ) {
1439                 host = "localhost";
1440         }
1441
1442         (void) ldap_pvt_tls_init();
1443
1444         /*
1445          * Fortunately, the lib uses blocking io...
1446          */
1447         if ( ldap_int_tls_connect( ld, conn ) < 0 ) {
1448                 ld->ld_errno = LDAP_CONNECT_ERROR;
1449                 return (ld->ld_errno);
1450         }
1451
1452         ssl = ldap_pvt_tls_sb_ctx( sb );
1453         assert( ssl != NULL );
1454
1455         /*
1456          * compare host with name(s) in certificate
1457          */
1458         if (ld->ld_options.ldo_tls_require_cert != LDAP_OPT_X_TLS_NEVER) {
1459                 ld->ld_errno = ldap_pvt_tls_check_hostname( ld, ssl, host );
1460                 if (ld->ld_errno != LDAP_SUCCESS) {
1461                         return ld->ld_errno;
1462                 }
1463         }
1464
1465         return LDAP_SUCCESS;
1466 }
1467
1468 /* Derived from openssl/apps/s_cb.c */
1469 static void
1470 tls_info_cb( const SSL *ssl, int where, int ret )
1471 {
1472         int w;
1473         char *op;
1474         char *state = (char *) SSL_state_string_long( (SSL *)ssl );
1475
1476         w = where & ~SSL_ST_MASK;
1477         if ( w & SSL_ST_CONNECT ) {
1478                 op = "SSL_connect";
1479         } else if ( w & SSL_ST_ACCEPT ) {
1480                 op = "SSL_accept";
1481         } else {
1482                 op = "undefined";
1483         }
1484
1485 #ifdef HAVE_EBCDIC
1486         if ( state ) {
1487                 state = LDAP_STRDUP( state );
1488                 __etoa( state );
1489         }
1490 #endif
1491         if ( where & SSL_CB_LOOP ) {
1492                 Debug( LDAP_DEBUG_TRACE,
1493                            "TLS trace: %s:%s\n",
1494                            op, state, 0 );
1495
1496         } else if ( where & SSL_CB_ALERT ) {
1497                 char *atype = (char *) SSL_alert_type_string_long( ret );
1498                 char *adesc = (char *) SSL_alert_desc_string_long( ret );
1499                 op = ( where & SSL_CB_READ ) ? "read" : "write";
1500 #ifdef HAVE_EBCDIC
1501                 if ( atype ) {
1502                         atype = LDAP_STRDUP( atype );
1503                         __etoa( atype );
1504                 }
1505                 if ( adesc ) {
1506                         adesc = LDAP_STRDUP( adesc );
1507                         __etoa( adesc );
1508                 }
1509 #endif
1510                 Debug( LDAP_DEBUG_TRACE,
1511                            "TLS trace: SSL3 alert %s:%s:%s\n",
1512                            op, atype, adesc );
1513 #ifdef HAVE_EBCDIC
1514                 if ( atype ) LDAP_FREE( atype );
1515                 if ( adesc ) LDAP_FREE( adesc );
1516 #endif
1517         } else if ( where & SSL_CB_EXIT ) {
1518                 if ( ret == 0 ) {
1519                         Debug( LDAP_DEBUG_TRACE,
1520                                    "TLS trace: %s:failed in %s\n",
1521                                    op, state, 0 );
1522                 } else if ( ret < 0 ) {
1523                         Debug( LDAP_DEBUG_TRACE,
1524                                    "TLS trace: %s:error in %s\n",
1525                                    op, state, 0 );
1526                 }
1527         }
1528 #ifdef HAVE_EBCDIC
1529         if ( state ) LDAP_FREE( state );
1530 #endif
1531 }
1532
1533 static int
1534 tls_verify_cb( int ok, X509_STORE_CTX *ctx )
1535 {
1536         X509 *cert;
1537         int errnum;
1538         int errdepth;
1539         X509_NAME *subject;
1540         X509_NAME *issuer;
1541         char *sname;
1542         char *iname;
1543         char *certerr = NULL;
1544
1545         cert = X509_STORE_CTX_get_current_cert( ctx );
1546         errnum = X509_STORE_CTX_get_error( ctx );
1547         errdepth = X509_STORE_CTX_get_error_depth( ctx );
1548
1549         /*
1550          * X509_get_*_name return pointers to the internal copies of
1551          * those things requested.  So do not free them.
1552          */
1553         subject = X509_get_subject_name( cert );
1554         issuer = X509_get_issuer_name( cert );
1555         /* X509_NAME_oneline, if passed a NULL buf, allocate memomry */
1556         sname = X509_NAME_oneline( subject, NULL, 0 );
1557         iname = X509_NAME_oneline( issuer, NULL, 0 );
1558         if ( !ok ) certerr = (char *)X509_verify_cert_error_string( errnum );
1559 #ifdef HAVE_EBCDIC
1560         if ( sname ) __etoa( sname );
1561         if ( iname ) __etoa( iname );
1562         if ( certerr ) {
1563                 certerr = LDAP_STRDUP( certerr );
1564                 __etoa( certerr );
1565         }
1566 #endif
1567         Debug( LDAP_DEBUG_TRACE,
1568                    "TLS certificate verification: depth: %d, err: %d, subject: %s,",
1569                    errdepth, errnum,
1570                    sname ? sname : "-unknown-" );
1571         Debug( LDAP_DEBUG_TRACE, " issuer: %s\n", iname ? iname : "-unknown-", 0, 0 );
1572         if ( !ok ) {
1573                 Debug( LDAP_DEBUG_ANY,
1574                         "TLS certificate verification: Error, %s\n",
1575                         certerr, 0, 0 );
1576         }
1577         if ( sname )
1578                 CRYPTO_free ( sname );
1579         if ( iname )
1580                 CRYPTO_free ( iname );
1581 #ifdef HAVE_EBCDIC
1582         if ( certerr ) LDAP_FREE( certerr );
1583 #endif
1584         return ok;
1585 }
1586
1587 static int
1588 tls_verify_ok( int ok, X509_STORE_CTX *ctx )
1589 {
1590         (void) tls_verify_cb( ok, ctx );
1591         return 1;
1592 }
1593
1594 /* Inspired by ERR_print_errors in OpenSSL */
1595 static void
1596 tls_report_error( void )
1597 {
1598         unsigned long l;
1599         char buf[200];
1600         const char *file;
1601         int line;
1602
1603         while ( ( l = ERR_get_error_line( &file, &line ) ) != 0 ) {
1604                 ERR_error_string_n( l, buf, sizeof( buf ) );
1605 #ifdef HAVE_EBCDIC
1606                 if ( file ) {
1607                         file = LDAP_STRDUP( file );
1608                         __etoa( (char *)file );
1609                 }
1610                 __etoa( buf );
1611 #endif
1612                 Debug( LDAP_DEBUG_ANY, "TLS: %s %s:%d\n",
1613                         buf, file, line );
1614 #ifdef HAVE_EBCDIC
1615                 if ( file ) LDAP_FREE( (void *)file );
1616 #endif
1617         }
1618 }
1619
1620 static RSA *
1621 tls_tmp_rsa_cb( SSL *ssl, int is_export, int key_length )
1622 {
1623         RSA *tmp_rsa;
1624
1625         /* FIXME:  Pregenerate the key on startup */
1626         /* FIXME:  Who frees the key? */
1627         tmp_rsa = RSA_generate_key( key_length, RSA_F4, NULL, NULL );
1628
1629         if ( !tmp_rsa ) {
1630                 Debug( LDAP_DEBUG_ANY,
1631                         "TLS: Failed to generate temporary %d-bit %s RSA key\n",
1632                         key_length, is_export ? "export" : "domestic", 0 );
1633                 return NULL;
1634         }
1635         return tmp_rsa;
1636 }
1637
1638 static int
1639 tls_seed_PRNG( const char *randfile )
1640 {
1641 #ifndef URANDOM_DEVICE
1642         /* no /dev/urandom (or equiv) */
1643         long total=0;
1644         char buffer[MAXPATHLEN];
1645
1646         if (randfile == NULL) {
1647                 /* The seed file is $RANDFILE if defined, otherwise $HOME/.rnd.
1648                  * If $HOME is not set or buffer too small to hold the pathname,
1649                  * an error occurs.     - From RAND_file_name() man page.
1650                  * The fact is that when $HOME is NULL, .rnd is used.
1651                  */
1652                 randfile = RAND_file_name( buffer, sizeof( buffer ) );
1653
1654         } else if (RAND_egd(randfile) > 0) {
1655                 /* EGD socket */
1656                 return 0;
1657         }
1658
1659         if (randfile == NULL) {
1660                 Debug( LDAP_DEBUG_ANY,
1661                         "TLS: Use configuration file or $RANDFILE to define seed PRNG\n",
1662                         0, 0, 0);
1663                 return -1;
1664         }
1665
1666         total = RAND_load_file(randfile, -1);
1667
1668         if (RAND_status() == 0) {
1669                 Debug( LDAP_DEBUG_ANY,
1670                         "TLS: PRNG not been seeded with enough data\n",
1671                         0, 0, 0);
1672                 return -1;
1673         }
1674
1675         /* assume if there was enough bits to seed that it's okay
1676          * to write derived bits to the file
1677          */
1678         RAND_write_file(randfile);
1679
1680 #endif
1681
1682         return 0;
1683 }
1684
1685 struct dhinfo {
1686         int keylength;
1687         const char *pem;
1688         size_t size;
1689 };
1690
1691
1692 /* From the OpenSSL 0.9.7 distro */
1693 static const char dhpem512[] =
1694 "-----BEGIN DH PARAMETERS-----\n\
1695 MEYCQQDaWDwW2YUiidDkr3VvTMqS3UvlM7gE+w/tlO+cikQD7VdGUNNpmdsp13Yn\n\
1696 a6LT1BLiGPTdHghM9tgAPnxHdOgzAgEC\n\
1697 -----END DH PARAMETERS-----\n";
1698
1699 static const char dhpem1024[] =
1700 "-----BEGIN DH PARAMETERS-----\n\
1701 MIGHAoGBAJf2QmHKtQXdKCjhPx1ottPb0PMTBH9A6FbaWMsTuKG/K3g6TG1Z1fkq\n\
1702 /Gz/PWk/eLI9TzFgqVAuPvr3q14a1aZeVUMTgo2oO5/y2UHe6VaJ+trqCTat3xlx\n\
1703 /mNbIK9HA2RgPC3gWfVLZQrY+gz3ASHHR5nXWHEyvpuZm7m3h+irAgEC\n\
1704 -----END DH PARAMETERS-----\n";
1705
1706 static const char dhpem2048[] =
1707 "-----BEGIN DH PARAMETERS-----\n\
1708 MIIBCAKCAQEA7ZKJNYJFVcs7+6J2WmkEYb8h86tT0s0h2v94GRFS8Q7B4lW9aG9o\n\
1709 AFO5Imov5Jo0H2XMWTKKvbHbSe3fpxJmw/0hBHAY8H/W91hRGXKCeyKpNBgdL8sh\n\
1710 z22SrkO2qCnHJ6PLAMXy5fsKpFmFor2tRfCzrfnggTXu2YOzzK7q62bmqVdmufEo\n\
1711 pT8igNcLpvZxk5uBDvhakObMym9mX3rAEBoe8PwttggMYiiw7NuJKO4MqD1llGkW\n\
1712 aVM8U2ATsCun1IKHrRxynkE1/MJ86VHeYYX8GZt2YA8z+GuzylIOKcMH6JAWzMwA\n\
1713 Gbatw6QwizOhr9iMjZ0B26TE3X8LvW84wwIBAg==\n\
1714 -----END DH PARAMETERS-----\n";
1715
1716 static const char dhpem4096[] =
1717 "-----BEGIN DH PARAMETERS-----\n\
1718 MIICCAKCAgEA/urRnb6vkPYc/KEGXWnbCIOaKitq7ySIq9dTH7s+Ri59zs77zty7\n\
1719 vfVlSe6VFTBWgYjD2XKUFmtqq6CqXMhVX5ElUDoYDpAyTH85xqNFLzFC7nKrff/H\n\
1720 TFKNttp22cZE9V0IPpzedPfnQkE7aUdmF9JnDyv21Z/818O93u1B4r0szdnmEvEF\n\
1721 bKuIxEHX+bp0ZR7RqE1AeifXGJX3d6tsd2PMAObxwwsv55RGkn50vHO4QxtTARr1\n\
1722 rRUV5j3B3oPMgC7Offxx+98Xn45B1/G0Prp11anDsR1PGwtaCYipqsvMwQUSJtyE\n\
1723 EOQWk+yFkeMe4vWv367eEi0Sd/wnC+TSXBE3pYvpYerJ8n1MceI5GQTdarJ77OW9\n\
1724 bGTHmxRsLSCM1jpLdPja5jjb4siAa6EHc4qN9c/iFKS3PQPJEnX7pXKBRs5f7AF3\n\
1725 W3RIGt+G9IVNZfXaS7Z/iCpgzgvKCs0VeqN38QsJGtC1aIkwOeyjPNy2G6jJ4yqH\n\
1726 ovXYt/0mc00vCWeSNS1wren0pR2EiLxX0ypjjgsU1mk/Z3b/+zVf7fZSIB+nDLjb\n\
1727 NPtUlJCVGnAeBK1J1nG3TQicqowOXoM6ISkdaXj5GPJdXHab2+S7cqhKGv5qC7rR\n\
1728 jT6sx7RUr0CNTxzLI7muV2/a4tGmj0PSdXQdsZ7tw7gbXlaWT1+MM2MCAQI=\n\
1729 -----END DH PARAMETERS-----\n";
1730
1731 static const struct dhinfo dhpem[] = {
1732         { 512, dhpem512, sizeof(dhpem512) },
1733         { 1024, dhpem1024, sizeof(dhpem1024) },
1734         { 2048, dhpem2048, sizeof(dhpem2048) },
1735         { 4096, dhpem4096, sizeof(dhpem4096) },
1736         { 0, NULL, 0 }
1737 };
1738
1739 static DH *
1740 tls_tmp_dh_cb( SSL *ssl, int is_export, int key_length )
1741 {
1742         struct dhplist *p = NULL;
1743         BIO *b = NULL;
1744         DH *dh = NULL;
1745         int i;
1746
1747         /* Do we have params of this length already? */
1748 #ifdef LDAP_R_COMPILE
1749         ldap_pvt_thread_mutex_lock( &tls_def_ctx_mutex );
1750 #endif
1751         for ( p = dhparams; p; p=p->next ) {
1752                 if ( p->keylength == key_length ) {
1753 #ifdef LDAP_R_COMPILE
1754                         ldap_pvt_thread_mutex_unlock( &tls_def_ctx_mutex );
1755 #endif
1756                         return p->param;
1757                 }
1758         }
1759
1760         /* No - check for hardcoded params */
1761
1762         for (i=0; dhpem[i].keylength; i++) {
1763                 if ( dhpem[i].keylength == key_length ) {
1764                         b = BIO_new_mem_buf( (char *)dhpem[i].pem, dhpem[i].size );
1765                         break;
1766                 }
1767         }
1768
1769         if ( b ) {
1770                 dh = PEM_read_bio_DHparams( b, NULL, NULL, NULL );
1771                 BIO_free( b );
1772         }
1773
1774         /* Generating on the fly is expensive/slow... */
1775         if ( !dh ) {
1776                 dh = DH_generate_parameters( key_length, DH_GENERATOR_2, NULL, NULL );
1777         }
1778         if ( dh ) {
1779                 p = LDAP_MALLOC( sizeof(struct dhplist) );
1780                 if ( p != NULL ) {
1781                         p->keylength = key_length;
1782                         p->param = dh;
1783                         p->next = dhparams;
1784                         dhparams = p;
1785                 }
1786         }
1787
1788 #ifdef LDAP_R_COMPILE
1789         ldap_pvt_thread_mutex_unlock( &tls_def_ctx_mutex );
1790 #endif
1791         return dh;
1792 }
1793 #endif
1794
1795 void *
1796 ldap_pvt_tls_sb_ctx( Sockbuf *sb )
1797 {
1798 #ifdef HAVE_TLS
1799         void                    *p;
1800
1801         if (HAS_TLS( sb )) {
1802                 ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_SSL, (void *)&p );
1803                 return p;
1804         }
1805 #endif
1806
1807         return NULL;
1808 }
1809
1810 int
1811 ldap_pvt_tls_get_strength( void *s )
1812 {
1813 #ifdef HAVE_TLS
1814         SSL_CIPHER *c;
1815
1816         c = SSL_get_current_cipher((SSL *)s);
1817         return SSL_CIPHER_get_bits(c, NULL);
1818 #else
1819         return 0;
1820 #endif
1821 }
1822
1823
1824 int
1825 ldap_pvt_tls_get_my_dn( void *s, struct berval *dn, LDAPDN_rewrite_dummy *func, unsigned flags )
1826 {
1827 #ifdef HAVE_TLS
1828         X509 *x;
1829         X509_NAME *xn;
1830         int rc;
1831
1832         x = SSL_get_certificate((SSL *)s);
1833
1834         if (!x) return LDAP_INVALID_CREDENTIALS;
1835
1836         xn = X509_get_subject_name(x);
1837         rc = ldap_X509dn2bv(xn, dn, (LDAPDN_rewrite_func *)func, flags );
1838         return rc;
1839 #else
1840         return LDAP_NOT_SUPPORTED;
1841 #endif
1842 }
1843
1844 int
1845 ldap_start_tls( LDAP *ld,
1846         LDAPControl **serverctrls,
1847         LDAPControl **clientctrls,
1848         int *msgidp )
1849 {
1850         return ldap_extended_operation( ld, LDAP_EXOP_START_TLS,
1851                 NULL, serverctrls, clientctrls, msgidp );
1852 }
1853
1854 int
1855 ldap_install_tls( LDAP *ld )
1856 {
1857 #ifndef HAVE_TLS
1858         return LDAP_NOT_SUPPORTED;
1859 #else
1860         if ( ldap_tls_inplace( ld ) ) {
1861                 return LDAP_LOCAL_ERROR;
1862         }
1863
1864         return ldap_int_tls_start( ld, ld->ld_defconn, NULL );
1865 #endif
1866 }
1867
1868 int
1869 ldap_start_tls_s ( LDAP *ld,
1870         LDAPControl **serverctrls,
1871         LDAPControl **clientctrls )
1872 {
1873 #ifndef HAVE_TLS
1874         return LDAP_NOT_SUPPORTED;
1875 #else
1876         int rc;
1877         char *rspoid = NULL;
1878         struct berval *rspdata = NULL;
1879
1880         /* XXYYZ: this initiates operation only on default connection! */
1881
1882         if ( ldap_tls_inplace( ld ) ) {
1883                 return LDAP_LOCAL_ERROR;
1884         }
1885
1886         rc = ldap_extended_operation_s( ld, LDAP_EXOP_START_TLS,
1887                 NULL, serverctrls, clientctrls, &rspoid, &rspdata );
1888
1889         if ( rspoid != NULL ) {
1890                 LDAP_FREE(rspoid);
1891         }
1892
1893         if ( rspdata != NULL ) {
1894                 ber_bvfree( rspdata );
1895         }
1896
1897         if ( rc == LDAP_SUCCESS ) {
1898                 rc = ldap_int_tls_start( ld, ld->ld_defconn, NULL );
1899         }
1900
1901         return rc;
1902 #endif
1903 }
1904