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