iodine 0.7.19 → 0.7.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a17af3bcb580a2154bb0114bf9a0e5d8bb7b361a58c217dc4b9aa471cc328401
-  data.tar.gz: 55498d33417433697f9deeb3d864f12af3cccdeb7c7f1a0cec6eb7a83ccc4a84
+  metadata.gz: 69bfcfdbbca3218b3e1865afa22a9ccfcbeb8cbbe5eadacbcac978b3bb11d1ec
+  data.tar.gz: 474d23c9adfd030ef247fb695630ea7a81337170f173aa25ac898689605dcaef
 SHA512:
-  metadata.gz: 3ed48224b228669f024c592708b805a0057ce53e11113693515ba953f6780bf1d8f6aeb448291b9e1c01a7495aa44a4d36fea90303996ff72aa9850a7bead669
-  data.tar.gz: bee740562fe189778db55c83c616db4509a16196abf44a8bf1d135432c0e4b99277fe4c91472a76f265d3d68c70f3ad680c6b54dd0254bd5d455f8f219560d93
+  metadata.gz: b30cb2e9178c39a10458af0368733d2b35dda7f2d5b3a95870ee3147f782a29fd4270358606c7be8459a8924f383bfcb382feb45f58f59bab181fdc158728ca0
+  data.tar.gz: 1ced424fdbc203a0e8efc9739b6a9cd99b3f4bf616f482f677ff9a6c87a336a9c453563d8338f3fc908ed50150699fd1d9bb5a11de4eb69da93869403685791b

data/CHANGELOG.md

