iodine 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 375dff05d190f0bd67e614a7e17ca4f260e94931
-  data.tar.gz: 40214b68ddd02635863435bd25aa513165815733
+  metadata.gz: 56640878e0c4cc4794f8cf3747a398a51847b0ae
+  data.tar.gz: 0c58b292c6002ea03e068eba06f5aa75c449d236
 SHA512:
-  metadata.gz: 7d65d83cb40603cb233af7be43ed1eed8151dc3530acf850b112583a06e77c026c9415e70ad4daeffe8c513a5164cdb2eddead101d35c08c2ffb60cbcae69d8a
-  data.tar.gz: 1910c42c7e776bd60cb564df4a09f7235a002833420cc81bcc5b17d14e3b70b7f78eaa685fbcd85058e552c249ae767bec7d3caf00478fa30979b1b146746ccb
+  metadata.gz: 193156a5098163d096af9c182ed20b7a6977234575d4fd49a81ba07d1f44dc677f8772bd6c873f79f0466b28037290463d070473eb057e4c522127e0a51d5e8a
+  data.tar.gz: ab58390cfd148cd7fa481cec9f3db47ccbe64188e993e9c34baaaab2b0eaaf51cb65c459d6a9ec0ee1315a0dcf0536d8931b72aae0d1fd2c0dd743216788aab0

data/CHANGELOG.md

@@ -6,6 +6,15 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+***
+
+#### Change log v.0.4.3
+
+This release is a ghost hunt release, attempting to find an issue noticed only during when deploying in the Heroku production environment.
+
+**Fix**: fixed a possible issue in fragmented pipelined Websocket messages. This
+
+
 ***
 
 #### Change log v.0.4.2

data/ext/iodine/facil.c

@@ -170,6 +170,24 @@ void evio_on_close(void *arg) { sock_force_close((intptr_t)arg); }
 void evio_on_error(void *arg) { sock_force_close((intptr_t)arg); }
 void evio_on_data(void *arg) { defer(deferred_on_data, arg, NULL); }
 
+/* *****************************************************************************
+Forcing IO events
+***************************************************************************** */
+
+void facil_force_event(intptr_t uuid, enum facil_io_event ev) {
+  switch (ev) {
+  case FIO_EVENT_ON_DATA:
+    evio_on_data((void *)uuid);
+    break;
+  case FIO_EVENT_ON_TIMEOUT:
+    defer(deferred_ping, (void *)uuid, NULL);
+    break;
+  case FIO_EVENT_ON_READY:
+    evio_on_ready((void *)uuid);
+    break;
+  }
+}
+
 /* *****************************************************************************
 Socket callbacks
 ***************************************************************************** */

data/ext/iodine/facil.h

@@ -303,6 +303,14 @@ void facil_set_timeout(intptr_t uuid, uint8_t timeout);
 /** Gets a timeout for a specific connection. Returns 0 if none. */
 uint8_t facil_get_timeout(intptr_t uuid);
 
+enum facil_io_event {
+  FIO_EVENT_ON_DATA,
+  FIO_EVENT_ON_READY,
+  FIO_EVENT_ON_TIMEOUT,
+};
+/** Schedules an IO event, even id it did not occur. */
+void facil_force_event(intptr_t uuid, enum facil_io_event);
+
 /* *****************************************************************************
 Helper API
 ***************************************************************************** */

data/ext/iodine/sock.c

@@ -1041,7 +1041,7 @@ after all the data was sent. This is a "busy" wait, polling isn't performed.
 */
 void sock_flush_strong(intptr_t uuid) {
   errno = 0;
-  while (sock_flush(uuid) == 0 && !errno)
+  while (sock_flush(uuid) == 0 && errno == 0)
     ;
 }
 /**

data/ext/iodine/websockets.c

@@ -246,245 +246,231 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
     return;
   ssize_t len = 0;
   ssize_t data_len = 0;
-  if (ws->resume_from) {
-    sock_touch(sockfd);
-    len = ws->resume_from;
-    ws->resume_from = 0;
-    goto resume_parsing;
-  }
-  while ((len = sock_read(sockfd, read_buffer.buffer, WEBSOCKET_READ_MAX)) >
-         0) {
-  resume_parsing:
-    data_len = 0;
-    read_buffer.pos = 0;
-    while (read_buffer.pos < len) {
-      // collect the frame's head
-      if (!ws->parser.state.has_head) {
-        ws->parser.state.has_head = 1;
-        *((char *)(&(ws->parser.head))) = read_buffer.buffer[read_buffer.pos];
-        // save a copy if it's the first head in a fragmented message
-        if (!(*(char *)(&ws->parser.head2))) {
-          ws->parser.head2 = ws->parser.head;
-        }
-        // advance
-        read_buffer.pos++;
-        // go back to the `while` head, to review if there's more data
-        continue;
+  if ((len = sock_read(sockfd, read_buffer.buffer, WEBSOCKET_READ_MAX)) <= 0)
+    return;
+  data_len = 0;
+  read_buffer.pos = 0;
+  while (read_buffer.pos < len) {
+    // collect the frame's head
+    if (!ws->parser.state.has_head) {
+      ws->parser.state.has_head = 1;
+      *((char *)(&(ws->parser.head))) = read_buffer.buffer[read_buffer.pos];
+      // save a copy if it's the first head in a fragmented message
+      if (!(*(char *)(&ws->parser.head2))) {
+        ws->parser.head2 = ws->parser.head;
       }
+      // advance
+      read_buffer.pos++;
+      // go back to the `while` head, to review if there's more data
+      continue;
+    }
 
-      // save the mask and size information
-      if (!ws->parser.state.at_len && !ws->parser.state.has_len) {
-        // uint8_t tmp = ws->parser.sdata.masked;
-        *((char *)(&(ws->parser.sdata))) = read_buffer.buffer[read_buffer.pos];
-        // ws->parser.sdata.masked |= tmp;
-        // set length
-        ws->parser.state.at_len = (ws->parser.sdata.size == 127
-                                       ? 7
-                                       : ws->parser.sdata.size == 126 ? 1 : 0);
-        if (!ws->parser.state.at_len) {
-          ws->parser.length = ws->parser.sdata.size;
-          ws->parser.state.has_len = 1;
-        }
-        read_buffer.pos++;
-        continue;
+    // save the mask and size information
+    if (!ws->parser.state.at_len && !ws->parser.state.has_len) {
+      // uint8_t tmp = ws->parser.sdata.masked;
+      *((char *)(&(ws->parser.sdata))) = read_buffer.buffer[read_buffer.pos];
+      // ws->parser.sdata.masked |= tmp;
+      // set length
+      ws->parser.state.at_len =
+          (ws->parser.sdata.size == 127 ? 7
+                                        : ws->parser.sdata.size == 126 ? 1 : 0);
+      if (!ws->parser.state.at_len) {
+        ws->parser.length = ws->parser.sdata.size;
+        ws->parser.state.has_len = 1;
       }
+      read_buffer.pos++;
+      continue;
+    }
 
-      // check that if we need to collect the length data
-      if (!ws->parser.state.has_len) {
-      // avoiding a loop so we don't mixup the meaning of "continue" and
-      // "break"
-      collect_len:
+    // check that if we need to collect the length data
+    if (!ws->parser.state.has_len) {
+    // avoiding a loop so we don't mixup the meaning of "continue" and
+    // "break"
+    collect_len:
 ////////// NOTICE: Network Byte Order requires us to translate the data
 #ifdef __BIG_ENDIAN__
-        if ((ws->parser.state.at_len == 1 && ws->parser.sdata.size == 126) ||
-            (ws->parser.state.at_len == 7 && ws->parser.sdata.size == 127)) {
-          ws->parser.psize.bytes[ws->parser.state.at_len] =
-              read_buffer.buffer[read_buffer.pos++];
-          ws->parser.state.has_len = 1;
-          ws->parser.length = (ws->parser.sdata.size == 126)
-                                  ? ws->parser.psize.len1
-                                  : ws->parser.psize.len2;
-        } else {
-          ws->parser.psize.bytes[ws->parser.state.at_len++] =
-              read_buffer.buffer[read_buffer.pos++];
-          if (read_buffer.pos < len)
-            goto collect_len;
-        }
+      if ((ws->parser.state.at_len == 1 && ws->parser.sdata.size == 126) ||
+          (ws->parser.state.at_len == 7 && ws->parser.sdata.size == 127)) {
+        ws->parser.psize.bytes[ws->parser.state.at_len] =
+            read_buffer.buffer[read_buffer.pos++];
+        ws->parser.state.has_len = 1;
+        ws->parser.length = (ws->parser.sdata.size == 126)
+                                ? ws->parser.psize.len1
+                                : ws->parser.psize.len2;
+      } else {
+        ws->parser.psize.bytes[ws->parser.state.at_len++] =
+            read_buffer.buffer[read_buffer.pos++];
+        if (read_buffer.pos < len)
+          goto collect_len;
+      }
 #else
-        if (ws->parser.state.at_len == 0) {
-          ws->parser.psize.bytes[ws->parser.state.at_len] =
-              read_buffer.buffer[read_buffer.pos++];
-          ws->parser.state.has_len = 1;
-          ws->parser.length = (ws->parser.sdata.size == 126)
-                                  ? ws->parser.psize.len1
-                                  : ws->parser.psize.len2;
-        } else {
-          ws->parser.psize.bytes[ws->parser.state.at_len--] =
-              read_buffer.buffer[read_buffer.pos++];
-          if (read_buffer.pos < len)
-            goto collect_len;
-        }
+      if (ws->parser.state.at_len == 0) {
+        ws->parser.psize.bytes[ws->parser.state.at_len] =
+            read_buffer.buffer[read_buffer.pos++];
+        ws->parser.state.has_len = 1;
+        ws->parser.length = (ws->parser.sdata.size == 126)
+                                ? ws->parser.psize.len1
+                                : ws->parser.psize.len2;
+      } else {
+        ws->parser.psize.bytes[ws->parser.state.at_len--] =
+            read_buffer.buffer[read_buffer.pos++];
+        if (read_buffer.pos < len)
+          goto collect_len;
+      }
 #endif
-        // check message size limit
-        if (ws->max_msg_size <
-            ws->length + (ws->parser.length - ws->parser.received)) {
-          // close connection!
-          fprintf(stderr, "ERROR Websocket: Payload too big, review limits.\n");
-          sock_close(sockfd);
-          return;
-        }
-        continue;
+      // check message size limit
+      if (ws->max_msg_size <
+          ws->length + (ws->parser.length - ws->parser.received)) {
+        // close connection!
+        fprintf(stderr, "ERROR Websocket: Payload too big, review limits.\n");
+        sock_close(sockfd);
+        return;
       }
+      continue;
+    }
 
-      // check that the data is masked and that we didn't colleced the mask yet
-      if (ws->parser.sdata.masked && !(ws->parser.state.has_mask)) {
-      // avoiding a loop so we don't mixup the meaning of "continue" and "break"
-      collect_mask:
-        if (ws->parser.state.at_mask == 3) {
-          ws->parser.mask[ws->parser.state.at_mask] =
-              read_buffer.buffer[read_buffer.pos++];
-          ws->parser.state.has_mask = 1;
-          ws->parser.state.at_mask = 0;
-        } else {
-          ws->parser.mask[ws->parser.state.at_mask++] =
-              read_buffer.buffer[read_buffer.pos++];
-          if (read_buffer.pos < len)
-            goto collect_mask;
-          else
-            continue;
-        }
-        // since it's possible that there's no more data (0 length frame),
-        // we don't use `continue` (check while loop) and we process what we
-        // have.
+    // check that the data is masked and that we didn't colleced the mask yet
+    if (ws->parser.sdata.masked && !(ws->parser.state.has_mask)) {
+    // avoiding a loop so we don't mixup the meaning of "continue" and "break"
+    collect_mask:
+      if (ws->parser.state.at_mask == 3) {
+        ws->parser.mask[ws->parser.state.at_mask] =
+            read_buffer.buffer[read_buffer.pos++];
+        ws->parser.state.has_mask = 1;
+        ws->parser.state.at_mask = 0;
+      } else {
+        ws->parser.mask[ws->parser.state.at_mask++] =
+            read_buffer.buffer[read_buffer.pos++];
+        if (read_buffer.pos < len)
+          goto collect_mask;
+        else
+          continue;
       }
+      // since it's possible that there's no more data (0 length frame),
+      // we don't use `continue` (check while loop) and we process what we
+      // have.
+    }
 
-      // Now that we know everything about the frame, let's collect the data
+    // Now that we know everything about the frame, let's collect the data
 
-      // How much data in the buffer is part of the frame?
-      data_len = len - read_buffer.pos;
-      if (data_len + ws->parser.received > ws->parser.length)
-        data_len = ws->parser.length - ws->parser.received;
+    // How much data in the buffer is part of the frame?
+    data_len = len - read_buffer.pos;
+    if (data_len + ws->parser.received > ws->parser.length)
+      data_len = ws->parser.length - ws->parser.received;
 
-      // a note about unmasking: since ws->parser.state.at_mask is only 2 bits,
-      // it will wrap around (i.e. 3++ == 0), so no modulus is required :-)
-      // unmask:
-      if (ws->parser.sdata.masked) {
-        for (int i = 0; i < data_len; i++) {
-          read_buffer.buffer[i + read_buffer.pos] ^=
-              ws->parser.mask[ws->parser.state.at_mask++];
-        }
-      } else if (ws->parser.client == 0) {
-        // enforce masking unless acting as client, also for security reasons...
-        fprintf(stderr, "ERROR Websockets: unmasked frame, disconnecting.\n");
-        sock_close(sockfd);
-        return;
+    // a note about unmasking: since ws->parser.state.at_mask is only 2 bits,
+    // it will wrap around (i.e. 3++ == 0), so no modulus is required :-)
+    // unmask:
+    if (ws->parser.sdata.masked) {
+      for (int i = 0; i < data_len; i++) {
+        read_buffer.buffer[i + read_buffer.pos] ^=
+            ws->parser.mask[ws->parser.state.at_mask++];
       }
-      // Copy the data to the Websocket buffer - only if it's a user message
-      if (data_len &&
-          (ws->parser.head.op_code == 1 || ws->parser.head.op_code == 2 ||
-           (!ws->parser.head.op_code && (ws->parser.head2.op_code == 1 ||
-                                         ws->parser.head2.op_code == 2)))) {
-        // review and resize the buffer's capacity - it can only grow.
-        if (ws->length + ws->parser.length - ws->parser.received >
-            ws->buffer.size) {
-          ws->buffer = resize_ws_buffer(ws, ws->buffer);
-          if (!ws->buffer.data) {
-            // no memory.
-            websocket_close(ws);
-            return;
-          }
-        }
-        // copy here
-        memcpy((uint8_t *)ws->buffer.data + ws->length,
-               read_buffer.buffer + read_buffer.pos, data_len);
-        ws->length += data_len;
-      }
-      // set the frame's data received so far (copied or not)
-      ws->parser.received += data_len;
-
-      // check that we have collected the whole of the frame.
-      if (ws->parser.length > ws->parser.received) {
-        read_buffer.pos += data_len;
-        // fprintf(stderr, "%p websocket has %lu out of %lu\n", (void *)ws,
-        //         ws->parser.received, ws->parser.length);
-        continue;
-      }
-
-      // we have the whole frame, time to process the data.
-      // pings, pongs and other non-user messages are handled independently.
-      if (ws->parser.head.op_code == 0 || ws->parser.head.op_code == 1 ||
-          ws->parser.head.op_code == 2) {
-        /* a user data frame - make sure we got the `fin` flag, or an error
-         * occured */
-        if (!ws->parser.head.fin) {
-          /* This frame was a partial message. */
-          goto reset_state;
+    } else if (ws->parser.client == 0) {
+      // enforce masking unless acting as client, also for security reasons...
+      fprintf(stderr, "ERROR Websockets: unmasked frame, disconnecting.\n");
+      sock_close(sockfd);
+      return;
+    }
+    // Copy the data to the Websocket buffer - only if it's a user message
+    if (data_len &&
+        (ws->parser.head.op_code == 1 || ws->parser.head.op_code == 2 ||
+         (!ws->parser.head.op_code &&
+          (ws->parser.head2.op_code == 1 || ws->parser.head2.op_code == 2)))) {
+      // review and resize the buffer's capacity - it can only grow.
+      if (ws->length + ws->parser.length - ws->parser.received >
+          ws->buffer.size) {
+        ws->buffer = resize_ws_buffer(ws, ws->buffer);
+        if (!ws->buffer.data) {
+          // no memory.
+          websocket_close(ws);
+          return;
         }
-        /* This was the last frame */
-        if (ws->on_message) /* call the on_message callback */
-          ws->on_message(ws, ws->buffer.data, ws->length,
-                         ws->parser.head2.op_code == 1);
-        goto reset_parser;
-      } else if (ws->parser.head.op_code == 8) {
-        /* op-code == close */
-        websocket_close(ws);
-        if (ws->parser.head2.op_code == ws->parser.head.op_code)
-          goto reset_parser;
-      } else if (ws->parser.head.op_code == 9) {
-        /* ping */
-        // write Pong - including ping data...
-        websocket_write_impl(sockfd, read_buffer.buffer + read_buffer.pos,
-                             data_len, 10, 1, 1, ws->parser.client);
-        if (ws->parser.head2.op_code == ws->parser.head.op_code)
-          goto reset_parser;
-      } else if (ws->parser.head.op_code == 10) {
-        /* pong */
-        // do nothing... almost
-        if (ws->parser.head2.op_code == ws->parser.head.op_code)
-          goto reset_parser;
-      } else if (ws->parser.head.op_code > 2 && ws->parser.head.op_code < 8) {
-        /* future control frames. ignore. */
-        if (ws->parser.head2.op_code == ws->parser.head.op_code)
-          goto reset_parser;
-      } else {
-        /* WTF? */
-        // fprintf(stderr, "%p websocket reached a WTF?! state..."
-        //                 "op1: %i , op2: %i\n",
-        //         (void *)ws, ws->parser.head.op_code,
-        //         ws->parser.head2.op_code);
-        fprintf(stderr, "ERROR Websockets: protocol error, disconnecting.\n");
-        sock_close(sockfd);
-        return;
       }
+      // copy here
+      memcpy((uint8_t *)ws->buffer.data + ws->length,
+             read_buffer.buffer + read_buffer.pos, data_len);
+      ws->length += data_len;
+    }
+    // set the frame's data received so far (copied or not)
+    ws->parser.received += data_len;
 
