iodine 0.7.37 → 0.7.42

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d09283cad97b84847493794f2245f7b477b6f0170a8332112c3836106d660373
-  data.tar.gz: 3727db00462421260d06689ac5c578cda9203d2dc2c3d4daed53b4f9dc6b84f5
+  metadata.gz: a3ae02e70ea4439584f432552b08cab2cb26ee33c70b2a7263fd56f75bbf7f40
+  data.tar.gz: 8fa79e4b09b1f7d9d889038a9e091da2632759683d6410c318c1d965f9768b4d
 SHA512:
-  metadata.gz: db93d224de064141cf4a422e05bba2e67c74ef0344dfce19579be48489cc16b070e24527e30aa4c081f9c38ca4aeb2c737f90d1edd8d157cf0d334b5f083965e
-  data.tar.gz: 8b6e496da5af91bf59225798c41d00776caafb3aec55a57c5ee43a1ca943a0312e676e119a9a41387c4beba5350d0f71c1ec70868d29933be6b140ac1d814b64
+  metadata.gz: 063baf66e22412189a923b4f8bb566ab9cfd14b267460bced8a6774abcc4ae9ae028a737a9e4c4963c84c3629e71bd147fb16d24d836b47eee09940a8a30f9a3
+  data.tar.gz: b16abe85cfebb592c05e9e87be4401fbaac436791489da5aab14199c30b3cfd9bd187ef4a382e2f6c6fc4024949b8b283d0879cf41d63123ca0845327b8b54c5

data/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,40 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+### System Information
+
+ - **OS**:             [e.g. macOS 10.15.4]
+ - **Ruby**:         [e.g. 2.7.0]
+ - **Version**:     [e.g. 0.7.38]
+ - **OpenSSL**:  [OpenSSL 1.1.1f 20 Mar 2020]
+
+### 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
+
+A clear and concise description of what actually happened.

data/.travis.yml

@@ -1,4 +1,7 @@
 language: ruby
+arch:
+  - amd64
+  - arm64
 os:
   - linux
   # - osx
@@ -6,15 +9,16 @@ before_install:
   - gem install bundler -v 1.10.6
   - bundle install
 rvm:
-  - 2.6.0
-  - 2.5.3
-  - 2.4.5
+  - 2.7.1
+  - 2.6.5
+  - 2.5.7
+  - 2.4.9
   - 2.3.8
   - 2.2.2
 notifications:
   email: false
 sudo: required
-dist: trusty
+dist: xenial
 addons:
   apt:
     sources:
@@ -24,7 +28,5 @@ addons:
 script:
   - echo CFLAGS = $CFLAGS
   - echo cflags = $cflags
-  - bundle exec rake compile && bundle exec rspec --format documentation
-  - gem uninstall -x iodine
-  - rake build
-  - find pkg/iodine-*.gem -exec gem install -V {} +
+  - bundle exec rake install
+  - env VERBOSE=1 bundle exec rspec --format documentation

data/CHANGELOG.md

@@ -6,6 +6,32 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.42 (2020-08-02)
+
+Fix: Implement fix suggested by @Shelvak (Néstor Coppi) in issue #98.
+
+#### Change log v.0.7.41 (2020-07-24)
+
+**Fix**: Hot Restart failed because listening sockets were cleared away. Credit to Néstor Coppi (@Shelvak) for exposing issue #97.
+
+**Fix**: CLI argument parsing is now only active when using the iodine CLI (or if defining `IODINE_PARSE_CLI` before requiring `iodine`). Credit to Aldis Berjoza (@graudeejs) for exposing issue #96.
+
+#### Change log v.0.7.40 (2020-05-23)
+
+**Fix**: fixed TLS logging and performance issues exposed by Franck Gille (@fgi) in issue #93.
+
+#### Change log v.0.7.39 (2020-05-18)
+
+**Security**: a request smuggling attack vector and Transfer Encoding attack vector in the HTTP/1.1 parser were exposed by Sam Sanoop from [the Snyk Security team (snyk.io)](https://snyk.io). The parser was updated to deal with these potential issues.
+
+**Fix**: (`http`) fixes an issue with date calculation - exposed by Franck Gille (@fgi) in issue #92.
+
+**Fix**: (`extconf`) fixes an installation concern raised by Benoit Daloze (@eregon), in issue #91. The default compiler is now used.
+
+#### 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/README.md

@@ -1,4 +1,5 @@
-# iodine - a fast HTTP / Websocket Server with native Pub/Sub support for the new web
+# iodine - Why Settle for a fast HTTP / WebSocket Server with native Pub/Sub?
+
 [![Gem](https://img.shields.io/gem/dt/iodine.svg)](https://rubygems.org/gems/iodine)
 [![Build Status](https://travis-ci.org/boazsegev/iodine.svg?branch=master)](https://travis-ci.org/boazsegev/iodine)
 [![Gem Version](https://badge.fury.io/rb/iodine.svg)](https://badge.fury.io/rb/iodine)
@@ -7,28 +8,30 @@
 
 [![Logo](https://github.com/boazsegev/iodine/raw/master/logo.png)](https://github.com/boazsegev/iodine)
 
-I believe that network concerns should be separated from application concerns - application developers really shouldn't need to worry about the transport layer.
+Iodine is a fast concurrent web application server for real-time Ruby applications, with native support for WebSockets and Pub/Sub services - but it's also so much more.
 
-And I know that these network concerns are more than just about the web server, which is why iodine is more than just an HTTP server.
+Iodine is a Ruby wrapper for many of the [facil.io](https://facil.io) C framework, leveraging the speed of C for many common web application tasks. In addition, iodine abstracts away all network concerns, so you never need to worry about the transport layer, free to concentrate on your application logic.
 
-Iodine is a fast concurrent web server for real-time Ruby applications, but it's also so much more. Iodine includes native support for:
+Iodine includes native support for:
 
 * HTTP, WebSockets and EventSource (SSE) Services (server);
 * WebSocket connections (server / client);
 * Pub/Sub (with optional Redis Pub/Sub scaling);
-* Static file service (with automatic `gzip` support for pre-compressed versions);
-* HTTP/1.1 keep-alive and pipelining;
+* Fast(!) builtin Mustache template engine.
+* Static file service (with automatic `gzip` support for pre-compressed assets);
+* Optimized Logging to `stderr`.
 * Asynchronous event scheduling and timers;
-* Hot Restart (using the USR1 signal);
+* HTTP/1.1 keep-alive and pipelining;
+* Heap Fragmentation Protection.
 * TLS 1.2 and above (Requires OpenSSL >= 1.1.0);
 * TCP/IP server and client connectivity;
 * Unix Socket server and client connectivity;
+* Hot Restart (using the USR1 signal and without hot deployment);
 * Custom protocol authoring;
-* Optimized Logging to `stderr`.
 * [Sequel](https://github.com/jeremyevans/sequel) and ActiveRecord forking protection.
 * and more!
 
-Iodine is an **evented** framework with a simple API that ports much of the [C facil.io framework](https://github.com/boazsegev/facil.io) to Ruby. This means that:
+Since iodine wraps much of the [C facil.io framework](https://github.com/boazsegev/facil.io) to Ruby:
 
 * Iodine can handle **thousands of concurrent connections** (tested with more then 20K connections on Linux)!
 
@@ -36,9 +39,9 @@ Iodine is an **evented** framework with a simple API that ports much of the [C f
 
 Iodine is a C extension for Ruby, developed and optimized for Ruby MRI 2.2.2 and up... it should support the whole Ruby 2.0 MRI family, but CI tests start at Ruby 2.2.2.
 
-**Note**: iodine does **not** support the streaming when using Rack. Streaming over Rack should be avoided on any server, WebSockets, SSE and `Range` requests should always be preferred. On iodine no data will be sent before the whole of the data is available.
+**Note**: iodine does **not** support streaming when using Rack. It's recommended to avoid blocking the server when using `body.each` since the `each` loop will block the iodine's thread until it's finished and iodine won't send any data before the loop is done.
 
-## Iodine - a fast & powerful HTTP + Websockets server with native Pub/Sub
+## Iodine - a fast & powerful HTTP + WebSockets server with native Pub/Sub
 
 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).
 
@@ -46,6 +49,10 @@ With `Iodine.listen service: :http` it's possible to run multiple HTTP applicati
 
 Iodine also supports native process cluster Pub/Sub and a native RedisEngine to easily scale iodine's Pub/Sub horizontally.
 
+### Known Issues and Reporting Issues
+
+See the [GitHub Open Issues](https://github.com/boazsegev/iodine/issues) list for known issues and to report new issues.
+
 ### Installing and Running Iodine
 
 Install iodine on any Linux / BSD / macOS system using:
@@ -68,6 +75,8 @@ bundler exec iodine
 
 #### Installing with SSL/TLS
 
+**Note**: iodine has known issues with the TLS/SSL support. TLS/SSL should **NOT** be used in production (see issues #95 and #94).
+
 Make sure to update OpenSSL to the latest version **before installing Ruby** (`rbenv` should do this automatically).
 
 To avoid name resolution conflicts, iodine will bind to the same OpenSSL version Ruby is bound to. To use SSL/TLS this should be OpenSSL >= 1.1.0 or LibreSSL >= 2.7.4.
@@ -85,9 +94,7 @@ Confirmed OpenSSL to be version 1.1.0 or above (OpenSSL 1.1.0j  20 Nov 2018)...
 ...
 ```
 
-**KNOWN ISSUE:**
-
-The installation script tests for OpenSSL 1.1.0 and above. However, this testing approach sometimes provides false positives. If TLS isn't required, install with `NO_SSL=1`. i.e.:
+The installation script tests for OpenSSL 1.1.0 and above. However, this testing approach sometimes provides false positives. **If TLS isn't required, install with `NO_SSL=1`**. i.e.:
 
 ```bash
 NO_SSL=1 bundler exec iodine
@@ -108,17 +115,19 @@ On Rails:
     if(defined?(Iodine))
       Iodine.threads = ENV.fetch("RAILS_MAX_THREADS", 5).to_i if Iodine.threads.zero?
       Iodine.workers = ENV.fetch("WEB_CONCURRENCY", 2).to_i if Iodine.workers.zero?
-      Iodine::DEFAULT_SETTINGS[:port] = ENV.fetch("PORT") if ENV.fetch("PORT")
+      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.
 
+**Note**: command-line instructions (CLI) should be the preferred way for configuring iodine, allowing for code-less configuration updates.
+
 ### 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.
 
-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.
+Iodine will calculate, when possible, a good enough default concurrency model for fast applications. 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:
 
@@ -134,13 +143,19 @@ export WORKERS=-1 # negative values are fractions of CPU cores.
 bundler exec iodine -p $PORT
 ```
 
+Negative values are evaluated as "CPU Cores / abs(Value)". i.e., on an 8 core CPU machine, this will produce 4 worker processes with 2 threads per worker:
+
+```bash
+bundler exec iodine -p $PORT -t 2 -w -2
+```
+
 ### Heap Fragmentation Protection
 
 Iodine includes a fast, network oriented, custom memory allocator, optimizing away some of the work usually placed on the Ruby Garbage Collector (GC).
 
 This approach helps to minimize heap fragmentation for long running processes, by grouping many short-lived objects into a common memory space.
 
-It's still recommended to consider [jemalloc](http://jemalloc.net) or other allocators that also help mitigate heap fragmentation issues.
+It is still recommended to consider [jemalloc](http://jemalloc.net) or other allocators that also help mitigate heap fragmentation issues.
 
 ### Static file serving support
 
@@ -433,11 +448,11 @@ Iodine.connect url: "wss://echo.websocket.org", handler: EchoClient.new, ping: 4
 Iodine.start
 ```
 
-### TLS 1.2 support
+### TLS >= 1.2 support
 
 >  Requires OpenSSL >= `1.1.0`. On Heroku, requires `heroku-18`.
 
-Iodine supports secure connections fore TLS version 1.2 and up (depending on the OpenSSL version).
+Iodine supports secure connections fore TLS version 1.2 **and up** (depending on the OpenSSL version).
 
 A self signed certificate is available using the `-tls` flag from the command-line.
 
@@ -478,31 +493,11 @@ run APP
 
 ### How does it compare to other servers?
 
-The honest answer is "I don't know". I recommend that you perform your own tests.
-
-In my tests, pitching Iodine against Puma, Iodine was anywhere between x1.5 and x7 faster than Puma (depending on use-case). such a big difference is suspect and I recommend that you test it yourself.
+In my tests, pitching Iodine against Puma, Iodine was anywhere between x1.5 and more than x10 faster than Puma (depending on use-case and settings).
 
-Also, performing benchmarks on a single machine isn't very reliable... but it's all I've got.
+Such a big difference is suspect and I recommend that you test it yourself - even better if you test performance using your own application and a number of possible different settings (how many threads per CPU core? how many worker processes? middleware vs. server request logging, etc').
 
-When benchmarking with `wrk`, on the same local machine with similar settings for both Puma and Iodine (4 workers, 16 threads each, 200 concurrent connections), I calculated Iodine to be x1.52 faster::
-
-* Iodine performed at 74,786.27 req/sec, consuming ~68.4Mb of memory.
-
-* Puma performed at 48,994.59 req/sec, consuming ~79.6Mb of memory.
-
-When benchmarking using a VM (crossing machine boundaries, 16 threads, 4 workers, 200 concurrent connections), I calculated Iodine to be x2.3 faster:
-
-* Iodine performed at 23,559.56 req/sec, consuming ~88.8Mb of memory.
-
-* Puma performed at 9,935.31 req/sec, consuming ~84.0Mb of memory.
-
-When benchmarking using a VM (crossing machine boundaries, single thread, single worker, 200 concurrent connections), I calculated Iodine to be x7.3 faster:
-
-* Iodine performed at 18,444.31 req/sec, consuming ~25.6Mb of memory.
-
-* 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`:
+I recommend benchmarking the performance for yourself using `wrk` or `ab`:
 
 ```bash
 $ wrk -c200 -d4 -t2 http://localhost:3000/
@@ -510,7 +505,7 @@ $ wrk -c200 -d4 -t2 http://localhost:3000/
 $ ab -n 100000 -c 200 -k http://127.0.0.1:3000/
 ```
 
-Create a simple `config.ru` file with a hello world app:
+The best application to use for benchmarking is your actual application. Or, you could create a simple `config.ru` file with a __hello world__ app:
 
 ```ruby
 App = Proc.new do |env|
@@ -523,17 +518,21 @@ end
 run App
 ```
 
-Then start comparing servers. Here are the settings I used to compare iodine and Puma (4 processes, 16 threads):
+Then start comparing servers. Here are the settings I used to compare iodine and Puma (4 processes, 4 threads):
 
 ```bash
-$ RACK_ENV=production iodine -p 3000 -t 16 -w 4
+$ RACK_ENV=production iodine -p 3000 -t 4 -w 4
 # vs.
-$ RACK_ENV=production puma -p 3000 -t 16 -w 4
+$ RACK_ENV=production puma -p 3000 -t 4 -w 4
 # Review the `iodine -?` help for more command line options.
 ```
 
 It's recommended that the servers (Iodine/Puma) and the client (`wrk`/`ab`) run on separate machines.
 
+It is worth noting that iodine can also speed up logging by replacing the logging middleware with `iodine -v`. This approach uses less memory and improves performance at the expense of fuzzy timing and some string caching.
+
+On my machine, testing with the logging functionality enabled, iodine was more then 10 times faster than puma (60.9K req/sec vs. 5.3K req/sec)
+
 ### A few notes
 
 Iodine's upgrade / callback 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.
@@ -770,6 +769,14 @@ Yes, please, here are some thoughts:
 
 * If you love the project or thought the code was nice, maybe helped you in your own project, drop me a line. I'd love to know.
 
+### Running the Tests
+
+Running this task will compile the C extensions then run RSpec tests:
+
+```sh
+bundle exec rake spec
+```
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -3,10 +3,12 @@ require "rake/extensiontask"
 
 begin
   require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new(:spec)
+  RSpec::Core::RakeTask.new(:rspec)
 rescue LoadError
 end
 
+task :spec => [:compile, :rspec]
+
 task :default => [:compile, :spec]
 
 Rake::ExtensionTask.new "iodine" do |ext|

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/exe/iodine

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
+IODINE_PARSE_CLI = true
 require 'iodine'
 
 # Load Rack if available (assume it will be used).

data/ext/iodine/extconf.rb

@@ -1,34 +1,5 @@
 require 'mkmf'
 
-if ENV['CC']
-  ENV['CPP'] ||= ENV['CC']
-  puts "detected user prefered compiler (#{ENV['CC']}):", `#{ENV['CC']} -v`
-elsif find_executable('clang') && puts('testing clang for stdatomic support...').nil? && system("printf \"\#include <stdatomic.h>\nint main(void) {}\" | clang -include stdatomic.h -xc -o /dev/null -", out: '/dev/null')
-  $CC = ENV['CC'] = 'clang'
-  $CPP = ENV['CPP'] = 'clang'
-  puts "using clang compiler v. #{`clang -dumpversion`}."
-elsif find_executable('gcc') && (`gcc -dumpversion 2>&1`.to_i >= 5)
-  $CC = ENV['CC'] = 'gcc'
-  $CPP = ENV['CPP'] = find_executable('g++') ? 'g++' : 'gcc'
-  puts "using gcc #{ `gcc -dumpversion 2>&1`.to_i }"
-elsif find_executable('gcc-6')
-  $CC = ENV['CC'] = 'gcc-6'
-  $CPP = ENV['CPP'] = find_executable('g++-6') ? 'g++-6' : 'gcc-6'
-  puts 'using gcc-6 compiler.'
-elsif find_executable('gcc-5')
-  $CC = ENV['CC'] = 'gcc-5'
-  $CPP = ENV['CPP'] = find_executable('g++-5') ? 'g++-5' : 'gcc-5'
-  puts 'using gcc-5 compiler.'
-elsif find_executable('gcc-4.9')
-  $CC = ENV['CC'] = 'gcc-4.9'
-  $CPP = ENV['CPP'] = find_executable('g++-4.9') ? 'g++-4.9' : 'gcc-4.9'
-  puts 'using gcc-4.9 compiler.'
-else
-  puts 'using an unknown (old?) compiler... who knows if this will work out... we hope.'
-end
-
-
-
 # Test polling
 def iodine_test_polling_support
   iodine_poll_test_kqueue = <<EOS
@@ -129,10 +100,5 @@ EOS
     end
   end
 end
-# $defs << "-DFIO_USE_RISKY_HASH"
-
-RbConfig::MAKEFILE_CONFIG['CFLAGS'] = $CFLAGS = "-std=c11 -DFIO_PRINT_STATE=0 #{$CFLAGS} #{$CFLAGS == ENV['CFLAGS'] ? "" : ENV['CFLAGS']}"
-RbConfig::MAKEFILE_CONFIG['CC'] = $CC = ENV['CC'] if ENV['CC']
-RbConfig::MAKEFILE_CONFIG['CPP'] = $CPP = ENV['CPP'] if ENV['CPP']
 
 create_makefile 'iodine/iodine'

data/ext/iodine/fio.c

@@ -36,6 +36,12 @@ Feel free to copy, use and enjoy according to the license provided.
 
 #include <arpa/inet.h>
 
+#if HAVE_OPENSSL
+#include <openssl/bio.h>
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+#endif
+
 /* force poll for testing? */
 #ifndef FIO_ENGINE_POLL
 #define FIO_ENGINE_POLL 0
@@ -277,26 +283,6 @@ static inline fio_packet_s *fio_packet_alloc(void) {
 Core Connection Data Clearing
 ***************************************************************************** */
 
-/* set the minimal max_protocol_fd */
-static void fio_max_fd_min(uint32_t fd) {
-  if (fio_data->max_protocol_fd > fd)
-    return;
-  fio_lock(&fio_data->lock);
-  if (fio_data->max_protocol_fd < fd)
-    fio_data->max_protocol_fd = fd;
-  fio_unlock(&fio_data->lock);
-}
-
-/* set the minimal max_protocol_fd */
-static void fio_max_fd_shrink(void) {
-  fio_lock(&fio_data->lock);
-  uint32_t fd = fio_data->max_protocol_fd;
-  while (fd && fd_data(fd).protocol == NULL)
-    --fd;
-  fio_data->max_protocol_fd = fd;
-  fio_unlock(&fio_data->lock);
-}
-
 /* resets connection data, marking it as either open or closed. */
 static inline int fio_clear_fd(intptr_t fd, uint8_t is_open) {
   fio_packet_s *packet;
@@ -318,6 +304,13 @@ static inline int fio_clear_fd(intptr_t fd, uint8_t is_open) {
       .counter = fd_data(fd).counter + 1,
       .packet_last = &fd_data(fd).packet,
   };
+  if (fio_data->max_protocol_fd < fd) {
+    fio_data->max_protocol_fd = fd;
+  } else {
+    while (fio_data->max_protocol_fd &&
+           !fd_data(fio_data->max_protocol_fd).open)
+      --fio_data->max_protocol_fd;
+  }
   fio_unlock(&(fd_data(fd).sock_lock));
   if (rw_hooks && rw_hooks->cleanup)
     rw_hooks->cleanup(rw_udata);
@@ -336,8 +329,8 @@ static inline int fio_clear_fd(intptr_t fd, uint8_t is_open) {
   if (protocol && protocol->on_close) {
     fio_defer(deferred_on_close, (void *)fd2uuid(fd), protocol);
   }
-  if (is_open)
-    fio_max_fd_min(fd);
+  FIO_LOG_DEBUG("FD %d re-initialized (state: %p-%s).", (int)fd,
+                (void *)fd2uuid(fd), (is_open ? "open" : "closed"));
   return 0;
 }
 
@@ -2887,7 +2880,7 @@ void fio_close(intptr_t uuid) {
   }
   if (uuid_data(uuid).packet || uuid_data(uuid).sock_lock) {
     uuid_data(uuid).close = 1;
-    fio_poll_add_write(fio_uuid2fd(uuid));
+    fio_force_event(uuid, FIO_EVENT_ON_READY);
     return;
   }
   fio_force_close(uuid);
@@ -3019,6 +3012,7 @@ test_errno:
   case ENOSPC:        /* fallthrough */
   case EADDRNOTAVAIL: /* fallthrough */
   case EINTR:
+  case 0:
     return 1;
   case EFAULT:
     FIO_LOG_ERROR("fio_flush EFAULT - possible memory address error sent to "
@@ -3032,8 +3026,8 @@ test_errno:
     fio_force_close(uuid);
     return -1;
   }
-  fprintf(stderr, "UUID error: %p (%d)\n", (void *)uuid, errno);
-  perror("No errno handler");
+  FIO_LOG_DEBUG("UUID error: %p (%d): %s\n", (void *)uuid, errno,
+                strerror(errno));
   return 0;
 
 invalid:
@@ -3099,6 +3093,19 @@ const fio_rw_hook_s FIO_DEFAULT_RW_HOOKS = {
     .cleanup = fio_hooks_default_cleanup,
 };
 
+static inline void fio_rw_hook_validate(fio_rw_hook_s *rw_hooks) {
+  if (!rw_hooks->read)
+    rw_hooks->read = fio_hooks_default_read;
+  if (!rw_hooks->write)
+    rw_hooks->write = fio_hooks_default_write;
+  if (!rw_hooks->flush)
+    rw_hooks->flush = fio_hooks_default_flush;
+  if (!rw_hooks->before_close)
+    rw_hooks->before_close = fio_hooks_default_before_close;
+  if (!rw_hooks->cleanup)
+    rw_hooks->cleanup = fio_hooks_default_cleanup;
+}
+
 /**
  * Replaces an existing read/write hook with another from within a read/write
  * hook callback.
@@ -3112,19 +3119,10 @@ int fio_rw_hook_replace_unsafe(intptr_t uuid, fio_rw_hook_s *rw_hooks,
   int replaced = -1;
   uint8_t was_locked;
   intptr_t fd = fio_uuid2fd(uuid);
-  if (!rw_hooks->read)
-    rw_hooks->read = fio_hooks_default_read;
-  if (!rw_hooks->write)
-    rw_hooks->write = fio_hooks_default_write;
-  if (!rw_hooks->flush)
-    rw_hooks->flush = fio_hooks_default_flush;
-  if (!rw_hooks->before_close)
-    rw_hooks->before_close = fio_hooks_default_before_close;
-  if (!rw_hooks->cleanup)
-    rw_hooks->cleanup = fio_hooks_default_cleanup;
+  fio_rw_hook_validate(rw_hooks);
   /* protect against some fulishness... but not all of it. */
   was_locked = fio_trylock(&fd_data(fd).sock_lock);
-  if (fd2uuid(fd) == uuid) {
+  if (uuid_is_valid(uuid)) {
     fd_data(fd).rw_hooks = rw_hooks;
     fd_data(fd).rw_udata = udata;
     replaced = 0;
@@ -3138,16 +3136,7 @@ int fio_rw_hook_replace_unsafe(intptr_t uuid, fio_rw_hook_s *rw_hooks,
 int fio_rw_hook_set(intptr_t uuid, fio_rw_hook_s *rw_hooks, void *udata) {
   if (fio_is_closed(uuid))
     goto invalid_uuid;
-  if (!rw_hooks->read)
-    rw_hooks->read = fio_hooks_default_read;
-  if (!rw_hooks->write)
-    rw_hooks->write = fio_hooks_default_write;
-  if (!rw_hooks->flush)
-    rw_hooks->flush = fio_hooks_default_flush;
-  if (!rw_hooks->before_close)
-    rw_hooks->before_close = fio_hooks_default_before_close;
-  if (!rw_hooks->cleanup)
-    rw_hooks->cleanup = fio_hooks_default_cleanup;
+  fio_rw_hook_validate(rw_hooks);
   intptr_t fd = fio_uuid2fd(uuid);
   fio_rw_hook_s *old_rw_hooks;
   void *old_udata;
@@ -3249,7 +3238,6 @@ static int fio_attach__internal(void *uuid_, void *protocol_) {
     /* adding a new uuid to the reactor */
     fio_poll_add(fio_uuid2fd(uuid));
   }
-  fio_max_fd_min(fio_uuid2fd(uuid));
   return 0;
 
 invalid_uuid:
@@ -3510,18 +3498,19 @@ static void fio_on_fork(void) {
   fio_poll_init();
   fio_state_callback_on_fork();
 
+  /* don't pass open connections belonging to the parent onto the child. */
   const size_t limit = fio_data->capa;
   for (size_t i = 0; i < limit; ++i) {
     fd_data(i).sock_lock = FIO_LOCK_INIT;
     fd_data(i).protocol_lock = FIO_LOCK_INIT;
-    if (fd_data(i).protocol) {
+    if (fd_data(i).protocol && fd_data(i).open) {
+      /* open without protocol might be waiting for the child (listening) */
       fd_data(i).protocol->rsv = 0;
       fio_force_close(fd2uuid(i));
     }
   }
 
   fio_pubsub_on_fork();
-  fio_max_fd_shrink();
   uint16_t old_active = fio_data->active;
   fio_data->active = 0;
   fio_defer_perform();
@@ -3681,24 +3670,30 @@ static void fio_review_timeout(void *arg, void *ignr) {
   uint16_t timeout = fd_data(fd).timeout;
   if (!timeout)
     timeout = 300; /* enforced timout settings */
-  if (!fd_data(fd).protocol || (fd_data(fd).active + timeout >= review))
+  if (!fd_data(fd).open || fd_data(fd).active + timeout >= review)
     goto finish;
-  tmp = protocol_try_lock(fd, FIO_PR_LOCK_STATE);
-  if (!tmp) {
-    if (errno == EBADF)
-      goto finish;
-    goto reschedule;
+  if (fd_data(fd).protocol) {
+    tmp = protocol_try_lock(fd, FIO_PR_LOCK_STATE);
+    if (!tmp) {
+      if (errno == EBADF)
+        goto finish;
+      goto reschedule;
+    }
+    if (prt_meta(tmp).locks[FIO_PR_LOCK_TASK] ||
+        prt_meta(tmp).locks[FIO_PR_LOCK_WRITE])
+      goto unlock;
+    fio_defer_push_task(deferred_ping, (void *)fio_fd2uuid((int)fd), NULL);
+  unlock:
+    protocol_unlock(tmp, FIO_PR_LOCK_STATE);
+  } else {
+    /* open FD but no protocol? RW hook thing or listening sockets? */
+    if (fd_data(fd).rw_hooks != &FIO_DEFAULT_RW_HOOKS)
+      fio_close(fd2uuid(fd));
   }
-  if (prt_meta(tmp).locks[FIO_PR_LOCK_TASK] ||
-      prt_meta(tmp).locks[FIO_PR_LOCK_WRITE])
-    goto unlock;
-  fio_defer_push_task(deferred_ping, (void *)fio_fd2uuid((int)fd), NULL);
-unlock:
-  protocol_unlock(tmp, FIO_PR_LOCK_STATE);
 finish:
   do {
     fd++;
-  } while (!fd_data(fd).protocol && (fd <= fio_data->max_protocol_fd));
+  } while (!fd_data(fd).open && (fd <= fio_data->max_protocol_fd));
 
   if (fio_data->max_protocol_fd < fd) {
     fio_data->need_review = 1;
@@ -3714,7 +3709,6 @@ static void fio_cycle_schedule_events(void) {
   static time_t last_to_review = 0;
   fio_mark_time();
   fio_timer_schedule();
-  fio_max_fd_shrink();
   if (fio_signal_children_flag) {
     /* hot restart support */
     fio_signal_children_flag = 0;
@@ -3923,16 +3917,22 @@ void fio_start FIO_IGNORE_MACRO(struct fio_start_args args) {
   fio_data->is_worker = 0;
 
   fio_state_callback_force(FIO_CALL_PRE_START);
-
   FIO_LOG_INFO(
       "Server is running %u %s X %u %s with facil.io " FIO_VERSION_STRING
       " (%s)\n"
+#if HAVE_OPENSSL
+      "* Linked to %s\n"
+#endif
       "* Detected capacity: %d open file limit\n"
       "* Root pid: %d\n"
       "* Press ^C to stop\n",
       fio_data->workers, fio_data->workers > 1 ? "workers" : "worker",
       fio_data->threads, fio_data->threads > 1 ? "threads" : "thread",
-      fio_engine(), fio_data->capa, (int)fio_data->parent);
+      fio_engine(),
+#if HAVE_OPENSSL
+      OpenSSL_version(0),
+#endif
+      fio_data->capa, (int)fio_data->parent);
 
   if (args.workers > 1) {
     for (int i = 0; i < args.workers && fio_data->active; ++i) {