@@ -6,6 +6,20 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.20
+
+**Security**: (`fio`) lower Slowloris detection limits (backlog limit is now 1,024 responses / messages per client). 
+
+**Security**: (`http`) HTTP/1.1 slow client throttling - new requests will not be consumed until pending responses were sent. Since HTTP/1.1 is a response-request protocol, this protocol specific approach should protect the HTTP application against slow clients.
+
+**Fix**: (`iodine`) remove redundant Content-Type printout. Credit to @giovannibonetti (Giovanni Bonetti) for exposing the issue (#53).
+
+**Fix**: (`fio`) fix capacity maximization log to accommodate issues where `getrlimit` would return a `rlim_max` that's too high for `rlim_cur` (macOS).
+
+**Fix**: (`fio`) fix uninitialized `kqueue` message in `fio_poll_remove_fd`.
+
+**Fix**: (`docs`) @giovannibonetti (Giovanni Bonetti) fixed an error in the Rails README section, PR #52.
+
 #### Change log v.0.7.19
 
 **Deprecation**: (`iodine`) deprecated the CLI option `-tls-password`, use `-tls-pass` instead.

data/README.md

@@ -40,32 +40,69 @@ Iodine is a C extension for Ruby, developed and optimized for Ruby MRI 2.2.2 and
 
 Iodine includes a light and fast HTTP and Websocket server written in C that was written according to the [Rack interface specifications](http://www.rubydoc.info/github/rack/rack/master/file/SPEC) and the [Websocket draft extension](./SPEC-Websocket-Draft.md).
 
-With `Iodine.listen2http` it's possible to run multiple HTTP applications (please remember not to set more than a single application on a single TCP/IP port). 
+With `Iodine.listen service: :http` it's possible to run multiple HTTP applications (please remember not to set more than a single application on a single TCP/IP port). 
 
 Iodine also supports native process cluster Pub/Sub and a native RedisEngine to easily scale iodine's Pub/Sub horizontally.
 
-### Running the web server
+### Installing and Running Iodine
 
-Using the iodine server is easy, simply add iodine as a gem to your Rack application:
+Install iodine on any Linux / BSD / macOS system using:
+
+```bash
+gem install iodine
+```
+
+Using the iodine server is easy, simply add iodine as a gem to your Rails / Sinatra / Rack application's `Gemfile`:
 
 ```ruby
-gem 'iodine', '~>0.6'
+gem 'iodine', '~>0.7'
+```
+
+Then start your application from the command-line / terminal using iodine:
+
+```bash
+bundler exec iodine
 ```
 
-Iodine will calculate, when possible, a good enough default concurrency model for lightweight applications... this might not fit your application if you use heavier database access or other blocking calls.
+### Running with Rails
+
+On Rails:
+
+1. Replace the `puma` gem with the `iodine` gem.
+
+1. Remove the `config/puma.rb` file (or comment out the code).
+
+1. Optionally, it's possible to add a `config/initializers/iodine.rb` file. For example:
+
+    ```ruby
+    # Iodine setup - use conditional setup to allow command-line arguments to override these:
+    if(defined?(Iodine))
+      Iodine.threads = ENV.fetch("RAILS_MAX_THREADS") { 5 } if Iodine.threads.zero?
+      Iodine.workers = ENV.fetch("WEB_CONCURRENCY") { 2 } if Iodine.workers.zero?
+      Iodine::DEFAULT_SETTINGS[:port] = ENV.fetch("PORT") if ENV.fetch("PORT")
+    end
+    ```
+
+When using native WebSockets with Rails, middle-ware is probably the best approach. A guide for this approach will, hopefully, get published in the future.
+
+### Optimizing Iodine's Concurrency
 
 To get the most out of iodine, consider the amount of CPU cores available and the concurrency level the application requires.
 
-The common model of 16 threads and 4 processes can be easily adopted:
+Iodine will calculate, when possible, a good enough default concurrency model. See if this works for your application or customize according to the application's needs.
+
+Command line arguments allow easy access to different options, including concurrency levels. i.e., to set up 16 threads and 4 processes:
 
 ```bash
 bundler exec iodine -p $PORT -t 16 -w 4
 ```
 
-During development, it's more common to use a single process and a few threads:
+The environment variables `THREADS` and `WORKERS` are automatically recognized when iodine is first required, allowing environment specific customization. i.e.:
 
 ```bash
-bundler exec iodine -p $PORT -t 16 -w 1
+export THREADS=16
+export WORKERS=-1 # negative values are fractions of CPU cores.
+bundler exec iodine -p $PORT
 ```
 
 ### Heap Fragmentation Protection
@@ -92,13 +129,13 @@ This can be done when starting the server from the command line:
 bundler exec iodine -p $PORT -t 16 -w 4 -www /my/public/folder
 ```
 
-Or by adding a single line to the application. i.e. (a `config.ru` example):
+Or using a simple Ruby script. i.e. (a `my_server.rb` example):
 
 ```ruby
 require 'iodine'
 # static file service
-Iodine.listen2http public: '/my/public/folder'
-# for static file service, we only need a single thread per worker.
+Iodine.listen, service: :http, public: '/my/public/folder'
+# for static file service, we only need a single thread and a single worker.
 Iodine.threads = 1
 Iodine.start
 ```
@@ -257,8 +294,8 @@ end
 * Iodine's Redis client does *not* support multiple databases. This is both because [database scoping is ignored by Redis during pub/sub](https://redis.io/topics/pubsub#database-amp-scoping) and because [Redis Cluster doesn't support multiple databases](https://redis.io/topics/cluster-spec). This indicated that multiple database support just isn't worth the extra effort and performance hit.
 
 * The iodine Redis client will use two Redis connections for the whole process cluster (a single publishing connection and a single subscription connection), minimizing the Redis load and network bandwidth.
-* 
-Connections will be automatically re-established if timeouts or errors occur.
+
+* Connections will be automatically re-established if timeouts or errors occur.
 
 ### Hot Restart
 
@@ -436,7 +473,6 @@ When benchmarking using a VM (crossing machine boundaries, single thread, single
 
 * Puma performed at 2,521.56 req/sec, consuming ~27.5Mb of memory.
 
-
 I have doubts about my own benchmarks and I recommend benchmarking the performance for yourself using `wrk` or `ab`:
 
 ```bash

data/ext/iodine/fio.c

@@ -78,7 +78,7 @@ Feel free to copy, use and enjoy according to the license provided.
 
 /* Slowloris mitigation  (must be less than 1<<16) */
 #ifndef FIO_SLOWLORIS_LIMIT
-#define FIO_SLOWLORIS_LIMIT (1 << 12)
+#define FIO_SLOWLORIS_LIMIT (1 << 10)
 #endif
 
 #if !defined(__clang__) && !defined(__GNUC__)
@@ -383,7 +383,7 @@ inline static void protocol_unlock(fio_protocol_s *pr,
 
 /** returns 1 if the UUID is valid and 0 if it isn't. */
 #define uuid_is_valid(uuid)                                                    \
-  ((intptr_t)(uuid) != -1 &&                                                   \
+  ((intptr_t)(uuid) >= 0 &&                                                    \
    ((uint32_t)fio_uuid2fd((uuid))) < fio_data->capa &&                         \
    ((uintptr_t)(uuid)&0xFF) == uuid_data((uuid)).counter)
 
@@ -1620,9 +1620,7 @@ static void fio_poll_init(void) {
   }
   return;
 error:
-#if DEBUB
-  perror("ERROR: (evoid) failed to initialize");
-#endif
+  FIO_LOG_FATAL("couldn't initialize epoll.");
   fio_poll_close();
   exit(errno);
   return;
@@ -1804,13 +1802,12 @@ static inline void fio_poll_add(intptr_t fd) {
 FIO_FUNC inline void fio_poll_remove_fd(intptr_t fd) {
   if (evio_fd < 0)
     return;
-  struct kevent chevent[3];
+  struct kevent chevent[2];
   EV_SET(chevent, fd, EVFILT_READ, EV_DELETE, 0, 0, NULL);
   EV_SET(chevent + 1, fd, EVFILT_WRITE, EV_DELETE, 0, 0, NULL);
-  EV_SET(chevent + 2, fd, EVFILT_TIMER, EV_DELETE, 0, 0, NULL);
   do {
     errno = 0;
-    kevent(evio_fd, chevent, 3, NULL, 0, NULL);
+    kevent(evio_fd, chevent, 2, NULL, 0, NULL);
   } while (errno == EINTR);
 }
 
@@ -1818,7 +1815,7 @@ static size_t fio_poll(void) {
   if (evio_fd < 0)
     return -1;
   int timeout_millisec = fio_timer_calc_first_interval();
-  struct kevent events[FIO_POLL_MAX_EVENTS];
+  struct kevent events[FIO_POLL_MAX_EVENTS] = {{0}};
 
   const struct timespec timeout = {
       .tv_sec = (timeout_millisec / 1000),
@@ -1831,23 +1828,13 @@ static size_t fio_poll(void) {
     for (int i = 0; i < active_count; i++) {
       // test for event(s) type
       if (events[i].filter == EVFILT_WRITE) {
-        // we can only write if there's no error in the socket
         fio_defer_push_urgent(deferred_on_ready,
                               ((void *)fd2uuid(events[i].udata)), NULL);
       } else if (events[i].filter == EVFILT_READ) {
         fio_defer_push_task(deferred_on_data, (void *)fd2uuid(events[i].udata),
                             NULL);
       }
-      // connection errors should be reported after `read` in case there's data
-      // left in the buffer... not that the edge case matters.
       if (events[i].flags & (EV_EOF | EV_ERROR)) {
-        // errors are hendled as disconnections (on_close)
-        // FIO_LOG_DEBUG("%p: %s\n", events[i].udata,
-        //               (events[i].flags & EV_EOF)
-        //                   ? "EV_EOF"
-        //                   : (events[i].flags & EV_ERROR) ? "EV_ERROR" :
-        //                   "WTF?");
-        // uuid_data(events[i].udata).open = 0;
         fio_force_close_in_poll(fd2uuid(events[i].udata));
       }
     }
@@ -1951,7 +1938,7 @@ static inline void fio_poll_remove_write(int fd) {
 /** returns non-zero if events were scheduled, 0 if idle */
 static size_t fio_poll(void) {
   /* shrink fd poll range */
-  size_t end = fio_data->capa;
+  size_t end = fio_data->capa; // max_protocol_fd might break TLS
   size_t start = 0;
   struct pollfd *list = NULL;
   fio_lock(&fio_data->lock);
@@ -2924,15 +2911,10 @@ ssize_t fio_flush(intptr_t uuid) {
   if (fio_trylock(&uuid_data(uuid).sock_lock))
     goto would_block;
 
-  if (uuid_data(uuid).packet_count >= FIO_SLOWLORIS_LIMIT) {
-    /* Slowloris attack assumed */
-    fio_unlock(&uuid_data(uuid).sock_lock);
-    uuid_data(uuid).close = 1;
-    goto closed;
-  }
   if (uuid_data(uuid).packet) {
     tmp = uuid_data(uuid).packet->write_func(fio_uuid2fd(uuid),
                                              uuid_data(uuid).packet);
+    const size_t old_count = uuid_data(uuid).packet_count;
     if (tmp == 0) {
       errno = ECONNRESET;
       fio_unlock(&uuid_data(uuid).sock_lock);
@@ -2941,6 +2923,12 @@ ssize_t fio_flush(intptr_t uuid) {
     } else if (tmp < 0) {
       goto test_errno;
     }
+
+    if (old_count >= 1024 && uuid_data(uuid).packet_count == old_count) {
+      /* Slowloris attack assumed */
+      goto attacked;
+    }
+
   } else {
     flushed = uuid_data(uuid).rw_hooks->flush(uuid, uuid_data(uuid).rw_udata);
     if (flushed < 0) {
@@ -2980,6 +2968,14 @@ flushed:
   touchfd(fio_uuid2fd(uuid));
   fio_unlock(&uuid_data(uuid).sock_lock);
   return 1;
+
+attacked:
+  /* don't close, just detach from facil.io and mark uuid as invalid */
+  FIO_LOG_WARNING("(facil.io) possible Slowloris attack from %.*s",
+                  (int)fio_peer_addr(uuid).len, fio_peer_addr(uuid).data);
+  fio_unlock(&uuid_data(uuid).sock_lock);
+  fio_clear_fd(fio_uuid2fd(uuid), 0);
+  return -1;
 }
 
 /** `fio_flush_all` attempts flush all the open connections. */
@@ -3482,13 +3478,7 @@ static void fio_mem_init(void);
 static void fio_cluster_init(void);
 static void fio_pubsub_initialize(void);
 static void __attribute__((constructor)) fio_lib_init(void) {
-  /* initialize memory allocator */
-  fio_mem_init();
-  /* initialize polling engine */
-  fio_poll_init();
-  /* initialize the cluster engine */
-  fio_pubsub_initialize();
-  /* detect socket capacity */
+  /* detect socket capacity - MUST be first...*/
   ssize_t capa = 0;
   {
 #ifdef _SC_OPEN_MAX
@@ -3499,22 +3489,27 @@ static void __attribute__((constructor)) fio_lib_init(void) {
     // try to maximize limits - collect max and set to max
     struct rlimit rlim = {.rlim_max = 0};
     if (getrlimit(RLIMIT_NOFILE, &rlim) == -1) {
-      FIO_LOG_WARNING("`getrlimit` failed in `sock_max_capacity`.");
+      FIO_LOG_WARNING("`getrlimit` failed in `fio_lib_init`.");
+      perror("\terrno:");
     } else {
-      // #if defined(__APPLE__) /* Apple's getrlimit is broken. */
-      //     rlim.rlim_cur = rlim.rlim_max >= FOPEN_MAX ? FOPEN_MAX :
-      //     rlim.rlim_max;
-      // #else
+      rlim_t original = rlim.rlim_cur;
       rlim.rlim_cur = rlim.rlim_max;
-      // #endif
-
-      if (rlim.rlim_cur > FIO_MAX_SOCK_CAPACITY)
-        rlim.rlim_cur = FIO_MAX_SOCK_CAPACITY;
-
-      if (!setrlimit(RLIMIT_NOFILE, &rlim))
-        getrlimit(RLIMIT_NOFILE, &rlim);
+      if (rlim.rlim_cur > FIO_MAX_SOCK_CAPACITY) {
+        rlim.rlim_cur = rlim.rlim_max = FIO_MAX_SOCK_CAPACITY;
+      }
+      while (setrlimit(RLIMIT_NOFILE, &rlim) == -1 && rlim.rlim_cur > original)
+        --rlim.rlim_cur;
+      getrlimit(RLIMIT_NOFILE, &rlim);
       capa = rlim.rlim_cur;
+      if (capa > 1024) /* leave a slice of room */
+        capa -= 16;
     }
+    /* initialize memory allocator */
+    fio_mem_init();
+    /* initialize polling engine */
+    fio_poll_init();
+    /* initialize the cluster engine */
+    fio_pubsub_initialize();
 #if DEBUG
 #if FIO_ENGINE_POLL
     FIO_LOG_STATE("facil.io " FIO_VERSION_STRING " capacity initialization:\n"
@@ -10544,10 +10539,6 @@ Poll (not kqueue or epoll) tests
 FIO_FUNC void fio_poll_test(void) {
   fprintf(stderr, "=== Testing poll add / remove fd\n");
   fio_poll_add(5);
-  FIO_ASSERT(fio_data->start == 5,
-             "fio_poll_add didn't update start position (%u)", fio_data->start);
-  FIO_ASSERT(fio_data->end == 6, "fio_poll_add didn't update end position (%u)",
-             fio_data->end);
   FIO_ASSERT(fio_data->poll[5].fd == 5, "fio_poll_add didn't set used fd data");
   FIO_ASSERT(fio_data->poll[5].events ==
                  (FIO_POLL_READ_EVENTS | FIO_POLL_WRITE_EVENTS),
@@ -10578,9 +10569,6 @@ FIO_FUNC void fio_poll_test(void) {
              "fio_poll_remove (both) didn't reset unused fd data");
   FIO_ASSERT(fio_data->poll[7].events == 0,
              "fio_poll_remove (both) didn't reset unused fd flags");
-  FIO_ASSERT(fio_data->end == 6,
-             "fio_poll_remove (both) didn't update end position (%u)",
-             fio_data->end);
   fio_poll_remove_fd(5);
   fprintf(stderr, "\n* passed.\n");
 }

data/ext/iodine/http1.c

@@ -666,16 +666,22 @@ static int http1_on_body_chunk(http1_parser_s *parser, char *data,
 
 /** called when a protocol error occurred. */
 static int http1_on_error(http1_parser_s *parser) {
+  FIO_LOG_DEBUG("HTTP parser error.");
   fio_close(parser2http(parser)->p.uuid);
   return -1;
 }
 
 /* *****************************************************************************
 Connection Callbacks
-*****************************************************************************
-*/
+***************************************************************************** */
 
 static inline void http1_consume_data(intptr_t uuid, http1pr_s *p) {
+  if (fio_pending(uuid) > 4) { /* throttle busy clients (slowloris) */
+    fio_suspend(uuid);
+    FIO_LOG_DEBUG("(HTTP/1,1) throttling client at %.*s",
+                  (int)fio_peer_addr(uuid).len, fio_peer_addr(uuid).data);
+    return;
+  }
   ssize_t i = 0;
   size_t org_len = p->buf_len;
   int pipeline_limit = 8;
@@ -739,6 +745,13 @@ static void http1_on_close(intptr_t uuid, fio_protocol_s *protocol) {
   (void)uuid;
 }
 
+/** called when the connection was closed, but will not run concurrently */
+static void http1_on_ready(intptr_t uuid, fio_protocol_s *protocol) {
+  /* resume slow clients from suspension */
+  fio_force_event(uuid, FIO_EVENT_ON_DATA);
+  (void)protocol;
+}
+
 /** called when a data is available for the first time */
 static void http1_on_data_first_time(intptr_t uuid, fio_protocol_s *protocol) {
   http1pr_s *p = (http1pr_s *)protocol;
@@ -764,8 +777,7 @@ static void http1_on_data_first_time(intptr_t uuid, fio_protocol_s *protocol) {
 
 /* *****************************************************************************
 Public API
-*****************************************************************************
-*/
+***************************************************************************** */
 
 /** Creates an HTTP1 protocol object and handles any unread data in the buffer
  * (if any). */
@@ -781,6 +793,7 @@ fio_protocol_s *http1_new(uintptr_t uuid, http_settings_s *settings,
           {
               .on_data = http1_on_data_first_time,
               .on_close = http1_on_close,
+              .on_ready = http1_on_ready,
           },
       .p.uuid = uuid,
       .p.settings = settings,

data/ext/iodine/iodine.c

@@ -375,6 +375,8 @@ static VALUE iodine_cli_parse(VALUE self) {
       FIO_CLI_PRINT_HEADER("Concurrency:"),
       FIO_CLI_INT("-workers -w number of processes to use."),
       FIO_CLI_INT("-threads -t number of threads per process."),
+      FIO_CLI_PRINT("Negative concurrency values "
+                    "map to fractions of available CPU cores."),
       FIO_CLI_PRINT_HEADER("HTTP Settings:"),
       FIO_CLI_STRING("-public -www public folder, for static file service."),
       FIO_CLI_BOOL("-log -v HTTP request logging."),
@@ -396,7 +398,8 @@ static VALUE iodine_cli_parse(VALUE self) {
       FIO_CLI_STRING(
           "-tls-pass -tls-password the password (if any) protecting the "
           "private key file."),
-      FIO_CLI_PRINT("\t\t-tls-password is deprecated, use -tls-pass"),
+      FIO_CLI_PRINT("\t\t\x1B[1m-tls-password\x1B[0m is deprecated, use "
+                    "\x1B[1m-tls-pass\x1B[0m"),
       FIO_CLI_PRINT_HEADER("Connecting Iodine to Redis:"),
       FIO_CLI_STRING(
           "-redis -r an optional Redis URL server address. Default: none."),
@@ -922,7 +925,7 @@ Supported Settigs:
 | `:url` | URL indicating service type, host name and port. Path will be parsed as a Unix socket. |
 | `:handler` | (deprecated: `:app`) see details below. |
 | `:address` | an IP address or a unix socket address. Only relevant if `:url` is missing. |
-| `:log` |  (HTTP only) request logging. |
+| `:log` |  (HTTP only) request logging. For global verbosity see {Iodine.verbosity} |
 | `:max_body` | (HTTP only) maximum upload size allowed per request before disconnection (in Mb). |
 | `:max_headers` |  (HTTP only) maximum total header length allowed per request (in Kb). |
 | `:max_msg` |  (WebSockets only) maximum message size pre message (in Kb). |

data/ext/iodine/iodine_http.c

@@ -398,7 +398,6 @@ static inline VALUE copy2env(iodine_http_request_handle_s *handle) {
     if (ct) {
       tmp = fiobj_obj2cstr(ct);
       if (tmp.len && tmp.data) {
-        fprintf(stderr, "Content type: %s\n", tmp.data);
         rb_hash_aset(env, CONTENT_TYPE,
                      rb_enc_str_new(tmp.data, tmp.len, IodineBinaryEncoding));
         fiobj_hash_delete2(h->headers, content_type_hash);
@@ -519,8 +518,7 @@ static VALUE for_each_body_string(VALUE str, VALUE body_) {
   // fprintf(stderr, "For_each - body\n");
   // write body
   if (TYPE(str) != T_STRING) {
-    fprintf(stderr, "Iodine Server Error:"
-                    "response body was not a String\n");
+    FIO_LOG_ERROR("(Iodine) response body not a String\n");
     return Qfalse;
   }
   if (RSTRING_LEN(str) && RSTRING_PTR(str)) {

data/ext/iodine/websocket_parser.h

@@ -373,8 +373,7 @@ static uint64_t websocket_client_wrap(void *target, void *msg, uint64_t len,
 
 /* *****************************************************************************
 Message unwrapping
-*****************************************************************************
-*/
+***************************************************************************** */
 
 /**
  * Returns all known information regarding the upcoming message.

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.7.19'.freeze
+  VERSION = '0.7.20'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.7.19
+  version: 0.7.20
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-27 00:00:00.000000000 Z
+date: 2019-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -220,7 +220,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 'Thank you for installing Iodine 0.7.19.
+post_install_message: 'Thank you for installing Iodine 0.7.20.
 
 '
 rdoc_options: []