iodine 0.2.12 → 0.2.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f452e7b373f6e571cfde2d15c813a2b56b68b7ec
-  data.tar.gz: ae82d8b0e5a8e89a341e94ad8fa64f4bdcbe2bab
+  metadata.gz: dc27a8990d89bbb19294133f6ec8178d2a586ea2
+  data.tar.gz: 8e9ec06545307abd666902d434438679e5bdd7ad
 SHA512:
-  metadata.gz: e10f6de46108d5282babbbbde57f24889def07db0807cdc5674257881c6082ec219107d44f7c25c1523bb9365386ae5b188129ef4cf410d49c9ab62dacb255bf
-  data.tar.gz: 5f9dddd11aaad923cedb1151902fc92398e863a281360873642594dd77dd6fbb844f9c1498ff0a6d622cc69de6b857b370b7eab35c2de672f51e6acd47098fc5
+  metadata.gz: a25fe9b7584dbeba407d55c1f150fdfab048fb7892a46ec32777d55b38ab3742faf0f7a972c118d3d6f26804380825324ff6f4b2665f91c56b0cb44f7f6c5ae6
+  data.tar.gz: b0e1ca2d60baae702e1f953cd6b9e13566168ae4fe989e1d31e6e0fd37cbbfc8bf3c3dfcf1e4e83049e09c45ca369c9efd08779965562b17cd576308925573e7

data/.travis.yml

@@ -5,7 +5,7 @@ os:
 before_install:
   - gem install bundler -v 1.10.6
 rvm:
-  - ruby-2.4.0-rc1
+  - 2.4.0
   - 2.3.1
   - 2.3.0
   - 2.2.4

data/CHANGELOG.md

@@ -8,9 +8,17 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ***
 
