iodine 0.7.39 → 0.7.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad7a8dc81e2698056037086bfd6dd2f24ee975229a928092ac039ae9c44cb0d7
-  data.tar.gz: 84ff62b2c79efe4b0f5f1d796e27e6513bc8a29414fbd771404c814567d1138c
+  metadata.gz: 9e0b09518eec222b16c1740793a825c123672f3f027c7182c7fc021c9894136d
+  data.tar.gz: 0cf02ed5b0a11526dadf984f7d58accc434c896aa011ed3f3319f418df80c73b
 SHA512:
-  metadata.gz: bc69044b0cac72fda7be13ffb6e039007282f07e6b2607ea23e0a97733250d1b883d5e9cee171c67095e4eebd623f04f4d9d08ee2067f5a42a923b6785e3b824
-  data.tar.gz: b182b80a365fabaa0b97ce312f4bd2033ed28ba5a07759674cd305486f7a43ae64704da76449a84379be1a844ffe2df9396a863f4e8df5a9883d796be9fc3a91
+  metadata.gz: 6bbcc4ffb71aaed9efef0549b91b4da786672b000ec3b14e87106ad65421a28fe36b415ef0a0f02b9da1620c7ef057abba50e93e88bea37bc82c26a2728fd793
+  data.tar.gz: bfcd03eda1096833ab4315935f435f9891349830db493a74d570c7830505a4e43d5b6c6f0d143273ddb83a076174183888b4f8173dc421c23e12a645edf2006b

data/CHANGELOG.md

