git.sur5r.net Git - bacula/bacula/blob - bacula/src/lib/tls.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2005-2010 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version three of the GNU Affero General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU Affero General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  * tls.c TLS support functions
  30  *
  31  * Author: Landon Fuller <landonf@threerings.net>
  32  *
  33  * This file was contributed to the Bacula project by Landon Fuller
  34  * and Three Rings Design, Inc.
  35  *
  36  * Three Rings Design, Inc. has been granted a perpetual, worldwide,
  37  * non-exclusive, no-charge, royalty-free, irrevocable copyright
  38  * license to reproduce, prepare derivative works of, publicly
  39  * display, publicly perform, sublicense, and distribute the original
  40  * work contributed by Three Rings Design, Inc. and its employees to
  41  * the Bacula project in source or object form.
  42  *
  43  * If you wish to license contributions from Three Rings Design, Inc,
  44  * under an alternate open source license please contact
  45  * Landon Fuller <landonf@threerings.net>.
  46  */
  47
  48
  49 #include "bacula.h"
  50 #include <assert.h>
  51
  52
  53 #ifdef HAVE_TLS /* Is TLS enabled? */
  54
  55 #ifdef HAVE_OPENSSL /* How about OpenSSL? */
  56
  57 /* No anonymous ciphers, no <128 bit ciphers, no export ciphers, no MD5 ciphers */
  58 #define TLS_DEFAULT_CIPHERS "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH"
  59
  60 /* TLS Context Structure */
  61 struct TLS_Context {
  62    SSL_CTX *openssl;
  63    CRYPTO_PEM_PASSWD_CB *pem_callback;
  64    const void *pem_userdata;
  65    bool tls_enable;
  66    bool tls_require;
  67 };
  68
  69 struct TLS_Connection {
  70    SSL *openssl;
  71 };
  72
  73 /*
  74  * OpenSSL certificate verification callback.
  75  * OpenSSL has already performed internal certificate verification.
  76  * We just report any errors that occured.
  77  */
  78 static int openssl_verify_peer(int ok, X509_STORE_CTX *store)
  79 {
  80    if (!ok) {
  81       X509 *cert = X509_STORE_CTX_get_current_cert(store);
  82       int depth = X509_STORE_CTX_get_error_depth(store);
  83       int err = X509_STORE_CTX_get_error(store);
  84       char issuer[256];
  85       char subject[256];
  86
  87       X509_NAME_oneline(X509_get_issuer_name(cert), issuer, 256);
  88       X509_NAME_oneline(X509_get_subject_name(cert), subject, 256);
  89
  90       Jmsg5(NULL, M_ERROR, 0, _("Error with certificate at depth: %d, issuer = %s,"
  91             " subject = %s, ERR=%d:%s\n"), depth, issuer,
  92               subject, err, X509_verify_cert_error_string(err));
  93
  94    }
  95
  96    return ok;
  97 }
  98
  99 /* Dispatch user PEM encryption callbacks */
 100 static int tls_pem_callback_dispatch (char *buf, int size, int rwflag, void *userdata)
 101 {
 102    TLS_CONTEXT *ctx = (TLS_CONTEXT *)userdata;
 103    return (ctx->pem_callback(buf, size, ctx->pem_userdata));
 104 }
 105
 106 /*
 107  * Create a new TLS_CONTEXT instance.
 108  *  Returns: Pointer to TLS_CONTEXT instance on success
 109  *           NULL on failure;
 110  */
 111 TLS_CONTEXT *new_tls_context(const char *ca_certfile, const char *ca_certdir,
 112                              const char *certfile, const char *keyfile,
 113                              CRYPTO_PEM_PASSWD_CB *pem_callback,
 114                              const void *pem_userdata, const char *dhfile,
 115                              bool verify_peer)
 116 {
 117    TLS_CONTEXT *ctx;
 118    BIO *bio;
 119    DH *dh;
 120
 121    ctx = (TLS_CONTEXT *)malloc(sizeof(TLS_CONTEXT));
 122
 123    /* Allocate our OpenSSL TLSv1 Context */
 124    ctx->openssl = SSL_CTX_new(TLSv1_method());
 125
 126    if (!ctx->openssl) {
 127       openssl_post_errors(M_FATAL, _("Error initializing SSL context"));
 128       goto err;
 129    }
 130
 131    /* Set up pem encryption callback */
 132    if (pem_callback) {
 133       ctx->pem_callback = pem_callback;
 134       ctx->pem_userdata = pem_userdata;
 135    } else {
 136       ctx->pem_callback = crypto_default_pem_callback;
 137       ctx->pem_userdata = NULL;
 138    }
 139    SSL_CTX_set_default_passwd_cb(ctx->openssl, tls_pem_callback_dispatch);
 140    SSL_CTX_set_default_passwd_cb_userdata(ctx->openssl, (void *) ctx);
 141
 142    /*
 143     * Set certificate verification paths. This requires that at least one
 144     * value be non-NULL
 145     */
 146    if (ca_certfile || ca_certdir) {
 147       if (!SSL_CTX_load_verify_locations(ctx->openssl, ca_certfile, ca_certdir)) {
 148          openssl_post_errors(M_FATAL, _("Error loading certificate verification stores"));
 149          goto err;
 150       }
 151    } else if (verify_peer) {
 152       /* At least one CA is required for peer verification */
 153       Jmsg0(NULL, M_ERROR, 0, _("Either a certificate file or a directory must be"
 154                          " specified as a verification store\n"));
 155       goto err;
 156    }
 157
 158    /*
 159     * Load our certificate file, if available. This file may also contain a
 160     * private key, though this usage is somewhat unusual.
 161     */
 162    if (certfile) {
 163       if (!SSL_CTX_use_certificate_chain_file(ctx->openssl, certfile)) {
 164          openssl_post_errors(M_FATAL, _("Error loading certificate file"));
 165          goto err;
 166       }
 167    }
 168
 169    /* Load our private key. */
 170    if (keyfile) {
 171       if (!SSL_CTX_use_PrivateKey_file(ctx->openssl, keyfile, SSL_FILETYPE_PEM)) {
 172          openssl_post_errors(M_FATAL, _("Error loading private key"));
 173          goto err;
 174       }
 175    }
 176
 177    /* Load Diffie-Hellman Parameters. */
 178    if (dhfile) {
 179       if (!(bio = BIO_new_file(dhfile, "r"))) {
 180          openssl_post_errors(M_FATAL, _("Unable to open DH parameters file"));
 181          goto err;
 182       }
 183       dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
 184       BIO_free(bio);
 185       if (!dh) {
 186          openssl_post_errors(M_FATAL, _("Unable to load DH parameters from specified file"));
 187          goto err;
 188       }
 189       if (!SSL_CTX_set_tmp_dh(ctx->openssl, dh)) {
 190          openssl_post_errors(M_FATAL, _("Failed to set TLS Diffie-Hellman parameters"));
 191          DH_free(dh);
 192          goto err;
 193       }
 194       /* Enable Single-Use DH for Ephemeral Keying */
 195       SSL_CTX_set_options(ctx->openssl, SSL_OP_SINGLE_DH_USE);
 196    }
 197
 198    if (SSL_CTX_set_cipher_list(ctx->openssl, TLS_DEFAULT_CIPHERS) != 1) {
 199       Jmsg0(NULL, M_ERROR, 0,
 200              _("Error setting cipher list, no valid ciphers available\n"));
 201       goto err;
 202    }
 203
 204    /* Verify Peer Certificate */
 205    if (verify_peer) {
 206       /* SSL_VERIFY_FAIL_IF_NO_PEER_CERT has no effect in client mode */
 207       SSL_CTX_set_verify(ctx->openssl,
 208                          SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
 209                          openssl_verify_peer);
 210    }
 211
 212    return ctx;
 213
 214 err:
 215    /* Clean up after ourselves */
 216    if(ctx->openssl) {
 217       SSL_CTX_free(ctx->openssl);
 218    }
 219    free(ctx);
 220    return NULL;
 221 }
 222
 223 /*
 224  * Free TLS_CONTEXT instance
 225  */
 226 void free_tls_context(TLS_CONTEXT *ctx)
 227 {
 228    SSL_CTX_free(ctx->openssl);
 229    free(ctx);
 230 }
 231
 232 bool get_tls_require(TLS_CONTEXT *ctx)
 233 {
 234    return ctx->tls_require;
 235 }
 236
 237 bool get_tls_enable(TLS_CONTEXT *ctx)
 238 {
 239    return ctx->tls_enable;
 240 }
 241
 242
 243 /*
 244  * Verifies a list of common names against the certificate
 245  * commonName attribute.
 246  *  Returns: true on success
 247  *           false on failure
 248  */
 249 bool tls_postconnect_verify_cn(JCR *jcr, TLS_CONNECTION *tls, alist *verify_list)
 250 {
 251    SSL *ssl = tls->openssl;
 252    X509 *cert;
 253    X509_NAME *subject;
 254    bool auth_success = false;
 255    char data[256];
 256
 257    /* Check if peer provided a certificate */
 258    if (!(cert = SSL_get_peer_certificate(ssl))) {
 259       Qmsg0(jcr, M_ERROR, 0, _("Peer failed to present a TLS certificate\n"));
 260       return false;
 261    }
 262
 263    if ((subject = X509_get_subject_name(cert)) != NULL) {
 264       if (X509_NAME_get_text_by_NID(subject, NID_commonName, data, sizeof(data)) > 0) {
 265          char *cn;
 266          /* NULL terminate data */
 267          data[255] = 0;
 268
 269          /* Try all the CNs in the list */
 270          foreach_alist(cn, verify_list) {
 271             if (strcasecmp(data, cn) == 0) {
 272                auth_success = true;
 273             }
 274          }
 275       }
 276    }
 277
 278    X509_free(cert);
 279    return auth_success;
 280 }
 281
 282 /*
 283  * Verifies a peer's hostname against the subjectAltName and commonName
 284  * attributes.
 285  *  Returns: true on success
 286  *           false on failure
 287  */
 288 bool tls_postconnect_verify_host(JCR *jcr, TLS_CONNECTION *tls, const char *host)
 289 {
 290    SSL *ssl = tls->openssl;
 291    X509 *cert;
 292    X509_NAME *subject;
 293    bool auth_success = false;
 294    int extensions;
 295    int i, j;
 296
 297    int cnLastPos = -1;
 298    X509_NAME_ENTRY *neCN;
 299    ASN1_STRING *asn1CN;
 300
 301    /* Check if peer provided a certificate */
 302    if (!(cert = SSL_get_peer_certificate(ssl))) {
 303       Qmsg1(jcr, M_ERROR, 0,
 304             _("Peer %s failed to present a TLS certificate\n"), host);
 305       return false;
 306    }
 307
 308    /* Check subjectAltName extensions first */
 309    if ((extensions = X509_get_ext_count(cert)) > 0) {
 310       for (i = 0; i < extensions; i++) {
 311          X509_EXTENSION *ext;
 312          const char *extname;
 313
 314          ext = X509_get_ext(cert, i);
 315          extname = OBJ_nid2sn(OBJ_obj2nid(X509_EXTENSION_get_object(ext)));
 316
 317          if (strcmp(extname, "subjectAltName") == 0) {
 318 #ifdef HAVE_OPENSSLv1
 319             const X509V3_EXT_METHOD *method;
 320 #else
 321             X509V3_EXT_METHOD *method;
 322 #endif
 323             STACK_OF(CONF_VALUE) *val;
 324             CONF_VALUE *nval;
 325             void *extstr = NULL;
 326 #if (OPENSSL_VERSION_NUMBER >= 0x0090800FL)
 327             const unsigned char *ext_value_data;
 328 #else
 329             unsigned char *ext_value_data;
 330 #endif
 331
 332             /* Get x509 extension method structure */
 333             if (!(method = X509V3_EXT_get(ext))) {
 334                break;
 335             }
 336
 337             ext_value_data = ext->value->data;
 338
 339 #if (OPENSSL_VERSION_NUMBER > 0x00907000L)
 340             if (method->it) {
 341                /* New style ASN1 */
 342
 343                /* Decode ASN1 item in data */
 344                extstr = ASN1_item_d2i(NULL, &ext_value_data, ext->value->length,
 345                                       ASN1_ITEM_ptr(method->it));
 346             } else {
 347                /* Old style ASN1 */
 348
 349                /* Decode ASN1 item in data */
 350                extstr = method->d2i(NULL, &ext_value_data, ext->value->length);
 351             }
 352
 353 #else
 354             extstr = method->d2i(NULL, &ext_value_data, ext->value->length);
 355 #endif
 356
 357             /* Iterate through to find the dNSName field(s) */
 358             val = method->i2v(method, extstr, NULL);
 359
 360             /* dNSName shortname is "DNS" */
 361             for (j = 0; j < sk_CONF_VALUE_num(val); j++) {
 362                nval = sk_CONF_VALUE_value(val, j);
 363                if (strcmp(nval->name, "DNS") == 0) {
 364                   if (strcasecmp(nval->value, host) == 0) {
 365                      auth_success = true;
 366                      goto success;
 367                   }
 368                }
 369             }
 370          }
 371       }
 372    }
 373
 374    /* Try verifying against the subject name */
 375    if (!auth_success) {
 376       if ((subject = X509_get_subject_name(cert)) != NULL) {
 377          /* Loop through all CNs */
 378          for (;;) {
 379             cnLastPos = X509_NAME_get_index_by_NID(subject, NID_commonName, cnLastPos);
 380             if (cnLastPos == -1) {
 381                break;
 382             }
 383             neCN = X509_NAME_get_entry(subject, cnLastPos);
 384             asn1CN = X509_NAME_ENTRY_get_data(neCN);
 385             if (strcasecmp((const char*)asn1CN->data, host) == 0) {
 386                auth_success = true;
 387                break;
 388             }
 389          }
 390       }
 391    }
 392
 393 success:
 394    X509_free(cert);
 395
 396    return auth_success;
 397 }
 398
 399 /*
 400  * Create a new TLS_CONNECTION instance.
 401  *
 402  * Returns: Pointer to TLS_CONNECTION instance on success
 403  *          NULL on failure;
 404  */
 405 TLS_CONNECTION *new_tls_connection(TLS_CONTEXT *ctx, int fd)
 406 {
 407    BIO *bio;
 408
 409    /*
 410     * Create a new BIO and assign the fd.
 411     * The caller will remain responsible for closing the associated fd
 412     */
 413    bio = BIO_new(BIO_s_socket());
 414    if (!bio) {
 415       /* Not likely, but never say never */
 416       openssl_post_errors(M_FATAL, _("Error creating file descriptor-based BIO"));
 417       return NULL; /* Nothing allocated, nothing to clean up */
 418    }
 419    BIO_set_fd(bio, fd, BIO_NOCLOSE);
 420
 421    /* Allocate our new tls connection */
 422    TLS_CONNECTION *tls = (TLS_CONNECTION *)malloc(sizeof(TLS_CONNECTION));
 423
 424    /* Create the SSL object and attach the socket BIO */
 425    if ((tls->openssl = SSL_new(ctx->openssl)) == NULL) {
 426       /* Not likely, but never say never */
 427       openssl_post_errors(M_FATAL, _("Error creating new SSL object"));
 428       goto err;
 429    }
 430
 431    SSL_set_bio(tls->openssl, bio, bio);
 432
 433    /* Non-blocking partial writes */
 434    SSL_set_mode(tls->openssl, SSL_MODE_ENABLE_PARTIAL_WRITE|SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
 435
 436    return tls;
 437
 438 err:
 439    /* Clean up */
 440    BIO_free(bio);
 441    SSL_free(tls->openssl);
 442    free(tls);
 443    return NULL;
 444 }
 445
 446 /*
 447  * Free TLS_CONNECTION instance
 448  */
 449 void free_tls_connection(TLS_CONNECTION *tls)
 450 {
 451    SSL_free(tls->openssl);
 452    free(tls);
 453 }
 454
 455 /* Does all the manual labor for tls_bsock_accept() and tls_bsock_connect() */
 456 static inline bool openssl_bsock_session_start(BSOCK *bsock, bool server)
 457 {
 458    TLS_CONNECTION *tls = bsock->tls;
 459    int err;
 460    int fdmax, flags;
 461    int stat = true;
 462    fd_set fdset;
 463    struct timeval tv;
 464
 465    /* Zero the fdset, we'll set our fd prior to each invocation of select() */
 466    FD_ZERO(&fdset);
 467    fdmax = bsock->m_fd + 1;
 468
 469    /* Ensure that socket is non-blocking */
 470    flags = bsock->set_nonblocking();
 471
 472    /* start timer */
 473    bsock->timer_start = watchdog_time;
 474    bsock->clear_timed_out();
 475    bsock->set_killable(false);
 476
 477    for (;;) {
 478       if (server) {
 479          err = SSL_accept(tls->openssl);
 480       } else {
 481          err = SSL_connect(tls->openssl);
 482       }
 483
 484       /* Handle errors */
 485       switch (SSL_get_error(tls->openssl, err)) {
 486       case SSL_ERROR_NONE:
 487          stat = true;
 488          goto cleanup;
 489       case SSL_ERROR_ZERO_RETURN:
 490          /* TLS connection was cleanly shut down */
 491          openssl_post_errors(bsock->get_jcr(), M_FATAL, _("Connect failure"));
 492          stat = false;
 493          goto cleanup;
 494       case SSL_ERROR_WANT_READ:
 495          /* If we timeout of a select, this will be unset */
 496          FD_SET((unsigned) bsock->m_fd, &fdset);
 497          /* Set our timeout */
 498          tv.tv_sec = 10;
 499          tv.tv_usec = 0;
 500          /* Block until we can read */
 501          select(fdmax, &fdset, NULL, NULL, &tv);
 502          break;
 503       case SSL_ERROR_WANT_WRITE:
 504          /* If we timeout of a select, this will be unset */
 505          FD_SET((unsigned) bsock->m_fd, &fdset);
 506          /* Set our timeout */
 507          tv.tv_sec = 10;
 508          tv.tv_usec = 0;
 509          /* Block until we can write */
 510          select(fdmax, NULL, &fdset, NULL, &tv);
 511          break;
 512       default:
 513          /* Socket Error Occurred */
 514          openssl_post_errors(bsock->get_jcr(), M_FATAL, _("Connect failure"));
 515          stat = false;
 516          goto cleanup;
 517       }
 518
 519       if (bsock->is_timed_out()) {
 520          goto cleanup;
 521       }
 522    }
 523
 524 cleanup:
 525    /* Restore saved flags */
 526    bsock->restore_blocking(flags);
 527    /* Clear timer */
 528    bsock->timer_start = 0;
 529    bsock->set_killable(true);
 530
 531    return stat;
 532 }
 533
 534 /*
 535  * Initiates a TLS connection with the server.
 536  *  Returns: true on success
 537  *           false on failure
 538  */
 539 bool tls_bsock_connect(BSOCK *bsock)
 540 {
 541    /* SSL_connect(bsock->tls) */
 542    return openssl_bsock_session_start(bsock, false);
 543 }
 544
 545 /*
 546  * Listens for a TLS connection from a client.
 547  *  Returns: true on success
 548  *           false on failure
 549  */
 550 bool tls_bsock_accept(BSOCK *bsock)
 551 {
 552    /* SSL_accept(bsock->tls) */
 553    return openssl_bsock_session_start(bsock, true);
 554 }
 555
 556 /*
 557  * Shutdown TLS_CONNECTION instance
 558  */
 559 void tls_bsock_shutdown(BSOCK *bsock)
 560 {
 561    /*
 562     * SSL_shutdown must be called twice to fully complete the process -
 563     * The first time to initiate the shutdown handshake, and the second to
 564     * receive the peer's reply.
 565     *
 566     * In addition, if the underlying socket is blocking, SSL_shutdown()
 567     * will not return until the current stage of the shutdown process has
 568     * completed or an error has occured. By setting the socket blocking
 569     * we can avoid the ugly for()/switch()/select() loop.
 570     */
 571    int err;
 572
 573    btimer_t *tid;
 574
 575    /* Set socket blocking for shutdown */
 576    bsock->set_blocking();
 577
 578    tid = start_bsock_timer(bsock, 60 * 2);
 579    err = SSL_shutdown(bsock->tls->openssl);
 580    stop_bsock_timer(tid);
 581    if (err == 0) {
 582       /* Complete shutdown */
 583       tid = start_bsock_timer(bsock, 60 * 2);
 584       err = SSL_shutdown(bsock->tls->openssl);
 585       stop_bsock_timer(tid);
 586    }
 587
 588
 589    switch (SSL_get_error(bsock->tls->openssl, err)) {
 590    case SSL_ERROR_NONE:
 591       break;
 592    case SSL_ERROR_ZERO_RETURN:
 593       /* TLS connection was shut down on us via a TLS protocol-level closure */
 594       openssl_post_errors(bsock->get_jcr(), M_ERROR, _("TLS shutdown failure."));
 595       break;
 596    default:
 597       /* Socket Error Occurred */
 598       openssl_post_errors(bsock->get_jcr(), M_ERROR, _("TLS shutdown failure."));
 599       break;
 600    }
 601 }
 602
 603 /* Does all the manual labor for tls_bsock_readn() and tls_bsock_writen() */
 604 static inline int openssl_bsock_readwrite(BSOCK *bsock, char *ptr, int nbytes, bool write)
 605 {
 606    TLS_CONNECTION *tls = bsock->tls;
 607    int fdmax, flags;
 608    fd_set fdset;
 609    struct timeval tv;
 610    int nleft = 0;
 611    int nwritten = 0;
 612
 613    /* Zero the fdset, we'll set our fd prior to each invocation of select() */
 614    FD_ZERO(&fdset);
 615    fdmax = bsock->m_fd + 1;
 616
 617    /* Ensure that socket is non-blocking */
 618    flags = bsock->set_nonblocking();
 619
 620    /* start timer */
 621    bsock->timer_start = watchdog_time;
 622    bsock->clear_timed_out();
 623    bsock->set_killable(false);
 624
 625    nleft = nbytes;
 626
 627    while (nleft > 0) {
 628       if (write) {
 629          nwritten = SSL_write(tls->openssl, ptr, nleft);
 630       } else {
 631          nwritten = SSL_read(tls->openssl, ptr, nleft);
 632       }
 633
 634       /* Handle errors */
 635       switch (SSL_get_error(tls->openssl, nwritten)) {
 636       case SSL_ERROR_NONE:
 637          nleft -= nwritten;
 638          if (nleft) {
 639             ptr += nwritten;
 640          }
 641          break;
 642
 643       case SSL_ERROR_SYSCALL:
 644          if (nwritten == -1) {
 645             if (errno == EINTR) {
 646                continue;
 647             }
 648             if (errno == EAGAIN) {
 649                bmicrosleep(0, 20000); /* try again in 20 ms */
 650                continue;
 651             }
 652          }
 653          openssl_post_errors(bsock->get_jcr(), M_FATAL, _("TLS read/write failure."));
 654          goto cleanup;
 655
 656       case SSL_ERROR_WANT_READ:
 657          /* If we timeout on a select, this will be unset */
 658          FD_SET((unsigned)bsock->m_fd, &fdset);
 659          tv.tv_sec = 10;
 660          tv.tv_usec = 0;
 661          /* Block until we can read */
 662          select(fdmax, &fdset, NULL, NULL, &tv);
 663          break;
 664
 665       case SSL_ERROR_WANT_WRITE:
 666          /* If we timeout on a select, this will be unset */
 667          FD_SET((unsigned)bsock->m_fd, &fdset);
 668          tv.tv_sec = 10;
 669          tv.tv_usec = 0;
 670          /* Block until we can write */
 671          select(fdmax, NULL, &fdset, NULL, &tv);
 672          break;
 673
 674       case SSL_ERROR_ZERO_RETURN:
 675          /* TLS connection was cleanly shut down */
 676          /* Fall through wanted */
 677       default:
 678          /* Socket Error Occured */
 679          openssl_post_errors(bsock->get_jcr(), M_FATAL, _("TLS read/write failure."));
 680          goto cleanup;
 681       }
 682
 683       /* Everything done? */
 684       if (nleft == 0) {
 685          goto cleanup;
 686       }
 687
 688       /* Timeout/Termination, let's take what we can get */
 689       if (bsock->is_timed_out() || bsock->is_terminated()) {
 690          goto cleanup;
 691       }
 692    }
 693
 694 cleanup:
 695    /* Restore saved flags */
 696    bsock->restore_blocking(flags);
 697
 698    /* Clear timer */
 699    bsock->timer_start = 0;
 700    bsock->set_killable(true);
 701    return nbytes - nleft;
 702 }
 703
 704
 705 int tls_bsock_writen(BSOCK *bsock, char *ptr, int32_t nbytes)
 706 {
 707    /* SSL_write(bsock->tls->openssl, ptr, nbytes) */
 708    return openssl_bsock_readwrite(bsock, ptr, nbytes, true);
 709 }
 710
 711 int tls_bsock_readn(BSOCK *bsock, char *ptr, int32_t nbytes)
 712 {
 713    /* SSL_read(bsock->tls->openssl, ptr, nbytes) */
 714    return openssl_bsock_readwrite(bsock, ptr, nbytes, false);
 715 }
 716
 717 #else /* HAVE_OPENSSL */
 718 # error No TLS implementation available.
 719 #endif /* !HAVE_OPENSSL */
 720
 721
 722 #else     /* TLS NOT enabled, dummy routines substituted */
 723
 724
 725 /* Dummy routines */
 726 TLS_CONTEXT *new_tls_context(const char *ca_certfile, const char *ca_certdir,
 727                              const char *certfile, const char *keyfile,
 728                              CRYPTO_PEM_PASSWD_CB *pem_callback,
 729                              const void *pem_userdata, const char *dhfile,
 730                              bool verify_peer)
 731 {
 732    return NULL;
 733 }
 734 void free_tls_context(TLS_CONTEXT *ctx) { }
 735
 736 void tls_bsock_shutdown(BSOCK *bsock) { }
 737
 738 void free_tls_connection(TLS_CONNECTION *tls) { }
 739
 740 bool get_tls_require(TLS_CONTEXT *ctx)
 741 {
 742    return false;
 743 }
 744
 745 bool get_tls_enable(TLS_CONTEXT *ctx)
 746 {
 747    return false;
 748 }
 749
 750 #endif /* HAVE_TLS */