+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.
+
+**Credit**: credit to Elia Schito (@elia) and Augusts Bautra (@Epigene) for fixing parts of the documentation (PR #11 , #12).
+
+***
+
 Change log v.0.2.12
 
-**Fix** removed `mempool` after it failed some stress and concurrency tests.
+**Fix**: removed `mempool` after it failed some stress and concurrency tests.
 
 ***
 

data/README.md

@@ -45,9 +45,10 @@ Puma's model of 16 threads and 4 processes is easily adopted and proved to provi
 bundler exec iodine -p $PORT -t 16 -w 4
 ```
 
-It should be noted that automatic process scaling will cause issues with Websocket broadcast (`each`) support, ssince the `Websocket#each` method will be limited to the calling process (other clients might be connected to a different process.
+It should be noted that automatic process scaling will cause issues with Websocket broadcast (`each`) support, since the `Websocket#each` method will be limited to the calling process (other clients might be connected to a different process).
 
-I recommended that you consider using Redis to scale Websocket "events" across processes / machines. look into [plezi.io](http://www.plezi.io) for automatic Websocket scaling with Redis and Iodine.
+It is recommended that you consider using Redis to scale Websocket "events" across processes / machines.  
+Look into [plezi.io](http://www.plezi.io) for automatic Websocket scaling with Redis and Iodine.
 
 ### Writing data to the network layer
 
@@ -55,7 +56,7 @@ Iodine allows Ruby to write strings to the network layer. This includes HTTP and
 
 Iodine will handle an internal buffer (~4 to ~16 Mb, version depending) so that `write` can return immediately (non-blocking).
 
-However, when the buffer is full, `write` will block until enough space in he buffer becomes available. Sending up to 16Kb of data (a single buffer "packet") is optimal. Sending a larger response might effect concurrency. Best Websocket response length is ~1Kb (1 TCP / IP packet) and allows for faster transmissions.
+However, when the buffer is full, `write` will block until enough space in the buffer becomes available. Sending up to 16Kb of data (a single buffer "packet") is optimal. Sending a larger response might effect concurrency. Best Websocket response length is ~1Kb (1 TCP / IP packet) and allows for faster transmissions.
 
 When using the Iodine's web server (`Iodine::Rack`), the static file service offered by Iodine streams files (instead of using the buffer). Every file response will require up to 2 buffer "packets" (~32Kb), one for the header and the other for file streaming.
 
@@ -155,7 +156,7 @@ Iodine.start
 
 #### TCP/IP (raw) sockets
 
-Upgrading to a custom protocol (i.e., in order to implement your own Websocket protocol with special extensions) is performed almost the ame way, using `env['upgrade.tcp']`. In the following (terminal) example, we'll use an echo server without (direct socket echo):
+Upgrading to a custom protocol (i.e., in order to implement your own Websocket protocol with special extensions) is performed almost the same way, using `env['upgrade.tcp']`. In the following (terminal) example, we'll use an echo server without direct socket echo:
 
 ```ruby
 require 'iodine'
@@ -180,7 +181,7 @@ Iodine.start
 
 #### A few notes
 
-This design has a number of benefits, some of them related to better IO handling, resource optimization (no need for two IO polling systems) etc'. This also allows us to use middleware without interfering with connection upgrades and provides up with backwards compatibility.
+This design has a number of benefits, some of them related to better IO handling, resource optimization (no need for two IO polling systems), etc. This also allows us to use middleware without interfering with connection upgrades and provides  backwards compatibility.
 
 Iodine::Rack imposes a few restrictions for performance and security reasons, such as that the headers (both sending and receiving) must be less than 8Kb in size. These restrictions shouldn't be an issue and are similar to limitations imposed by Apache.
 
@@ -270,7 +271,7 @@ Review the `iodine -?` help for more data.
 
 Remember to compare the memory footprint after running some requests - it's not just speed that C is helping with, it's also memory management and object pooling (i.e., Iodine uses a buffer packet pool management).
 
-## Can I try before before I buy?
+## Can I try before I buy?
 
 Well, it is **free** and **open source**, no need to buy.. and of course you can try it out.
 
@@ -280,9 +281,9 @@ It's installable just like any other gem on MRI, run:
 $ gem install iodine
 ```
 
-If building the native C extension fails, please notice that some Ruby installations, such as on Ubuntu, require that you separately install the development headers (`ruby.h` and friends). I have no idea why they do that, as you will need the development headers for any native gems you want to install - so hurry up and get it.
+If building the native C extension fails, please note that some Ruby installations, such as on Ubuntu, require that you separately install the development headers (`ruby.h` and friends). I have no idea why they do that, as you will need the development headers for any native gems you want to install - so hurry up and get them.
 
-If you have the development headers but still can't compile the Iodine extension, [open an issue](https://github.com/boazsegev/iodine/issues) with any messages you're getting and I be happy to look into it.
+If you have the development headers but still can't compile the Iodine extension, [open an issue](https://github.com/boazsegev/iodine/issues) with any messages you're getting and I'll be happy to look into it.
 
 ## Mr. Sandman, write me a server
 
@@ -370,7 +371,7 @@ Here's a few things you can use from this project and they seem to be handy to h
 
     Some people use global Ruby arrays, adding and removing Ruby objects to the array, but that sounds like a performance hog to me.
 
-    This one is a simple binary tree with a Ruby GC callback. Remember to initialize the Registry (`Registry.init(owner)`) so it's "owned" by some Roby-land object, this allows it to bridge the two worlds for the GC's mark and sweep.
+    This one is a simple binary tree with a Ruby GC callback. Remember to initialize the Registry (`Registry.init(owner)`) so it's "owned" by some Ruby-land object, this allows it to bridge the two worlds for the GC's mark and sweep.
 
     I'm attaching it to one of Iodine's library classes, just in-case someone adopts my code and decides the registry should be owned by the global Object class.
 

data/bin/ws-echo

@@ -111,3 +111,5 @@ Iodine.start
 #   ws.onclose = function(e) {console.log("closed")};
 #   ws.onopen = function(e) {e.target.send("hi");};
 # };
+# ws = new WebSocket("ws://localhost:3000"); ws.onmessage = function(e) {console.log("Got message " + e.data.length + " bytes long"); for(var i = 0; i < e.data.length ; i += 4) {if (e.data.slice(i, i+4) != "text") {console.log( "incoming message corrupted? ", e.data.slice(i, i+4) ); return;};}; }; ws.onclose = function(e) {console.log("closed")}; ws.onopen = function(e) {ws.send("hi");};
+# str = "text"; function size_test() { if(ws.readyState != 1) return; if(str.length > 4194304) {console.log("str reached 4MiB!"); str = "test"; return;}; ws.send(str); str = str + str; window.setTimeout(size_test, 150); }; size_test();

data/ext/iodine/websockets.c

@@ -41,7 +41,7 @@ struct buffer_s resize_ws_buffer(ws_s *owner, struct buffer_s);
 void free_ws_buffer(ws_s *owner, struct buffer_s);
 
 /** Sets the initial buffer size. (4Kb)*/
-#define WS_INITIAL_BUFFER_SIZE 4096
+#define WS_INITIAL_BUFFER_SIZE 4096UL
 
 /*******************************************************************************
 Buffer management - simple implementation...
@@ -65,6 +65,7 @@ struct buffer_s resize_ws_buffer(ws_s *owner, struct buffer_s buff) {
   void *tmp = realloc(buff.data, buff.size);
   if (!tmp) {
     free_ws_buffer(owner, buff);
+    buff.data = NULL;
     buff.size = 0;
   }
   buff.data = tmp;
@@ -110,12 +111,11 @@ struct Websocket {
   struct {
     union {
       unsigned len1 : 16;
-      unsigned long len2 : 64;
+      unsigned long long len2 : 64;
       char bytes[8];
     } psize;
     size_t length;
     size_t received;
-    int data_len;
     char mask[4];
     struct {
       unsigned op_code : 4;
@@ -133,8 +133,9 @@ struct Websocket {
       unsigned at_mask : 2;
       unsigned has_len : 1;
       unsigned at_len : 3;
-      unsigned client : 1;
+      unsigned has_head : 1;
     } state;
+    unsigned client : 1;
   } parser;
 };
 
@@ -146,9 +147,10 @@ char *WEBSOCKET_ID_STR = "websockets";
 /**
 A thread localized buffer used for reading and parsing data from the socket.
 */
+#define WEBSOCKET_READ_MAX 4096
 static __thread struct {
   int pos;
-  char buffer[1024];
+  char buffer[WEBSOCKET_READ_MAX];
 } read_buffer;
 
 /*******************************************************************************
@@ -200,12 +202,15 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
   if (ws == NULL || ws->protocol.service != WEBSOCKET_ID_STR)
     return;
   ssize_t len = 0;
-  while ((len = sock_read(sockfd, read_buffer.buffer, 1024)) > 0) {
-    ws->parser.data_len = 0;
+  ssize_t data_len = 0;
+  while ((len = sock_read(sockfd, read_buffer.buffer, WEBSOCKET_READ_MAX)) >
+         0) {
+    data_len = 0;
     read_buffer.pos = 0;
     while (read_buffer.pos < len) {
       // collect the frame's head
-      if (!(*(char *)(&ws->parser.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))) {
@@ -218,18 +223,24 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
       }
 
       // save the mask and size information
-      if (!(*(char *)(&ws->parser.sdata))) {
+      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;
+        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.sdata.size >= 126 && !(ws->parser.state.has_len)) {
+      if (!ws->parser.state.has_len) {
       // avoiding a loop so we don't mixup the meaning of "continue" and
       // "break"
       collect_len:
@@ -264,10 +275,16 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
             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;
-      } else if (!ws->parser.length && ws->parser.sdata.size < 126)
-        // we should have the length data in the head
-        ws->parser.length = ws->parser.sdata.size;
+      }
 
       // 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)) {
@@ -294,35 +311,29 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
       // Now that we know everything about the frame, let's collect the data
 
       // How much data in the buffer is part of the frame?
-      ws->parser.data_len = len - read_buffer.pos;
-      if (ws->parser.data_len + ws->parser.received > ws->parser.length)
-        ws->parser.data_len = ws->parser.length - ws->parser.received;
+      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 < ws->parser.data_len; i++) {
+        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.state.client == 0) {
+      } 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 (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))) {
-        // check message size limit
-        if (ws->max_msg_size < ws->length + ws->parser.data_len) {
-          // close connection!
-          fprintf(stderr, "ERROR Websocket: Payload too big, review limits.\n");
-          sock_close(sockfd);
-          return;
-        }
+      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) {
@@ -335,42 +346,37 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
         }
         // copy here
         memcpy((uint8_t *)ws->buffer.data + ws->length,
-               read_buffer.buffer + read_buffer.pos, ws->parser.data_len);
-        ws->length += ws->parser.data_len;
+               read_buffer.buffer + read_buffer.pos, data_len);
+        ws->length += data_len;
       }
       // set the frame's data received so far (copied or not)
-      // we couldn't do it soonet, because we needed the value to compute the
-      // Ruby buffer capacity (within the GVL resize function).
-      ws->parser.received += ws->parser.data_len;
+      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 += ws->parser.data_len;
+        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-Ruby handled messages.
+      // 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 */
-        if (ws->parser.head.fin) {
-          /* This was the last frame */
-          if (ws->parser.head2.op_code == 1) {
-            /* text data */
-          } else if (ws->parser.head2.op_code == 2) {
-            /* binary data */
-          } else // not a recognized frame, don't act
-            goto reset_parser;
-          // call the on_message callback
-
-          if (ws->on_message)
-            ws->on_message(ws, ws->buffer.data, ws->length,
-                           ws->parser.head2.op_code == 1);
-          goto reset_parser;
+        /* 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) {
-        /* close */
+        /* op-code == close */
         websocket_close(ws);
         if (ws->parser.head2.op_code == ws->parser.head.op_code)
           goto reset_parser;
@@ -378,8 +384,7 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
         /* ping */
         // write Pong - including ping data...
         websocket_write_impl(sockfd, read_buffer.buffer + read_buffer.pos,
-                             ws->parser.data_len, 10, 1, 1,
-                             ws->parser.state.client);
+                             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) {
@@ -393,26 +398,34 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
           goto reset_parser;
       } else {
         /* WTF? */
-        if (ws->parser.head.fin)
-          goto reset_parser;
+        // 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;
       }
-      // not done, but move the pos marker along
-      read_buffer.pos += ws->parser.data_len;
-      continue;
 
     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 += ws->parser.data_len;
-      // clear the parser
-      *((char *)(&(ws->parser.state))) = *((char *)(&(ws->parser.sdata))) =
-          *((char *)(&(ws->parser.head2))) = *((char *)(&(ws->parser.head))) =
-              0;
-      // // // the above should be the same as... but it isn't
-      // *((uint32_t*)(&(ws->parser.head))) = 0;
-      // set the union size to 0
-      ws->length = ws->parser.received = ws->parser.length =
-          ws->parser.psize.len2 = ws->parser.data_len = 0;
+      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;
     }
   }
 #undef ws
@@ -733,8 +746,7 @@ void *websocket_set_udata(ws_s *ws, void *udata) {
 /** Writes data to the websocket. Returns -1 on failure (0 on success). */
 int websocket_write(ws_s *ws, void *data, size_t size, uint8_t is_text) {
   if (sock_isvalid(ws->fd)) {
-    websocket_write_impl(ws->fd, data, size, is_text, 1, 1,
-                         ws->parser.state.client);
+    websocket_write_impl(ws->fd, data, size, is_text, 1, 1, ws->parser.client);
     return 0;
   }
   return -1;
@@ -809,6 +821,7 @@ struct websocket_multi_write {
   spn_lock_i lock;
   size_t count;
   size_t length;
+  uint8_t as_client;
   uint8_t buffer[];
 };
 
@@ -832,7 +845,8 @@ static void ws_finish_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
 
 static void ws_direct_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
   struct websocket_multi_write *multi = arg;
-  (void)(_ws);
+  if (((ws_s *)(_ws))->parser.client != multi->as_client)
+    return;
 
   sock_packet_s *packet = sock_checkout_packet();
   *packet = (sock_packet_s){
@@ -852,6 +866,8 @@ static void ws_direct_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
 
 static void ws_check_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
   struct websocket_multi_write *multi = arg;
+  if (((ws_s *)(_ws))->parser.client != multi->as_client)
+    return;
   if (multi->if_callback((void *)_ws, multi->arg))
     ws_direct_multi_write(fd, _ws, arg);
 }
@@ -868,6 +884,7 @@ void websocket_write_each(ws_s *ws_originator, void *data, size_t len,
   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),
               multi, ws_finish_multi_write);

data/ext/iodine/websockets.h

@@ -136,9 +136,11 @@ 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. If some data should be sent in client mode
-and other in server mode, consider using the `if_callback` to make sure the data
-is encoded properly.
+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.
  */
 void websocket_write_each(ws_s *ws_originator, void *data, size_t len,
                           uint8_t is_text, uint8_t as_client,

data/iodine.gemspec

@@ -36,8 +36,8 @@ Gem::Specification.new do |spec|
 
   spec.requirements << 'A Unix based system: Linux / macOS / BSD.'
   spec.requirements << 'An updated C compiler.'
-  spec.requirements << 'Ruby >= 2.2.2'
-  spec.requirements << 'Ruby >= 2.3.0 is recommended.'
+  spec.requirements << 'Ruby >= 2.2.2 required for Rack.'
+  spec.requirements << 'Ruby >= 2.3.0 recommended.'
 
   spec.add_development_dependency 'bundler', '~> 1.10'
   spec.add_development_dependency 'rake', '~> 12.0'

data/lib/iodine/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.2.12
+  version: 0.2.13
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-21 00:00:00.000000000 Z
+date: 2017-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -199,8 +199,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - 'A Unix based system: Linux / macOS / BSD.'
 - An updated C compiler.
-- Ruby >= 2.2.2
-- Ruby >= 2.3.0 is recommended.
+- Ruby >= 2.2.2 required for Rack.
+- Ruby >= 2.3.0 recommended.
 rubyforge_project: 
 rubygems_version: 2.6.8
 signing_key: