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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2005-2011 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
 476    for (;;) {
 477       if (server) {
 478          err = SSL_accept(tls->openssl);
 479       } else {
 480          err = SSL_connect(tls->openssl);
 481       }
 482
 483       /* Handle errors */
 484       switch (SSL_get_error(tls->openssl, err)) {
 485       case SSL_ERROR_NONE:
 486          stat = true;
 487          goto cleanup;
 488       case SSL_ERROR_ZERO_RETURN:
 489          /* TLS connection was cleanly shut down */
 490          openssl_post_errors(bsock->get_jcr(), M_FATAL, _("Connect failure"));
 491          stat = false;
 492          goto cleanup;
 493       case SSL_ERROR_WANT_READ:
 494          /* If we timeout of a select, this will be unset */
 495          FD_SET((unsigned) bsock->m_fd, &fdset);
 496          /* Set our timeout */
 497          tv.tv_sec = 10;
 498          tv.tv_usec = 0;
 499          /* Block until we can read */
 500          select(fdmax, &fdset, NULL, NULL, &tv);
 501          break;
 502       case SSL_ERROR_WANT_WRITE:
 503          /* If we timeout of a select, this will be unset */
 504          FD_SET((unsigned) bsock->m_fd, &fdset);
 505          /* Set our timeout */
 506          tv.tv_sec = 10;
 507          tv.tv_usec = 0;
 508          /* Block until we can write */
 509          select(fdmax, NULL, &fdset, NULL, &tv);
 510          break;
 511       default:
 512          /* Socket Error Occurred */
 513          openssl_post_errors(bsock->get_jcr(), M_FATAL, _("Connect failure"));
 514          stat = false;
 515          goto cleanup;
 516       }
 517
 518       if (bsock->is_timed_out()) {
 519          goto cleanup;
 520       }
 521    }
 522
 523 cleanup:
 524    /* Restore saved flags */
 525    bsock->restore_blocking(flags);
 526    /* Clear timer */
 527    bsock->timer_start = 0;
 528
 529    return stat;
 530 }
 531
 532 /*
 533  * Initiates a TLS connection with the server.
 534  *  Returns: true on success
 535  *           false on failure
 536  */
 537 bool tls_bsock_connect(BSOCK *bsock)
 538 {
 539    /* SSL_connect(bsock->tls) */
 540    return openssl_bsock_session_start(bsock, false);
 541 }
 542
 543 /*
 544  * Listens for a TLS connection from a client.
 545  *  Returns: true on success
 546  *           false on failure
 547  */
 548 bool tls_bsock_accept(BSOCK *bsock)
 549 {
 550    /* SSL_accept(bsock->tls) */
 551    return openssl_bsock_session_start(bsock, true);
 552 }
 553
 554 /*
 555  * Shutdown TLS_CONNECTION instance
 556  */
 557 void tls_bsock_shutdown(BSOCK *bsock)
 558 {
 559    /*
 560     * SSL_shutdown must be called twice to fully complete the process -
 561     * The first time to initiate the shutdown handshake, and the second to
 562     * receive the peer's reply.
 563     *
 564     * In addition, if the underlying socket is blocking, SSL_shutdown()
 565     * will not return until the current stage of the shutdown process has
 566     * completed or an error has occured. By setting the socket blocking
 567     * we can avoid the ugly for()/switch()/select() loop.
 568     */
 569    int err;
 570
 571    btimer_t *tid;
 572
 573    /* Set socket blocking for shutdown */
 574    bsock->set_blocking();
 575
 576    tid = start_bsock_timer(bsock, 60 * 2);
 577    err = SSL_shutdown(bsock->tls->openssl);
 578    stop_bsock_timer(tid);
 579    if (err == 0) {
 580       /* Complete shutdown */
 581       tid = start_bsock_timer(bsock, 60 * 2);
 582       err = SSL_shutdown(bsock->tls->openssl);
 583       stop_bsock_timer(tid);
 584    }
 585
 586
 587    switch (SSL_get_error(bsock->tls->openssl, err)) {
 588    case SSL_ERROR_NONE:
 589       break;
 590    case SSL_ERROR_ZERO_RETURN:
 591       /* TLS connection was shut down on us via a TLS protocol-level closure */
 592       openssl_post_errors(bsock->get_jcr(), M_ERROR, _("TLS shutdown failure."));
 593       break;
 594    default:
 595       /* Socket Error Occurred */
 596       openssl_post_errors(bsock->get_jcr(), M_ERROR, _("TLS shutdown failure."));
 597       break;
 598    }
 599 }
 600
 601 /* Does all the manual labor for tls_bsock_readn() and tls_bsock_writen() */
 602 static inline int openssl_bsock_readwrite(BSOCK *bsock, char *ptr, int nbytes, bool write)
 603 {
 604    TLS_CONNECTION *tls = bsock->tls;
 605    int fdmax, flags;
 606    fd_set fdset;
 607    struct timeval tv;
 608    int nleft = 0;
 609    int nwritten = 0;
 610
 611    /* Zero the fdset, we'll set our fd prior to each invocation of select() */
 612    FD_ZERO(&fdset);
 613    fdmax = bsock->m_fd + 1;
 614
 615    /* Ensure that socket is non-blocking */
 616    flags = bsock->set_nonblocking();
 617
 618    /* start timer */
 619    bsock->timer_start = watchdog_time;
 620    bsock->clear_timed_out();
 621
 622    nleft = nbytes;
 623
 624    while (nleft > 0) {
 625       if (write) {
 626          nwritten = SSL_write(tls->openssl, ptr, nleft);
 627       } else {
 628          nwritten = SSL_read(tls->openssl, ptr, nleft);
 629       }
 630
 631       /* Handle errors */
 632       switch (SSL_get_error(tls->openssl, nwritten)) {
 633       case SSL_ERROR_NONE:
 634          nleft -= nwritten;
 635          if (nleft) {
 636             ptr += nwritten;
 637          }
 638          break;
 639
 640       case SSL_ERROR_SYSCALL:
 641          if (nwritten == -1) {
 642             if (errno == EINTR) {
 643                continue;
 644             }
 645             if (errno == EAGAIN) {
 646                bmicrosleep(0, 20000); /* try again in 20 ms */
 647                continue;
 648             }
 649          }
 650          openssl_post_errors(bsock->get_jcr(), M_FATAL, _("TLS read/write failure."));
 651          goto cleanup;
 652
 653       case SSL_ERROR_WANT_READ:
 654          /* If we timeout on a select, this will be unset */
 655          FD_SET((unsigned)bsock->m_fd, &fdset);
 656          tv.tv_sec = 10;
 657          tv.tv_usec = 0;
 658          /* Block until we can read */
 659          select(fdmax, &fdset, NULL, NULL, &tv);
 660          break;
 661
 662       case SSL_ERROR_WANT_WRITE:
 663          /* If we timeout on a select, this will be unset */
 664          FD_SET((unsigned)bsock->m_fd, &fdset);
 665          tv.tv_sec = 10;
 666          tv.tv_usec = 0;
 667          /* Block until we can write */
 668          select(fdmax, NULL, &fdset, NULL, &tv);
 669          break;
 670
 671       case SSL_ERROR_ZERO_RETURN:
 672          /* TLS connection was cleanly shut down */
 673          /* Fall through wanted */
 674       default:
 675          /* Socket Error Occured */
 676          openssl_post_errors(bsock->get_jcr(), M_FATAL, _("TLS read/write failure."));
 677          goto cleanup;
 678       }
 679
 680       /* Everything done? */
 681       if (nleft == 0) {
 682          goto cleanup;
 683       }
 684
 685       /* Timeout/Termination, let's take what we can get */
 686       if (bsock->is_timed_out() || bsock->is_terminated()) {
 687          goto cleanup;
 688       }
 689    }
 690
 691 cleanup:
 692    /* Restore saved flags */
 693    bsock->restore_blocking(flags);
 694
 695    /* Clear timer */
 696    bsock->timer_start = 0;
 697    return nbytes - nleft;
 698 }
 699
 700
 701 int tls_bsock_writen(BSOCK *bsock, char *ptr, int32_t nbytes)
 702 {
 703    /* SSL_write(bsock->tls->openssl, ptr, nbytes) */
 704    return openssl_bsock_readwrite(bsock, ptr, nbytes, true);
 705 }
 706
 707 int tls_bsock_readn(BSOCK *bsock, char *ptr, int32_t nbytes)
 708 {
 709    /* SSL_read(bsock->tls->openssl, ptr, nbytes) */
 710    return openssl_bsock_readwrite(bsock, ptr, nbytes, false);
 711 }
 712
 713 #else /* HAVE_OPENSSL */
 714 # error No TLS implementation available.
 715 #endif /* !HAVE_OPENSSL */
 716
 717
 718 #else     /* TLS NOT enabled, dummy routines substituted */
 719
 720
 721 /* Dummy routines */
 722 TLS_CONTEXT *new_tls_context(const char *ca_certfile, const char *ca_certdir,
 723                              const char *certfile, const char *keyfile,
 724                              CRYPTO_PEM_PASSWD_CB *pem_callback,
 725                              const void *pem_userdata, const char *dhfile,
 726                              bool verify_peer)
 727 {
 728    return NULL;
 729 }
 730 void free_tls_context(TLS_CONTEXT *ctx) { }
 731
 732 void tls_bsock_shutdown(BSOCK *bsock) { }
 733
 734 void free_tls_connection(TLS_CONNECTION *tls) { }
 735
 736 bool get_tls_require(TLS_CONTEXT *ctx)
 737 {
 738    return false;
 739 }
 740
 741 bool get_tls_enable(TLS_CONTEXT *ctx)
 742 {
 743    return false;
 744 }
 745
 746 #endif /* HAVE_TLS */