iodine 0.7.6 → 0.7.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 978b528f65f3a43372f47339c6f76ced52bfc12264665bf57c0d2f285b2a4ad2
-  data.tar.gz: b75b56ceebbda9a80510740f3d11425980a3562d46542e308e818fcf0fd9b219
+  metadata.gz: 5f1e30dc08b1f6e19e59689fc251f50d1fe2de15377c36d9d6c0244a3a569352
+  data.tar.gz: 3ea55ee5a0c809ba5f3bbde618beef72a2dd151242f5aadbf2b68c0d3a403d68
 SHA512:
-  metadata.gz: bf003b8b3ddf3a1be5c81cee28588a31ed9af159ad5e2b49d69d3e1a8bc6cf75149ba4191bc80c8e55e55cf5a9fae6b47d7c615662a6073824086b91d1a5811f
-  data.tar.gz: 923b37d94efd4e31d96743df37425334268c1c3a9fd51d44265f8a9603ff92346cc4d793e24a39203a93e5aabadf64981190ad88f843fb50fc276452ee6cb38e
+  metadata.gz: d0a8c45de3d93f4e7304a172b8111ea8cd0c5e727431fccb06982b930d596c571c3319819d72221dffe82cde14211bdefc1795ffc275fc8a5ba5255036bb81da
+  data.tar.gz: 537d0c329cf43df25ca7318b99d049cc590103e2b65bb90058dc246b6d0442404ec70eda473f6d97d6020f4b7f4163a270f0dcc2e8a9285298fd07ca4c712808

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.7
+
+**Fix**: (facil.io) fixed critical issue with cookies, where no more than a single cookie could be set (duplicate headers would be zeroed out before being set). Credit to @ojab for exposing the issue.
+
 #### Change log v.0.7.6
 
 **Fix**: (facil.io edge) timeout review was experiencing some errors that could cause timeouts to be ignored. This was fixed in the facil.io edge branch.

data/ext/iodine/fio.c

@@ -1264,7 +1264,7 @@ void fio_expected_concurrency(int16_t *threads, int16_t *processes) {
     }
 #endif
     *threads = *processes = (int16_t)cpu_count;
-    if (cpu_count > FIO_CPU_CORES_LIMIT) {
+    if (cpu_count > 3) {
       /* leave a core available for the kernel */
       --(*processes);
     }
@@ -1288,7 +1288,7 @@ void fio_expected_concurrency(int16_t *threads, int16_t *processes) {
         *processes = -1 * *threads;
       *threads = tmp_threads;
       if (cpu_adjust && (*processes * tmp_threads) >= cpu_count &&
-          cpu_count > FIO_CPU_CORES_LIMIT) {
+          cpu_count > 3) {
         /* leave a core available for the kernel */
         --*processes;
       }
@@ -2734,7 +2734,7 @@ const fio_rw_hook_s FIO_DEFAULT_RW_HOOKS = {
 /** Sets a socket hook state (a pointer to the struct). */
 int fio_rw_hook_set(intptr_t uuid, fio_rw_hook_s *rw_hooks, void *udata) {
   if (fio_is_closed(uuid))
-    return -1;
+    goto invalid_uuid;
   if (!rw_hooks->read)
     rw_hooks->read = fio_hooks_default_read;
   if (!rw_hooks->write)
@@ -2745,18 +2745,26 @@ int fio_rw_hook_set(intptr_t uuid, fio_rw_hook_s *rw_hooks, void *udata) {
     rw_hooks->before_close = fio_hooks_default_before_close;
   if (!rw_hooks->cleanup)
     rw_hooks->cleanup = fio_hooks_default_cleanup;
-  uuid = fio_uuid2fd(uuid);
+  intptr_t fd = fio_uuid2fd(uuid);
   fio_rw_hook_s *old_rw_hooks;
   void *old_udata;
-  fio_lock(&fd_data(uuid).sock_lock);
-  old_rw_hooks = fd_data(uuid).rw_hooks;
-  old_udata = fd_data(uuid).rw_udata;
-  fd_data(uuid).rw_hooks = rw_hooks;
-  fd_data(uuid).rw_udata = udata;
-  fio_unlock(&fd_data(uuid).sock_lock);
+  fio_lock(&fd_data(fd).sock_lock);
+  if (fd2uuid(fd) != uuid) {
+    fio_unlock(&fd_data(fd).sock_lock);
+    goto invalid_uuid;
+  }
+  old_rw_hooks = fd_data(fd).rw_hooks;
+  old_udata = fd_data(fd).rw_udata;
+  fd_data(fd).rw_hooks = rw_hooks;
+  fd_data(fd).rw_udata = udata;
+  fio_unlock(&fd_data(fd).sock_lock);
   if (old_rw_hooks && old_rw_hooks->cleanup)
     old_rw_hooks->cleanup(old_udata);
   return 0;
+invalid_uuid:
+  if (!rw_hooks->cleanup)
+    rw_hooks->cleanup(udata);
+  return -1;
 }
 
 /* *****************************************************************************
@@ -7975,6 +7983,7 @@ FIO_FUNC inline void fio_str_test(void) {
     }
     fprintf(stderr, "* reviewing reference counting `fio_str_free2` (2/2).\n");
     fio_str_free2(s);
+    fprintf(stderr, "* finished reference counting test.\n");
   }
   fio_str_free(&str);
   if (1) {
@@ -8032,7 +8041,17 @@ FIO_FUNC inline void fio_str_test(void) {
     str = FIO_STR_INIT_STATIC("Welcome");
     fio_str_info_s state = fio_str_write(&str, " Home", 5);
     FIO_ASSERT(state.capa > 0, "Static string not converted to non-static.");
-    fio_str_free(&str);
+    FIO_ASSERT(str.dealloc, "MIssing static string deallocation function"
+                            " after `fio_str_write`.");
+
+    fprintf(stderr, "* reviewing `fio_str_detach`.\n");
+    char *cstr = fio_str_detach(&str);
+    FIO_ASSERT(cstr, "`fio_str_detach` returned NULL");
+    FIO_ASSERT(!memcmp(cstr, "Welcome Home\0", 13),
+               "`fio_str_detach` string error");
+    fio_free(cstr);
+    FIO_ASSERT(fio_str_len(&str) == 0, "`fio_str_detach` data wasn't cleared.");
+    // fio_str_free(&str);
   }
   fprintf(stderr, "* passed.\n");
 }

data/ext/iodine/fio.h

@@ -1226,7 +1226,10 @@ typedef struct fio_rw_hook_s {
    */
   ssize_t (*flush)(intptr_t uuid, void *udata);
   /**
-   * Called to perform cleanup after the socket was closed.
+   * Called to perform cleanup after the socket was closed or a new read/write
+   * hook was set using `fio_rw_hook_set`.
+   *
+   * This callback is always called, even if `fio_rw_hook_set` fails.
    * */
   void (*cleanup)(void *udata);
 } fio_rw_hook_s;
@@ -3023,7 +3026,8 @@ typedef struct {
  * The `capacity` value should exclude the NUL character (if exists).
  */
 #define FIO_STR_INIT_STATIC(buffer)                                            \
-  ((fio_str_s){.data = (buffer), .len = strlen((buffer)), .dealloc = NULL})
+  ((fio_str_s){                                                                \
+      .data = (char *)(buffer), .len = strlen((buffer)), .dealloc = NULL})
 
 /**
  * Allocates a new fio_str_s object on the heap and initializes it.
@@ -3086,6 +3090,20 @@ FIO_FUNC void fio_str_free2(fio_str_s *s);
 inline FIO_FUNC ssize_t fio_str_send_free2(const intptr_t uuid,
                                            const fio_str_s *str);
 
+/**
+ * Returns a C string with the existing data, clearing the `fio_str_s` object's
+ * String.
+ *
+ * Note: the String data is removed from the container, but the container isn't
+ * freed.
+ *
+ * Returns NULL if there's no String data.
+ *
+ * Remember to `fio_free` the returned data and - if required - `fio_str_free2`
+ * the container.
+ */
+FIO_FUNC char *fio_str_detach(fio_str_s *s);
+
 /* *****************************************************************************
 String API - String state (data pointers, length, capacity, etc')
 ***************************************************************************** */
@@ -3394,6 +3412,58 @@ FIO_FUNC void fio_str_free2(fio_str_s *s) {
   FIO_FREE(s);
 }
 
+/**
+ * Returns a C string with the existing data, clearing the `fio_str_s` object's
+ * String.
+ *
+ * Note: the String data is removed from the container, but the container isn't
+ * freed.
+ *
+ * Returns NULL if there's no String data.
+ *
+ * Remember to `fio_free` the returned data and - if required - `fio_str_free2`
+ * the container.
+ */
+FIO_FUNC char *fio_str_detach(fio_str_s *s) {
+  if (!s)
+    return NULL;
+  fio_str_info_s i = fio_str_info(s);
+  if (s->small || !s->data) {
+    if (!i.len) {
+      i.data = NULL;
+      goto finish;
+    }
+    /* make a copy */
+    void *tmp = FIO_MALLOC(i.len + 1);
+    memcpy(tmp, i.data, i.len + 1);
+    i.data = tmp;
+  } else {
+    if (!i.len && s->data) {
+      if (s->dealloc)
+        s->dealloc(s->data);
+      i.data = NULL;
+    } else if (s->dealloc != FIO_FREE) {
+      /* make a copy */
+      void *tmp = FIO_MALLOC(i.len + 1);
+      memcpy(tmp, i.data, i.len + 1);
+      i.data = tmp;
+      if (s->dealloc)
+        s->dealloc(s->data);
+    }
+  }
+finish:
+#ifdef FIO_STR_NO_REF
+  *s = (fio_str_s){.small = 1};
+
+#else
+  *s = (fio_str_s){
+      .small = s->small,
+      .ref = s->ref,
+  };
+#endif
+  return i.data;
+}
+
 /** Returns the String's length in bytes. */
 inline FIO_FUNC size_t fio_str_len(fio_str_s *s) {
   return (s->small || !s->data) ? (s->small >> 1) : s->len;
@@ -3474,8 +3544,8 @@ String Implementation - Memory management
  * directly to `mmap` (due to their size, usually over 12KB).
  */
 #define ROUND_UP_CAPA2WORDS(num)                                               \
-  (((num + 1) & (sizeof(long double) - 1))                                     \
-       ? ((num + 1) | (sizeof(long double) - 1))                               \
+  ((((num) + 1) & (sizeof(long double) - 1))                                   \
+       ? (((num) + 1) | (sizeof(long double) - 1))                             \
        : (num))
 /**
  * Requires the String to have at least `needed` capacity. Returns the current
@@ -3499,6 +3569,7 @@ FIO_FUNC fio_str_info_s fio_str_capa_assert(fio_str_s *s, size_t needed) {
       memcpy(tmp, s->data, s->len);
       if (s->dealloc)
         s->dealloc(s->data);
+      s->dealloc = FIO_FREE;
     }
     s->capa = needed;
     s->data = tmp;
@@ -4184,9 +4255,14 @@ static FIO_ARY_TYPE const FIO_NAME(s___const_invalid_object);
 /* minimizes allocation "dead space" by alligning allocated length to 16bytes */
 #undef FIO_ARY_SIZE2WORDS
 #define FIO_ARY_SIZE2WORDS(size)                                               \
-  ((sizeof(FIO_ARY_TYPE) & 15) ? (((size) & ~(sizeof(FIO_ARY_TYPE) - 1)) +     \
-                                  (16 - (sizeof(FIO_ARY_TYPE) - 1)))           \
-                               : (size))
+  ((sizeof(FIO_ARY_TYPE) & 1)                                                  \
+       ? (((size) & (~15)) + 16)                                               \
+       : (sizeof(FIO_ARY_TYPE) & 2)                                            \
+             ? (((size) & (~7)) + 8)                                           \
+             : (sizeof(FIO_ARY_TYPE) & 4)                                      \
+                   ? (((size) & (~3)) + 4)                                     \
+                   : (sizeof(FIO_ARY_TYPE) & 8) ? (((size) & (~1)) + 2)        \
+                                                : (size))
 
 /* *****************************************************************************
 Array API

data/ext/iodine/fiobj_hash.c

@@ -25,7 +25,7 @@ License: MIT
   } while (0)
 #define FIO_SET_OBJ_TYPE FIOBJ
 #define FIO_SET_OBJ_COMPARE(o1, o2) fiobj_iseq((o1), (o2))
-#define FIO_SET_OBJ_COPY(dest, obj) ((dest) = (obj)) /* take ownership */
+#define FIO_SET_OBJ_COPY(dest, obj) ((dest) = fiobj_dup(obj))
 #define FIO_SET_OBJ_DESTROY(obj)                                               \
   do {                                                                         \
     fiobj_free((obj));                                                         \
@@ -201,6 +201,7 @@ int fiobj_hash_set(FIOBJ hash, FIOBJ key, FIOBJ obj) {
   if (FIOBJ_TYPE_IS(key, FIOBJ_T_STRING))
     fiobj_str_freeze(key);
   fio_hash___insert(&obj2hash(hash)->hash, fiobj_obj2hash(key), key, obj, NULL);
+  fiobj_free(obj); /* take ownership - free the user's reference. */
   return 0;
 }
 
@@ -239,6 +240,7 @@ FIOBJ fiobj_hash_replace(FIOBJ hash, FIOBJ key, FIOBJ obj) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
   FIOBJ old = FIOBJ_INVALID;
   fio_hash___insert(&obj2hash(hash)->hash, fiobj_obj2hash(key), key, obj, &old);
+  fiobj_free(obj); /* take ownership - free the user's reference. */
   return old;
 }
 
@@ -270,7 +272,8 @@ FIOBJ fiobj_hash_remove2(FIOBJ hash, uint64_t hash_value) {
  * Returns -1 on type error or if the object never existed.
  */
 int fiobj_hash_delete(FIOBJ hash, FIOBJ key) {
-  return fiobj_hash_remove(hash, key);
+  return fio_hash___remove(&obj2hash(hash)->hash, fiobj_obj2hash(key), key,
+                           NULL);
 }
 
 /**

data/ext/iodine/http.c

@@ -42,11 +42,30 @@ static inline int patch_clock_gettime(int clk_id, struct timespec *t) {
 /* *****************************************************************************
 SSL/TLS patch
 ***************************************************************************** */
-void __attribute__((weak)) fio_tls_accept(intptr_t uuid, void *tls) {
+
+/**
+ * Adds an ALPN protocol callback to the SSL/TLS context.
+ *
+ * The first protocol added will act as the default protocol to be selected.
+ */
+void __attribute__((weak))
+fio_tls_proto_add(void *tls, const char *protocol_name,
+                  void (*callback)(intptr_t uuid, void *udata)) {
+  FIO_LOG_FATAL("HTTP SSL/TLS required but unavailable!");
+  exit(-1);
+  (void)tls;
+  (void)protocol_name;
+  (void)callback;
+}
+#pragma weak fio_tls_proto_add
+
+void __attribute__((weak))
+fio_tls_accept(intptr_t uuid, void *tls, void *udata) {
   FIO_LOG_FATAL("HTTP SSL/TLS required but unavailable!");
   exit(-1);
   (void)uuid;
   (void)tls;
+  (void)udata;
 }
 #pragma weak fio_tls_accept
 
@@ -57,11 +76,13 @@ void __attribute__((weak)) fio_tls_accept(intptr_t uuid, void *tls) {
  * The `uuid` should be a socket UUID that is already connected to a peer (i.e.,
  * the result of `fio_accept`).
  */
-void __attribute__((weak)) fio_tls_connect(intptr_t uuid, void *tls) {
+void __attribute__((weak))
+fio_tls_connect(intptr_t uuid, void *tls, void *udata) {
   FIO_LOG_FATAL("HTTP SSL/TLS required but unavailable!");
   exit(-1);
   (void)uuid;
   (void)tls;
+  (void)udata;
 }
 #pragma weak fio_tls_connect
 
@@ -177,8 +198,7 @@ int http_set_header(http_s *r, FIOBJ name, FIOBJ value) {
   return 0;
 }
 /**
- * Sets a response header, taking ownership of the value object, but NOT the
- * name object (so name objects could be reused in future responses).
+ * Sets a response header.
  *
  * Returns -1 on error and 0 on success.
  */
@@ -907,10 +927,14 @@ static void http_settings_free(http_settings_s *s) {
 Listening to HTTP connections
 ***************************************************************************** */
 
+static void http_on_server_protocol_http1(intptr_t uuid, void *set) {
+  fio_protocol_s *pr = http1_new(uuid, set, NULL, 0);
+  if (!pr)
+    fio_close(uuid);
+}
+
 static void http_on_open(intptr_t uuid, void *set) {
   static uint8_t at_capa;
-  if (((http_settings_s *)set)->tls)
-    fio_tls_accept(uuid, ((http_settings_s *)set)->tls);
   fio_timeout_set(uuid, ((http_settings_s *)set)->timeout);
   if (fio_uuid2fd(uuid) >= ((http_settings_s *)set)->max_clients) {
     if (!at_capa)
@@ -921,9 +945,10 @@ static void http_on_open(intptr_t uuid, void *set) {
     return;
   }
   at_capa = 0;
-  fio_protocol_s *pr = http1_new(uuid, set, NULL, 0);
-  if (!pr)
-    fio_close(uuid);
+  if (((http_settings_s *)set)->tls)
+    fio_tls_accept(uuid, ((http_settings_s *)set)->tls, set);
+  else
+    http_on_server_protocol_http1(uuid, set);
 }
 
 static void http_on_finish(intptr_t uuid, void *set) {
@@ -955,6 +980,9 @@ intptr_t http_listen(const char *port, const char *binding,
 
   http_settings_s *settings = http_settings_new(arg_settings);
   settings->is_client = 0;
+  if (settings->tls) {
+    fio_tls_proto_add(settings->tls, "http/1.1", http_on_server_protocol_http1);
+  }
 
   return fio_listen(.port = port, .address = binding,
                     .on_finish = http_on_finish, .on_open = http_on_open,
@@ -996,13 +1024,13 @@ static void http_on_close_client(intptr_t uuid, fio_protocol_s *protocol) {
   http_settings_free(set);
 }
 
-static void http_on_open_client(intptr_t uuid, void *set_) {
+static void http_on_open_client_perform(http_settings_s *set) {
+  http_s *h = set->udata;
+  set->on_response(h);
+}
+static void http_on_open_client_http1(intptr_t uuid, void *set_) {
   http_settings_s *set = set_;
   http_s *h = set->udata;
-  set->udata = h->udata;
-  if (set->tls)
-    fio_tls_connect(uuid, set->tls);
-  fio_timeout_set(uuid, set->timeout);
   fio_protocol_s *pr = http1_new(uuid, set, NULL, 0);
   if (!pr) {
     fio_close(uuid);
@@ -1016,7 +1044,16 @@ static void http_on_open_client(intptr_t uuid, void *set_) {
   }
   h->private_data.flag = (uintptr_t)pr;
   h->private_data.vtbl = http1_vtable();
-  set->on_response(h);
+  http_on_open_client_perform(set);
+}
+
+static void http_on_open_client(intptr_t uuid, void *set_) {
+  http_settings_s *set = set_;
+  fio_timeout_set(uuid, set->timeout);
+  if (set->tls)
+    fio_tls_connect(uuid, set->tls, set_);
+  else
+    http_on_open_client_http1(uuid, set);
 }
 
 static void http_on_client_failed(intptr_t uuid, void *set_) {
@@ -1127,6 +1164,10 @@ intptr_t http_connect(const char *address,
     arg_settings.timeout = 30;
   http_settings_s *settings = http_settings_new(arg_settings);
   settings->is_client = 1;
+  if (settings->tls) {
+    fio_tls_proto_add(settings->tls, "http/1.1", http_on_open_client_http1);
+  }
+
   if (!arg_settings.ws_timeout)
     settings->ws_timeout = 0; /* allow server to dictate timeout */
   if (!arg_settings.timeout)

data/ext/iodine/http.h

@@ -148,8 +148,7 @@ typedef struct {
 int http_set_header(http_s *h, FIOBJ name, FIOBJ value);
 
 /**
- * Sets a response header, taking ownership of the value object, but NOT the
- * name object (so name objects could be reused in future responses).
+ * Sets a response header.
  *
  * Returns -1 on error and 0 on success.
  */

data/ext/iodine/http_internal.h

@@ -217,8 +217,8 @@ static inline void set_header_add(FIOBJ hash, FIOBJ name, FIOBJ value) {
     fiobj_ary_push(tmp, old);
     old = tmp;
   }
-  fiobj_ary_push(old, value);
-  fiobj_hash_replace(hash, name, old);
+  fiobj_ary_push(old, value); /* value is owned by both hash and array */
+  fiobj_hash_replace(hash, name, old); /* don't free `value` (leave in array) */
 }
 
 #endif /* H_HTTP_INTERNAL_H */

data/ext/iodine/iodine_http.c

@@ -467,6 +467,7 @@ static int for_each_header_data(VALUE key, VALUE val, VALUE h_) {
   char *val_s = RSTRING_PTR(val);
   int val_len = RSTRING_LEN(val);
   // make the headers lowercase
+
   FIOBJ name = fiobj_str_new(key_s, key_len);
   {
     fio_str_info_s tmp = fiobj_obj2cstr(name);
@@ -475,16 +476,17 @@ static int for_each_header_data(VALUE key, VALUE val, VALUE h_) {
     }
   }
   // scan the value for newline (\n) delimiters
-  int pos_s = 0, pos_e = 0;
-  while (pos_e < val_len) {
+  char *pos_s = val_s;
+  char *pos_e = val_s + val_len;
+  while (pos_s < pos_e) {
     // scanning for newline (\n) delimiters
-    while (pos_e < val_len && val_s[pos_e] != '\n')
-      pos_e++;
-    http_set_header(h, name, fiobj_str_new(val_s + pos_s, pos_e - pos_s));
-    // fprintf(stderr, "For_each - headers: wrote header\n");
+    char *const start = pos_s;
+    pos_s = memchr(pos_s, '\n', pos_e - pos_s);
+    if (!pos_s)
+      pos_s = pos_e;
+    http_set_header(h, name, fiobj_str_new(start, (pos_s - start)));
     // move forward (skip the '\n' if exists)
-    ++pos_e;
-    pos_s = pos_e;
+    ++pos_s;
   }
   fiobj_free(name);
   // no errors, return 0

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.7.6'.freeze
+  VERSION = '0.7.7'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.7.6
+  version: 0.7.7
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-05 00:00:00.000000000 Z
+date: 2018-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -244,7 +244,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 'Thank you for installing Iodine 0.7.6.
+post_install_message: 'Thank you for installing Iodine 0.7.7.
 
 '
 rdoc_options: []