iodine 0.7.60 → 0.8.0

data/ext/iodine/fio_tls_openssl.c

@@ -1,1106 +0,0 @@
-/*
-Copyright: Boaz Segev, 2018-2019
-License: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
-*/
-#ifdef __MINGW32__
-// make pedantic compiler happy
-typedef struct {
-  int bogus;
-} bogus_s;
-
-#else
-#include <fio.h>
-
-/**
- * This implementation of the facil.io SSL/TLS wrapper API wraps the OpenSSL API
- * to provide TLS 1.2 and TLS 1.3 to facil.io applications.
- *
- * The implementation requires `HAVE_OPENSSL` to be set.
- */
-#include "fio_tls.h"
-
-#if HAVE_OPENSSL
-#include <openssl/bio.h>
-#include <openssl/err.h>
-#include <openssl/ssl.h>
-
-#define REQUIRE_LIBRARY()
-#define FIO_TLS_WEAK
-
-/* *****************************************************************************
-The SSL/TLS helper data types (can be left as is)
-***************************************************************************** */
-#define FIO_INCLUDE_STR      1
-#define FIO_FORCE_MALLOC_TMP 1
-#include <fio.h>
-
-#ifndef FIO_TLS_TIMEOUT
-#define FIO_TLS_TIMEOUT 4
-#endif
-
-typedef struct {
-  fio_str_s private_key;
-  fio_str_s public_key;
-  fio_str_s password;
-} cert_s;
-
-static inline int fio_tls_cert_cmp(const cert_s *dest, const cert_s *src) {
-  return fio_str_iseq(&dest->private_key, &src->private_key);
-}
-static inline void fio_tls_cert_copy(cert_s *dest, cert_s *src) {
-  *dest = (cert_s){
-      .private_key = FIO_STR_INIT,
-      .public_key = FIO_STR_INIT,
-      .password = FIO_STR_INIT,
-  };
-  fio_str_concat(&dest->private_key, &src->private_key);
-  fio_str_concat(&dest->public_key, &src->public_key);
-  fio_str_concat(&dest->password, &src->password);
-}
-static inline void fio_tls_cert_destroy(cert_s *obj) {
-  fio_str_free(&obj->private_key);
-  fio_str_free(&obj->public_key);
-  fio_str_free(&obj->password);
-}
-
-#define FIO_ARY_NAME            cert_ary
-#define FIO_ARY_TYPE            cert_s
-#define FIO_ARY_COMPARE(k1, k2) (fio_tls_cert_cmp(&(k1), &(k2)))
-#define FIO_ARY_COPY(dest, obj) fio_tls_cert_copy(&(dest), &(obj))
-#define FIO_ARY_DESTROY(key)    fio_tls_cert_destroy(&(key))
-#define FIO_FORCE_MALLOC_TMP    1
-#include <fio.h>
-
-typedef struct {
-  fio_str_s pem;
-} trust_s;
-
-static inline int fio_tls_trust_cmp(const trust_s *dest, const trust_s *src) {
-  return fio_str_iseq(&dest->pem, &src->pem);
-}
-static inline void fio_tls_trust_copy(trust_s *dest, trust_s *src) {
-  *dest = (trust_s){
-      .pem = FIO_STR_INIT,
-  };
-  fio_str_concat(&dest->pem, &src->pem);
-}
-static inline void fio_tls_trust_destroy(trust_s *obj) {
-  fio_str_free(&obj->pem);
-}
-
-#define FIO_ARY_NAME            trust_ary
-#define FIO_ARY_TYPE            trust_s
-#define FIO_ARY_COMPARE(k1, k2) (fio_tls_trust_cmp(&(k1), &(k2)))
-#define FIO_ARY_COPY(dest, obj) fio_tls_trust_copy(&(dest), &(obj))
-#define FIO_ARY_DESTROY(key)    fio_tls_trust_destroy(&(key))
-#define FIO_FORCE_MALLOC_TMP    1
-#include <fio.h>
-
-typedef struct {
-  fio_str_s name; /* fio_str_s provides cache locality for small strings */
-  void (*on_selected)(intptr_t uuid, void *udata_connection, void *udata_tls);
-  void *udata_tls;
-  void (*on_cleanup)(void *udata_tls);
-} alpn_s;
-
-static inline int fio_alpn_cmp(const alpn_s *dest, const alpn_s *src) {
-  return fio_str_iseq(&dest->name, &src->name);
-}
-static inline void fio_alpn_copy(alpn_s *dest, alpn_s *src) {
-  *dest = (alpn_s){
-      .name = FIO_STR_INIT,
-      .on_selected = src->on_selected,
-      .udata_tls = src->udata_tls,
-      .on_cleanup = src->on_cleanup,
-  };
-  fio_str_concat(&dest->name, &src->name);
-}
-static inline void fio_alpn_destroy(alpn_s *obj) {
-  if (obj->on_cleanup)
-    obj->on_cleanup(obj->udata_tls);
-  fio_str_free(&obj->name);
-}
-
-#define FIO_SET_NAME                alpn_list
-#define FIO_SET_OBJ_TYPE            alpn_s
-#define FIO_SET_OBJ_COMPARE(k1, k2) fio_alpn_cmp(&(k1), &(k2))
-#define FIO_SET_OBJ_COPY(dest, obj) fio_alpn_copy(&(dest), &(obj))
-#define FIO_SET_OBJ_DESTROY(key)    fio_alpn_destroy(&(key))
-#define FIO_FORCE_MALLOC_TMP        1
-#include <fio.h>
-
-/* *****************************************************************************
-The SSL/TLS type
-***************************************************************************** */
-
-/** An opaque type used for the SSL/TLS functions. */
-struct fio_tls_s {
-  size_t ref;       /* Reference counter, to guards the ALPN registry */
-  alpn_list_s alpn; /* ALPN is the name for the protocol selection extension */
-
-  /*** the next two components could be optimized away with tweaking stuff ***/
-
-  cert_ary_s sni;    /* SNI (server name extension) stores ID certificates */
-  trust_ary_s trust; /* Trusted certificate registry (peer verification) */
-
-  /************ TODO: implementation data fields go here ******************/
-
-  SSL_CTX *ctx;            /* The Open SSL context (updated each time). */
-  unsigned char *alpn_str; /* the computed server-format ALPN string */
-  int alpn_len;
-};
-
-/* *****************************************************************************
-ALPN Helpers
-***************************************************************************** */
-
-/** Returns a pointer to the ALPN data (callback, etc') IF exists in the TLS. */
-FIO_FUNC inline alpn_s *alpn_find(fio_tls_s *tls, char *name, size_t len) {
-  alpn_s tmp = {.name = FIO_STR_INIT_STATIC2(name, len)};
-  alpn_list__map_s_ *pos =
-      alpn_list__find_map_pos_(&tls->alpn, fio_str_hash(&tmp.name), tmp);
-  if (!pos || !pos->pos)
-    return NULL;
-  return &pos->pos->obj;
-}
-
-/** Adds an ALPN data object to the ALPN "list" (set) */
-FIO_FUNC inline void alpn_add(fio_tls_s *tls,
-                              const char *protocol_name,
-                              void (*on_selected)(intptr_t uuid,
-                                                  void *udata_connection,
-                                                  void *udata_tls),
-                              void *udata_tls,
-                              void (*on_cleanup)(void *udata_tls)) {
-  alpn_s tmp = {
-      .name = FIO_STR_INIT_STATIC(protocol_name),
-      .on_selected = on_selected,
-      .udata_tls = udata_tls,
-      .on_cleanup = on_cleanup,
-  };
-  if (fio_str_len(&tmp.name) > 255) {
-    FIO_LOG_ERROR("ALPN protocol names are limited to 255 bytes.");
-    return;
-  }
-  alpn_list_overwrite(&tls->alpn, fio_str_hash(&tmp.name), tmp, NULL);
-  tmp.on_cleanup = NULL;
-  fio_alpn_destroy(&tmp);
-}
-
-/** Returns a pointer to the default (first) ALPN object in the TLS (if any). */
-FIO_FUNC inline alpn_s *alpn_default(fio_tls_s *tls) {
-  if (!tls || !alpn_list_count(&tls->alpn) || !tls->alpn.ordered)
-    return NULL;
-  return &tls->alpn.ordered[0].obj;
-}
-
-typedef struct {
-  alpn_s alpn;
-  intptr_t uuid;
-  void *udata_connection;
-} alpn_task_s;
-
-FIO_FUNC inline void alpn_select___task(void *t_, void *ignr_) {
-  alpn_task_s *t = t_;
-  if (fio_is_valid(t->uuid)) {
-    fio_timeout_set(t->uuid, 0); // remove TLS timeout
-    t->alpn.on_selected(t->uuid, t->udata_connection, t->alpn.udata_tls);
-  } else {
-    t->alpn.on_selected(-1, t->udata_connection, t->alpn.udata_tls);
-  }
-  fio_free(t);
-  (void)ignr_;
-}
-
-/** Schedules the ALPN protocol callback. */
-FIO_FUNC inline void alpn_select(alpn_s *alpn,
-                                 intptr_t uuid,
-                                 void *udata_connection) {
-  if (!alpn || !alpn->on_selected)
-    return;
-  alpn_task_s *t = fio_malloc(sizeof(*t));
-  *t = (alpn_task_s){
-      .alpn = *alpn,
-      .uuid = uuid,
-      .udata_connection = udata_connection,
-  };
-  fio_defer(alpn_select___task, t, NULL);
-}
-
-/* *****************************************************************************
-OpenSSL Helpers
-***************************************************************************** */
-
-static EVP_PKEY *fio_tls_pkey = NULL;
-
-static void fio_tls_clear_root_key(void *key) {
-  EVP_PKEY_free(key);
-  fio_tls_pkey = NULL;
-}
-
-static void fio_tls_make_root_key(void) {
-  static fio_lock_i lock = FIO_LOCK_INIT;
-  fio_lock(&lock);
-  if (fio_tls_pkey)
-    goto finish;
-  /* create private key, free it at exit */
-  FIO_LOG_DEBUG("calculating a new TLS private key... might take a while.");
-
-  fio_tls_pkey = EVP_PKEY_new();
-  FIO_ASSERT(fio_tls_pkey, "OpenSSL failed to create private key.");
-
-  /* TODO: replace RSA with something else? is there something else? */
-  RSA *rsa = RSA_new();
-  BIGNUM *e = BN_new();
-  BN_clear(e);
-  BN_add_word(e, 65537);
-  FIO_ASSERT_ALLOC(e);
-  FIO_ASSERT(RSA_generate_key_ex(rsa, 2048, e, NULL),
-             "OpenSSL failed to create RSA key.");
-  BN_free(e);
-  EVP_PKEY_assign_RSA(fio_tls_pkey, rsa);
-  fio_state_callback_add(FIO_CALL_AT_EXIT,
-                         fio_tls_clear_root_key,
-                         fio_tls_pkey);
-finish:
-  fio_unlock(&lock);
-}
-
-static X509 *fio_tls_create_self_signed(char *server_name) {
-  X509 *cert = X509_new();
-  static uint32_t counter = 0;
-  FIO_ASSERT(cert,
-             "OpenSSL failed to allocate memory for self-signed ceritifcate.");
-  fio_tls_make_root_key();
-
-  /* serial number */
-  fio_atomic_add(&counter, 1);
-  ASN1_INTEGER_set(X509_get_serialNumber(cert), counter);
-
-  /* validity (180 days) */
-  X509_gmtime_adj(X509_get_notBefore(cert), 0);
-  X509_gmtime_adj(X509_get_notAfter(cert), 15552000L);
-
-  /* set (public) key */
-  X509_set_pubkey(cert, fio_tls_pkey);
-
-  /* set identity details */
-  X509_NAME *s = X509_get_subject_name(cert);
-  size_t srv_name_len = strlen(server_name);
-  X509_NAME_add_entry_by_txt(s,
-                             "O",
-                             MBSTRING_ASC,
-                             (unsigned char *)server_name,
-                             srv_name_len,
-                             -1,
-                             0);
-  X509_NAME_add_entry_by_txt(s,
-                             "CN",
-                             MBSTRING_ASC,
-                             (unsigned char *)server_name,
-                             srv_name_len,
-                             -1,
-                             0);
-  X509_NAME_add_entry_by_txt(s,
-                             "CA",
-                             MBSTRING_ASC,
-                             (unsigned char *)server_name,
-                             srv_name_len,
-                             -1,
-                             0);
-  X509_set_issuer_name(cert, s);
-
-  /* sign certificate */
-  FIO_ASSERT(X509_sign(cert, fio_tls_pkey, EVP_sha512()),
-             "OpenSSL failed to signe self-signed certificate");
-  // FILE *fp = fopen("tmp.pem", "ab+");
-  // if (fp) {
-  //   PEM_write_X509(fp, cert);
-  //   fclose(fp);
-  // }
-
-  return cert;
-}
-
-/* *****************************************************************************
-SSL/TLS Context (re)-building
-***************************************************************************** */
-
-#define TLS_BUFFER_LENGTH (1 << 15)
-typedef struct {
-  SSL *ssl;
-  fio_tls_s *tls;
-  void *alpn_arg;
-  intptr_t uuid;
-  uint8_t is_server;
-  volatile uint8_t alpn_ok;
-} fio_tls_connection_s;
-
-static void fio_tls_alpn_fallback(fio_tls_connection_s *c) {
-  alpn_s *alpn = alpn_default(c->tls);
-  if (!alpn || !alpn->on_selected)
-    return;
-  /* set protocol to default protocol */
-  FIO_LOG_DEBUG("TLS ALPN handshake missing, falling back on %s for %p",
-                fio_str_info(&alpn->name).data,
-                (void *)c->uuid);
-  alpn_select(alpn, c->uuid, c->alpn_arg);
-}
-static int fio_tls_alpn_selector_cb(SSL *ssl,
-                                    const unsigned char **out,
-                                    unsigned char *outlen,
-                                    const unsigned char *in,
-                                    unsigned int inlen,
-                                    void *tls_) {
-  fio_tls_s *tls = tls_;
-  alpn_s *alpn;
-  /* TODO: select ALPN and call on_selected */
-  fio_tls_connection_s *c = SSL_get_ex_data(ssl, 0);
-  c->alpn_ok = 1;
-
-  if (alpn_list_count(&tls->alpn) == 0)
-    return SSL_TLSEXT_ERR_NOACK;
-  const unsigned char *end = in + inlen;
-  while (in < end) {
-    uint8_t l = in[0];
-    alpn = alpn_find(tls, (char *)in + 1, l);
-    in += l + 1;
-    if (!alpn)
-      continue;
-    fio_str_info_s info = fio_str_info(&alpn->name);
-    *out = (unsigned char *)info.data;
-    *outlen = (unsigned char)info.len;
-    FIO_LOG_DEBUG("TLS ALPN set to: %s for %p", info.data, (void *)c->uuid);
-    alpn_select(alpn, c->uuid, c->alpn_arg);
-    return SSL_TLSEXT_ERR_OK;
-  }
-  /* set protocol to default protocol */
-  alpn = alpn_default(tls);
-  alpn_select(alpn, c->uuid, c->alpn_arg);
-  FIO_LOG_DEBUG(
-      "TLS ALPN handshake failed, falling back on default (%s) for %p",
-      fio_str_data(&alpn->name),
-      (void *)c->uuid);
-  return SSL_TLSEXT_ERR_NOACK;
-  (void)ssl;
-  (void)out;
-  (void)outlen;
-  (void)in;
-  (void)inlen;
-  (void)tls;
-}
-
-/** Called when the library specific data for the context should be destroyed */
-static void fio_tls_destroy_context(fio_tls_s *tls) {
-  /* TODO: Library specific implementation */
-  SSL_CTX_free(tls->ctx);
-  free(tls->alpn_str);
-
-  tls->ctx = NULL;
-  tls->alpn_str = NULL;
-  tls->alpn_len = 0;
-  FIO_LOG_DEBUG("destroyed TLS context for OpenSSL %p", (void *)tls);
-}
-
-static int fio_tls_pem_passwd_cb(char *buf,
-                                 int size,
-                                 int rwflag,
-                                 void *password) {
-  fio_str_info_s *p = password;
-  if (!p || !p->len || !size)
-    return 0;
-  int len = (size <= (int)p->len) ? (size - 1) : (int)p->len;
-  memcpy(buf, p->data, len);
-  buf[len] = 0;
-  return len;
-  (void)rwflag;
-}
-
-/** Called when the library specific data for the context should be built */
-static void fio_tls_build_context(fio_tls_s *tls) {
-  fio_tls_destroy_context(tls);
-  /* TODO: Library specific implementation */
-
-  /* create new context */
-  tls->ctx = SSL_CTX_new(TLS_method());
-  SSL_CTX_set_mode(tls->ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
-  /* see: https://caniuse.com/#search=tls */
-  SSL_CTX_set_min_proto_version(tls->ctx, TLS1_2_VERSION);
-  SSL_CTX_set_options(tls->ctx, SSL_OP_NO_COMPRESSION);
-
-  /* attach certificates */
-  FIO_ARY_FOR(&tls->sni, pos) {
-    fio_str_info_s keys[4] = {
-        fio_str_info(&pos->private_key),
-        fio_str_info(&pos->public_key),
-        fio_str_info(&pos->password),
-        /* empty password slot for public key */
-    };
-    if (keys[0].len && keys[1].len) {
-      if (1) {
-        /* Extract private key from private key file */
-        BIO *bio = BIO_new_mem_buf(keys[0].data, keys[0].len);
-        if (bio) {
-          EVP_PKEY *k = PEM_read_bio_PrivateKey(bio,
-                                                NULL,
-                                                fio_tls_pem_passwd_cb,
-                                                keys + 2);
-          if (k) {
-            FIO_LOG_DEBUG("TLS read private key from PEM file.");
-            SSL_CTX_use_PrivateKey(tls->ctx, k);
-          }
-          BIO_free(bio);
-        }
-      }
-      /* Certificate Files loaded */
-      for (int ki = 0; ki < 2; ++ki) {
-        /* Extract as much data as possible from each file */
-        BIO *bio = BIO_new_mem_buf(keys[ki].data, keys[ki].len);
-        FIO_ASSERT(bio, "OpenSSL error allocating BIO.");
-        STACK_OF(X509_INFO) *inf = PEM_X509_INFO_read_bio(bio,
-                                                          NULL,
-                                                          fio_tls_pem_passwd_cb,
-                                                          keys + ki + 2);
-        if (inf) {
-          for (int i = 0; i < sk_X509_INFO_num(inf); ++i) {
-            /* for each element in PEM */
-            X509_INFO *tmp = sk_X509_INFO_value(inf, i);
-            if (tmp->x509) {
-              FIO_LOG_DEBUG("TLS adding certificate from PEM file.");
-              if (i == 0) {
-                SSL_CTX_use_certificate(tls->ctx, tmp->x509);
-              } else {
-                SSL_CTX_add1_chain_cert(tls->ctx, tmp->x509);
-              }
-            }
-            if (tmp->x_pkey) {
-              FIO_LOG_DEBUG("TLS adding private key from PEM file.");
-              SSL_CTX_use_PrivateKey(tls->ctx, tmp->x_pkey->dec_pkey);
-            }
-          }
-          sk_X509_INFO_pop_free(inf, X509_INFO_free);
-        } else {
-          /* TODO: attempt DER format? */
-          // X509 *c;
-          // EVP_PKEY *k;
-          // const uint8_t *pdata = (uint8_t *)&keys[ki].data;
-          // d2i_X509(&c, &pdata, keys[ki].len);
-          // pdata = (uint8_t *)&keys[ki].data;
-          // d2i_AutoPrivateKey(&k, &pdata, keys[ki].len);
-        }
-        BIO_free(bio);
-      }
-    } else if (keys[0].len) {
-      /* Self Signed Certificates, only if server name is provided. */
-      SSL_CTX_use_certificate(tls->ctx,
-                              fio_tls_create_self_signed(keys[0].data));
-      SSL_CTX_use_PrivateKey(tls->ctx, fio_tls_pkey);
-    }
-  }
-
-  /* setup ALPN support */
-  if (1) {
-    size_t alpn_pos = 0;
-    /* looping twice is better than malloc fragmentation. */
-    FIO_SET_FOR_LOOP(&tls->alpn, pos) {
-      fio_str_info_s s = fio_str_info(&pos->obj.name);
-      if (!s.len)
-        continue;
-      alpn_pos += s.len + 1;
-    }
-    tls->alpn_str = malloc((alpn_pos | 15) + 1); /* round up to 16 + padding */
-    alpn_pos = 0;
-    FIO_SET_FOR_LOOP(&tls->alpn, pos) {
-      fio_str_info_s s = fio_str_info(&pos->obj.name);
-      if (!s.len)
-        continue;
-      tls->alpn_str[alpn_pos++] = (uint8_t)s.len;
-      memcpy(tls->alpn_str + alpn_pos, s.data, s.len);
-      alpn_pos += s.len;
-    }
-    tls->alpn_len = alpn_pos;
-    SSL_CTX_set_alpn_select_cb(tls->ctx, fio_tls_alpn_selector_cb, tls);
-    SSL_CTX_set_alpn_protos(tls->ctx, tls->alpn_str, tls->alpn_len);
-  }
-
-  /* Peer Verification / Trust */
-  if (trust_ary_count(&tls->trust)) {
-    /* TODO: enable peer verification */
-    X509_STORE *store = X509_STORE_new();
-    SSL_CTX_set_cert_store(tls->ctx, store);
-    SSL_CTX_set_verify(tls->ctx, SSL_VERIFY_PEER, NULL);
-    /* TODO: Add each ceriticate in the PEM to the trust "store" */
-    FIO_ARY_FOR(&tls->trust, pos) {
-      fio_str_info_s pem = fio_str_info(&pos->pem);
-      BIO *bio = BIO_new_mem_buf(pem.data, pem.len);
-      FIO_ASSERT(bio, "OpenSSL error allocating BIO.");
-      STACK_OF(X509_INFO) *inf = PEM_X509_INFO_read_bio(bio, NULL, NULL, NULL);
-      if (inf) {
-        for (int i = 0; i < sk_X509_INFO_num(inf); ++i) {
-          /* for each element in PEM */
-          X509_INFO *tmp = sk_X509_INFO_value(inf, i);
-          if (tmp->x509) {
-            FIO_LOG_DEBUG("TLS trusting certificate from PEM file.");
-            X509_STORE_add_cert(store, tmp->x509);
-          }
-          if (tmp->crl) {
-            X509_STORE_add_crl(store, tmp->crl);
-          }
-        }
-        sk_X509_INFO_pop_free(inf, X509_INFO_free);
-      }
-      BIO_free(bio);
-    }
-  }
-
-  FIO_LOG_DEBUG("(re)built TLS context for OpenSSL %p", (void *)tls);
-}
-
-/* *****************************************************************************
-SSL/TLS RW Hooks
-***************************************************************************** */
-
-static void fio_tls_delayed_close(void *uuid, void *ignr_) {
-  fio_close((intptr_t)uuid);
-  (void)ignr_;
-}
-
-/* TODO: this is an example implementation - fix for specific library. */
-
-/**
- * Implement reading from a file descriptor. Should behave like the file
- * system `read` call, including the setup or errno to EAGAIN / EWOULDBLOCK.
- *
- * Note: facil.io library functions MUST NEVER be called by any r/w hook, or a
- * deadlock might occur.
- */
-static ssize_t fio_tls_read(intptr_t uuid,
-                            void *udata,
-                            void *buf,
-                            size_t count) {
-  fio_tls_connection_s *c = udata;
-  ssize_t ret = SSL_read(c->ssl, buf, count);
-  if (ret > 0)
-    return ret;
-  ret = SSL_get_error(c->ssl, ret);
-  switch (ret) {
-  case SSL_ERROR_SSL:                                           /* overflow */
-  case SSL_ERROR_ZERO_RETURN: return 0;                         /* EOF */
-  case SSL_ERROR_SYSCALL: /* allow errno to inform us */ break; /* return -1 */
-  case SSL_ERROR_NONE:                                          /* overflow */
-  case SSL_ERROR_WANT_CONNECT:                                  /* overflow */
-  case SSL_ERROR_WANT_ACCEPT:                                   /* overflow */
-  case SSL_ERROR_WANT_X509_LOOKUP:                              /* overflow */
-  case SSL_ERROR_WANT_WRITE:                                    /* overflow */
-  case SSL_ERROR_WANT_READ:                                     /* overflow */
-#ifdef SSL_ERROR_WANT_ASYNC
-  case SSL_ERROR_WANT_ASYNC:                                    /* overflow */
-#endif
-  default: errno = EWOULDBLOCK; break;
-  }
-  return -1;
-  (void)uuid;
-}
-
-/**
- * When implemented, this function will be called to flush any data remaining
- * in the internal buffer.
- *
- * The function should return the number of bytes remaining in the internal
- * buffer (0 is a valid response) or -1 (on error).
- *
- * Note: facil.io library functions MUST NEVER be called by any r/w hook, or a
- * deadlock might occur.
- */
-static ssize_t fio_tls_flush(intptr_t uuid, void *udata) {
-  (void)uuid;
-  (void)udata;
-  return 0;
-}
-
-/**
- * Implement writing to a file descriptor. Should behave like the file system
- * `write` call.
- *
- * If an internal buffer is implemented and it is full, errno should be set to
- * EWOULDBLOCK and the function should return -1.
- *
- * Note: facil.io library functions MUST NEVER be called by any r/w hook, or a
- * deadlock might occur.
- */
-static ssize_t fio_tls_write(intptr_t uuid,
-                             void *udata,
-                             const void *buf,
-                             size_t count) {
-  fio_tls_connection_s *c = udata;
-  ssize_t ret = SSL_write(c->ssl, buf, count);
-  if (ret > 0)
-    return ret;
-  ret = SSL_get_error(c->ssl, ret);
-  switch (ret) {
-  case SSL_ERROR_SSL:                                           /* overflow */
-  case SSL_ERROR_ZERO_RETURN: return 0;                         /* EOF */
-  case SSL_ERROR_SYSCALL: /* allow errno to inform us */ break; /* return -1 */
-  case SSL_ERROR_NONE:                                          /* overflow */
-  case SSL_ERROR_WANT_CONNECT:                                  /* overflow */
-  case SSL_ERROR_WANT_ACCEPT:                                   /* overflow */
-  case SSL_ERROR_WANT_X509_LOOKUP:                              /* overflow */
-  case SSL_ERROR_WANT_WRITE:                                    /* overflow */
-  case SSL_ERROR_WANT_READ:                                     /* overflow */
-#ifdef SSL_ERROR_WANT_ASYNC
-  case SSL_ERROR_WANT_ASYNC:                                    /* overflow */
-#endif
-  default: errno = EWOULDBLOCK; break;
-  }
-  return -1;
-  (void)uuid;
-}
-
-/**
- * The `close` callback should close the underlying socket / file descriptor.
- *
- * If the function returns a non-zero value, it will be called again after an
- * attempt to flush the socket and any pending outgoing buffer.
- *
- * Note: facil.io library functions MUST NEVER be called by any r/w hook, or a
- * deadlock might occur.
- * */
-static ssize_t fio_tls_before_close(intptr_t uuid, void *udata) {
-  fio_tls_connection_s *c = udata;
-  SSL_shutdown(c->ssl);
-  return 1;
-  (void)uuid;
-}
-/**
- * Called to perform cleanup after the socket was closed.
- * */
-static void fio_tls_cleanup(void *udata) {
-  fio_tls_connection_s *c = udata;
-  if (!c->alpn_ok) {
-    alpn_select(alpn_default(c->tls), -1, c->alpn_arg);
-  }
-  SSL_free(c->ssl);
-  FIO_LOG_DEBUG("TLS cleanup for %p", (void *)c->uuid);
-  fio_tls_destroy(c->tls); /* manage reference count */
-  free(udata);
-}
-
-static fio_rw_hook_s FIO_TLS_HOOKS = {
-    .read = fio_tls_read,
-    .write = fio_tls_write,
-    .flush = fio_tls_flush,
-    .before_close = fio_tls_before_close,
-    .cleanup = fio_tls_cleanup,
-};
-
-#define FIO_TLS_HANDSHAKE_ERROR      0
-#define FIO_TLS_HANDSHAKE_OK         1
-#define FIO_TLS_HANDSHAKE_NEED_READ  2
-#define FIO_TLS_HANDSHAKE_NEED_WRITE 4
-
-static size_t fio_tls_handshake(intptr_t uuid, void *udata) {
-  size_t status = FIO_TLS_HANDSHAKE_ERROR;
-  fio_tls_connection_s *c = udata;
-
-  int ri;
-  if (c->is_server) {
-    ri = SSL_accept(c->ssl);
-  } else {
-    ri = SSL_connect(c->ssl);
-  }
-  if (ri != 1) {
-    ri = SSL_get_error(c->ssl, ri);
-    switch (ri) {
-    case SSL_ERROR_NONE:
-      // FIO_LOG_DEBUG("SSL_accept/SSL_connect %p state: SSL_ERROR_NONE",
-      //               (void *)uuid);
-      status = FIO_TLS_HANDSHAKE_NEED_READ | FIO_TLS_HANDSHAKE_NEED_WRITE;
-      return status;
-    case SSL_ERROR_WANT_WRITE:
-      // FIO_LOG_DEBUG("SSL_accept/SSL_connect %p state: SSL_ERROR_WANT_WRITE",
-      //               (void *)uuid);
-      status = FIO_TLS_HANDSHAKE_NEED_WRITE;
-      return status;
-    case SSL_ERROR_WANT_READ:
-      // FIO_LOG_DEBUG("SSL_accept/SSL_connect %p state: SSL_ERROR_WANT_READ",
-      //               (void *)uuid);
-      status = FIO_TLS_HANDSHAKE_NEED_READ;
-      return status;
-    case SSL_ERROR_SYSCALL:
-      if (errno) {
-        FIO_LOG_DEBUG(
-            "SSL_accept/SSL_connect %p error: SSL_ERROR_SYSCALL, errno: %s",
-            (void *)uuid,
-            strerror(errno));
-      }
-      break;
-    case SSL_ERROR_SSL:
-      FIO_LOG_DEBUG(
-          "SSL_accept/SSL_connect %p error: SSL_ERROR_SSL (non SSL attempt?)",
-          (void *)uuid);
-      break;
-    case SSL_ERROR_ZERO_RETURN:
-      FIO_LOG_DEBUG("SSL_accept/SSL_connect %p error: SSL_ERROR_ZERO_RETURN",
-                    (void *)uuid);
-      break;
-    case SSL_ERROR_WANT_CONNECT:
-      FIO_LOG_DEBUG("SSL_accept/SSL_connect %p error: SSL_ERROR_WANT_CONNECT",
-                    (void *)uuid);
-      break;
-    case SSL_ERROR_WANT_ACCEPT:
-      FIO_LOG_DEBUG("SSL_accept/SSL_connect %p error: SSL_ERROR_WANT_ACCEPT",
-                    (void *)uuid);
-      break;
-    case SSL_ERROR_WANT_X509_LOOKUP:
-      FIO_LOG_DEBUG(
-          "SSL_accept/SSL_connect %p error: SSL_ERROR_WANT_X509_LOOKUP",
-          (void *)uuid);
-      break;
-#ifdef SSL_ERROR_WANT_ASYNC
-    case SSL_ERROR_WANT_ASYNC:
-      FIO_LOG_DEBUG("SSL_accept/SSL_connect %p error: SSL_ERROR_WANT_ASYNC",
-                    (void *)uuid);
-      break;
-#endif
-#ifdef SSL_ERROR_WANT_CLIENT_HELLO_CB
-    case SSL_ERROR_WANT_CLIENT_HELLO_CB:
-      FIO_LOG_DEBUG(
-          "SSL_accept/SSL_connect %p error: SSL_ERROR_WANT_CLIENT_HELLO_CB",
-          (void *)uuid);
-      break;
-#endif
-    default:
-      FIO_LOG_DEBUG("SSL_accept/SSL_connect %p error: unknown (%d).",
-                    (void *)uuid,
-                    ri);
-      break;
-    }
-    fio_rw_hook_replace_unsafe(uuid, &FIO_TLS_HOOKS, udata);
-    fio_defer(fio_tls_delayed_close, (void *)uuid, NULL);
-    return status;
-  }
-  if (!c->alpn_ok) {
-    c->alpn_ok = 1;
-    if (c->is_server) {
-      fio_tls_alpn_fallback(c);
-    } else {
-      const unsigned char *proto;
-      unsigned int proto_len;
-      SSL_get0_alpn_selected(c->ssl, &proto, &proto_len);
-      alpn_s *alpn = NULL;
-      if (proto_len > 0) {
-        alpn = alpn_find(c->tls, (char *)proto, proto_len);
-      }
-      if (!alpn) {
-        alpn = alpn_default(c->tls);
-        FIO_LOG_DEBUG("ALPN missing for TLS client %p", (void *)uuid);
-      }
-      if (alpn)
-        FIO_LOG_DEBUG("setting ALPN %s for TLS client %p",
-                      fio_str_data(&alpn->name),
-                      (void *)uuid);
-      alpn_select(alpn, c->uuid, c->alpn_arg);
-    }
-  }
-  if (fio_rw_hook_replace_unsafe(uuid, &FIO_TLS_HOOKS, udata) == 0) {
-    FIO_LOG_DEBUG("Completed TLS handshake for %p", (void *)uuid);
-  } else {
-    FIO_LOG_DEBUG("Something went wrong during TLS handshake for %p",
-                  (void *)uuid);
-    return status;
-  }
-  /* make sure the connection is re-added to the reactor */
-  fio_force_event(uuid, FIO_EVENT_ON_DATA);
-  /* log session ID for WireShark */
-#if FIO_TLS_PRINT_SECRET
-  if (FIO_LOG_LEVEL >= FIO_LOG_LEVEL_DEBUG) {
-    unsigned char buff[SSL_MAX_MASTER_KEY_LENGTH + 2];
-    size_t ret = SSL_SESSION_get_master_key(SSL_get_session(c->ssl),
-                                            buff,
-                                            SSL_MAX_MASTER_KEY_LENGTH + 1);
-    buff[ret] = 0;
-    unsigned char buff2[(SSL_MAX_MASTER_KEY_LENGTH + 2) << 1];
-    for (size_t i = 0; i < ret; ++i) {
-      buff2[i] = ((buff[i] >> 4) >= 10) ? ('A' + (buff[i] >> 4) - 10)
-                                        : ('0' + (buff[i] >> 4));
-      buff2[i + 1] = ((buff[i] & 15) >= 10) ? ('A' + (buff[i] & 15) - 10)
-                                            : ('0' + (buff[i] & 15));
-    }
-    buff2[(ret << 1)] = 0;
-    FIO_LOG_DEBUG("OpenSSL Master Key for uuid %p:\n\t\t%s",
-                  (void *)uuid,
-                  buff2);
-  }
-#endif
-  status = FIO_TLS_HANDSHAKE_OK;
-  return status;
-}
-
-static ssize_t fio_tls_read4handshake(intptr_t uuid,
-                                      void *udata,
-                                      void *buf,
-                                      size_t count) {
-  // FIO_LOG_DEBUG("TLS handshake from read %p", (void *)uuid);
-  size_t s = fio_tls_handshake(uuid, udata);
-  if (s == FIO_TLS_HANDSHAKE_OK)
-    return fio_tls_read(uuid, udata, buf, count);
-  if (!s)
-    return 0;
-  errno = EWOULDBLOCK;
-  return -1;
-}
-
-static ssize_t fio_tls_write4handshake(intptr_t uuid,
-                                       void *udata,
-                                       const void *buf,
-                                       size_t count) {
-  // FIO_LOG_DEBUG("TLS handshake from write %p", (void *)uuid);
-  size_t s = fio_tls_handshake(uuid, udata);
-  if (s == FIO_TLS_HANDSHAKE_OK)
-    return fio_tls_write(uuid, udata, buf, count);
-  if (!s)
-    return 0;
-  errno = EWOULDBLOCK;
-  return -1;
-}
-
-static ssize_t fio_tls_flush4handshake(intptr_t uuid, void *udata) {
-  // FIO_LOG_DEBUG("TLS handshake from flush %p", (void *)uuid);
-  size_t s = fio_tls_handshake(uuid, udata);
-  if (s == FIO_TLS_HANDSHAKE_OK) {
-    return fio_tls_flush(uuid, udata);
-  }
-  if (!s)
-    return 0;
-  errno = 0;
-  return s | FIO_TLS_HANDSHAKE_NEED_WRITE;
-}
-
-static fio_rw_hook_s FIO_TLS_HANDSHAKE_HOOKS = {
-    .read = fio_tls_read4handshake,
-    .write = fio_tls_write4handshake,
-    .before_close = fio_tls_before_close,
-    .flush = fio_tls_flush4handshake,
-    .cleanup = fio_tls_cleanup,
-};
-static inline void fio_tls_attach2uuid(intptr_t uuid,
-                                       fio_tls_s *tls,
-                                       void *udata,
-                                       uint8_t is_server) {
-  fio_atomic_add(&tls->ref, 1);
-  /* create SSL connection context from global context */
-  fio_tls_connection_s *c = malloc(sizeof(*c));
-  FIO_ASSERT_ALLOC(c);
-  *c = (fio_tls_connection_s){
-      .alpn_arg = udata,
-      .tls = tls,
-      .uuid = uuid,
-      .ssl = SSL_new(tls->ctx),
-      .is_server = is_server,
-      .alpn_ok = 0,
-  };
-  FIO_ASSERT_ALLOC(c->ssl);
-  /* set facil.io data in the SSL object */
-  SSL_set_ex_data(c->ssl, 0, (void *)c);
-  /* attach socket - TODO: Switch to BIO socket */
-  BIO *bio = BIO_new_socket(fio_uuid2fd(uuid), 0);
-  BIO_up_ref(bio);
-  SSL_set0_rbio(c->ssl, bio);
-  SSL_set0_wbio(c->ssl, bio);
-  /* set RW hooks */
-  fio_rw_hook_set(uuid, &FIO_TLS_HANDSHAKE_HOOKS, c);
-  if (is_server) {
-    /* Server mode (accept) */
-    FIO_LOG_DEBUG("Attaching TLS read/write hook for %p (server mode).",
-                  (void *)uuid);
-    SSL_set_accept_state(c->ssl);
-  } else {
-    /* Client mode (connect) */
-    FIO_LOG_DEBUG("Attaching TLS read/write hook for %p (client mode).",
-                  (void *)uuid);
-    SSL_set_connect_state(c->ssl);
-  }
-  fio_force_event(uuid, FIO_EVENT_ON_READY);
-}
-
-/* *****************************************************************************
-SSL/TLS API implementation - this can be pretty much used as is...
-***************************************************************************** */
-
-/**
- * Creates a new SSL/TLS context / settings object with a default certificate
- * (if any).
- */
-fio_tls_s *FIO_TLS_WEAK fio_tls_new(const char *server_name,
-                                    const char *cert,
-                                    const char *key,
-                                    const char *pk_password) {
-  REQUIRE_LIBRARY();
-  fio_tls_s *tls = calloc(sizeof(*tls), 1);
-  tls->ref = 1;
-  fio_tls_cert_add(tls, server_name, key, cert, pk_password);
-  return tls;
-}
-
-/**
- * Adds a certificate  a new SSL/TLS context / settings object.
- */
-void FIO_TLS_WEAK fio_tls_cert_add(fio_tls_s *tls,
-                                   const char *server_name,
-                                   const char *cert,
-                                   const char *key,
-                                   const char *pk_password) {
-  REQUIRE_LIBRARY();
-  cert_s c = {
-      .private_key = FIO_STR_INIT,
-      .public_key = FIO_STR_INIT,
-      .password = FIO_STR_INIT_STATIC2(pk_password,
-                                       (pk_password ? strlen(pk_password) : 0)),
-  };
-  if (key && cert) {
-    if (fio_str_readfile(&c.private_key, key, 0, 0).data == NULL)
-      goto file_missing;
-    if (fio_str_readfile(&c.public_key, cert, 0, 0).data == NULL)
-      goto file_missing;
-    cert_ary_push(&tls->sni, c);
-  } else if (server_name) {
-    /* Self-Signed TLS Certificates */
-    c.private_key = FIO_STR_INIT_STATIC(server_name);
-    cert_ary_push(&tls->sni, c);
-  }
-  fio_tls_cert_destroy(&c);
-  fio_tls_build_context(tls);
-  return;
-file_missing:
-  FIO_LOG_FATAL("TLS certificate file missing for either %s or %s or both.",
-                key,
-                cert);
-  exit(-1);
-}
-
-/**
- * Adds an ALPN protocol callback to the SSL/TLS context.
- *
- * The first protocol added will act as the default protocol to be selected.
- *
- * The callback should accept the `uuid`, the user data pointer passed to
- * either `fio_tls_accept` or `fio_tls_connect` (here: `udata_connetcion`) and
- * the user data pointer passed to the `fio_tls_alpn_add` function
- * (`udata_tls`).
- *
- * The `on_cleanup` callback will be called when the TLS object is destroyed
- * (or `fio_tls_alpn_add` is called again with the same protocol name). The
- * `udata_tls` argumrnt will be passed along, as is, to the callback (if set).
- *
- * Except for the `tls` and `protocol_name` arguments, all arguments can be
- * NULL.
- */
-void FIO_TLS_WEAK fio_tls_alpn_add(fio_tls_s *tls,
-                                   const char *protocol_name,
-                                   void (*on_selected)(intptr_t uuid,
-                                                       void *udata_connection,
-                                                       void *udata_tls),
-                                   void *udata_tls,
-                                   void (*on_cleanup)(void *udata_tls)) {
-  REQUIRE_LIBRARY();
-  alpn_add(tls, protocol_name, on_selected, udata_tls, on_cleanup);
-  fio_tls_build_context(tls);
-}
-
-/**
- * Returns the number of registered ALPN protocol names.
- *
- * This could be used when deciding if protocol selection should be delegated
- * to the ALPN mechanism, or whether a protocol should be immediately
- * assigned.
- *
- * If no ALPN protocols are registered, zero (0) is returned.
- */
-uintptr_t FIO_TLS_WEAK fio_tls_alpn_count(fio_tls_s *tls) {
-  return tls ? alpn_list_count(&tls->alpn) : 0;
-}
-
-/**
- * Adds a certificate to the "trust" list, which automatically adds a peer
- * verification requirement.
- *
- *      fio_tls_trust(tls, "google-ca.pem" );
- */
-void FIO_TLS_WEAK fio_tls_trust(fio_tls_s *tls, const char *public_cert_file) {
-  REQUIRE_LIBRARY();
-  trust_s c = {
-      .pem = FIO_STR_INIT,
-  };
-  if (!public_cert_file)
-    return;
-  if (fio_str_readfile(&c.pem, public_cert_file, 0, 0).data == NULL)
-    goto file_missing;
-  trust_ary_push(&tls->trust, c);
-  fio_tls_trust_destroy(&c);
-  fio_tls_build_context(tls);
-  return;
-file_missing:
-  FIO_LOG_FATAL("TLS certificate file missing for %s ", public_cert_file);
-  exit(-1);
-}
-
-/**
- * Establishes an SSL/TLS connection as an SSL/TLS Server, using the specified
- * context / settings object.
- *
- * The `uuid` should be a socket UUID that is already connected to a peer
- * (i.e., the result of `fio_accept`).
- *
- * The `udata` is an opaque user data pointer that is passed along to the
- * protocol selected (if any protocols were added using `fio_tls_alpn_add`).
- */
-void FIO_TLS_WEAK fio_tls_accept(intptr_t uuid, fio_tls_s *tls, void *udata) {
-  REQUIRE_LIBRARY();
-  fio_timeout_set(uuid, FIO_TLS_TIMEOUT);
-  fio_tls_attach2uuid(uuid, tls, udata, 1);
-}
-
-/**
- * Establishes an SSL/TLS connection as an SSL/TLS Client, using the specified
- * context / settings object.
- *
- * The `uuid` should be a socket UUID that is already connected to a peer
- * (i.e., one received by a `fio_connect` specified callback `on_connect`).
- *
- * The `udata` is an opaque user data pointer that is passed along to the
- * protocol selected (if any protocols were added using `fio_tls_alpn_add`).
- */
-void FIO_TLS_WEAK fio_tls_connect(intptr_t uuid, fio_tls_s *tls, void *udata) {
-  REQUIRE_LIBRARY();
-  fio_tls_attach2uuid(uuid, tls, udata, 0);
-}
-
-/**
- * Increase the reference count for the TLS object.
- *
- * Decrease with `fio_tls_destroy`.
- */
-void FIO_TLS_WEAK fio_tls_dup(fio_tls_s *tls) { fio_atomic_add(&tls->ref, 1); }
-
-/**
- * Destroys the SSL/TLS context / settings object and frees any related
- * resources / memory.
- */
-void FIO_TLS_WEAK fio_tls_destroy(fio_tls_s *tls) {
-  if (!tls)
-    return;
-  REQUIRE_LIBRARY();
-  if (fio_atomic_sub(&tls->ref, 1))
-    return;
-  fio_tls_destroy_context(tls);
-  alpn_list_free(&tls->alpn);
-  cert_ary_free(&tls->sni);
-  trust_ary_free(&tls->trust);
-  free(tls);
-  FIO_LOG_DEBUG("freed TLS context %p", (void *)tls);
-}
-
-#endif /* Library compiler flags */
-#endif