-    reset_parser:
-      ws->length = 0;
-      // clear the parser's multi-frame state
-      *((char *)(&(ws->parser.head2))) = 0;
-      ws->parser.sdata.masked = 0;
-    reset_state:
-      // move the pos marker along - in case we have more then one frame in the
-      // buffer
+    // check that we have collected the whole of the frame.
+    if (ws->parser.length > ws->parser.received) {
       read_buffer.pos += data_len;
-      // reset parser state
-      ws->parser.state.has_len = 0;
-      ws->parser.state.at_len = 0;
-      ws->parser.state.has_mask = 0;
-      ws->parser.state.at_mask = 0;
-      ws->parser.state.has_head = 0;
-      ws->parser.sdata.size = 0;
-      *((char *)(&(ws->parser.head))) = 0;
-      ws->parser.received = ws->parser.length = ws->parser.psize.len2 =
-          data_len = 0;
-      if (read_buffer.pos < len) {
-        /* we just finished an on_message callback, let's fragment the event. */
-        ws->resume_from = len;
-        facil_defer(.task = on_data_def, .task_type = FIO_PR_LOCK_TASK,
-                    .uuid = sockfd);
-        return;
+      // fprintf(stderr, "%p websocket has %lu out of %lu\n", (void *)ws,
+      //         ws->parser.received, ws->parser.length);
+      continue;
+    }
+
+    // we have the whole frame, time to process the data.
+    // pings, pongs and other non-user messages are handled independently.
+    if (ws->parser.head.op_code == 0 || ws->parser.head.op_code == 1 ||
+        ws->parser.head.op_code == 2) {
+      /* a user data frame - make sure we got the `fin` flag, or an error
+       * occured */
+      if (!ws->parser.head.fin) {
+        /* This frame was a partial message. */
+        goto reset_state;
       }
+      /* This was the last frame */
+      if (ws->on_message) /* call the on_message callback */
+        ws->on_message(ws, ws->buffer.data, ws->length,
+                       ws->parser.head2.op_code == 1);
+      goto reset_parser;
+    } else if (ws->parser.head.op_code == 8) {
+      /* op-code == close */
+      websocket_close(ws);
+      if (ws->parser.head2.op_code == ws->parser.head.op_code)
+        goto reset_parser;
+    } else if (ws->parser.head.op_code == 9) {
+      /* ping */
+      // write Pong - including ping data...
+      websocket_write_impl(sockfd, read_buffer.buffer + read_buffer.pos,
+                           data_len, 10, 1, 1, ws->parser.client);
+      if (ws->parser.head2.op_code == ws->parser.head.op_code)
+        goto reset_parser;
+    } else if (ws->parser.head.op_code == 10) {
+      /* pong */
+      // do nothing... almost
+      if (ws->parser.head2.op_code == ws->parser.head.op_code)
+        goto reset_parser;
+    } else if (ws->parser.head.op_code > 2 && ws->parser.head.op_code < 8) {
+      /* future control frames. ignore. */
+      if (ws->parser.head2.op_code == ws->parser.head.op_code)
+        goto reset_parser;
+    } else {
+      /* WTF? */
+      // fprintf(stderr, "%p websocket reached a WTF?! state..."
+      //                 "op1: %i , op2: %i\n",
+      //         (void *)ws, ws->parser.head.op_code,
+      //         ws->parser.head2.op_code);
+      fprintf(stderr, "ERROR Websockets: protocol error, disconnecting.\n");
+      sock_close(sockfd);
+      return;
     }
+
+  reset_parser:
+    ws->length = 0;
+    // clear the parser's multi-frame state
+    *((char *)(&(ws->parser.head2))) = 0;
+    ws->parser.sdata.masked = 0;
+  reset_state:
+    // move the pos marker along - in case we have more then one frame in the
+    // buffer
+    read_buffer.pos += data_len;
+    // reset parser state
+    ws->parser.state.has_len = 0;
+    ws->parser.state.at_len = 0;
+    ws->parser.state.has_mask = 0;
+    ws->parser.state.at_mask = 0;
+    ws->parser.state.has_head = 0;
+    ws->parser.sdata.size = 0;
+    *((char *)(&(ws->parser.head))) = 0;
+    ws->parser.received = ws->parser.length = ws->parser.psize.len2 = data_len =
+        0;
   }
+  facil_force_event(sockfd, FIO_EVENT_ON_DATA);
 #undef ws
 }
 

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.4.2'.freeze
+  VERSION = '0.4.3'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Boaz Segev