@@ -6,6 +6,10 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.40 (2020-05-23)
+
+**Fix**: fixed TLS logging and performance issues exposed by Franck Gille (@fgi) in issue #93.
+
 #### Change log v.0.7.39 (2020-05-18)
 
 **Security**: a request smuggling attack vector and Transfer Encoding attack vector in the HTTP/1.1 parser were exposed by Sam Sanoop from [the Snyk Security team (snyk.io)](https://snyk.io). The parser was updated to deal with these potential issues.

data/ext/iodine/fio.c

@@ -277,26 +277,6 @@ static inline fio_packet_s *fio_packet_alloc(void) {
 Core Connection Data Clearing
 ***************************************************************************** */
 
-/* set the minimal max_protocol_fd */
-static void fio_max_fd_min(uint32_t fd) {
-  if (fio_data->max_protocol_fd > fd)
-    return;
-  fio_lock(&fio_data->lock);
-  if (fio_data->max_protocol_fd < fd)
-    fio_data->max_protocol_fd = fd;
-  fio_unlock(&fio_data->lock);
-}
-
-/* set the minimal max_protocol_fd */
-static void fio_max_fd_shrink(void) {
-  fio_lock(&fio_data->lock);
-  uint32_t fd = fio_data->max_protocol_fd;
-  while (fd && fd_data(fd).protocol == NULL)
-    --fd;
-  fio_data->max_protocol_fd = fd;
-  fio_unlock(&fio_data->lock);
-}
-
 /* resets connection data, marking it as either open or closed. */
 static inline int fio_clear_fd(intptr_t fd, uint8_t is_open) {
   fio_packet_s *packet;
@@ -318,6 +298,13 @@ static inline int fio_clear_fd(intptr_t fd, uint8_t is_open) {
       .counter = fd_data(fd).counter + 1,
       .packet_last = &fd_data(fd).packet,
   };
+  if (fio_data->max_protocol_fd < fd) {
+    fio_data->max_protocol_fd = fd;
+  } else {
+    while (fio_data->max_protocol_fd &&
+           !fd_data(fio_data->max_protocol_fd).open)
+      --fio_data->max_protocol_fd;
+  }
   fio_unlock(&(fd_data(fd).sock_lock));
   if (rw_hooks && rw_hooks->cleanup)
     rw_hooks->cleanup(rw_udata);
@@ -336,8 +323,8 @@ static inline int fio_clear_fd(intptr_t fd, uint8_t is_open) {
   if (protocol && protocol->on_close) {
     fio_defer(deferred_on_close, (void *)fd2uuid(fd), protocol);
   }
-  if (is_open)
-    fio_max_fd_min(fd);
+  FIO_LOG_DEBUG("FD %d re-initialized (state: %p-%s).", (int)fd,
+                (void *)fd2uuid(fd), (is_open ? "open" : "closed"));
   return 0;
 }
 
@@ -2887,7 +2874,7 @@ void fio_close(intptr_t uuid) {
   }
   if (uuid_data(uuid).packet || uuid_data(uuid).sock_lock) {
     uuid_data(uuid).close = 1;
-    fio_poll_add_write(fio_uuid2fd(uuid));
+    fio_force_event(uuid, FIO_EVENT_ON_READY);
     return;
   }
   fio_force_close(uuid);
@@ -3019,6 +3006,7 @@ test_errno:
   case ENOSPC:        /* fallthrough */
   case EADDRNOTAVAIL: /* fallthrough */
   case EINTR:
+  case 0:
     return 1;
   case EFAULT:
     FIO_LOG_ERROR("fio_flush EFAULT - possible memory address error sent to "
@@ -3032,8 +3020,8 @@ test_errno:
     fio_force_close(uuid);
     return -1;
   }
-  fprintf(stderr, "UUID error: %p (%d)\n", (void *)uuid, errno);
-  perror("No errno handler");
+  FIO_LOG_DEBUG("UUID error: %p (%d): %s\n", (void *)uuid, errno,
+                strerror(errno));
   return 0;
 
 invalid:
@@ -3099,6 +3087,19 @@ const fio_rw_hook_s FIO_DEFAULT_RW_HOOKS = {
     .cleanup = fio_hooks_default_cleanup,
 };
 
+static inline void fio_rw_hook_validate(fio_rw_hook_s *rw_hooks) {
+  if (!rw_hooks->read)
+    rw_hooks->read = fio_hooks_default_read;
+  if (!rw_hooks->write)
+    rw_hooks->write = fio_hooks_default_write;
+  if (!rw_hooks->flush)
+    rw_hooks->flush = fio_hooks_default_flush;
+  if (!rw_hooks->before_close)
+    rw_hooks->before_close = fio_hooks_default_before_close;
+  if (!rw_hooks->cleanup)
+    rw_hooks->cleanup = fio_hooks_default_cleanup;
+}
+
 /**
  * Replaces an existing read/write hook with another from within a read/write
  * hook callback.
@@ -3112,19 +3113,10 @@ int fio_rw_hook_replace_unsafe(intptr_t uuid, fio_rw_hook_s *rw_hooks,
   int replaced = -1;
   uint8_t was_locked;
   intptr_t fd = fio_uuid2fd(uuid);
-  if (!rw_hooks->read)
-    rw_hooks->read = fio_hooks_default_read;
-  if (!rw_hooks->write)
-    rw_hooks->write = fio_hooks_default_write;
-  if (!rw_hooks->flush)
-    rw_hooks->flush = fio_hooks_default_flush;
-  if (!rw_hooks->before_close)
-    rw_hooks->before_close = fio_hooks_default_before_close;
-  if (!rw_hooks->cleanup)
-    rw_hooks->cleanup = fio_hooks_default_cleanup;
+  fio_rw_hook_validate(rw_hooks);
   /* protect against some fulishness... but not all of it. */
   was_locked = fio_trylock(&fd_data(fd).sock_lock);
-  if (fd2uuid(fd) == uuid) {
+  if (uuid_is_valid(uuid)) {
     fd_data(fd).rw_hooks = rw_hooks;
     fd_data(fd).rw_udata = udata;
     replaced = 0;
@@ -3138,16 +3130,7 @@ int fio_rw_hook_replace_unsafe(intptr_t uuid, fio_rw_hook_s *rw_hooks,
 int fio_rw_hook_set(intptr_t uuid, fio_rw_hook_s *rw_hooks, void *udata) {
   if (fio_is_closed(uuid))
     goto invalid_uuid;
-  if (!rw_hooks->read)
-    rw_hooks->read = fio_hooks_default_read;
-  if (!rw_hooks->write)
-    rw_hooks->write = fio_hooks_default_write;
-  if (!rw_hooks->flush)
-    rw_hooks->flush = fio_hooks_default_flush;
-  if (!rw_hooks->before_close)
-    rw_hooks->before_close = fio_hooks_default_before_close;
-  if (!rw_hooks->cleanup)
-    rw_hooks->cleanup = fio_hooks_default_cleanup;
+  fio_rw_hook_validate(rw_hooks);
   intptr_t fd = fio_uuid2fd(uuid);
   fio_rw_hook_s *old_rw_hooks;
   void *old_udata;
@@ -3249,7 +3232,6 @@ static int fio_attach__internal(void *uuid_, void *protocol_) {
     /* adding a new uuid to the reactor */
     fio_poll_add(fio_uuid2fd(uuid));
   }
-  fio_max_fd_min(fio_uuid2fd(uuid));
   return 0;
 
 invalid_uuid:
@@ -3521,7 +3503,6 @@ static void fio_on_fork(void) {
   }
 
   fio_pubsub_on_fork();
-  fio_max_fd_shrink();
   uint16_t old_active = fio_data->active;
   fio_data->active = 0;
   fio_defer_perform();
@@ -3681,24 +3662,29 @@ static void fio_review_timeout(void *arg, void *ignr) {
   uint16_t timeout = fd_data(fd).timeout;
   if (!timeout)
     timeout = 300; /* enforced timout settings */
-  if (!fd_data(fd).protocol || (fd_data(fd).active + timeout >= review))
+  if (!fd_data(fd).open || fd_data(fd).active + timeout >= review)
     goto finish;
-  tmp = protocol_try_lock(fd, FIO_PR_LOCK_STATE);
-  if (!tmp) {
-    if (errno == EBADF)
-      goto finish;
-    goto reschedule;
+  if (fd_data(fd).protocol) {
+    tmp = protocol_try_lock(fd, FIO_PR_LOCK_STATE);
+    if (!tmp) {
+      if (errno == EBADF)
+        goto finish;
+      goto reschedule;
+    }
+    if (prt_meta(tmp).locks[FIO_PR_LOCK_TASK] ||
+        prt_meta(tmp).locks[FIO_PR_LOCK_WRITE])
+      goto unlock;
+    fio_defer_push_task(deferred_ping, (void *)fio_fd2uuid((int)fd), NULL);
+  unlock:
+    protocol_unlock(tmp, FIO_PR_LOCK_STATE);
+  } else {
+    /* open FD but no protocol? */
+    fio_close(fd2uuid(fd));
   }
-  if (prt_meta(tmp).locks[FIO_PR_LOCK_TASK] ||
-      prt_meta(tmp).locks[FIO_PR_LOCK_WRITE])
-    goto unlock;
-  fio_defer_push_task(deferred_ping, (void *)fio_fd2uuid((int)fd), NULL);
-unlock:
-  protocol_unlock(tmp, FIO_PR_LOCK_STATE);
 finish:
   do {
     fd++;
-  } while (!fd_data(fd).protocol && (fd <= fio_data->max_protocol_fd));
+  } while (!fd_data(fd).open && (fd <= fio_data->max_protocol_fd));
 
   if (fio_data->max_protocol_fd < fd) {
     fio_data->need_review = 1;
@@ -3714,7 +3700,6 @@ static void fio_cycle_schedule_events(void) {
   static time_t last_to_review = 0;
   fio_mark_time();
   fio_timer_schedule();
-  fio_max_fd_shrink();
   if (fio_signal_children_flag) {
     /* hot restart support */
     fio_signal_children_flag = 0;

data/ext/iodine/fio_tls_missing.c

@@ -33,6 +33,11 @@ Feel free to copy, use and enjoy according to the license provided.
   FIO_LOG_FATAL("No supported SSL/TLS library available.");                    \
   exit(-1);
 #endif
+
+#ifndef FIO_TLS_TIMEOUT
+#define FIO_TLS_TIMEOUT 4
+#endif
+
 /* STOP deleting after this line */
 
 /* *****************************************************************************
@@ -590,6 +595,7 @@ file_missing:
  */
 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);
 }
 

data/ext/iodine/fio_tls_openssl.c

@@ -29,6 +29,10 @@ The SSL/TLS helper data types (can be left as is)
 #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;
@@ -190,8 +194,12 @@ typedef struct {
 
 FIO_FUNC inline void alpn_select___task(void *t_, void *ignr_) {
   alpn_task_s *t = t_;
-  t->alpn.on_selected((fio_is_valid(t->uuid) ? t->uuid : -1),
-                      t->udata_connection, t->alpn.udata_tls);
+  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_;
 }
@@ -537,19 +545,21 @@ static ssize_t fio_tls_read(intptr_t uuid, void *udata, void *buf,
   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
-  case SSL_ERROR_WANT_WRITE: /* overflow */
-  case SSL_ERROR_WANT_READ:
   default:
+    errno = EWOULDBLOCK;
     break;
   }
-  errno = EWOULDBLOCK;
   return -1;
   (void)uuid;
 }
@@ -591,19 +601,21 @@ static ssize_t fio_tls_write(intptr_t uuid, void *udata, const void *buf,
   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
-  case SSL_ERROR_WANT_WRITE: /* overflow */
-  case SSL_ERROR_WANT_READ:
   default:
+    errno = EWOULDBLOCK;
     break;
   }
-  errno = EWOULDBLOCK;
   return -1;
   (void)uuid;
 }
@@ -640,13 +652,20 @@ static void fio_tls_cleanup(void *udata) {
 static fio_rw_hook_s FIO_TLS_HOOKS = {
     .read = fio_tls_read,
     .write = fio_tls_write,
-    .before_close = fio_tls_before_close,
     .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);
@@ -659,26 +678,29 @@ static size_t fio_tls_handshake(intptr_t uuid, void *udata) {
     case SSL_ERROR_NONE:
       // FIO_LOG_DEBUG("SSL_accept/SSL_connect %p state: SSL_ERROR_NONE",
       //               (void *)uuid);
-      return 0;
+      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);
-      //   fio_force_event(uuid, FIO_EVENT_ON_READY);
-      return 0;
+      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);
-      // fio_force_event(uuid, FIO_EVENT_ON_DATA);
-      return 0;
+      status = FIO_TLS_HANDSHAKE_NEED_READ;
+      return status;
     case SSL_ERROR_SYSCALL:
-      FIO_LOG_DEBUG(
-          "SSL_accept/SSL_connect %p error: SSL_ERROR_SYSCALL, errno: %s",
-          (void *)uuid, strerror(errno));
-      // fio_force_event(uuid, FIO_EVENT_ON_DATA);
-      return 0;
+      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",
-                    (void *)uuid);
+      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",
@@ -715,8 +737,9 @@ static size_t fio_tls_handshake(intptr_t uuid, void *udata) {
                     (void *)uuid, ri);
       break;
     }
+    fio_rw_hook_replace_unsafe(uuid, &FIO_TLS_HOOKS, udata);
     fio_defer(fio_tls_delayed_close, (void *)uuid, NULL);
-    return 0;
+    return status;
   }
   if (!c->alpn_ok) {
     c->alpn_ok = 1;
@@ -745,7 +768,7 @@ static size_t fio_tls_handshake(intptr_t uuid, void *udata) {
   } else {
     FIO_LOG_DEBUG("Something went wrong during TLS handshake for %p",
                   (void *)uuid);
-    return 0;
+    return status;
   }
   /* make sure the connection is re-added to the reactor */
   fio_force_event(uuid, FIO_EVENT_ON_DATA);
@@ -768,14 +791,18 @@ static size_t fio_tls_handshake(intptr_t uuid, void *udata) {
                   buff2);
   }
 #endif
-  return 1;
+  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);
-  if (fio_tls_handshake(uuid, udata))
+  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;
 }
@@ -783,20 +810,27 @@ static ssize_t fio_tls_read4handshake(intptr_t uuid, void *udata, void *buf,
 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);
-  if (fio_tls_handshake(uuid, udata))
+  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);
-  if (fio_tls_handshake(uuid, udata)) {
+  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 1;
+  return s | FIO_TLS_HANDSHAKE_NEED_WRITE;
 }
+
 static fio_rw_hook_s FIO_TLS_HANDSHAKE_HOOKS = {
     .read = fio_tls_read4handshake,
     .write = fio_tls_write4handshake,
@@ -967,6 +1001,7 @@ file_missing:
  */
 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);
 }
 
@@ -1007,6 +1042,7 @@ void FIO_TLS_WEAK fio_tls_destroy(fio_tls_s *tls) {
   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 */

data/ext/iodine/http.c

@@ -874,19 +874,23 @@ static uint8_t fio_http_at_capa = 0;
 
 static void http_on_server_protocol_http1(intptr_t uuid, void *set,
                                           void *ignr_) {
-  fio_timeout_set(uuid, ((http_settings_s *)set)->timeout);
-  if (fio_uuid2fd(uuid) >= ((http_settings_s *)set)->max_clients) {
-    if (!fio_http_at_capa)
-      FIO_LOG_WARNING("HTTP server at capacity");
-    fio_http_at_capa = 1;
-    http_send_error2(uuid, 503, set);
-    fio_close(uuid);
+  if ((unsigned int)fio_uuid2fd(uuid) >=
+      ((http_settings_s *)set)->max_clients) {
+    if (fio_uuid2fd(uuid) != -1) {
+      if (!fio_http_at_capa)
+        FIO_LOG_WARNING("HTTP server at capacity");
+      fio_http_at_capa = 1;
+      http_send_error2(uuid, 503, set);
+      fio_close(uuid);
+    }
     return;
   }
   fio_http_at_capa = 0;
   fio_protocol_s *pr = http1_new(uuid, set, NULL, 0);
   if (!pr)
     fio_close(uuid);
+  else
+    fio_timeout_set(uuid, ((http_settings_s *)set)->timeout);
   (void)ignr_;
 }
 

data/ext/iodine/http1.c

@@ -786,7 +786,8 @@ fio_protocol_s *http1_new(uintptr_t uuid, http_settings_s *settings,
   if (unread_data && unread_length > HTTP_MAX_HEADER_LENGTH)
     return NULL;
   http1pr_s *p = fio_malloc(sizeof(*p) + HTTP_MAX_HEADER_LENGTH);
-  // FIO_LOG_DEBUG("Allocated HTTP/1.1 protocol at. %p", (void *)p);
+  // FIO_LOG_DEBUG("Allocated HTTP/1.1 protocol %p(%d)=>%p", (void *)uuid,
+  //               (int)fio_uuid2fd(uuid), (void *)p);
   FIO_ASSERT_ALLOC(p);
   *p = (http1pr_s){
       .p.protocol =
@@ -817,8 +818,9 @@ void http1_destroy(fio_protocol_s *pr) {
   http1pr_s *p = (http1pr_s *)pr;
   http1_pr2handle(p).status = 0;
   http_s_destroy(&http1_pr2handle(p), 0);
+  // FIO_LOG_DEBUG("Deallocating HTTP/1.1 protocol %p(%d)=>%p", (void
+  // *)p->p.uuid, (int)fio_uuid2fd(p->p.uuid), (void *)p);
   fio_free(p);
-  // FIO_LOG_DEBUG("Deallocated HTTP/1.1 protocol at. %p", (void *)p);
 }
 
 /* *****************************************************************************

data/ext/iodine/iodine_tls.c

@@ -208,22 +208,8 @@ static VALUE iodine_tls_alpn(VALUE self, VALUE protocol_name) {
 }
 
 /**
-Loads the mustache template found in `:filename`. If `:template` is provided
-it will be used instead of reading the file's content.
-
-    Iodine::Mustache.new(filename, template = nil)
-
-When template data is provided, filename (if any) will only be used for
-partial template path resolution and the template data will be used for the
-template's content. This allows, for example, for front matter to be extracted
-before parsing the template.
-
-Once a template was loaded, it could be rendered using {render}.
-
-Accepts named arguments as well:
-
-    Iodine::Mustache.new(filename: "foo.mustache", template: "{{ bar }}")
-
+Creates a new {Iodine::TLS} object and calles the {#use_certificate} method with
+the supplied arguments.
 */
 static VALUE iodine_tls_new(int argc, VALUE *argv, VALUE self) {
   if (argc) {

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.7.39'.freeze
+  VERSION = '0.7.40'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.7.39
+  version: 0.7.40
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-18 00:00:00.000000000 Z
+date: 2020-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -243,7 +243,7 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
 post_install_message: |-
-  Thank you for installing Iodine 0.7.39.
+  Thank you for installing Iodine 0.7.40.
   Remember: if iodine supports your business, it's only fair to give value back (code contributions / donations).
 rdoc_options: []
 require_paths: