iodine 0.7.24 → 0.7.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14bd75ae5e5c3c0c2fa768fa147a4dfdeb27feb66b7db6896478814cd06c8452
-  data.tar.gz: 84b5ee6178d1bc91945a43d79d4180d08a90f4975d74ef62f7ec0c9e7cea9b66
+  metadata.gz: 78a87730fe356cbad1e97b0f8b236aa0d11922a5f4d9a2bc0dcd0b2d78ed76b9
+  data.tar.gz: 78867a8cb0fa36d09a642e1bde58226e7bc1db8286890d2fa393021607e05319
 SHA512:
-  metadata.gz: 39c5fcb1bd65f16a20854493d900f39bcdd8dcf705828af5dabec5842290ac879c5dd3e2fd8c7eaa491cf90b3ef81a68636f34744a85bd23483c7545c2acf518
-  data.tar.gz: 1743ce505418cc271f1607632dddbadaddf88aa6ba8c22fa1b459df8a8a70b19007bc14dba93860971bebb0e7a84b643812dea4e66af0ea95b48cc2415122161
+  metadata.gz: c300c420d934e36214360481db13975971934d34566c172e301b3f9432263bdbb1a8fe3fec0002dab56485749cc49519d940735ef21d545b0b83fa5bd5cd024e
+  data.tar.gz: d38221c36a4a2c889d68e0992b8e1da0f62ad93a5114b4dc74953f72d5dd959bb71b82b3a28b2b2913b0251f983e8d30b5e0c7d4f9fb4b3e930f272e7424d9db

data/CHANGELOG.md

@@ -6,6 +6,12 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.25
+
+**Fix**: (`iodine`) fixed host name binding when running `iodine` using `rackup` or through `Rack`. Credit to @adam12 (Adam Daniels) for PR #60.
+
+**Fix**: (`iodine`) removed bundler requirement in the `iodine.gemspec` file.
+
 #### Change log v.0.7.24
 
 **Fix**: (`fio`) fixed server shutdown on pub/sub stress, where internal pub/sub stress was mistakingly identified as a Slowloris attack. Credit to @moxgeek (Marouane Elmidaoui) for exposing this issue (plezi#32).

data/ext/iodine/extconf.rb

@@ -1,7 +1,5 @@
 require 'mkmf'
 
-abort 'Missing a Linux/Unix OS evented API (epoll/kqueue).' unless have_func('kevent') || have_func('epoll_ctl')
-
 if ENV['CC']
   ENV['CPP'] ||= ENV['CC']
   puts "detected user prefered compiler (#{ENV['CC']}):", `#{ENV['CC']} -v`
@@ -29,6 +27,72 @@ 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
+\#define _GNU_SOURCE
+\#include <stdlib.h>
+\#include <sys/event.h>
+int main(void) {
+  int fd = kqueue();
+}
+EOS
+
+  iodine_poll_test_epoll = <<EOS
+\#define _GNU_SOURCE
+\#include <stdlib.h>
+\#include <stdio.h>
+\#include <sys/types.h>
+\#include <sys/stat.h>
+\#include <fcntl.h>
+\#include <sys/epoll.h>
+int main(void) {
+  int fd = epoll_create1(EPOLL_CLOEXEC);
+}
+EOS
+
+  iodine_poll_test_poll = <<EOS
+\#define _GNU_SOURCE
+\#include <stdlib.h>
+\#include <poll.h>
+int main(void) {
+  struct pollfd plist[18];
+  memset(plist, 0, sizeof(plist[0]) * 18);
+  poll(plist, 1, 1);
+}
+EOS
+
+  # Test for manual selection and then TRY_COMPILE with each polling engine
+  if ENV['FIO_POLL']
+    puts "skipping polling tests, enforcing manual selection of: poll"
+    $defs << "-DFIO_ENGINE_POLL"
+  elsif ENV['FIO_FORCE_POLL']
+    puts "skipping polling tests, enforcing manual selection of: poll"
+    $defs << "-DFIO_ENGINE_POLL"
+  elsif ENV['FIO_FORCE_EPOLL']
+    puts "skipping polling tests, enforcing manual selection of: epoll"
+    $defs << "-DFIO_ENGINE_EPOLL"
+  elsif ENV['FIO_FORCE_KQUEUE']
+    puts "* Skipping polling tests, enforcing manual selection of: kqueue"
+    $defs << "-DFIO_ENGINE_KQUEUE"
+  elsif try_compile(iodine_poll_test_epoll)
+    puts "detected `epoll`"
+    $defs << "-DFIO_ENGINE_EPOLL"
+  elsif try_compile(iodine_poll_test_kqueue)
+    puts "detected `kqueue`"
+    $defs << "-DFIO_ENGINE_KQUEUE"
+  elsif try_compile(iodine_poll_test_poll)
+    puts "detected `poll` - this is suboptimal fallback!"
+    $defs << "-DFIO_ENGINE_POLL"
+  else
+    puts "* WARNING: No supported polling engine! expecting compilation to fail."
+  end
+end
+
+iodine_test_polling_support()
+
 # Test for OpenSSL version equal to 1.0.0 or greater.
 unless ENV['NO_SSL'] || ENV['NO_TLS'] || ENV["DISABLE_SSL"]
   OPENSSL_TEST_CODE = <<EOS
@@ -55,10 +119,10 @@ EOS
   rescue LoadError
   else
     if have_library('crypto') && have_library('ssl')
-      puts "Detected OpenSSL library, testing for version and required functions."
+      puts "detected OpenSSL library, testing for version and required functions."
       if try_compile(OPENSSL_TEST_CODE)
         $defs << "-DHAVE_OPENSSL"
-        puts "Confirmed OpenSSL to be version 1.1.0 or above (#{OpenSSL::OPENSSL_LIBRARY_VERSION})...\n* Compiling with HAVE_OPENSSL."
+        puts "confirmed OpenSSL to be version 1.1.0 or above (#{OpenSSL::OPENSSL_LIBRARY_VERSION})...\n* compiling with HAVE_OPENSSL."
       else
         puts "FAILED: OpenSSL version not supported (#{OpenSSL::OPENSSL_LIBRARY_VERSION} is too old)."
       end

data/ext/iodine/fio.c

@@ -44,7 +44,8 @@ Feel free to copy, use and enjoy according to the license provided.
 #if !FIO_ENGINE_POLL && !FIO_ENGINE_EPOLL && !FIO_ENGINE_KQUEUE
 #if defined(__linux__)
 #define FIO_ENGINE_EPOLL 1
-#elif defined(__APPLE__) || defined(__unix__)
+#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) ||     \
+    defined(__OpenBSD__) || defined(__bsdi__) || defined(__DragonFly__)
 #define FIO_ENGINE_KQUEUE 1
 #else
 #define FIO_ENGINE_POLL 1
@@ -1345,6 +1346,15 @@ Section Start Marker
 
 volatile uint8_t fio_signal_children_flag = 0;
 
+/* store old signal handlers to propegate signal handling */
+static struct sigaction fio_old_sig_chld;
+static struct sigaction fio_old_sig_pipe;
+static struct sigaction fio_old_sig_term;
+static struct sigaction fio_old_sig_int;
+#if !FIO_DISABLE_HOT_RESTART
+static struct sigaction fio_old_sig_usr1;
+#endif
+
 /*
  * Zombie Reaping
  * With thanks to Dr Graham D Shaw.
@@ -1356,15 +1366,20 @@ static void reap_child_handler(int sig) {
   while (waitpid(-1, NULL, WNOHANG) > 0)
     ;
   errno = old_errno;
+  if (fio_old_sig_chld.sa_handler != SIG_IGN &&
+      fio_old_sig_chld.sa_handler != SIG_DFL)
+    fio_old_sig_chld.sa_handler(sig);
 }
 
 /* initializes zombie reaping for the process */
 void fio_reap_children(void) {
   struct sigaction sa;
+  if (fio_old_sig_chld.sa_handler)
+    return;
   sa.sa_handler = reap_child_handler;
   sigemptyset(&sa.sa_mask);
   sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
-  if (sigaction(SIGCHLD, &sa, 0) == -1) {
+  if (sigaction(SIGCHLD, &sa, &fio_old_sig_chld) == -1) {
     perror("Child reaping initialization failed");
     kill(0, SIGINT);
     exit(errno);
@@ -1373,66 +1388,87 @@ void fio_reap_children(void) {
 
 /* handles the SIGUSR1, SIGINT and SIGTERM signals. */
 static void sig_int_handler(int sig) {
+  struct sigaction *old = NULL;
   switch (sig) {
 #if !FIO_DISABLE_HOT_RESTART
   case SIGUSR1:
     fio_signal_children_flag = 1;
+    old = &fio_old_sig_usr1;
     break;
 #endif
-  case SIGINT:  /* fallthrough */
+  case SIGINT: /* fallthrough */
+    if (!old)
+      old = &fio_old_sig_int;
   case SIGTERM: /* fallthrough */
+    if (!old)
+      old = &fio_old_sig_term;
     fio_stop();
     break;
+  case SIGPIPE: /* fallthrough */
+    if (!old)
+      old = &fio_old_sig_pipe;
   default:
     break;
   }
+  /* propagate signale handling to previous existing handler (if any) */
+  if (old->sa_handler != SIG_IGN && old->sa_handler != SIG_DFL)
+    old->sa_handler(sig);
 }
 
 /* setup handling for the SIGUSR1, SIGPIPE, SIGINT and SIGTERM signals. */
 static void fio_signal_handler_setup(void) {
   /* setup signal handling */
-  struct sigaction act, old;
-  memset(&act, 0, sizeof(old));
-  memset(&old, 0, sizeof(old));
+  struct sigaction act;
+  if (fio_old_sig_int.sa_handler)
+    return;
+
+  memset(&act, 0, sizeof(act));
 
   act.sa_handler = sig_int_handler;
   sigemptyset(&act.sa_mask);
   act.sa_flags = SA_RESTART | SA_NOCLDSTOP;
 
-  if (sigaction(SIGINT, &act, &old)) {
+  if (sigaction(SIGINT, &act, &fio_old_sig_int)) {
     perror("couldn't set signal handler");
     return;
   };
 
-  if (sigaction(SIGTERM, &act, &old)) {
+  if (sigaction(SIGTERM, &act, &fio_old_sig_term)) {
     perror("couldn't set signal handler");
     return;
   };
 #if !FIO_DISABLE_HOT_RESTART
-  if (sigaction(SIGUSR1, &act, &old)) {
+  if (sigaction(SIGUSR1, &act, &fio_old_sig_usr1)) {
     perror("couldn't set signal handler");
     return;
   };
 #endif
 
   act.sa_handler = SIG_IGN;
-  if (sigaction(SIGPIPE, &act, &old)) {
+  if (sigaction(SIGPIPE, &act, &fio_old_sig_pipe)) {
     perror("couldn't set signal handler");
     return;
   };
 }
-static void fio_signal_handler_reset(void) {
-  struct sigaction act, old;
-  memset(&act, 0, sizeof(old));
+
+void fio_signal_handler_reset(void) {
+  struct sigaction old;
+  if (!fio_old_sig_int.sa_handler)
+    return;
   memset(&old, 0, sizeof(old));
-  act.sa_handler = SIG_DFL;
-  sigemptyset(&act.sa_mask);
-  sigaction(SIGINT, &act, &old);
-  sigaction(SIGTERM, &act, &old);
+  sigaction(SIGINT, &fio_old_sig_int, &old);
+  sigaction(SIGTERM, &fio_old_sig_term, &old);
+  sigaction(SIGPIPE, &fio_old_sig_pipe, &old);
+  if (fio_old_sig_chld.sa_handler)
+    sigaction(SIGCHLD, &fio_old_sig_chld, &old);
 #if !FIO_DISABLE_HOT_RESTART
-  sigaction(SIGUSR1, &act, &old);
+  sigaction(SIGUSR1, &fio_old_sig_usr1, &old);
+  memset(&fio_old_sig_usr1, 0, sizeof(fio_old_sig_usr1));
 #endif
-  sigaction(SIGPIPE, &act, &old);
+  memset(&fio_old_sig_int, 0, sizeof(fio_old_sig_int));
+  memset(&fio_old_sig_term, 0, sizeof(fio_old_sig_term));
+  memset(&fio_old_sig_pipe, 0, sizeof(fio_old_sig_pipe));
+  memset(&fio_old_sig_chld, 0, sizeof(fio_old_sig_chld));
 }
 
 /**
@@ -2552,17 +2588,17 @@ Internal socket flushing related functions
 #define BUFFER_FILE_READ_SIZE 49152
 #endif
 
-#ifndef USE_SENDFILE
-
+#if !defined(USE_SENDFILE) && !defined(USE_SENDFILE_LINUX) &&                  \
+    !defined(USE_SENDFILE_BSD) && !defined(USE_SENDFILE_APPLE)
 #if defined(__linux__) /* linux sendfile works  */
 #include <sys/sendfile.h>
-#define USE_SENDFILE 1
-#elif defined(__unix__) /* BSD sendfile should work, but isn't tested */
+#define USE_SENDFILE_LINUX 1
+#elif defined(__FreeBSD__) /* FreeBSD sendfile should work - not tested */
 #include <sys/uio.h>
-#define USE_SENDFILE 1
+#define USE_SENDFILE_BSD 1
 #elif defined(__APPLE__) /* Is the apple sendfile still broken? */
 #include <sys/uio.h>
-#define USE_SENDFILE 1
+#define USE_SENDFILE_APPLE 2
 #else /* sendfile might not be available - always set to 0 */
 #define USE_SENDFILE 0
 #endif
@@ -2638,7 +2674,7 @@ read_error:
   return -1;
 }
 
-#if USE_SENDFILE && defined(__linux__) /* linux sendfile API */
+#if USE_SENDFILE_LINUX /* linux sendfile API */
 
 static int fio_sock_sendfile_from_fd(int fd, fio_packet_s *packet) {
   ssize_t sent;
@@ -2652,15 +2688,14 @@ static int fio_sock_sendfile_from_fd(int fd, fio_packet_s *packet) {
   return sent;
 }
 
-#elif USE_SENDFILE &&                                                          \
-    (defined(__APPLE__) || defined(__unix__)) /* BSD / Apple API */
+#elif USE_SENDFILE_LINUX_BSD || USE_SENDFILE_APPLE /* FreeBSD / Apple API */
 
 static int fio_sock_sendfile_from_fd(int fd, fio_packet_s *packet) {
   off_t act_sent = 0;
   ssize_t ret = 0;
   while (packet->length) {
     act_sent = packet->length;
-#if defined(__APPLE__)
+#if USE_SENDFILE_APPLE
     ret = sendfile(packet->data.fd, fd, packet->offset, &act_sent, NULL, 0);
 #else
     ret = sendfile(packet->data.fd, fd, packet->offset, (size_t)act_sent, NULL,
@@ -2682,8 +2717,8 @@ error:
 }
 
 #else
-static int (*sock_sendfile_from_fd)(int fd, struct packet_s *packet) =
-    sock_write_from_fd;
+static int (*fio_sock_sendfile_from_fd)(int fd, struct packet_s *packet) =
+    fio_sock_write_from_fd;
 
 #endif
 
@@ -3541,23 +3576,23 @@ static void __attribute__((constructor)) fio_lib_init(void) {
     fio_pubsub_initialize();
 #if DEBUG
 #if FIO_ENGINE_POLL
-    FIO_LOG_STATE("facil.io " FIO_VERSION_STRING " capacity initialization:\n"
-                  "*    Meximum open files %zu out of %zu\n"
-                  "*    Allocating %zu bytes for state handling.\n"
-                  "*    %zu bytes per connection + %zu for state handling.",
-                  capa, (size_t)rlim.rlim_max,
-                  (sizeof(*fio_data) + (capa * (sizeof(*fio_data->poll))) +
-                   (capa * (sizeof(*fio_data->info)))),
-                  (sizeof(*fio_data->poll) + sizeof(*fio_data->info)),
-                  sizeof(*fio_data));
+    FIO_LOG_INFO("facil.io " FIO_VERSION_STRING " capacity initialization:\n"
+                 "*    Meximum open files %zu out of %zu\n"
+                 "*    Allocating %zu bytes for state handling.\n"
+                 "*    %zu bytes per connection + %zu for state handling.",
+                 capa, (size_t)rlim.rlim_max,
+                 (sizeof(*fio_data) + (capa * (sizeof(*fio_data->poll))) +
+                  (capa * (sizeof(*fio_data->info)))),
+                 (sizeof(*fio_data->poll) + sizeof(*fio_data->info)),
+                 sizeof(*fio_data));
 #else
-    FIO_LOG_STATE("facil.io " FIO_VERSION_STRING " capacity initialization:\n"
-                  "*    Meximum open files %zu out of %zu\n"
-                  "*    Allocating %zu bytes for state handling.\n"
-                  "*    %zu bytes per connection + %zu for state handling.",
-                  capa, (size_t)rlim.rlim_max,
-                  (sizeof(*fio_data) + (capa * (sizeof(*fio_data->info)))),
-                  (sizeof(*fio_data->info)), sizeof(*fio_data));
+    FIO_LOG_INFO("facil.io " FIO_VERSION_STRING " capacity initialization:\n"
+                 "*    Meximum open files %zu out of %zu\n"
+                 "*    Allocating %zu bytes for state handling.\n"
+                 "*    %zu bytes per connection + %zu for state handling.",
+                 capa, (size_t)rlim.rlim_max,
+                 (sizeof(*fio_data) + (capa * (sizeof(*fio_data->info)))),
+                 (sizeof(*fio_data->info)), sizeof(*fio_data));
 #endif
 #endif
   }
@@ -3874,7 +3909,7 @@ void fio_start FIO_IGNORE_MACRO(struct fio_start_args args) {
 
   fio_state_callback_force(FIO_CALL_PRE_START);
 
-  FIO_LOG_STATE(
+  FIO_LOG_INFO(
       "Server is running %u %s X %u %s with facil.io " FIO_VERSION_STRING
       " (%s)\n"
       "* Detected capacity: %d open file limit\n"

data/ext/iodine/fio.h

@@ -168,10 +168,10 @@ Version and helper macros
 
 #ifndef FIO_PRINT_STATE
 /**
- * Enables the FIO_LOG_STATE(msg,...) macro, which prints information level
- * messages to stderr.
+ * Enables the depraceted FIO_LOG_STATE(msg,...) macro, which prints information
+ * level messages to stderr.
  */
-#define FIO_PRINT_STATE 1
+#define FIO_PRINT_STATE 0
 #endif
 
 #ifndef FIO_PUBSUB_SUPPORT
@@ -463,7 +463,9 @@ int __attribute__((weak)) FIO_LOG_LEVEL;
 #endif
 
 #if FIO_PRINT_STATE
-#define FIO_LOG_STATE(...) FIO_LOG_PRINT(FIO_LOG_LEVEL_INFO, __VA_ARGS__)
+#define FIO_LOG_STATE(...)                                                     \
+  FIO_LOG_PRINT(FIO_LOG_LEVEL_INFO,                                            \
+                "WARNING: FIO_LOG_STATE is deprecated\n" __VA_ARGS__)
 #else
 #define FIO_LOG_STATE(...)
 #endif
@@ -987,6 +989,18 @@ pid_t fio_parent_pid(void);
  */
 void fio_reap_children(void);
 
+/**
+ * Resets any existing signal handlers, restoring their state to before they
+ * were set by facil.io.
+ *
+ * This stops both child reaping (`fio_reap_children`) and the default facil.io
+ * signal handlers (i.e., CTRL-C).
+ *
+ * This function will be called automatically by facil.io whenever facil.io
+ * stops.
+ */
+void fio_signal_handler_reset(void);
+
 /**
  * Returns the last time the server reviewed any pending IO events.
  */
@@ -2159,8 +2173,9 @@ FIO_FUNC inline uintptr_t fio_ct_if2(uintptr_t cond, uintptr_t a, uintptr_t b) {
 #endif
 
 /* Note: using BIG_ENDIAN invokes false positives on some systems */
-#if (defined(__BIG_ENDIAN__) && __BIG_ENDIAN__) ||                             \
-    (defined(__LITTLE_ENDIAN__) && !__LITTLE_ENDIAN__) ||                      \
+#if !defined(__BIG_ENDIAN__)
+/* nothing to do */
+#elif (defined(__LITTLE_ENDIAN__) && !__LITTLE_ENDIAN__) ||                    \
     (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
 #define __BIG_ENDIAN__ 1
 #elif !defined(__BIG_ENDIAN__) && !defined(__BYTE_ORDER__) &&                  \
@@ -2208,12 +2223,14 @@ FIO_FUNC inline uintptr_t fio_ct_if2(uintptr_t cond, uintptr_t a, uintptr_t b) {
 /** 32Bit right rotation, inlined. */
 #define fio_rrot32(i, bits)                                                    \
   (((uint32_t)(i) >> ((bits)&31UL)) | ((uint32_t)(i) << ((-(bits)) & 31UL)))
+
 /** 64Bit left rotation, inlined. */
 #define fio_lrot64(i, bits)                                                    \
   (((uint64_t)(i) << ((bits)&63UL)) | ((uint64_t)(i) >> ((-(bits)) & 63UL)))
 /** 64Bit right rotation, inlined. */
 #define fio_rrot64(i, bits)                                                    \
   (((uint64_t)(i) >> ((bits)&63UL)) | ((uint64_t)(i) << ((-(bits)) & 63UL)))
+
 /** unknown size element - left rotation, inlined. */
 #define fio_lrot(i, bits)                                                      \
   (((i) << ((bits) & ((sizeof((i)) << 3) - 1))) |                              \

data/ext/iodine/fio_tls_missing.c

@@ -134,7 +134,7 @@ static inline void fio_alpn_destroy(alpn_s *obj) {
 #include <fio.h>
 
 /* *****************************************************************************
-The SSL/TLS type
+The SSL/TLS Context type
 ***************************************************************************** */
 
 /** An opaque type used for the SSL/TLS functions. */

data/ext/iodine/hpack.h

@@ -27,32 +27,22 @@
 #define HPACK_MAX_TABLE_SIZE 65535
 
 /* *****************************************************************************
-Types
+Required Callbacks
 ***************************************************************************** */
 
-/** A Short String (SString) struct, up to 65,535 bytes long */
-typedef struct sstring_s {
-  uint16_t len;
-  uint8_t data[];
-} sstring_s;
-
-/** An HTTP/2 Header */
-typedef struct http2_header_s {
-  sstring_s *name;
-  sstring_s *value;
-} http2_header_s;
-
-/** An HTTP/2 Header Collection */
-typedef struct http2_header_array_s {
-  size_t len;
-  http2_header_s headers[];
-} http2_header_array_s;
+/* *****************************************************************************
+Types
+***************************************************************************** */
 
 /** The HPACK context. */
 typedef struct hpack_context_s hpack_context_s;
 
 /* *****************************************************************************
-API
+Context API
+***************************************************************************** */
+
+/* *****************************************************************************
+Primitive Types API
 ***************************************************************************** */
 
 /**
@@ -98,6 +88,70 @@ static inline int hpack_string_pack(void *dest, size_t limit, void *data,
 static inline int hpack_string_unpack(void *dest, size_t limit, void *encoded,
                                       size_t len, size_t *pos);
 
+/* *****************************************************************************
+Static table API
+***************************************************************************** */
+
+/**
+ * Sets the provided pointers with the information in the static header table.
+ *
+ * The `index` is 1..61 (not zero based).
+ *
+ * Set `get_value` to 1 to collect the value data rather then the header name.
+ *
+ * Returns -1 if request is out of bounds.
+ */
+static int hpack_header_static_find(uint8_t index, uint8_t get_value,
+                                    const char **name, size_t *len);
+
+/* *****************************************************************************
+Huffman API (internal)
+***************************************************************************** */
+
+/* the huffman encoding map */
+typedef const struct {
+  const uint32_t code;
+  const uint8_t bits;
+} huffman_encode_s;
+static const huffman_encode_s huffman_encode_table[];
+
+/* the huffman decoding binary tree type */
+typedef struct {
+  const int16_t value;     // value, -1 == none.
+  const uint8_t offset[2]; // offset for 0 and one. 0 == leaf node.
+} huffman_decode_s;
+static const huffman_decode_s huffman_decode_tree[];
+
+/**
+ * Unpack (de-compress) using HPACK huffman - returns the number of bytes
+ * written and advances the position marker.
+ */
+static MAYBE_UNUSED int hpack_huffman_unpack(void *dest, size_t limit,
+                                             void *encoded, size_t len,
+                                             size_t *pos);
+
+/**
+ *  Pack (compress) using HPACK huffman - returns the number of bytes written or
+ * required.
+ */
+static MAYBE_UNUSED int hpack_huffman_pack(void *dest, const int limit,
+                                           void *data, size_t len);
+
+/* *****************************************************************************
+
+
+
+
+
+                                  Implementation
+
+
+
+
+
+
+***************************************************************************** */
+
 /* *****************************************************************************
 Integer encoding
 ***************************************************************************** */
@@ -185,39 +239,6 @@ static inline int64_t hpack_int_unpack(void *data_, size_t len, uint8_t prefix,
   return (int64_t)result;
 }
 
-/* *****************************************************************************
-Huffman (internal API)
-***************************************************************************** */
-
-/* the huffman encoding map */
-typedef const struct {
-  const uint32_t code;
-  const uint8_t bits;
-} huffman_encode_s;
-static const huffman_encode_s huffman_encode_table[];
-
-/* the huffman decoding binary tree type */
-typedef struct {
-  const int16_t value;     // value, -1 == none.
-  const uint8_t offset[2]; // offset for 0 and one. 0 == leaf node.
-} huffman_decode_s;
-static const huffman_decode_s huffman_decode_tree[];
-
-/**
- * Unpack (de-compress) using HPACK huffman - returns the number of bytes
- * written and advances the position marker.
- */
-static MAYBE_UNUSED int hpack_huffman_unpack(void *dest, size_t limit,
-                                             void *encoded, size_t len,
-                                             size_t *pos);
-
-/**
- *  Pack (compress) using HPACK huffman - returns the number of bytes written or
- * required.
- */
-static MAYBE_UNUSED int hpack_huffman_pack(void *dest, const int limit,
-                                           void *data, size_t len);
-
 /* *****************************************************************************
 String encoding
 ***************************************************************************** */
@@ -402,9 +423,111 @@ calc_final_length:
 }
 
 /* *****************************************************************************
+Header static table lookup
+***************************************************************************** */
+
+const static struct {
+  struct hpack_static_data_s {
+    const char *val;
+    const size_t len;
+  } data[2];
+} MAYBE_UNUSED hpack_static_table[] = {
+    /* [0] */ {.data = {{.len = 0}, {.len = 0}}},
+    {.data = {{.val = ":authority", .len = 10}, {.len = 0}}},
+    {.data = {{.val = ":method", .len = 7}, {.val = "GET", .len = 3}}},
+    {.data = {{.val = ":method", .len = 7}, {.val = "POST", .len = 4}}},
+    {.data = {{.val = ":path", .len = 5}, {.val = "/", .len = 1}}},
+    {.data = {{.val = ":path", .len = 5}, {.val = "/index.html", .len = 11}}},
+    {.data = {{.val = ":scheme", .len = 7}, {.val = "http", .len = 0}}},
+    {.data = {{.val = ":scheme", .len = 7}, {.val = "https", .len = 0}}},
+    {.data = {{.val = ":status", .len = 7}, {.val = "200", .len = 0}}},
+    {.data = {{.val = ":status", .len = 7}, {.val = "204", .len = 0}}},
+    {.data = {{.val = ":status", .len = 7}, {.val = "206", .len = 0}}},
+    {.data = {{.val = ":status", .len = 7}, {.val = "304", .len = 0}}},
+    {.data = {{.val = ":status", .len = 7}, {.val = "400", .len = 0}}},
+    {.data = {{.val = ":status", .len = 7}, {.val = "404", .len = 0}}},
+    {.data = {{.val = ":status", .len = 7}, {.val = "500", .len = 0}}},
+    {.data = {{.val = "accept-charset", .len = 14}, {.len = 0}}},
+    {.data = {{.val = "accept-encoding", .len = 15},
+              {.val = "gzip, deflate", .len = 13}}},
+    {.data = {{.val = "accept-language", .len = 15}, {.len = 0}}},
+    {.data = {{.val = "accept-ranges", .len = 13}, {.len = 0}}},
+    {.data = {{.val = "accept", .len = 6}, {.len = 0}}},
+    {.data = {{.val = "access-control-allow-origin", .len = 27}, {.len = 0}}},
+    {.data = {{.val = "age", .len = 3}, {.len = 0}}},
+    {.data = {{.val = "allow", .len = 5}, {.len = 0}}},
+    {.data = {{.val = "authorization", .len = 13}, {.len = 0}}},
+    {.data = {{.val = "cache-control", .len = 13}, {.len = 0}}},
+    {.data = {{.val = "content-disposition", .len = 0}, {.len = 0}}},
+    {.data = {{.val = "content-encoding", .len = 16}, {.len = 0}}},
+    {.data = {{.val = "content-language", .len = 16}, {.len = 0}}},
+    {.data = {{.val = "content-length", .len = 14}, {.len = 0}}},
+    {.data = {{.val = "content-location", .len = 16}, {.len = 0}}},
+    {.data = {{.val = "content-range", .len = 13}, {.len = 0}}},
+    {.data = {{.val = "content-type", .len = 12}, {.len = 0}}},
+    {.data = {{.val = "cookie", .len = 6}, {.len = 0}}},
+    {.data = {{.val = "date", .len = 4}, {.len = 0}}},
+    {.data = {{.val = "etag", .len = 4}, {.len = 0}}},
+    {.data = {{.val = "expect", .len = 6}, {.len = 0}}},
+    {.data = {{.val = "expires", .len = 7}, {.len = 0}}},
+    {.data = {{.val = "from", .len = 4}, {.len = 0}}},
+    {.data = {{.val = "host", .len = 4}, {.len = 0}}},
+    {.data = {{.val = "if-match", .len = 8}, {.len = 0}}},
+    {.data = {{.val = "if-modified-since", .len = 17}, {.len = 0}}},
+    {.data = {{.val = "if-none-match", .len = 13}, {.len = 0}}},
+    {.data = {{.val = "if-range", .len = 8}, {.len = 0}}},
+    {.data = {{.val = "if-unmodified-since", .len = 19}, {.len = 0}}},
+    {.data = {{.val = "last-modified", .len = 13}, {.len = 0}}},
+    {.data = {{.val = "link", .len = 4}, {.len = 0}}},
+    {.data = {{.val = "location", .len = 8}, {.len = 0}}},
+    {.data = {{.val = "max-forwards", .len = 12}, {.len = 0}}},
+    {.data = {{.val = "proxy-authenticate", .len = 18}, {.len = 0}}},
+    {.data = {{.val = "proxy-authorization", .len = 19}, {.len = 0}}},
+    {.data = {{.val = "range", .len = 5}, {.len = 0}}},
+    {.data = {{.val = "referer", .len = 7}, {.len = 0}}},
+    {.data = {{.val = "refresh", .len = 7}, {.len = 0}}},
+    {.data = {{.val = "retry-after", .len = 11}, {.len = 0}}},
+    {.data = {{.val = "server", .len = 6}, {.len = 0}}},
+    {.data = {{.val = "set-cookie", .len = 10}, {.len = 0}}},
+    {.data = {{.val = "strict-transport-security", .len = 25}, {.len = 0}}},
+    {.data = {{.val = "transfer-encoding", .len = 17}, {.len = 0}}},
+    {.data = {{.val = "user-agent", .len = 10}, {.len = 0}}},
+    {.data = {{.val = "vary", .len = 4}, {.len = 0}}},
+    {.data = {{.val = "via", .len = 3}, {.len = 0}}},
+    {.data = {{.val = "www-authenticate", .len = 16}, {.len = 0}}},
+};
+
+static MAYBE_UNUSED int hpack_header_static_find(uint8_t index,
+                                                 uint8_t requested_type,
+                                                 const char **name,
+                                                 size_t *len) {
+  if (requested_type > 1 ||
+      index >= (sizeof(hpack_static_table) / sizeof(hpack_static_table[0])))
+    goto err;
+  struct hpack_static_data_s d = hpack_static_table[index].data[requested_type];
+  *name = d.val;
+  *len = d.len;
+  return 0;
+err:
+
+  *name = NULL;
+  *len = 0;
+  return -1;
+}
+
+/* *****************************************************************************
+
+
+
+
+
+
+                                  Testing
+
+
+
 
 
-                                    Testing
 
 
 ***************************************************************************** */
@@ -712,12 +835,14 @@ void hpack_test(void) {
 
 
 
+
                   Auto-generate binary tree from table data
 
 
 
 
 
+
 ***************************************************************************** */
 
 #if HPACK_BUILD_HPACK_STRUCT
@@ -953,7 +1078,7 @@ void huffman__print_tree(void) {
         (tree[i].value == -1) ? 0 : encode_table[tree[i].value].code,
         (tree[i].value == -1) ? 0 : encode_table[tree[i].value].bits);
   }
-  fprintf(stderr, "};\n\n\n******************************************\n\n");
+  fprintf(stderr, "};\n\n\n**************( stop copying )**************\n\n");
   for (int i = 0; i < 256; ++i) {
     uint8_t data[4] = {0};
     uint8_t result = 0;
@@ -985,9 +1110,21 @@ int main(void) {
 #endif
 
 /* *****************************************************************************
-Paste auto-generated b-tree here:
-*****************************************************************************
-*/
+
+
+
+
+
+
+                      Paste auto-generated data here
+
+
+
+
+
+
+
+***************************************************************************** */
 
 /** Static Huffman encoding map, left aligned */
 static const huffman_encode_s huffman_encode_table[] = {
@@ -1768,8 +1905,17 @@ static const huffman_decode_s huffman_decode_tree[] = {
 };
 
 /* *****************************************************************************
-Don't overwrite after this
-*****************************************************************************
-*/
+
+
+
+
+
+                              Don't overwrite this
+
+
+
+
+
+***************************************************************************** */
 
 #endif /* H_HPACK_H */

data/iodine.gemspec

@@ -37,7 +37,7 @@ Gem::Specification.new do |spec|
   spec.requirements << 'Ruby >= 2.5.0 recommended.'
   spec.requirements << 'TLS requires OpenSSL >= 1.1.0'
 
-  spec.add_development_dependency 'bundler', '>= 1.10', '< 2.0'
+  # spec.add_development_dependency 'bundler', '>= 1.10', '< 2.0'
   spec.add_development_dependency 'rake', '~> 12.0', '< 13.0'
   spec.add_development_dependency 'minitest', '>=5', '< 6.0'
   spec.add_development_dependency 'rake-compiler', '>= 1', '< 2.0'

data/lib/iodine.rb

@@ -130,6 +130,23 @@ module Iodine
       end
     end
 
+    ### trap some signals to avoid exception reports
+    begin
+      old_sigint = Signal.trap("SIGINT") { old_sigint.call if old_sigint.respond_to?(:call) }
+    rescue Exception
+    end
+    begin
+      old_sigterm = Signal.trap("SIGTERM") { old_sigterm.call if old_sigterm.respond_to?(:call) }
+    rescue Exception
+    end
+    begin
+      old_sigpipe = Signal.trap("SIGPIPE") { old_sigpipe.call if old_sigpipe.respond_to?(:call) }
+    rescue Exception
+    end
+    begin
+      old_sigusr1 = Signal.trap("SIGUSR1") { old_sigusr1.call if old_sigusr1.respond_to?(:call) }
+    rescue Exception
+    end
 end
 
 require 'rack/handler/iodine' unless defined? ::Iodine::Rack::IODINE_RACK_LOADED

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.7.24'.freeze
+  VERSION = '0.7.25'.freeze
 end

data/lib/rack/handler/iodine.rb

@@ -7,7 +7,7 @@ module Iodine
     # Runs a Rack app, as par the Rack handler requirements.
     def self.run(app, options = {})
       # nested applications... is that a thing?
-      Iodine.listen(service: :http, handler: app, port: options[:Port], address: options[:Address])
+      Iodine.listen(service: :http, handler: app, port: options[:Port], address: options[:Host])
 
       # start Iodine
       Iodine.start

metadata

@@ -1,35 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.7.24
+  version: 0.7.25
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-02-17 00:00:00.000000000 Z
+date: 2019-02-22 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.10'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.10'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -221,7 +201,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 'Thank you for installing Iodine 0.7.24.
+post_install_message: 'Thank you for installing Iodine 0.7.25.
 
 '
 rdoc_options: []