iodine 0.7.37 → 0.7.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d09283cad97b84847493794f2245f7b477b6f0170a8332112c3836106d660373
-  data.tar.gz: 3727db00462421260d06689ac5c578cda9203d2dc2c3d4daed53b4f9dc6b84f5
+  metadata.gz: 698e63218598fd769063529e151ab15aab31e413365a6e80130e464adac9eea3
+  data.tar.gz: d4b146805592a1ef5476461c349eeb31069a3213af7257caeaaccbd91b6f1929
 SHA512:
-  metadata.gz: db93d224de064141cf4a422e05bba2e67c74ef0344dfce19579be48489cc16b070e24527e30aa4c081f9c38ca4aeb2c737f90d1edd8d157cf0d334b5f083965e
-  data.tar.gz: 8b6e496da5af91bf59225798c41d00776caafb3aec55a57c5ee43a1ca943a0312e676e119a9a41387c4beba5350d0f71c1ec70868d29933be6b140ac1d814b64
+  metadata.gz: bc9d26dacd98d979d1e110eaa4c7ac04451c8332658a7be2004bd54b9d9f94adf1e55f2ee5407fd2e9f0c27295f32f9f40c3667ae42cee5fb6f76bd1a3000b8c
+  data.tar.gz: 224db61d880f272de498cd766d40e9641ade6fceb7c0626ba88a5cca3244561b542f846df8102a22dcb48b88b2bc2f4943a6b30d102391c36f3dde7f3ff8b9af

data/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,47 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+### System Information
+
+ - **OS**:             [e.g. macOS 10.14.6]
+ - **Ruby**:         [e.g. 2.6.1]
+ - **Version**:     [e.g. 0.7.37]
+ - **OpenSSL**:  [OpenSSL 1.1.1d 10 Sep 2019]
+
+### Description
+
+A clear and concise description of what the bug is.
+
+### Rack App to Reproduce
+
+```ruby
+APP = {|env| [200, {}, "Hello World"] }
+run APP
+```
+
+### Testing code
+
+```sh
+curl http://localhost:3000/
+```
+
+### Expected behavior
+
+A clear and concise description of what you expected to happen.
+
+### Actual behavior
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.

data/.travis.yml

@@ -6,9 +6,9 @@ before_install:
   - gem install bundler -v 1.10.6
   - bundle install
 rvm:
-  - 2.6.0
-  - 2.5.3
-  - 2.4.5
+  - 2.6.5
+  - 2.5.7
+  - 2.4.9
   - 2.3.8
   - 2.2.2
 notifications:
@@ -24,7 +24,8 @@ addons:
 script:
   - echo CFLAGS = $CFLAGS
   - echo cflags = $cflags
-  - bundle exec rake compile && bundle exec rspec --format documentation
+  - bundle exec rake compile
+  - env VERBOSE=1 bundle exec rspec --format documentation
   - gem uninstall -x iodine
   - rake build
   - find pkg/iodine-*.gem -exec gem install -V {} +

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.38
+
+**Fix**: (`http`) fixes an issue and improves support for chunked encoded payloads. Credit to Ian Ker-Seymer ( @ianks ) for exposing this, writing tests and opening both the issue #87 and the PR #88.
+
 #### Change log v.0.7.37
 
 **Fix**: requests will fail when the path contains a dangling `?` (empty query). Credit to @adam12 for exposing this and opening issue #86.

data/examples/shootout.ru

@@ -22,6 +22,14 @@ module ShootoutApp
       len += out[-1].length
       request.params.each { |k,v| out << "#{k}: #{v}\n" ; len += out[-1].length }
     end
+    if(env['rack.input'])
+      env['rack.input'].rewind
+      out << "Body\n\n"
+      out << env['rack.input'].read
+      len += out[-1].length + 6
+      out << "\n\nBody Length: #{out[-1].length}\n\n"
+      len += out[-1].length
+    end
     [200, { 'Content-Length' => len.to_s, 'Content-Type' => 'text/plain; charset=UTF-8;' }, out]
   end
   # We'll base the shootout on the internal Pub/Sub service.

data/ext/iodine/fio.h

@@ -109,7 +109,7 @@ Version and helper macros
 
 #define FIO_VERSION_MAJOR 0
 #define FIO_VERSION_MINOR 7
-#define FIO_VERSION_PATCH 3
+#define FIO_VERSION_PATCH 4
 #define FIO_VERSION_BETA 0
 
 /* Automatically convert version data to a string constant - ignore these two */

data/ext/iodine/http1_parser.c

@@ -22,6 +22,10 @@ Seeking for characters in a string
 #define ALLOW_UNALIGNED_MEMORY_ACCESS 0
 #endif
 
+#ifndef HTTP_ADD_CONTENT_LENGTH_HEADER_IF_MISSING
+#define HTTP_ADD_CONTENT_LENGTH_HEADER_IF_MISSING 1
+#endif
+
 #if FIO_MEMCHAR
 
 /**
@@ -31,6 +35,9 @@ Seeking for characters in a string
  */
 static int seek2ch(uint8_t **buffer, register uint8_t *const limit,
                    const uint8_t c) {
+  if (*buffer >= limit)
+    return 0;
+
   if (**buffer == c) {
 #if HTTP1_PARSER_CONVERT_EOL2NUL
     **buffer = 0;
@@ -47,8 +54,6 @@ static int seek2ch(uint8_t **buffer, register uint8_t *const limit,
   {
     const uint8_t *alignment =
         (uint8_t *)(((uintptr_t)(*buffer) & (~(uintptr_t)7)) + 8);
-    if (*buffer < alignment)
-      *buffer += 1; /* already tested this char */
     if (limit >= alignment) {
       while (*buffer < alignment) {
         if (**buffer == c) {
@@ -94,7 +99,9 @@ finish:
 /* a helper that seeks any char, converts it to NUL and returns 1 if found. */
 inline static uint8_t seek2ch(uint8_t **pos, uint8_t *const limit, uint8_t ch) {
   /* This is library based alternative that is sometimes slower  */
-  if (*pos >= limit || **pos == ch) {
+  if (*pos >= limit)
+    return 0;
+  if (**pos == ch) {
     return 1;
   }
   uint8_t *tmp = memchr(*pos, ch, limit - (*pos));
@@ -125,6 +132,66 @@ inline static uint8_t seek2eol(uint8_t **pos, uint8_t *const limit) {
   return 1;
 }
 
+/* *****************************************************************************
+String to Number
+***************************************************************************** */
+
+/** Converts a String to a number using base 10 */
+static long long http1_atol(const uint8_t *buf, const uint8_t **end) {
+  register unsigned long long i = 0;
+  uint8_t inv = 0;
+  while (*buf == ' ' || *buf == '\t' || *buf == '\f')
+    ++buf;
+  while (*buf == '-' || *buf == '+')
+    inv ^= (*(buf++) == '-');
+  while (i <= ((((~0ULL) >> 1) / 10)) && *buf >= '0' && *buf <= '9') {
+    i = i * 10;
+    i += *buf - '0';
+    ++buf;
+  }
+  /* test for overflow */
+  if (i >= (~((~0ULL) >> 1)) || (*buf >= '0' && *buf <= '9'))
+    i = (~0ULL >> 1);
+  if (inv)
+    i = 0ULL - i;
+  if (end)
+    *end = buf;
+  return i;
+}
+
+/** Converts a String to a number using base 16, overflow limited to 113bytes */
+static long long http1_atol16(const uint8_t *buf, const uint8_t **end) {
+  register unsigned long long i = 0;
+  uint8_t inv = 0;
+  for (int limit_ = 0;
+       (*buf == ' ' || *buf == '\t' || *buf == '\f') && limit_ < 32; ++limit_)
+    ++buf;
+  for (int limit_ = 0; (*buf == '-' || *buf == '+') && limit_ < 32; ++limit_)
+    inv ^= (*(buf++) == '-');
+  if (*buf == '0')
+    ++buf;
+  if ((*buf | 32) == 'x')
+    ++buf;
+  for (int limit_ = 0; (*buf == '0') && limit_ < 32; ++limit_)
+    ++buf;
+  while (!(i & (~((~(0ULL)) >> 4)))) {
+    if (*buf >= '0' && *buf <= '9') {
+      i <<= 4;
+      i |= *buf - '0';
+    } else if ((*buf | 32) >= 'a' && (*buf | 32) <= 'f') {
+      i <<= 4;
+      i |= (*buf | 32) - ('a' - 10);
+    } else
+      break;
+    ++buf;
+  }
+  if (inv)
+    i = 0ULL - i;
+  if (end)
+    *end = buf;
+  return i;
+}
+
 /* *****************************************************************************
 HTTP/1.1 parsre stages
 ***************************************************************************** */
@@ -224,43 +291,113 @@ inline static int consume_header(struct http1_fio_parser_args_s *args,
   if (start_value[0] == ' ') {
     start_value++;
   };
-#if ALLOW_UNALIGNED_MEMORY_ACCESS && HTTP_HEADERS_LOWERCASE
-  /* enable this section to test unaligned memory access */
+
   if ((end_name - start) == 14 &&
+#if HTTP1_UNALIGNED_MEMORY_ACCESS_ENABLED && HTTP_HEADERS_LOWERCASE
       *((uint64_t *)start) == *((uint64_t *)"content-") &&
-      *((uint64_t *)(start + 6)) == *((uint64_t *)"t-length")) {
+      *((uint64_t *)(start + 6)) == *((uint64_t *)"t-length")
+#else
+      HEADER_NAME_IS_EQ((char *)start, "content-length", 14)
+#endif
+  ) {
     /* handle the special `content-length` header */
-    args->parser->state.content_length = atol((char *)start_value);
-  } else if ((end_name - start) == 17 &&
+    args->parser->state.content_length = http1_atol(start_value, NULL);
+  } else if ((end_name - start) == 17 && (end - start_value) >= 7 &&
+#if HTTP1_UNALIGNED_MEMORY_ACCESS_ENABLED && HTTP_HEADERS_LOWERCASE
              *((uint64_t *)start) == *((uint64_t *)"transfer") &&
-             *((uint64_t *)(start + 8)) == *((uint64_t *)"-encodin") &&
-             *((uint32_t *)start_value) == *((uint32_t *)"chun") &&
-             *((uint32_t *)(start_value + 3)) == *((uint32_t *)"nked")) {
-    /* handle the special `transfer-encoding: chunked` header */
-    args->parser->state.reserved |= 64;
-  } else if ((end_name - start) == 7 &&
-             *((uint64_t *)start) == *((uint64_t *)"trailer")) {
-    /* chunked data with trailer... */
-    args->parser->state.reserved |= 64;
-    args->parser->state.reserved |= 32;
-  }
+             *((uint64_t *)(start + 8)) == *((uint64_t *)"-encodin")
 #else
-  if ((end_name - start) == 14 &&
-      HEADER_NAME_IS_EQ((char *)start, "content-length", 14)) {
-    /* handle the special `content-length` header */
-    args->parser->state.content_length = atol((char *)start_value);
-  } else if ((end_name - start) == 17 &&
-             HEADER_NAME_IS_EQ((char *)start, "transfer-encoding", 17) &&
-             memcmp(start_value, "chunked", 7)) {
-    /* handle the special `transfer-encoding: chunked` header */
-    args->parser->state.reserved |= 64;
+             HEADER_NAME_IS_EQ((char *)start, "transfer-encoding", 17)
+#endif
+  ) {
+    /* handle the special `transfer-encoding: chunked` header? */
+    /* this removes the `chunked` marker and "unchunks" the data */
+    if (
+#if HTTP1_UNALIGNED_MEMORY_ACCESS_ENABLED
+        (((uint32_t *)(start_value))[0] | 0x20202020) ==
+            ((uint32_t *)"chun")[0] &&
+        (((uint32_t *)(start_value + 3))[0] | 0x20202020) ==
+            ((uint32_t *)"nked")[0]
+#else
+        ((start_value[0] | 32) == 'c' && (start_value[1] | 32) == 'h' &&
+         (start_value[2] | 32) == 'u' && (start_value[3] | 32) == 'n' &&
+         (start_value[4] | 32) == 'k' && (start_value[5] | 32) == 'e' &&
+         (start_value[6] | 32) == 'd')
+#endif
+    ) {
+      /* simple case,`chunked` at the beginning */
+      args->parser->state.reserved |= 64;
+      start_value += 7;
+      while (start_value < end && (*start_value == ',' || *start_value == ' '))
+        ++start_value;
+      if (!(end - start_value))
+        return 0;
+    } else if ((end - start_value) > 7 &&
+               ((end[(-7 + 0)] | 32) == 'c' && (end[(-7 + 1)] | 32) == 'h' &&
+                (end[(-7 + 2)] | 32) == 'u' && (end[(-7 + 3)] | 32) == 'n' &&
+                (end[(-7 + 4)] | 32) == 'k' && (end[(-7 + 5)] | 32) == 'e' &&
+                (end[(-7 + 6)] | 32) == 'd')) {
+      /* simple case,`chunked` at the end of list */
+      args->parser->state.reserved |= 64;
+      end -= 7;
+      while (start_value < end && (end[-1] == ',' || end[-1] == ' '))
+        --end;
+      if (!(end - start_value))
+        return 0;
+    } else if ((end - start_value) > 7 && (end - start_value) < 256) {
+      /* complex case, `the, chunked, marker, is in the middle of list */
+      uint8_t val[256];
+      size_t val_len = 0;
+      while (start_value < end) {
+        if (
+#if HTTP1_UNALIGNED_MEMORY_ACCESS_ENABLED
+            (((uint32_t *)(start_value))[0] | 0x20202020) ==
+                ((uint32_t *)"chun")[0] &&
+            (((uint32_t *)(start_value + 3))[0] | 0x20202020) ==
+                ((uint32_t *)"nked")[0]
+#else
+            ((start_value[0] | 32) == 'c' && (start_value[1] | 32) == 'h' &&
+             (start_value[2] | 32) == 'u' && (start_value[3] | 32) == 'n' &&
+             (start_value[4] | 32) == 'k' && (start_value[5] | 32) == 'e' &&
+             (start_value[6] | 32) == 'd')
+#endif
+
+        ) {
+          args->parser->state.reserved |= 64;
+          start_value += 7;
+          /* skip comma / white space */
+          while (start_value < end &&
+                 (*start_value == ',' || *start_value == ' '))
+            ++start_value;
+          break;
+        }
+        val[val_len++] = *start_value;
+        ++start_value;
+      }
+      while (start_value < end) {
+        val[val_len++] = *start_value;
+        ++start_value;
+      }
+      /* perform callback with `val` */
+      val[val_len] = 0;
+      if (val_len && args->on_header(args->parser, (char *)start,
+                                     (end_name - start), (char *)val, val_len))
+        return -1;
+      return 0;
+    }
   } else if ((end_name - start) == 7 &&
-             HEADER_NAME_IS_EQ((char *)start, "trailer", 7)) {
+#if HTTP1_UNALIGNED_MEMORY_ACCESS_ENABLED && HTTP_HEADERS_LOWERCASE
+             *((uint64_t *)start) == *((uint64_t *)"trailer")
+#else
+             HEADER_NAME_IS_EQ((char *)start, "trailer", 7)
+#endif
+  ) {
     /* chunked data with trailer... */
     args->parser->state.reserved |= 64;
     args->parser->state.reserved |= 32;
+    // return 0; /* hide Trailer header, since we process the headers? */
   }
-#endif
+
   /* perform callback */
   if (args->on_header(args->parser, (char *)start, (end_name - start),
                       (char *)start_value, end - start_value))
@@ -295,27 +432,46 @@ inline static int consume_body_chunked(struct http1_fio_parser_args_s *args,
   uint8_t *end = *start;
   while (*start < stop) {
     if (args->parser->state.content_length == 0) {
-      size_t eol_len;
-      /* consume seperator */
-      while (*start < stop && (**start == '\n' || **start == '\r'))
-        ++(*start);
-      /* collect chunked length */
-      if (!(eol_len = seek2eol(&end, stop))) {
-        /* requires length data to continue */
+      if (end + 2 >= stop)
         return 0;
+      if ((end[0] == '\r' && end[1] == '\n')) {
+        /* remove tailing EOL that wasn't processed and retest */
+        end += 2;
+        *start = end;
+        if (end + 2 >= stop)
+          return 0;
       }
-      /* an empty EOL is possible in mid stream processing */
-      if (*start + eol_len > end && (*start = end) && !seek2eol(&end, stop)) {
+      long long chunk_len = http1_atol16(end, (const uint8_t **)&end);
+      if (end + 2 > stop) /* overflowed? */
         return 0;
-      }
-      args->parser->state.content_length = 0 - strtol((char *)*start, NULL, 16);
-      *start = end = end + 1;
+      if ((end[0] != '\r' || end[1] != '\n'))
+        return -1; /* required EOL after content length */
+      end += 2;
+
+      args->parser->state.content_length = 0 - chunk_len;
+      *start = end;
       if (args->parser->state.content_length == 0) {
-        /* all chunked data was parsed */
+        /* all chunked data was parsed - update content-length */
         args->parser->state.content_length = args->parser->state.read;
         /* consume trailing EOL */
-        if (seek2eol(start, stop))
-          (*start)++;
+        if (*start + 2 <= stop)
+          *start += 2;
+#ifdef HTTP_ADD_CONTENT_LENGTH_HEADER_IF_MISSING
+        { /* add virtual header ... ? */
+          char buf[512];
+          size_t buf_len = 512;
+          size_t tmp_len = args->parser->state.read;
+          buf[--buf_len] = 0;
+          while (tmp_len) {
+            size_t mod = tmp_len / 10;
+            buf[--buf_len] = '0' + (tmp_len - (mod * 10));
+            tmp_len = mod;
+          }
+          if (args->on_header(args->parser, "content-length", 14,
+                              (char *)buf + buf_len, 511 - buf_len))
+            return -1;
+        }
+#endif
         if (args->parser->state.reserved & 32) {
           /* remove the "headers complete" and "trailer" flags */
           args->parser->state.reserved &= 0xDD; /* 0xDD == ~2 & ~32 & 0xFF */

data/ext/iodine/iodine_http.c

@@ -28,6 +28,8 @@ typedef struct {
 } iodine_http_settings_s;
 
 /* these three are used also by iodin_rack_io.c */
+VALUE IODINE_R_INPUT_DEFAULT;
+VALUE IODINE_R_INPUT;
 VALUE IODINE_R_HIJACK;
 VALUE IODINE_R_HIJACK_IO;
 VALUE IODINE_R_HIJACK_CB;
@@ -846,6 +848,7 @@ static void initialize_env_template(void) {
     }
     add_str_to_env(env_template_no_upgrade, "SCRIPT_NAME", sn);
   }
+  rb_hash_aset(env_template_no_upgrade, IODINE_R_INPUT, IODINE_R_INPUT_DEFAULT);
   add_value_to_env(env_template_no_upgrade, "rack.errors", rb_stderr);
   add_value_to_env(env_template_no_upgrade, "rack.hijack?", Qtrue);
   add_value_to_env(env_template_no_upgrade, "rack.multiprocess", Qtrue);
@@ -1111,6 +1114,7 @@ void iodine_init_http(void) {
   rack_set(XSENDFILE_TYPE_HEADER, "HTTP_X_SENDFILE_TYPE");
   rack_set(CONTENT_LENGTH_HEADER, "Content-Length");
 
+  rack_set(IODINE_R_INPUT, "rack.input");
   rack_set(IODINE_R_HIJACK_IO, "rack.hijack_io");
   rack_set(IODINE_R_HIJACK, "rack.hijack");
   rack_set(IODINE_R_HIJACK_CB, "iodine.hijack_cb");
@@ -1132,5 +1136,12 @@ void iodine_init_http(void) {
   IodineUTF8Encoding = rb_enc_find("UTF-8");
   IodineBinaryEncoding = rb_enc_find("binary");
 
+  {
+    VALUE STRIO_CLASS = rb_const_get(rb_cObject, rb_intern("StringIO"));
+    IODINE_R_INPUT_DEFAULT = rb_str_new_static("", 0);
+    IODINE_R_INPUT_DEFAULT =
+        rb_funcallv(STRIO_CLASS, rb_intern("new"), 1, &IODINE_R_INPUT_DEFAULT);
+    rb_global_variable(&IODINE_R_INPUT_DEFAULT);
+  }
   initialize_env_template();
 }

data/ext/iodine/iodine_http.h

@@ -9,6 +9,8 @@ Feel free to copy, use and enjoy according to the license provided.
 #include "iodine.h"
 
 /* these three are used also by rb-rack-io.c */
+extern VALUE IODINE_R_INPUT;
+extern VALUE IODINE_R_INPUT_DEFAULT;
 extern VALUE IODINE_R_HIJACK;
 extern VALUE IODINE_R_HIJACK_IO;
 extern VALUE IODINE_R_HIJACK_CB;

data/ext/iodine/iodine_rack_io.c

@@ -216,7 +216,7 @@ static VALUE new_rack_io(http_s *h, VALUE env) {
   rb_ivar_set(rack_io, io_id, ULL2NUM(h->body));
   set_handle(rack_io, h);
   rb_ivar_set(rack_io, env_id, env);
-  rb_hash_aset(env, R_INPUT, rack_io);
+  rb_hash_aset(env, IODINE_R_INPUT, rack_io);
   rb_hash_aset(env, IODINE_R_HIJACK, rb_obj_method(rack_io, hijack_func_sym));
   return rack_io;
 }
@@ -240,10 +240,6 @@ static void init_rack_io(void) {
   iodine_new_func_id = rb_intern("new");
   hijack_func_sym = ID2SYM(rb_intern("_hijack"));
 
-  R_INPUT = rb_enc_str_new("rack.input", 10, rb_ascii8bit_encoding());
-  rb_obj_freeze(R_INPUT);
-  IodineStore.add(R_INPUT);
-
   TCPSOCKET_CLASS = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
   // IO methods
 

data/iodine.gemspec

@@ -33,7 +33,7 @@ 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 required for Rack 2.'
+  spec.requirements << 'Ruby >= 2.3.8 (Ruby EOL).'
   spec.requirements << 'Ruby >= 2.5.0 recommended.'
   spec.requirements << 'TLS requires OpenSSL >= 1.1.0'
 

data/lib/iodine.rb

@@ -1,3 +1,4 @@
+require 'stringio' # Used internally as a default RackIO
 require 'socket'  # TCPSocket is used internally for Hijack support
 # require 'openssl' # For SSL/TLS support using OpenSSL
 

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.7.37'.freeze
+  VERSION = '0.7.38'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.7.37
+  version: 0.7.38
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-11-13 00:00:00.000000000 Z
+date: 2019-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -121,6 +121,7 @@ extensions:
 - ext/iodine/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/ISSUE_TEMPLATE/bug_report.md"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -243,7 +244,7 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
 post_install_message: |-
-  Thank you for installing Iodine 0.7.37.
+  Thank you for installing Iodine 0.7.38.
   Remember: if iodine supports your business, it's only fair to give value back (code contributions / donations).
 rdoc_options: []
 require_paths:
@@ -262,7 +263,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - 'A Unix based system: Linux / macOS / BSD.'
 - An updated C compiler.
-- Ruby >= 2.2.2 required for Rack 2.
+- Ruby >= 2.3.8 (Ruby EOL).
 - Ruby >= 2.5.0 recommended.
 - TLS requires OpenSSL >= 1.1.0
 rubygems_version: 3.0.1