iodine 0.2.13 → 0.2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc27a8990d89bbb19294133f6ec8178d2a586ea2
-  data.tar.gz: 8e9ec06545307abd666902d434438679e5bdd7ad
+  metadata.gz: ccbe7057ea01a3ced6291824c722160e8566200c
+  data.tar.gz: ef231d216e71b62b57331d34161858c4b3fb0284
 SHA512:
-  metadata.gz: a25fe9b7584dbeba407d55c1f150fdfab048fb7892a46ec32777d55b38ab3742faf0f7a972c118d3d6f26804380825324ff6f4b2665f91c56b0cb44f7f6c5ae6
-  data.tar.gz: b0e1ca2d60baae702e1f953cd6b9e13566168ae4fe989e1d31e6e0fd37cbbfc8bf3c3dfcf1e4e83049e09c45ca369c9efd08779965562b17cd576308925573e7
+  metadata.gz: 00c4e4dfd7633df4fdf2f9ade456326e27671f8cb1f9dcdd0693ec6c2f1eb65a896f502c5e40065b155ee876b8f9e7be5446dccffa2b3d2cf5cf19ef52a888a4
+  data.tar.gz: 9153c0444bdb26d6f5d3864fb7986d9851e1793e61c53387fe8e2826e7de87d48aee369f37100ebf3b9fb92fede369e3f1e7293988c4606a358e7041d4822eb1

data/CHANGELOG.md

@@ -8,6 +8,16 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ***
 
+Change log v.0.2.14
+
+**Fix**: fixed the experimental `each_write`. An issue was found where passing a block might crash Iodine, since the block will be freed by the GC before Iodine was done with it. Now the block is correctly added to the object Registry, preventing premature memory deallocation.
+
+**Fix**: fixed another issue with `each_write` where a race condition review was performed outside the protected critical section, in some cases this would caused memory to be freed twice and crash the server. This issue is now resolved.
+
+**Deprecation**: In version 0.2.1 we have notified that the the websocket method `uuid` was deprecated in favor of `conn_id`, as suggested by the [Rack Websocket Draft](https://github.com/rack/rack/pull/1107). This deprecation is now enforced.
+
+***
+
 Change log v.0.2.13
 
 **Fix**: Fixed an issue presented in the C layer, where big fragmented websocket messages sent by the client could cause parsing errors and potentially, in some cases, cause a server thread to spin in a loop (DoS). Credit to @Filly for exposing the issue in the [`facil.io`](https://github.com/boazsegev/facil.io) layer. It should be noted that Chrome is the only browser where this issue could be invoked for testing.

data/bin/ws-shootout

@@ -98,3 +98,5 @@ Iodine.start
 #   ws.onclose = function(e) {console.log("closed")};
 #   ws.onopen = function(e) {e.target.send("hi");};
 # };
+
+# sleep 10 while `websocket-bench broadcast ws://127.0.0.1:3000/ --concurrent 10 --sample-size 100 --step-size 1000 --limit-percentile 95 --limit-rtt 250ms --initial-clients 1000`.tap {|s| puts s; puts "zzz..."}

data/exe/iodine

@@ -16,8 +16,8 @@ Both <options> and <filename> are optional.
 
 Available options:
  -p          Port number. Default: 3000.
- -t          Number of threads. Default: 1 => single worker thread.
- -w          Number of worker processes. Default: 1 => a single process.
+ -t          Number of threads. Default: half of the CPU core count.
+ -w          Number of worker processes. half of the CPU core count.
  -www        Public folder for static file serving. Default: nil (none).
  -v          Log responses.
  -q          Never log responses.

data/ext/iodine/http_response.h

@@ -109,7 +109,7 @@ If this isn't set manually, the first call to
 being written (which might be less then the total data sent, if the sending is
 fragmented).
 
-Set the value to -1 to force the HttpResponse not to write nor automate the
+Set the value to -1 to force the HttpResponse not to write the
 `Content-Length` header.
 */
   ssize_t content_length;

data/ext/iodine/iodine_websocket.c

@@ -252,6 +252,12 @@ static uint8_t iodine_ws_if_callback(ws_s *ws, void *block) {
   return ret && ret != Qnil && ret != Qfalse;
 }
 
+static void iodine_ws_write_each_complete(ws_s *ws, void *block) {
+  (void)ws;
+  if ((VALUE)block != Qnil)
+    Registry.remove((VALUE)block);
+}
+
 /**
  * Writes data to all the Websocket connections sharing the same process
  * (worker) except `self`.
@@ -276,10 +282,15 @@ static VALUE iodine_ws_multiwrite(VALUE self, VALUE data) {
   VALUE block = Qnil;
   if (rb_block_given_p())
     block = rb_block_proc();
-  websocket_write_each(ws, RSTRING_PTR(data), RSTRING_LEN(data),
-                       rb_enc_get(data) == UTF8Encoding, 0,
-                       ((block == Qnil) ? NULL : iodine_ws_if_callback),
-                       (void *)block);
+  if (block != Qnil)
+    Registry.add(block);
+  websocket_write_each(.origin = ws, .data = RSTRING_PTR(data),
+                       .length = RSTRING_LEN(data),
+                       .is_text = (rb_enc_get(data) == UTF8Encoding),
+                       .on_finished = iodine_ws_write_each_complete,
+                       .filter =
+                           ((block == Qnil) ? NULL : iodine_ws_if_callback),
+                       .arg = (void *)block);
   return Qtrue;
 }
 
@@ -519,7 +530,7 @@ void Init_iodine_websocket(void) {
   rb_define_method(rWebsocket, "each_write", iodine_ws_multiwrite, 1);
   rb_define_method(rWebsocket, "close", iodine_ws_close, 0);
 
-  rb_define_method(rWebsocket, "uuid", iodine_ws_uuid, 0);
+  // rb_define_method(rWebsocket, "uuid", iodine_ws_uuid, 0);
   rb_define_method(rWebsocket, "conn_id", iodine_ws_uuid, 0);
   rb_define_method(rWebsocket, "has_pending?", iodine_ws_has_pending, 0);
   rb_define_method(rWebsocket, "defer", iodine_defer, -1);

data/ext/iodine/libreact.h

@@ -65,7 +65,7 @@ typedef union {
 } fduuid_u;
 
 #define FDUUID_FAIL(uuid) (uuid == -1)
-#define sock_uuid2fd(uuid) ((fduuid_u)(uuid)).data.fd
+#define sock_uuid2fd(uuid) ((fduuid_u *)(&uuid))->data.fd
 #endif
 
 /*****************************/ /** \file

data/ext/iodine/libserver.c

@@ -647,8 +647,9 @@ Sets a connection's timeout.
 Returns -1 on error (i.e. connection closed), otherwise returns 0.
 */
 void server_set_timeout(intptr_t fd, uint8_t timeout) {
-  if (valid_uuid(fd) == 0)
+  if (valid_uuid(fd) == 0) {
     return;
+  }
   lock_uuid(fd);
   uuid_data(fd).active = server_data.last_tick;
   uuid_data(fd).timeout = timeout;
@@ -758,11 +759,11 @@ static inline srv_task_s *task_alloc(void) {
 }
 
 /* allows for later implementation of a task pool with minimal code updates. */
-static inline void task_free(srv_task_s *task) { return free(task); }
+static inline void task_free(srv_task_s *task) { free(task); }
 
 /* performs a single connection task. */
 static void perform_single_task(void *task) {
-  if (sock_isvalid(p2task(task).target) == 0) {
+  if (p2task(task).target < 0 || sock_isvalid(p2task(task).target) == 0) {
     if (p2task(task).on_finish) // an invalid connection fallback
       task2fallback(task)(p2task(task).origin, p2task(task).arg);
     task_free(task);
@@ -771,7 +772,7 @@ static void perform_single_task(void *task) {
   if (try_lock_uuid(p2task(task).target) == 0) {
     // get protocol
     protocol_s *protocol = protocol_uuid(p2task(task).target);
-    if (protocol_set_busy(protocol) == 0) {
+    if (protocol && protocol_set_busy(protocol) == 0) {
       // clear the original busy flag
       unlock_uuid(p2task(task).target);
       p2task(task).task(p2task(task).target, protocol, p2task(task).arg);
@@ -871,7 +872,7 @@ void server_each(intptr_t origin_fd, const char *service,
   *t = (srv_task_s){.service = service,
                     .origin = origin_fd,
                     .task = task,
-                    .on_finish = on_finish,
+                    .on_finish = (void *)on_finish,
                     .arg = arg};
   if (async_run(perform_each_task, t))
     goto error;
@@ -895,8 +896,10 @@ void server_task(intptr_t caller_fd,
   t = task_alloc();
   if (t == NULL)
     goto error;
-  *t = (srv_task_s){
-      .target = caller_fd, .task = task, .on_finish = fallback, .arg = arg};
+  *t = (srv_task_s){.target = caller_fd,
+                    .task = task,
+                    .on_finish = (void *)fallback,
+                    .arg = arg};
   if (async_run(perform_single_task, t))
     goto error;
   return;

data/ext/iodine/libsock.c

@@ -194,12 +194,13 @@ static size_t fd_capacity = 0;
 
 #define uuid2info(uuid) fd_info[sock_uuid2fd(uuid)]
 #define is_valid(uuid)                                                         \
-  (fd_info[sock_uuid2fd(uuid)].fduuid.data.counter ==                          \
+  (sock_uuid2fd(uuid) >= 0 && sock_uuid2fd(uuid) <= (int)fd_capacity &&        \
+   fd_info[sock_uuid2fd(uuid)].fduuid.data.counter ==                          \
        ((fduuid_u *)(&uuid))->data.counter &&                                  \
    uuid2info(uuid).open)
 
 static struct {
-  sock_packet_s *pool;
+  sock_packet_s *volatile pool;
   sock_packet_s *allocated;
   spn_lock_i lock;
 } buffer_pool = {.lock = SPN_LOCK_INIT};

data/ext/iodine/spnlock.h

@@ -62,13 +62,13 @@ typedef atomic_bool spn_lock_i;
 #define SPN_LOCK_INIT ATOMIC_VAR_INIT(0)
 /** returns 1 if the lock was busy (TRUE == FAIL). */
 static inline int spn_trylock(spn_lock_i *lock) {
-  __asm__ volatile("" ::: "memory");
+  __sync_synchronize();
   return atomic_exchange(lock, 1);
 }
 /** Releases a lock. */
 static inline void spn_unlock(spn_lock_i *lock) {
   atomic_store(lock, 0);
-  __asm__ volatile("" ::: "memory");
+  __sync_synchronize();
 }
 /** returns a lock's state (non 0 == Busy). */
 static inline int spn_is_locked(spn_lock_i *lock) { return atomic_load(lock); }
@@ -98,6 +98,7 @@ static inline int spn_trylock(spn_lock_i *lock) { return __sync_swap(lock, 1); }
 typedef volatile uint8_t spn_lock_i;
 /** returns 1 if the lock was busy (TRUE == FAIL). */
 static inline int spn_trylock(spn_lock_i *lock) {
+  __sync_synchronize();
   return __sync_fetch_and_or(lock, 1);
 }
 #define SPN_TMP_HAS_BUILTIN 1
@@ -116,6 +117,7 @@ typedef volatile uint8_t spn_lock_i;
 /** returns 1 if the lock was busy (TRUE == FAIL). */
 static inline int spn_trylock(spn_lock_i *lock) {
   spn_lock_i tmp;
+  __asm__ volatile("mfence" ::: "memory");
   __asm__ volatile("xchgb %0,%1" : "=r"(tmp), "=m"(*lock) : "0"(1) : "memory");
   return tmp;
 }

data/ext/iodine/websockets.c

@@ -520,11 +520,12 @@ static size_t websocket_encode(void *buff, void *data, size_t len, char text,
               .size = len,
               .masked = client};
     memcpy(buff, &head, 2);
-    if (client)
+    if (client) {
       websocket_mask((uint8_t *)buff + 2, data, len);
-    else
+      len += 4;
+    } else
       memcpy((uint8_t *)buff + 2, data, len);
-    return len + 2 + (client ? 4 : 0);
+    return len + 2;
   } else if (len < (1UL << 16)) {
     /* head is 4 bytes */
     struct {
@@ -542,11 +543,12 @@ static size_t websocket_encode(void *buff, void *data, size_t len, char text,
               .masked = client,
               .length = htons(len)};
     memcpy(buff, &head, 4);
-    if (client)
+    if (client) {
       websocket_mask((uint8_t *)buff + 4, data, len);
-    else
+      len += 4;
+    } else
       memcpy((uint8_t *)buff + 4, data, len);
-    return len + 4 + (client ? 4 : 0);
+    return len + 4;
   }
   /* Really Long Message  */
   struct {
@@ -565,11 +567,12 @@ static size_t websocket_encode(void *buff, void *data, size_t len, char text,
   };
   memcpy(buff, &head, 2);
   ((size_t *)((uint8_t *)buff + 2))[0] = bswap64(len);
-  if (client)
+  if (client) {
     websocket_mask((uint8_t *)buff + 10, data, len);
-  else
+    len += 4;
+  } else
     memcpy((uint8_t *)buff + 10, data, len);
-  return len + 10 + (client ? 4 : 0);
+  return len + 10;
 }
 
 static void websocket_write_impl(intptr_t fd, void *data, size_t len,
@@ -817,23 +820,45 @@ Multi-Write (direct broadcast) Implementation
 */
 struct websocket_multi_write {
   uint8_t (*if_callback)(ws_s *ws_to, void *arg);
+  void (*on_finished)(ws_s *ws_origin, void *arg);
+  intptr_t origin;
   void *arg;
   spn_lock_i lock;
+  /* ... we need to have padding for pointer arithmatics... */
+  uint8_t as_client;
+  /* ... we need to have padding for pointer arithmatics... */
   size_t count;
   size_t length;
-  uint8_t as_client;
-  uint8_t buffer[];
+  uint8_t buffer[]; /* starts on border alignment */
 };
 
+static void ws_mw_defered_on_finish_fb(intptr_t fd, void *arg) {
+  (void)(fd);
+  struct websocket_multi_write *fin = arg;
+  fin->on_finished(NULL, fin->arg);
+  free(fin);
+}
+static void ws_mw_defered_on_finish(intptr_t fd, protocol_s *ws, void *arg) {
+  (void)(fd);
+  struct websocket_multi_write *fin = arg;
+  fin->on_finished((ws->service == WEBSOCKET_ID_STR ? (ws_s *)ws : NULL),
+                   fin->arg);
+  free(fin);
+}
+
 static void ws_reduce_or_free_multi_write(void *buff) {
-  struct websocket_multi_write *mw =
-      (void *)((uintptr_t)buff - sizeof(struct websocket_multi_write));
+  struct websocket_multi_write *mw = (void *)((uintptr_t)buff - sizeof(*mw));
   spn_lock(&mw->lock);
   mw->count -= 1;
-  spn_unlock(&mw->lock);
   if (!mw->count) {
-    free(mw);
-  }
+    spn_unlock(&mw->lock);
+    if (mw->on_finished) {
+      server_task(mw->origin, ws_mw_defered_on_finish, mw,
+                  ws_mw_defered_on_finish_fb);
+    } else
+      free(mw);
+  } else
+    spn_unlock(&mw->lock);
 }
 
 static void ws_finish_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
@@ -872,20 +897,28 @@ static void ws_check_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
     ws_direct_multi_write(fd, _ws, arg);
 }
 
-void websocket_write_each(ws_s *ws_originator, void *data, size_t len,
-                          uint8_t is_text, uint8_t as_client,
-                          uint8_t (*if_callback)(ws_s *ws_to, void *arg),
-                          void *arg) {
+#undef websocket_write_each
+int websocket_write_each(struct websocket_write_each_args_s args) {
+  if (!args.data || !args.length)
+    return -1;
   struct websocket_multi_write *multi =
-      malloc(len + 14 /* max head size */ + sizeof(*multi));
-  multi->length =
-      websocket_encode(multi->buffer, data, len, is_text, 1, 1, as_client);
-  multi->if_callback = if_callback;
-  multi->arg = arg;
-  multi->lock = SPN_LOCK_INIT;
-  multi->count = 1;
-  multi->as_client = as_client;
-  server_each((ws_originator ? ws_originator->fd : -1), WEBSOCKET_ID_STR,
-              (if_callback ? ws_check_multi_write : ws_direct_multi_write),
+      malloc(sizeof(*multi) + args.length + 16 /* max head size + 2 */);
+  if (!multi)
+    return -1;
+  *multi = (struct websocket_multi_write){
+      .length = websocket_encode(multi->buffer, args.data, args.length,
+                                 args.is_text, 1, 1, args.as_client),
+      .if_callback = args.filter,
+      .on_finished = args.on_finished,
+      .arg = args.arg,
+      .origin = (args.origin ? args.origin->fd : -1),
+      .as_client = args.as_client,
+      .lock = SPN_LOCK_INIT,
+      .count = 1,
+  };
+
+  server_each(multi->origin, WEBSOCKET_ID_STR,
+              (args.filter ? ws_check_multi_write : ws_direct_multi_write),
               multi, ws_finish_multi_write);
+  return 0;
 }

data/ext/iodine/websockets.h

@@ -128,24 +128,44 @@ Performs a task on each websocket connection that shares the same process
 void websocket_each(ws_s *ws_originator,
                     void (*task)(ws_s *ws_target, void *arg), void *arg,
                     void (*on_finish)(ws_s *ws_originator, void *arg));
+
+/**
+The Arguments passed to the `websocket_write_each` function / macro are defined
+here, for convinience of calling the function.
+*/
+struct websocket_write_each_args_s {
+  /** The originating websocket client will be excluded from the `write`.
+    * Can be NULL. */
+  ws_s *origin;
+  /** The data to be written to the websocket - required(!) */
+  void *data;
+  /** The length of the data to be written to the websocket - required(!) */
+  size_t length;
+  /** Text mode vs. binary mode. Defaults to binary mode. */
+  uint8_t is_text;
+  /** Set to 1 to send the data to websockets where this application is the
+   * client. Defaults to 0 (the data is sent to all clients where this
+   * application is the server). */
+  uint8_t as_client;
+  /** A filter callback, allowing us to exclude some clients.
+   * Should return 1 to send data and 0 to exclude. */
+  uint8_t (*filter)(ws_s *ws_to, void *arg);
+  /** A callback called once all the data was sent. */
+  void (*on_finished)(ws_s *ws_to, void *arg);
+  /** A user specified argumernt passed to each of the callbacks. */
+  void *arg;
+};
 /**
 Writes data to each websocket connection that shares the same process
 (except the originating `ws_s` connection which is allowed to be NULL).
 
-If an `if_callback` is provided, the data will be written to the connection only
-if the `if_callback` returns TRUE (a non zero value).
-
-The `as_client` is a boolean value indicating if the data should be masked (sent
-to a server, in client mode) or not. The data will only be sent to the
-connections matching the required state (i.e., if `as_client == 1`, the data
-will only be sent to connections where this process behaves as a websocket
-client). If some data should be sent in client mode and other in server mode,
-than the function must be called twice.
+Accepts a sing `struct websocket_write_each_args_s` argument. See the struct
+details for possible arguments.
  */
-void websocket_write_each(ws_s *ws_originator, void *data, size_t len,
-                          uint8_t is_text, uint8_t as_client,
-                          uint8_t (*if_callback)(ws_s *ws_to, void *arg),
-                          void *arg); /**
+int websocket_write_each(struct websocket_write_each_args_s args);
+#define websocket_write_each(...)                                              \
+  websocket_write_each((struct websocket_write_each_args_s){__VA_ARGS__})
+/**
 Counts the number of websocket connections.
 */
 size_t websocket_count(ws_s *ws);

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.2.13'.freeze
+  VERSION = '0.2.14'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.2.13
+  version: 0.2.14
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-25 00:00:00.000000000 Z
+date: 2017-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack