iodine 0.4.19 → 0.5.0

data/ext/iodine/iodine.c

@@ -15,16 +15,24 @@ Feel free to copy, use and enjoy according to the license provided.
 
 VALUE Iodine;
 VALUE IodineBase;
-VALUE Iodine_Version;
+
+VALUE iodine_force_var_id;
+VALUE iodine_channel_var_id;
+VALUE iodine_pattern_var_id;
+VALUE iodine_text_var_id;
+VALUE iodine_binary_var_id;
+VALUE iodine_engine_var_id;
+VALUE iodine_message_var_id;
 
 ID iodine_fd_var_id;
+ID iodine_cdata_var_id;
 ID iodine_timeout_var_id;
 ID iodine_call_proc_id;
 ID iodine_new_func_id;
 ID iodine_on_open_func_id;
 ID iodine_on_message_func_id;
 ID iodine_on_data_func_id;
-ID iodine_on_ready_func_id;
+ID iodine_on_drained_func_id;
 ID iodine_on_shutdown_func_id;
 ID iodine_on_close_func_id;
 ID iodine_ping_func_id;
@@ -149,17 +157,11 @@ static VALUE iodine_run(VALUE self) {
 /* *****************************************************************************
 Idling
 ***************************************************************************** */
-#include "fio_list.h"
+#include "fio_llist.h"
 #include "spnlock.inc"
 
-typedef struct {
-  fio_list_s node;
-  VALUE block;
-} iodine_idle_block_s;
-
 static spn_lock_i iodine_on_idle_lock = SPN_LOCK_INIT;
-static fio_list_s iodine_on_idle_list =
-    FIO_LIST_INIT_STATIC(iodine_on_idle_list);
+static fio_ls_s iodine_on_idle_list = FIO_LS_INIT(iodine_on_idle_list);
 
 /**
 Schedules a single occuring event for the next idle cycle.
@@ -174,22 +176,20 @@ i.e.
 */
 VALUE iodine_sched_on_idle(VALUE self) {
   rb_need_block();
-  iodine_idle_block_s *b = malloc(sizeof(*b));
-  b->block = rb_block_proc();
-  Registry.add(b->block);
+  VALUE block = rb_block_proc();
+  Registry.add(block);
   spn_lock(&iodine_on_idle_lock);
-  fio_list_push(iodine_idle_block_s, node, iodine_on_idle_list, b);
+  fio_ls_push(&iodine_on_idle_list, (void *)block);
   spn_unlock(&iodine_on_idle_lock);
-  return b->block;
+  return block;
   (void)self;
 }
 
 static void iodine_on_idle(void) {
-  iodine_idle_block_s *b;
   spn_lock(&iodine_on_idle_lock);
-  while ((b = fio_list_shift(iodine_idle_block_s, node, iodine_on_idle_list))) {
-    defer(iodine_perform_deferred, (void *)b->block, NULL);
-    free(b);
+  while (fio_ls_any(&iodine_on_idle_list)) {
+    VALUE block = (VALUE)fio_ls_shift(&iodine_on_idle_list);
+    defer(iodine_perform_deferred, (void *)block, NULL);
   }
   spn_unlock(&iodine_on_idle_lock);
 }
@@ -202,14 +202,17 @@ Running the server
 
 static volatile int sock_io_thread = 0;
 static pthread_t sock_io_pthread;
+typedef struct {
+  size_t threads;
+  size_t processes;
+} iodine_start_settings_s;
 
 static void *iodine_io_thread(void *arg) {
   (void)arg;
   struct timespec tm;
-  // static const struct timespec tm = {.tv_nsec = 524288UL};
   while (sock_io_thread) {
     sock_flush_all();
-    tm = (struct timespec){.tv_nsec = 524288UL, .tv_sec = 1};
+    tm = (struct timespec){.tv_nsec = 0, .tv_sec = 1};
     nanosleep(&tm, NULL);
   }
   return NULL;
@@ -224,39 +227,17 @@ static void iodine_join_io_thread(void) {
   pthread_join(sock_io_pthread, NULL);
 }
 
-static void *srv_start_no_gvl(void *_) {
-  (void)(_);
-  // collect requested settings
-  VALUE rb_th_i = rb_iv_get(Iodine, "@threads");
-  VALUE rb_pr_i = rb_iv_get(Iodine, "@processes");
-  ssize_t threads = (TYPE(rb_th_i) == T_FIXNUM) ? FIX2LONG(rb_th_i) : 0;
-  ssize_t processes = (TYPE(rb_pr_i) == T_FIXNUM) ? FIX2LONG(rb_pr_i) : 0;
-// print a warnning if settings are sub optimal
-#ifdef _SC_NPROCESSORS_ONLN
-  size_t cpu_count = sysconf(_SC_NPROCESSORS_ONLN);
-  if (processes <= 0)
-    processes = 0;
-  if (threads <= 0)
-    threads = 0;
-
-  if (processes && threads && cpu_count > 0 &&
-      (((size_t)processes << 1) < cpu_count ||
-       (size_t)processes > (cpu_count << 1)))
-    fprintf(stderr,
-            "\n* Performance warnning:\n"
-            "  - This computer reports %lu available CPUs... "
-            "they will not be fully utilized.\n",
-            cpu_count);
-#else
-  if (processes <= 0)
-    processes = 0;
-  if (threads <= 0)
-    threads = 0;
-#endif
+static void *srv_start_no_gvl(void *s_) {
+  iodine_start_settings_s *s = s_;
   sock_io_thread = 1;
   defer(iodine_start_io_thread, NULL, NULL);
   fprintf(stderr, "\n");
-  facil_run(.threads = threads, .processes = processes,
+  if (s->processes == 1 || (s->processes == 0 && s->threads > 0)) {
+    /* single worker */
+    RubyCaller.call(Iodine, rb_intern("before_fork"));
+    RubyCaller.call(Iodine, rb_intern("after_fork"));
+  }
+  facil_run(.threads = s->threads, .processes = s->processes,
             .on_idle = iodine_on_idle, .on_finish = iodine_join_io_thread);
   return NULL;
 }
@@ -296,8 +277,13 @@ static int iodine_review_rack_app(void) {
                rb_ivar_get(rack, rb_intern("@ws_timeout")));
   rb_hash_aset(opt, ID2SYM(rb_intern("timeout")),
                rb_ivar_get(rack, rb_intern("@ws_timeout")));
-  if (rb_funcall2(Iodine, rb_intern("listen2http"), 1, &opt) == Qfalse)
+  rb_hash_aset(opt, ID2SYM(rb_intern("max_headers")),
+               rb_ivar_get(rack, rb_intern("@max_headers")));
+  if (rb_funcall2(Iodine, rb_intern("listen2http"), 1, &opt) == Qfalse) {
+    Registry.remove(opt);
     return -1;
+  }
+  Registry.remove(opt);
   return 0;
 }
 
@@ -308,12 +294,32 @@ Starts the Iodine event loop. This will hang the thread until an interrupt
 Returns the Iodine module.
 */
 static VALUE iodine_start(VALUE self) {
+  /* re-register the Rack::Push namespace to point at Iodine */
+  if (rb_const_defined(rb_cObject, rb_intern("Rack"))) {
+    VALUE rack = rb_const_get(rb_cObject, rb_intern("Rack"));
+    if (rack != Qnil) {
+      if (rb_const_defined(rack, rb_intern("PubSub"))) {
+        rb_const_remove(rack, rb_intern("PubSub"));
+      }
+      rb_const_set(rack, rb_intern("PubSub"), Iodine);
+    }
+  }
   /* for the special Iodine::Rack object and backwards compatibility */
   if (iodine_review_rack_app()) {
     fprintf(stderr, "ERROR: (iodine) cann't start Iodine::Rack.\n");
     return Qnil;
   }
-  rb_thread_call_without_gvl2(srv_start_no_gvl, (void *)self, NULL, NULL);
+
+  VALUE rb_th_i = rb_iv_get(Iodine, "@threads");
+  VALUE rb_pr_i = rb_iv_get(Iodine, "@processes");
+
+  iodine_start_settings_s s = {
+      .threads = ((TYPE(rb_th_i) == T_FIXNUM) ? FIX2INT(rb_th_i) : 0),
+      .processes = ((TYPE(rb_pr_i) == T_FIXNUM) ? FIX2INT(rb_pr_i) : 0)};
+
+  RubyCaller.set_gvl_state(1);
+  RubyCaller.leave_gvl(srv_start_no_gvl, (void *)&s);
+
   return self;
 }
 
@@ -342,39 +348,52 @@ static void patch_env(void) {
 #ifdef __APPLE__
   /* patch for dealing with the High Sierra `fork` limitations */
   void *obj_c_runtime = dlopen("Foundation.framework/Foundation", RTLD_LAZY);
+  (void)obj_c_runtime;
 #endif
 }
 
-////////////////////////////////////////////////////////////////////////
-// Ruby loads the library and invokes the Init_<lib_name> function...
-//
-// Here we connect all the C code to the Ruby interface, completing the bridge
-// between Lib-Server and Ruby.
+/* *****************************************************************************
+Ruby loads the library and invokes the Init_<lib_name> function...
+
+Here we connect all the C code to the Ruby interface, completing the bridge
+between Lib-Server and Ruby.
+***************************************************************************** */
 void Init_iodine(void) {
+  // Set GVL for main thread
+  RubyCaller.set_gvl_state(1);
   // load any environment specific patches
   patch_env();
   // initialize globally used IDs, for faster access to the Ruby layer.
-  iodine_fd_var_id = rb_intern("scrtfd");
+  iodine_buff_var_id = rb_intern("scrtbuffer");
   iodine_call_proc_id = rb_intern("call");
+  iodine_cdata_var_id = rb_intern("iodine_cdata");
+  iodine_fd_var_id = rb_intern("iodine_fd");
   iodine_new_func_id = rb_intern("new");
-  iodine_on_open_func_id = rb_intern("on_open");
-  iodine_on_message_func_id = rb_intern("on_message");
+  iodine_on_close_func_id = rb_intern("on_close");
   iodine_on_data_func_id = rb_intern("on_data");
+  iodine_on_message_func_id = rb_intern("on_message");
+  iodine_on_open_func_id = rb_intern("on_open");
+  iodine_on_drained_func_id = rb_intern("on_drained");
   iodine_on_shutdown_func_id = rb_intern("on_shutdown");
-  iodine_on_close_func_id = rb_intern("on_close");
-  iodine_on_ready_func_id = rb_intern("on_ready");
   iodine_ping_func_id = rb_intern("ping");
-  iodine_buff_var_id = rb_intern("scrtbuffer");
   iodine_timeout_var_id = rb_intern("@timeout");
-  iodine_to_s_method_id = rb_intern("to_s");
   iodine_to_i_func_id = rb_intern("to_i");
+  iodine_to_s_method_id = rb_intern("to_s");
+
+  iodine_binary_var_id = ID2SYM(rb_intern("binary"));
+  iodine_channel_var_id = ID2SYM(rb_intern("channel"));
+  iodine_engine_var_id = ID2SYM(rb_intern("engine"));
+  iodine_force_var_id = ID2SYM(rb_intern("encoding"));
+  iodine_message_var_id = ID2SYM(rb_intern("message"));
+  iodine_pattern_var_id = ID2SYM(rb_intern("pattern"));
+  iodine_text_var_id = ID2SYM(rb_intern("text"));
 
   IodineBinaryEncodingIndex = rb_enc_find_index("binary");
   IodineUTF8EncodingIndex = rb_enc_find_index("UTF-8");
   IodineBinaryEncoding = rb_enc_find("binary");
   IodineUTF8Encoding = rb_enc_find("UTF-8");
 
-  // The core Iodine module wraps libserver functionality and little more.
+  // The core Iodine module wraps facil.io functionality and little more.
   Iodine = rb_define_module("Iodine");
 
   // the Iodine singleton functions
@@ -386,8 +405,7 @@ void Init_iodine(void) {
   rb_define_module_function(Iodine, "run_every", iodine_run_every, -1);
   rb_define_module_function(Iodine, "on_idle", iodine_sched_on_idle, 0);
 
-  // Every Protocol (and Server?) instance will hold a reference to the server
-  // define the Server Ruby class.
+  /// Iodine::Base is for internal use.
   IodineBase = rb_define_module_under(Iodine, "Base");
   rb_define_module_function(IodineBase, "db_print_registry",
                             iodine_print_registry, 0);

data/ext/iodine/iodine.h

@@ -30,22 +30,30 @@ Feel free to copy, use and enjoy according to the license provided.
 
 extern VALUE Iodine;
 extern VALUE IodineBase;
-extern VALUE Iodine_Version;
 
-extern ID iodine_fd_var_id;
-extern ID iodine_timeout_var_id;
+extern VALUE iodine_binary_var_id;
+extern VALUE iodine_channel_var_id;
+extern VALUE iodine_engine_var_id;
+extern VALUE iodine_force_var_id;
+extern VALUE iodine_message_var_id;
+extern VALUE iodine_pattern_var_id;
+extern VALUE iodine_text_var_id;
+
+extern ID iodine_buff_var_id;
 extern ID iodine_call_proc_id;
+extern ID iodine_cdata_var_id;
+extern ID iodine_fd_var_id;
 extern ID iodine_new_func_id;
-extern ID iodine_on_open_func_id;
-extern ID iodine_on_message_func_id;
+extern ID iodine_on_close_func_id;
 extern ID iodine_on_data_func_id;
-extern ID iodine_on_ready_func_id;
+extern ID iodine_on_message_func_id;
+extern ID iodine_on_open_func_id;
+extern ID iodine_on_drained_func_id;
 extern ID iodine_on_shutdown_func_id;
-extern ID iodine_on_close_func_id;
 extern ID iodine_ping_func_id;
-extern ID iodine_buff_var_id;
-extern ID iodine_to_s_method_id;
+extern ID iodine_timeout_var_id;
 extern ID iodine_to_i_func_id;
+extern ID iodine_to_s_method_id;
 
 extern rb_encoding *IodineBinaryEncoding;
 extern rb_encoding *IodineUTF8Encoding;
@@ -53,10 +61,17 @@ extern int IodineBinaryEncodingIndex;
 extern int IodineUTF8EncodingIndex;
 
 UNUSED_FUNC static inline void iodine_set_fd(VALUE handler, intptr_t fd) {
-  rb_ivar_set(handler, iodine_fd_var_id, LONG2NUM((long)fd));
+  rb_ivar_set(handler, iodine_fd_var_id, LL2NUM((long)fd));
 }
 UNUSED_FUNC static inline intptr_t iodine_get_fd(VALUE handler) {
-  return ((intptr_t)NUM2LONG(rb_ivar_get(handler, iodine_fd_var_id)));
+  return ((intptr_t)NUM2LL(rb_ivar_get(handler, iodine_fd_var_id)));
+}
+
+UNUSED_FUNC static inline void iodine_set_cdata(VALUE handler, void *protocol) {
+  rb_ivar_set(handler, iodine_cdata_var_id, ULL2NUM((uintptr_t)protocol));
+}
+UNUSED_FUNC static inline void *iodine_get_cdata(VALUE handler) {
+  return ((void *)NUM2ULL(rb_ivar_get(handler, iodine_cdata_var_id)));
 }
 
 #endif

data/ext/iodine/iodine_helpers.c

@@ -140,13 +140,14 @@ static VALUE date_str(int argc, VALUE *argv, VALUE self) {
     if (TYPE(argv[0]) != T_FIXNUM)
       argv[0] = rb_funcallv(argv[0], iodine_to_i_func_id, 0, NULL);
     Check_Type(argv[0], T_FIXNUM);
-    last_tick = FIX2ULONG(argv[0]) ? FIX2ULONG(argv[0]) : facil_last_tick();
+    last_tick =
+        FIX2ULONG(argv[0]) ? FIX2ULONG(argv[0]) : facil_last_tick().tv_sec;
   } else
-    last_tick = facil_last_tick();
+    last_tick = facil_last_tick().tv_sec;
   VALUE str = rb_str_buf_new(32);
   struct tm tm;
 
-  http_gmtime(&last_tick, &tm);
+  http_gmtime(last_tick, &tm);
   size_t len = http_date2str(RSTRING_PTR(str), &tm);
   rb_str_set_len(str, len);
   return str;
@@ -168,11 +169,11 @@ Since Iodine uses time caching within it's reactor, using the default value
 static VALUE iodine_rfc2822(VALUE self, VALUE rtm) {
   time_t last_tick;
   rtm = rb_funcallv(rtm, iodine_to_i_func_id, 0, NULL);
-  last_tick = FIX2ULONG(rtm) ? FIX2ULONG(rtm) : facil_last_tick();
+  last_tick = FIX2ULONG(rtm) ? FIX2ULONG(rtm) : facil_last_tick().tv_sec;
   VALUE str = rb_str_buf_new(34);
   struct tm tm;
 
-  http_gmtime(&last_tick, &tm);
+  http_gmtime(last_tick, &tm);
   size_t len = http_date2rfc2822(RSTRING_PTR(str), &tm);
   rb_str_set_len(str, len);
   return str;
@@ -194,11 +195,11 @@ Since Iodine uses time caching within it's reactor, using the default value
 static VALUE iodine_rfc2109(VALUE self, VALUE rtm) {
   time_t last_tick;
   rtm = rb_funcallv(rtm, iodine_to_i_func_id, 0, NULL);
-  last_tick = FIX2ULONG(rtm) ? FIX2ULONG(rtm) : facil_last_tick();
+  last_tick = FIX2ULONG(rtm) ? FIX2ULONG(rtm) : facil_last_tick().tv_sec;
   VALUE str = rb_str_buf_new(32);
   struct tm tm;
 
-  http_gmtime(&last_tick, &tm);
+  http_gmtime(last_tick, &tm);
   size_t len = http_date2rfc2109(RSTRING_PTR(str), &tm);
   rb_str_set_len(str, len);
   return str;

data/ext/iodine/iodine_http.c

@@ -5,22 +5,26 @@ License: MIT
 Feel free to copy, use and enjoy according to the license provided.
 */
 #include "iodine_http.h"
+#include "fio_mem.h"
+#include "http.h"
+#include "iodine_json.h"
 #include "iodine_websockets.h"
 #include "rb-rack-io.h"
 
 #include <arpa/inet.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
 #include <sys/socket.h>
 
 /* *****************************************************************************
 Available Globals
 ***************************************************************************** */
-VALUE IodineHTTP;
+static VALUE IodineHTTP;
 
 typedef struct {
   VALUE app;
   VALUE env;
-  unsigned long max_msg : 56;
-  unsigned ping : 8;
 } iodine_http_settings_s;
 
 /* these three are used also by rb-rack-io.c */
@@ -28,23 +32,35 @@ VALUE IODINE_R_HIJACK;
 VALUE IODINE_R_HIJACK_IO;
 VALUE IODINE_R_HIJACK_CB;
 
-VALUE UPGRADE_TCP;
-VALUE UPGRADE_TCP_Q;
-VALUE UPGRADE_WEBSOCKET;
-VALUE UPGRADE_WEBSOCKET_Q;
+static VALUE UPGRADE_TCP;
+static VALUE UPGRADE_TCP_Q;
+static VALUE UPGRADE_WEBSOCKET;
+static VALUE UPGRADE_WEBSOCKET_Q;
+static VALUE RACK_UPGRADE;
+static VALUE RACK_UPGRADE_Q;
+static VALUE RACK_UPGRADE_SSE;
+static VALUE RACK_UPGRADE_WEBSOCKET;
 
 static VALUE hijack_func_sym;
-static ID to_fixnum_func_id;
 static ID close_method_id;
 static ID each_method_id;
 static ID attach_method_id;
 
+static VALUE env_template_no_upgrade;
+static VALUE env_template_websockets;
+static VALUE env_template_sse;
+
+static uint8_t support_xsendfile = 0;
+
 #define rack_declare(rack_name) static VALUE rack_name
 
 #define rack_set(rack_name, str)                                               \
   (rack_name) = rb_enc_str_new((str), strlen((str)), IodineBinaryEncoding);    \
   rb_global_variable(&(rack_name));                                            \
   rb_obj_freeze(rack_name);
+#define rack_set_sym(rack_name, sym)                                           \
+  (rack_name) = rb_id2sym(rb_intern2((sym), strlen((sym))));                   \
+  rb_global_variable(&(rack_name));
 
 #define rack_autoset(rack_name) rack_set((rack_name), #rack_name)
 
@@ -67,9 +83,27 @@ rack_declare(CONTENT_TYPE);
 rack_declare(R_URL_SCHEME);          // rack.url_scheme
 rack_declare(R_INPUT);               // rack.input
 rack_declare(XSENDFILE);             // for X-Sendfile support
+rack_declare(XSENDFILE_TYPE);        // for X-Sendfile support
+rack_declare(XSENDFILE_TYPE_HEADER); // for X-Sendfile support
 rack_declare(CONTENT_LENGTH_HEADER); // for X-Sendfile support
-// rack_declare(IODINE_R_HIJACK); // rack.hijack
-// rack_declare(IODINE_R_HIJACK_CB);// rack.hijack_io
+
+/* used internally to handle requests */
+typedef struct {
+  http_s *h;
+  FIOBJ body;
+  enum iodine_http_response_type_enum {
+    IODINE_HTTP_NONE,
+    IODINE_HTTP_SENDBODY,
+    IODINE_HTTP_XSENDFILE,
+    IODINE_HTTP_EMPTY,
+    IODINE_HTTP_ERROR,
+  } type;
+  enum iodine_upgrade_type_enum {
+    IODINE_UPGRADE_NONE = 0,
+    IODINE_UPGRADE_WEBSOCKET,
+    IODINE_UPGRADE_SSE,
+  } upgrade;
+} iodine_http_request_handle_s;
 
 /* *****************************************************************************
 Copying data from the C request to the Rack's ENV
@@ -77,116 +111,184 @@ Copying data from the C request to the Rack's ENV
 
 #define to_upper(c) (((c) >= 'a' && (c) <= 'z') ? ((c) & ~32) : (c))
 
-static inline VALUE copy2env(http_request_s *request, VALUE template) {
-  VALUE env = rb_hash_dup(template);
+int iodine_copy2env_task(FIOBJ o, void *env_) {
+  VALUE env = (VALUE)env_;
+  FIOBJ name = fiobj_hash_key_in_loop();
+  fio_cstr_s tmp = fiobj_obj2cstr(name);
+  VALUE hname = (VALUE)0;
+  if (tmp.len > 59) {
+    char *buf = fio_malloc(tmp.len + 5);
+    memcpy(buf, "HTTP_", 5);
+    for (size_t i = 0; i < tmp.len; ++i) {
+      buf[i + 5] = (tmp.data[i] == '-') ? '_' : to_upper(tmp.data[i]);
+    }
+    hname = rb_enc_str_new(buf, tmp.len + 5, IodineBinaryEncoding);
+    fio_free(buf);
+  } else {
+    char buf[64];
+    memcpy(buf, "HTTP_", 5);
+    for (size_t i = 0; i < tmp.len; ++i) {
+      buf[i + 5] = (tmp.data[i] == '-') ? '_' : to_upper(tmp.data[i]);
+    }
+    hname = rb_enc_str_new(buf, tmp.len + 5, IodineBinaryEncoding);
+  }
+
+  if (FIOBJ_TYPE_IS(o, FIOBJ_T_STRING)) {
+    tmp = fiobj_obj2cstr(o);
+    rb_hash_aset(env, hname,
+                 rb_enc_str_new(tmp.data, tmp.len, IodineBinaryEncoding));
+
+  } else {
+    /* it's an array */
+    VALUE ary = rb_ary_new();
+    rb_hash_aset(env, hname, ary);
+    size_t count = fiobj_ary_count(o);
+    for (size_t i = 0; i < count; ++i) {
+      tmp = fiobj_obj2cstr(fiobj_ary_index(o, i));
+      rb_ary_push(ary, rb_enc_str_new(tmp.data, tmp.len, IodineBinaryEncoding));
+    }
+  }
+  return 0;
+}
+static inline VALUE copy2env(iodine_http_request_handle_s *handle) {
+  VALUE env;
+  http_s *h = handle->h;
+  switch (handle->upgrade) {
+  case IODINE_UPGRADE_WEBSOCKET:
+    env = rb_hash_dup(env_template_websockets);
+    break;
+  case IODINE_UPGRADE_SSE:
+    env = rb_hash_dup(env_template_sse);
+    break;
+  case IODINE_UPGRADE_NONE:
+    env = rb_hash_dup(env_template_no_upgrade);
+    break;
+  }
   Registry.add(env);
-  VALUE hname; /* will be used later, both as tmp and to iterate header names */
+
+  fio_cstr_s tmp;
   char *pos = NULL;
-  const char *reader = NULL;
   /* Copy basic data */
+  tmp = fiobj_obj2cstr(h->method);
   rb_hash_aset(env, REQUEST_METHOD,
-               rb_enc_str_new(request->method, request->method_len,
-                              IodineBinaryEncoding));
-
-  rb_hash_aset(
-      env, PATH_INFO,
-      rb_enc_str_new(request->path, request->path_len, IodineBinaryEncoding));
-  rb_hash_aset(env, QUERY_STRING,
-               (request->query
-                    ? rb_enc_str_new(request->query, request->query_len,
-                                     IodineBinaryEncoding)
-                    : QUERY_ESTRING));
-  rb_hash_aset(env, QUERY_STRING,
-               (request->query
-                    ? rb_enc_str_new(request->query, request->query_len,
-                                     IodineBinaryEncoding)
-                    : QUERY_ESTRING));
-
-  hname = rb_enc_str_new(request->version, request->version_len,
-                         IodineBinaryEncoding);
-  rb_hash_aset(env, SERVER_PROTOCOL, hname);
-  rb_hash_aset(env, HTTP_VERSION, hname);
-
-  // Suppoer for Ruby web-console.
-  hname = rb_str_buf_new(64);
-  sock_peer_addr_s addrinfo = sock_peer_addr(request->fd);
-  if (addrinfo.addrlen &&
-      inet_ntop(
-          addrinfo.addr->sa_family,
-          addrinfo.addr->sa_family == AF_INET
-              ? (void *)&((struct sockaddr_in *)addrinfo.addr)->sin_addr
-              : (void *)&((struct sockaddr_in6 *)addrinfo.addr)->sin6_addr,
-          RSTRING_PTR(hname), 64)) {
-    rb_str_set_len(hname, strlen(RSTRING_PTR(hname)));
-    rb_hash_aset(env, REMOTE_ADDR, hname);
+               rb_enc_str_new(tmp.data, tmp.len, IodineBinaryEncoding));
+  tmp = fiobj_obj2cstr(h->path);
+  rb_hash_aset(env, PATH_INFO,
+               rb_enc_str_new(tmp.data, tmp.len, IodineBinaryEncoding));
+  if (h->query) {
+    tmp = fiobj_obj2cstr(h->query);
+    rb_hash_aset(env, QUERY_STRING,
+                 tmp.len
+                     ? rb_enc_str_new(tmp.data, tmp.len, IodineBinaryEncoding)
+                     : QUERY_ESTRING);
+  } else {
+    rb_hash_aset(env, QUERY_STRING, QUERY_ESTRING);
+  }
+  {
+    // HTTP version appears twice
+    tmp = fiobj_obj2cstr(h->version);
+    VALUE hname = rb_enc_str_new(tmp.data, tmp.len, IodineBinaryEncoding);
+    rb_hash_aset(env, SERVER_PROTOCOL, hname);
+    rb_hash_aset(env, HTTP_VERSION, hname);
   }
 
-  /* setup input IO + hijack support */
-  rb_hash_aset(env, R_INPUT, (hname = IodineRackIO.create(request, env)));
-
-  /* publish upgrade support */
-  if (request->upgrade) {
-    rb_hash_aset(env, UPGRADE_WEBSOCKET_Q, Qtrue);
-    rb_hash_aset(env, UPGRADE_TCP_Q, Qtrue);
+  { // Support for Ruby web-console.
+    char buf[64];
+    buf[63] = 0;
+    sock_peer_addr_s addrinfo = http_peer_addr(h);
+    if (addrinfo.addrlen &&
+        inet_ntop(
+            addrinfo.addr->sa_family,
+            addrinfo.addr->sa_family == AF_INET
+                ? (void *)&((struct sockaddr_in *)addrinfo.addr)->sin_addr
+                : (void *)&((struct sockaddr_in6 *)addrinfo.addr)->sin6_addr,
+            buf, 64)) {
+      rb_hash_aset(env, REMOTE_ADDR, rb_str_new(buf, strlen(buf)));
+    }
   }
 
-  hname = rb_obj_method(hname, hijack_func_sym);
-  rb_hash_aset(env, IODINE_R_HIJACK, hname);
+  /* setup input IO + hijack support */
+  {
+    VALUE m;
+    rb_hash_aset(env, R_INPUT, (m = IodineRackIO.create(h, env)));
+    m = rb_obj_method(m, hijack_func_sym);
+    rb_hash_aset(env, IODINE_R_HIJACK, m);
+  }
 
   /* handle the HOST header, including the possible host:#### format*/
-  pos = (char *)request->host;
+  static uint64_t host_hash = 0;
+  if (!host_hash)
+    host_hash = fio_siphash("host", 4);
+  tmp = fiobj_obj2cstr(fiobj_hash_get2(h->headers, host_hash));
+  pos = tmp.data;
   while (*pos && *pos != ':')
     pos++;
   if (*pos == 0) {
-    rb_hash_aset(
-        env, SERVER_NAME,
-        rb_enc_str_new(request->host, request->host_len, IodineBinaryEncoding));
+    rb_hash_aset(env, SERVER_NAME,
+                 rb_enc_str_new(tmp.data, tmp.len, IodineBinaryEncoding));
     rb_hash_aset(env, SERVER_PORT, QUERY_ESTRING);
   } else {
-    rb_hash_aset(env, SERVER_NAME,
-                 rb_enc_str_new(request->host, pos - request->host,
-                                IodineBinaryEncoding));
-    rb_hash_aset(env, SERVER_PORT,
-                 rb_enc_str_new(pos + 1,
-                                request->host_len - ((pos + 1) - request->host),
-                                IodineBinaryEncoding));
+    rb_hash_aset(
+        env, SERVER_NAME,
+        rb_enc_str_new(tmp.data, pos - tmp.data, IodineBinaryEncoding));
+    ++pos;
+    rb_hash_aset(
+        env, SERVER_PORT,
+        rb_enc_str_new(pos, tmp.len - (pos - tmp.data), IodineBinaryEncoding));
   }
 
-  /* default schema to http, it might be updated later */
-  rb_hash_aset(env, R_URL_SCHEME, HTTP_SCHEME);
-
-  /* add all headers, exclude special cases */
-  http_header_s header = http_request_header_first(request);
-  while (header.name) {
-    if (header.name_len == 14 &&
-        strncasecmp("content-length", header.name, 14) == 0) {
-      rb_hash_aset(
-          env, CONTENT_LENGTH,
-          rb_enc_str_new(header.value, header.value_len, IodineBinaryEncoding));
-      header = http_request_header_next(request);
-      continue;
-    } else if (header.name_len == 12 &&
-               strncasecmp("content-type", header.name, 12) == 0) {
-      rb_hash_aset(
-          env, CONTENT_TYPE,
-          rb_enc_str_new(header.value, header.value_len, IodineBinaryEncoding));
-      header = http_request_header_next(request);
-      continue;
-    } else if (header.name_len == 27 &&
-               strncasecmp("x-forwarded-proto", header.name, 27) == 0) {
-      if (header.value_len >= 5 && !strncasecmp(header.value, "https", 5)) {
+  /* remove special headers */
+  {
+    static uint64_t content_length_hash = 0;
+    if (!content_length_hash)
+      content_length_hash = fio_siphash("content-length", 14);
+    FIOBJ cl = fiobj_hash_get2(h->headers, content_length_hash);
+    if (cl) {
+      tmp = fiobj_obj2cstr(fiobj_hash_get2(h->headers, content_length_hash));
+      if (tmp.data) {
+        rb_hash_aset(env, CONTENT_LENGTH,
+                     rb_enc_str_new(tmp.data, tmp.len, IodineBinaryEncoding));
+        fiobj_hash_delete2(h->headers, content_length_hash);
+      }
+    }
+  }
+  {
+    static uint64_t content_type_hash = 0;
+    if (!content_type_hash)
+      content_type_hash = fio_siphash("content-type", 12);
+    FIOBJ ct = fiobj_hash_get2(h->headers, content_type_hash);
+    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);
+      }
+    }
+  }
+  /* handle scheme / sepcial forwarding headers */
+  {
+    FIOBJ objtmp;
+    static uint64_t xforward_hash = 0;
+    if (!xforward_hash)
+      xforward_hash = fio_siphash("x-forwarded-proto", 27);
+    static uint64_t forward_hash = 0;
+    if (!forward_hash)
+      forward_hash = fio_siphash("forwarded", 9);
+    if ((objtmp = fiobj_hash_get2(h->headers, xforward_hash))) {
+      tmp = fiobj_obj2cstr(objtmp);
+      if (tmp.len >= 5 && !strncasecmp(tmp.data, "https", 5)) {
         rb_hash_aset(env, R_URL_SCHEME, HTTPS_SCHEME);
-      } else if (header.value_len == 4 &&
-                 *((uint32_t *)header.value) == *((uint32_t *)"http")) {
+      } else if (tmp.len == 4 && !strncasecmp(tmp.data, "http", 4)) {
         rb_hash_aset(env, R_URL_SCHEME, HTTP_SCHEME);
       } else {
         rb_hash_aset(env, R_URL_SCHEME,
-                     rb_enc_str_new(header.value, header.value_len,
-                                    IodineBinaryEncoding));
+                     rb_enc_str_new(tmp.data, tmp.len, IodineBinaryEncoding));
       }
-    } else if (header.name_len == 9 &&
-               strncasecmp("forwarded", header.name, 9) == 0) {
-      pos = (char *)header.value;
+    } else if ((objtmp = fiobj_hash_get2(h->headers, forward_hash))) {
+      tmp = fiobj_obj2cstr(objtmp);
+      pos = tmp.data;
       if (pos) {
         while (*pos) {
           if (((*(pos++) | 32) == 'p') && ((*(pos++) | 32) == 'r') &&
@@ -209,25 +311,17 @@ static inline VALUE copy2env(http_request_s *request, VALUE template) {
           }
         }
       }
+    } else {
     }
-
-    hname = rb_str_buf_new(6 + header.name_len);
-    memcpy(RSTRING_PTR(hname), "HTTP_", 5);
-    pos = RSTRING_PTR(hname) + 5;
-    reader = header.name;
-    while (*reader) {
-      *(pos++) = *reader == '-' ? '_' : to_upper(*reader);
-      ++reader;
-    }
-    *pos = 0;
-    rb_str_set_len(hname, 5 + header.name_len);
-    rb_hash_aset(
-        env, hname,
-        rb_enc_str_new(header.value, header.value_len, IodineBinaryEncoding));
-    header = http_request_header_next(request);
   }
+
+  /* add all remianing headers */
+  fiobj_each1(h->headers, 0, iodine_copy2env_task, (void *)env);
   return env;
 }
+#undef add_str_to_env
+#undef add_value_to_env
+#undef add_header_to_env
 
 /* *****************************************************************************
 Handling the HTTP response
@@ -235,7 +329,8 @@ Handling the HTTP response
 
 // itterate through the headers and add them to the response buffer
 // (we are recycling the request's buffer)
-static int for_each_header_data(VALUE key, VALUE val, VALUE _res) {
+static int for_each_header_data(VALUE key, VALUE val, VALUE h_) {
+  http_s *h = (http_s *)h_;
   // fprintf(stderr, "For_each - headers\n");
   if (TYPE(key) != T_STRING)
     key = RubyCaller.call(key, iodine_to_s_method_id);
@@ -246,30 +341,37 @@ static int for_each_header_data(VALUE key, VALUE val, VALUE _res) {
     if (TYPE(val) != T_STRING)
       return ST_STOP;
   }
+  char *key_s = RSTRING_PTR(key);
+  int key_len = RSTRING_LEN(key);
   char *val_s = RSTRING_PTR(val);
   int val_len = RSTRING_LEN(val);
+  // make the headers lowercase
+  FIOBJ name = fiobj_str_new(key_s, key_len);
+  {
+    fio_cstr_s tmp = fiobj_obj2cstr(name);
+    for (int i = 0; i < key_len; ++i) {
+      tmp.data[i] = tolower(tmp.data[i]);
+    }
+  }
   // scan the value for newline (\n) delimiters
   int pos_s = 0, pos_e = 0;
   while (pos_e < val_len) {
     // scanning for newline (\n) delimiters
     while (pos_e < val_len && val_s[pos_e] != '\n')
       pos_e++;
-    http_response_write_header(
-        (void *)_res, .name = RSTRING_PTR(key), .name_len = RSTRING_LEN(key),
-        .value = val_s + pos_s, .value_len = pos_e - pos_s);
+    http_set_header(h, name, fiobj_str_new(val_s + pos_s, pos_e - pos_s));
     // fprintf(stderr, "For_each - headers: wrote header\n");
     // move forward (skip the '\n' if exists)
-    pos_s = pos_e + 1;
-    pos_e++;
+    ++pos_e;
+    pos_s = pos_e;
   }
+  fiobj_free(name);
   // no errors, return 0
   return ST_CONTINUE;
 }
 
 // writes the body to the response object
-static VALUE for_each_body_string(VALUE str, VALUE _res, int argc, VALUE argv) {
-  (void)(argv);
-  (void)(argc);
+static VALUE for_each_body_string(VALUE str, VALUE body_) {
   // fprintf(stderr, "For_each - body\n");
   // write body
   if (TYPE(str) != T_STRING) {
@@ -277,51 +379,45 @@ static VALUE for_each_body_string(VALUE str, VALUE _res, int argc, VALUE argv) {
                     "response body was not a String\n");
     return Qfalse;
   }
-  if (RSTRING_LEN(str)) {
-    if (http_response_write_body((void *)_res, RSTRING_PTR(str),
-                                 RSTRING_LEN(str))) {
-      // fprintf(stderr, "Iodine Server Error:"
-      //                 "couldn't write response to connection\n");
-      return Qfalse;
-    }
+  if (RSTRING_LEN(str) && RSTRING_PTR(str)) {
+    fiobj_str_write((FIOBJ)body_, RSTRING_PTR(str), RSTRING_LEN(str));
   }
   return Qtrue;
 }
 
-static inline int ruby2c_response_send(http_response_s *response,
+static inline int ruby2c_response_send(iodine_http_request_handle_s *handle,
                                        VALUE rbresponse, VALUE env) {
   (void)(env);
   VALUE body = rb_ary_entry(rbresponse, 2);
-  if (response->status < 200 || response->status == 204 ||
-      response->status == 304) {
+  if (handle->h->status < 200 || handle->h->status == 204 ||
+      handle->h->status == 304) {
     if (rb_respond_to(body, close_method_id))
       RubyCaller.call(body, close_method_id);
     body = Qnil;
-    response->content_length = -1;
+    handle->type = IODINE_HTTP_NONE;
+    return 0;
   }
-
-  if (TYPE(body) == T_ARRAY && RARRAY_LEN(body) == 1) { // [String] is likely
-    body = rb_ary_entry(body, 0);
-    // fprintf(stderr, "Body was a single item array, unpacket to string\n");
+  if (TYPE(body) == T_ARRAY) {
+    if (RARRAY_LEN(body) == 0) { // only headers
+      handle->type = IODINE_HTTP_EMPTY;
+    } else if (RARRAY_LEN(body) == 1) { // [String] is likely
+      body = rb_ary_entry(body, 0);
+      // fprintf(stderr, "Body was a single item array, unpacket to string\n");
+    }
   }
 
   if (TYPE(body) == T_STRING) {
     // fprintf(stderr, "Review body as String\n");
     if (RSTRING_LEN(body))
-      http_response_write_body(response, RSTRING_PTR(body), RSTRING_LEN(body));
-    return 0;
-  } else if (body == Qnil) {
+      handle->body = fiobj_str_new(RSTRING_PTR(body), RSTRING_LEN(body));
+    handle->type = IODINE_HTTP_SENDBODY;
     return 0;
   } else if (rb_respond_to(body, each_method_id)) {
     // fprintf(stderr, "Review body as for-each ...\n");
-    if (!response->connection_written && !response->content_length_written) {
-      // close the connection to indicate message length...
-      // protection from bad code
-      response->should_close = 1;
-      response->content_length = -1;
-    }
+    handle->body = fiobj_str_buf(1);
+    handle->type = IODINE_HTTP_SENDBODY;
     rb_block_call(body, each_method_id, 0, NULL, for_each_body_string,
-                  (VALUE)response);
+                  (VALUE)handle->body);
     // we need to call `close` in case the object is an IO / BodyProxy
     if (rb_respond_to(body, close_method_id))
       RubyCaller.call(body, close_method_id);
@@ -334,36 +430,37 @@ static inline int ruby2c_response_send(http_response_s *response,
 Handling Upgrade cases
 ***************************************************************************** */
 
-static inline int ruby2c_review_upgrade(http_response_s *response,
+static inline int ruby2c_review_upgrade(iodine_http_request_handle_s *req,
                                         VALUE rbresponse, VALUE env) {
+  http_s *h = req->h;
   VALUE handler;
   if ((handler = rb_hash_aref(env, IODINE_R_HIJACK_CB)) != Qnil) {
     // send headers
-    http_response_finish(response);
-    //  remove socket from facil.io
-    facil_attach(response->fd, NULL);
+    http_finish(h);
     // call the callback
     VALUE io_ruby = RubyCaller.call(rb_hash_aref(env, IODINE_R_HIJACK),
                                     iodine_call_proc_id);
     RubyCaller.call2(handler, iodine_call_proc_id, 1, &io_ruby);
   } else if ((handler = rb_hash_aref(env, IODINE_R_HIJACK_IO)) != Qnil) {
-    // send nothing.
-    http_response_destroy(response);
-    //  remove socket from facil.io
-    facil_attach(response->fd, NULL);
-  } else if ((handler = rb_hash_aref(env, UPGRADE_WEBSOCKET)) != Qnil) {
-    iodine_http_settings_s *settings = response->request->settings->udata;
+    //  do nothing
+  } else if (req->upgrade == IODINE_UPGRADE_WEBSOCKET &&
+             ((handler = rb_hash_aref(env, RACK_UPGRADE)) != Qnil ||
+              (handler = rb_hash_aref(env, UPGRADE_WEBSOCKET)) != Qnil)) {
     // use response as existing base for native websocket upgrade
-    iodine_websocket_upgrade(response->request, response, handler,
-                             settings->max_msg, settings->ping);
+    iodine_upgrade_websocket(h, handler);
+  } else if (req->upgrade == IODINE_UPGRADE_SSE &&
+             (handler = rb_hash_aref(env, RACK_UPGRADE)) != Qnil) {
+    // use response as existing base for SSE upgrade
+    iodine_upgrade_sse(h, handler);
   } else if ((handler = rb_hash_aref(env, UPGRADE_TCP)) != Qnil) {
-    intptr_t fduuid = response->fd;
+    // hijack post headers (might be very bad)
+    intptr_t uuid = http_hijack(h, NULL);
     // send headers
-    http_response_finish(response);
+    http_finish(h);
     // upgrade protocol
-    VALUE args[2] = {(ULONG2NUM(sock_uuid2fd(fduuid))), handler};
+    VALUE args[2] = {(ULONG2NUM(sock_uuid2fd(uuid))), handler};
     RubyCaller.call2(Iodine, attach_method_id, 2, args);
-    // prevent response processing.
+    // nothing left to do to prevent response processing.
   } else {
     return 0;
   }
@@ -379,176 +476,155 @@ static inline int ruby2c_review_upgrade(http_response_s *response,
 Handling HTTP requests
 ***************************************************************************** */
 
-static void *on_rack_request_in_GVL(http_request_s *request) {
-  http_response_s *response = http_response_create(request);
-  iodine_http_settings_s *settings = request->settings->udata;
-  if (request->settings->log_static)
-    http_response_log_start(response);
-  if (!settings->app)
+static inline void *iodine_handle_request_in_GVL(void *handle_) {
+  iodine_http_request_handle_s *handle = handle_;
+  VALUE rbresponse = 0;
+  VALUE env = 0;
+  http_s *h = handle->h;
+  if (!h->udata)
     goto err_not_found;
 
-  // create /register env variable
-  VALUE env = copy2env(request, settings->env);
+  // create / register env variable
+  env = copy2env(handle);
   // will be used later
   VALUE tmp;
   // pass env variable to handler
-  VALUE rbresponse =
-      RubyCaller.call2(settings->app, iodine_call_proc_id, 1, &env);
+  rbresponse = RubyCaller.call2((VALUE)h->udata, iodine_call_proc_id, 1, &env);
+  // test handler's return value
   if (rbresponse == 0 || rbresponse == Qnil)
     goto internal_error;
   Registry.add(rbresponse);
+
   // set response status
   tmp = rb_ary_entry(rbresponse, 0);
-  if (TYPE(tmp) == T_STRING)
-    tmp = rb_funcall2(tmp, to_fixnum_func_id, 0, NULL);
-  if (TYPE(tmp) != T_FIXNUM)
+  if (TYPE(tmp) == T_STRING) {
+    char *data = RSTRING_PTR(tmp);
+    h->status = fio_atol(&data);
+  } else if (TYPE(tmp) == T_FIXNUM) {
+    h->status = FIX2ULONG(tmp);
+  } else {
     goto internal_error;
-  response->status = FIX2ULONG(tmp);
+  }
+
   // handle header copy from ruby land to C land.
   VALUE response_headers = rb_ary_entry(rbresponse, 1);
   if (TYPE(response_headers) != T_HASH)
     goto internal_error;
   // extract the X-Sendfile header (never show original path)
-  // X-Sendfile support only present when iodine sercers static files.
+  // X-Sendfile support only present when iodine serves static files.
   VALUE xfiles;
-  if (request->settings->public_folder &&
+  if (support_xsendfile &&
       (xfiles = rb_hash_aref(response_headers, XSENDFILE)) != Qnil &&
       TYPE(xfiles) == T_STRING) {
-    int fr = 0;
     if (OBJ_FROZEN(response_headers)) {
       response_headers = rb_hash_dup(response_headers);
-      Registry.add(response_headers);
-      fr = 1;
     }
+    Registry.add(response_headers);
+    handle->body = fiobj_str_new(RSTRING_PTR(xfiles), RSTRING_LEN(xfiles));
+    handle->type = IODINE_HTTP_XSENDFILE;
     rb_hash_delete(response_headers, XSENDFILE);
-    // remove XFile's content length headers, as this will be controled by
-    // Iodine
+    // remove content length headers, as this will be controled by iodine
     rb_hash_delete(response_headers, CONTENT_LENGTH_HEADER);
     // review each header and write it to the response.
-    rb_hash_foreach(response_headers, for_each_header_data, (VALUE)(response));
-    if (fr)
-      Registry.remove(response_headers);
+    rb_hash_foreach(response_headers, for_each_header_data, (VALUE)(h));
+    Registry.remove(response_headers);
     // send the file directly and finish
-    if (http_response_sendfile2(response, request, RSTRING_PTR(xfiles),
-                                RSTRING_LEN(xfiles), NULL, 0, 1)) {
-      http_response_destroy(response);
-      response = http_response_create(request);
-      if (request->settings->log_static)
-        http_response_log_start(response);
-      Registry.remove(rbresponse);
-      Registry.remove(env);
-      goto err_not_found;
-    }
-    goto external_done;
+    return NULL;
   }
   // review each header and write it to the response.
-  rb_hash_foreach(response_headers, for_each_header_data, (VALUE)(response));
-  // If the X-Sendfile header was provided, send the file directly and finish
-  // review for belated (post response headers) upgrade.
-  if (ruby2c_review_upgrade(response, rbresponse, env))
+  rb_hash_foreach(response_headers, for_each_header_data, (VALUE)(h));
+  // review for upgrade.
+  if (h->status < 300 && ruby2c_review_upgrade(handle, rbresponse, env))
     goto external_done;
   // send the request body.
-  if (ruby2c_response_send(response, rbresponse, env))
+  if (ruby2c_response_send(handle, rbresponse, env))
     goto internal_error;
 
   Registry.remove(rbresponse);
   Registry.remove(env);
-  http_response_finish(response);
   return NULL;
 
 external_done:
   Registry.remove(rbresponse);
   Registry.remove(env);
+  handle->type = IODINE_HTTP_NONE;
   return NULL;
 
 err_not_found:
-  response->status = 404;
-  if (!request->settings->public_folder ||
-      http_response_sendfile2(response, request,
-                              request->settings->public_folder,
-                              request->settings->public_folder_length,
-                              "404.html", 8, request->settings->log_static)) {
-    http_response_write_body(response, "Error 404, Page Not Found.", 26);
-    http_response_finish(response);
-  }
+  Registry.remove(rbresponse);
+  Registry.remove(env);
+  h->status = 404;
+  handle->type = IODINE_HTTP_ERROR;
   return NULL;
 
 internal_error:
-  if (rbresponse && rbresponse != Qnil)
-    Registry.remove(rbresponse);
+  Registry.remove(rbresponse);
   Registry.remove(env);
-  http_response_destroy(response);
-  response = http_response_create(request);
-  if (request->settings->log_static)
-    http_response_log_start(response);
-  response->status = 500;
-  if (!request->settings->public_folder ||
-      http_response_sendfile2(response, request,
-                              request->settings->public_folder,
-                              request->settings->public_folder_length,
-                              "500.html", 8, request->settings->log_static)) {
-    http_response_write_body(response, "Error 500, Internal error.", 26);
-    http_response_finish(response);
-  }
+  h->status = 500;
+  handle->type = IODINE_HTTP_ERROR;
   return NULL;
 }
 
-static void on_rack_request(http_request_s *request) {
-  // if (request->body_file)
-  //   fprintf(stderr, "Request data is stored in a temporary file\n");
-  RubyCaller.call_c((void *(*)(void *))on_rack_request_in_GVL, request);
-}
-
-/* *****************************************************************************
-Initializing basic Rack ENV template
-***************************************************************************** */
-
-#define add_str_to_env(env, key, value)                                        \
-  {                                                                            \
-    VALUE k = rb_enc_str_new((key), strlen((key)), IodineBinaryEncoding);      \
-    rb_obj_freeze(k);                                                          \
-    VALUE v = rb_enc_str_new((value), strlen((value)), IodineBinaryEncoding);  \
-    rb_obj_freeze(v);                                                          \
-    rb_hash_aset(env, k, v);                                                   \
+static inline void
+iodine_perform_handle_action(iodine_http_request_handle_s handle) {
+  switch (handle.type) {
+  case IODINE_HTTP_SENDBODY: {
+    fio_cstr_s data = fiobj_obj2cstr(handle.body);
+    http_send_body(handle.h, data.data, data.len);
+    fiobj_free(handle.body);
+    break;
   }
-#define add_value_to_env(env, key, value)                                      \
-  {                                                                            \
-    VALUE k = rb_enc_str_new((key), strlen((key)), IodineBinaryEncoding);      \
-    rb_obj_freeze(k);                                                          \
-    rb_hash_aset((env), k, value);                                             \
+  case IODINE_HTTP_XSENDFILE: {
+    /* remove chunked content-encoding header, if any (Rack issue #1266) */
+    if (fiobj_obj2cstr(
+            fiobj_hash_get2(handle.h->private_data.out_headers,
+                            fiobj_obj2hash(HTTP_HEADER_CONTENT_ENCODING)))
+            .len == 7)
+      fiobj_hash_delete2(handle.h->private_data.out_headers,
+                         fiobj_obj2hash(HTTP_HEADER_CONTENT_ENCODING));
+    fio_cstr_s data = fiobj_obj2cstr(handle.body);
+    if (http_sendfile2(handle.h, data.data, data.len, NULL, 0)) {
+      http_send_error(handle.h, 404);
+    }
+    fiobj_free(handle.body);
+    break;
   }
+  case IODINE_HTTP_EMPTY:
+    http_finish(handle.h);
+    fiobj_free(handle.body);
+    break;
+  case IODINE_HTTP_NONE:
+    /* nothing to do - this had to be performed within the Ruby GIL :-( */
+    break;
+  case IODINE_HTTP_ERROR:
+    http_send_error(handle.h, handle.h->status);
+    fiobj_free(handle.body);
+    break;
+  }
+}
+static void on_rack_request(http_s *h) {
+  iodine_http_request_handle_s handle = (iodine_http_request_handle_s){
+      .h = h, .upgrade = IODINE_UPGRADE_NONE,
+  };
+  RubyCaller.call_c((void *(*)(void *))iodine_handle_request_in_GVL, &handle);
+  iodine_perform_handle_action(handle);
+}
 
-static void init_env_template(iodine_http_settings_s *set, uint8_t xsendfile) {
-  VALUE tmp;
-  set->env = rb_hash_new();
-  Registry.add(set->env);
-
-  // Start with the stuff Iodine will review.
-  rb_hash_aset(set->env, UPGRADE_WEBSOCKET, Qnil);
-  rb_hash_aset(set->env, UPGRADE_TCP, Qnil);
-  if (xsendfile) {
-    add_value_to_env(set->env, "sendfile.type", XSENDFILE);
-    add_value_to_env(set->env, "HTTP_X_SENDFILE_TYPE", XSENDFILE);
-  }
-  rb_hash_aset(set->env, UPGRADE_WEBSOCKET_Q, Qnil);
-  rb_hash_aset(set->env, UPGRADE_TCP_Q, Qnil);
-
-  // add the rack.version
-  tmp = rb_ary_new(); // rb_ary_new is Ruby 2.0 compatible
-  rb_ary_push(tmp, INT2FIX(1));
-  rb_ary_push(tmp, INT2FIX(3));
-  // rb_ary_push(tmp, rb_enc_str_new("1", 1, IodineBinaryEncoding));
-  // rb_ary_push(tmp, rb_enc_str_new("3", 1, IodineBinaryEncoding));
-  add_value_to_env(set->env, "rack.version", tmp);
-  add_value_to_env(set->env, "rack.errors", rb_stderr);
-  add_value_to_env(set->env, "rack.multithread", Qtrue);
-  add_value_to_env(set->env, "rack.multiprocess", Qtrue);
-  add_value_to_env(set->env, "rack.run_once", Qfalse);
-  add_value_to_env(set->env, "rack.hijack?", Qtrue);
-  add_str_to_env(set->env, "SCRIPT_NAME", "");
+static void on_rack_upgrade(http_s *h, char *proto, size_t len) {
+  iodine_http_request_handle_s handle = (iodine_http_request_handle_s){.h = h};
+  if (len == 9 && proto[1] == 'e') {
+    handle.upgrade = IODINE_UPGRADE_WEBSOCKET;
+  } else if (len == 3 && proto[0] == 's') {
+    handle.upgrade = IODINE_UPGRADE_SSE;
+  } else {
+    http_send_error(h, 400);
+    return;
+  }
+  RubyCaller.call_c(iodine_handle_request_in_GVL, &handle);
+  iodine_perform_handle_action(handle);
+  (void)proto;
+  (void)len;
 }
-#undef add_str_to_env
-#undef add_value_to_env
 
 /* *****************************************************************************
 Listenninng to HTTP
@@ -566,9 +642,7 @@ void *iodine_print_http_msg2_in_gvl(void *d_) {
             "Iodine HTTP Server on port %s:\n"
             " *    Serving static files from %s\n\n",
             StringValueCStr(arg->port), StringValueCStr(arg->www));
-    Registry.remove(arg->www);
   }
-  Registry.remove(arg->port);
   return NULL;
 }
 
@@ -584,49 +658,51 @@ void *iodine_print_http_msg_in_gvl(void *d_) {
     fprintf(stderr,
             "\nStarting up Iodine HTTP Server on port %s:\n"
             " * Ruby v.%s\n * Iodine v.%s \n"
-            " * %lu max concurrent connections / open files\n"
             " * Serving static files from %s\n\n",
             StringValueCStr(arg->port), StringValueCStr(ruby_version),
-            StringValueCStr(iodine_version), (size_t)sock_max_capacity(),
-            StringValueCStr(arg->www));
-    Registry.remove(arg->www);
-  } else
+            StringValueCStr(iodine_version), StringValueCStr(arg->www));
+  } else {
     fprintf(stderr,
             "\nStarting up Iodine HTTP Server on port %s:\n"
-            " * Ruby v.%s\n * Iodine v.%s \n"
-            " * %lu max concurrent connections / open files\n\n",
+            " * Ruby v.%s\n * Iodine v.%s \n\n",
             StringValueCStr(arg->port), StringValueCStr(ruby_version),
-            StringValueCStr(iodine_version), (size_t)sock_max_capacity());
-  Registry.remove(arg->port);
+            StringValueCStr(iodine_version));
+  }
 
   return NULL;
 }
 
 static void iodine_print_http_msg1(void *www, void *port) {
-  if (defer_fork_pid())
-    return;
+  if (getpid() != facil_parent_pid())
+    goto finish;
   struct {
     void *www;
     void *port;
   } data = {.www = www, .port = port};
   RubyCaller.call_c(iodine_print_http_msg_in_gvl, (void *)&data);
+finish:
+  if (www) {
+    Registry.remove((VALUE)www);
+  }
+  Registry.remove((VALUE)port);
 }
 static void iodine_print_http_msg2(void *www, void *port) {
-  if (defer_fork_pid())
-    return;
+  if (getpid() != facil_parent_pid())
+    goto finish;
   struct {
     void *www;
     void *port;
   } data = {.www = www, .port = port};
   RubyCaller.call_c(iodine_print_http_msg2_in_gvl, (void *)&data);
+finish:
+  if (www) {
+    Registry.remove((VALUE)www);
+  }
+  Registry.remove((VALUE)port);
 }
 
-static void free_iodine_http(intptr_t uuid, void *set_) {
-  iodine_http_settings_s *set = set_;
-  Registry.remove(set->app);
-  Registry.remove(set->env);
-  free(set);
-  (void)uuid;
+static void free_iodine_http(http_settings_s *s) {
+  Registry.remove((VALUE)s->udata);
 }
 /**
 Listens to incoming HTTP connections and handles incoming requests using the
@@ -643,10 +719,10 @@ port:: the port to listen to. Default: 3000.
 address:: the address to bind to. Default: binds to all possible addresses.
 log:: enable response logging (Hijacked sockets aren't logged). Default: off.
 public:: The root public folder for static file service. Default: none.
-timeout:: Timeout for inactive HTTP/1.x connections. Defaults: 5 seconds.
+timeout:: Timeout for inactive HTTP/1.x connections. Defaults: 40 seconds.
 max_body:: The maximum body size for incoming HTTP messages. Default: ~50Mib.
 max_msg:: The maximum Websocket message size allowed. Default: ~250Kib.
-ping:: The Websocket `ping` interval. Default: 40 sec.
+ping:: The Websocket `ping` interval. Default: 40 seconds.
 
 Either the `app` or the `public` properties are required. If niether exists,
 the function will fail. If both exist, Iodine will serve static files as well
@@ -668,6 +744,7 @@ VALUE iodine_http_listen(VALUE self, VALUE opt) {
   uint8_t log_http = 0;
   size_t ping = 0;
   size_t max_body = 0;
+  size_t max_headers = 0;
   size_t max_msg = 0;
   Check_Type(opt, T_HASH);
   VALUE app = rb_hash_aref(opt, ID2SYM(rb_intern("app")));
@@ -687,6 +764,11 @@ VALUE iodine_http_listen(VALUE self, VALUE opt) {
     Check_Type(tmp, T_FIXNUM);
     max_body = FIX2ULONG(tmp);
   }
+  tmp = rb_hash_aref(opt, ID2SYM(rb_intern("max_headers")));
+  if (tmp != Qnil && tmp != Qfalse) {
+    Check_Type(tmp, T_FIXNUM);
+    max_headers = FIX2ULONG(tmp);
+  }
 
   tmp = rb_hash_aref(opt, ID2SYM(rb_intern("ping")));
   if (tmp != Qnil && tmp != Qfalse) {
@@ -712,6 +794,9 @@ VALUE iodine_http_listen(VALUE self, VALUE opt) {
   if ((www != Qnil && www != Qfalse)) {
     Check_Type(www, T_STRING);
     Registry.add(www);
+    rb_hash_aset(env_template_no_upgrade, XSENDFILE_TYPE, XSENDFILE);
+    rb_hash_aset(env_template_no_upgrade, XSENDFILE_TYPE_HEADER, XSENDFILE);
+    support_xsendfile = 1;
   } else
     www = 0;
 
@@ -737,27 +822,27 @@ VALUE iodine_http_listen(VALUE self, VALUE opt) {
                "The `port` property MUST be either a String or a Number");
     if (RB_TYPE_P(port, T_FIXNUM))
       port = rb_funcall2(port, iodine_to_s_method_id, 0, NULL);
-  } else
+    Registry.add(port);
+  } else if (port == Qfalse)
+    port = 0;
+  else {
     port = rb_str_new("3000", 4);
-  Registry.add(port);
+    Registry.add(port);
+  }
 
   if ((app != Qnil && app != Qfalse))
     Registry.add(app);
   else
     app = 0;
 
-  iodine_http_settings_s *set = malloc(sizeof(*set));
-  *set = (iodine_http_settings_s){.app = app, .ping = ping, .max_msg = max_msg};
-
-  init_env_template(set, (www ? 1 : 0));
-
-  if (http_listen(StringValueCStr(port),
-                  (address ? StringValueCStr(address) : NULL),
-                  .on_request = on_rack_request, .udata = set,
-                  .timeout = (tout ? FIX2INT(tout) : tout),
-                  .on_finish = free_iodine_http, .log_static = log_http,
-                  .max_body_size = max_body,
-                  .public_folder = (www ? StringValueCStr(www) : NULL))) {
+  if (http_listen(
+          StringValueCStr(port), (address ? StringValueCStr(address) : NULL),
+          .on_request = on_rack_request, .on_upgrade = on_rack_upgrade,
+          .udata = (void *)app, .timeout = (tout ? FIX2INT(tout) : tout),
+          .ws_timeout = ping, .ws_max_msg_size = max_msg,
+          .max_header_size = max_headers, .on_finish = free_iodine_http,
+          .log = log_http, .max_body_size = max_body,
+          .public_folder = (www ? StringValueCStr(www) : NULL))) {
     fprintf(stderr,
             "ERROR: Failed to initialize a listening HTTP socket for port %s\n",
             port ? StringValueCStr(port) : "3000");
@@ -770,9 +855,9 @@ VALUE iodine_http_listen(VALUE self, VALUE opt) {
             "static files.\n",
             (port ? StringValueCStr(port) : "3000"));
   }
-  if (called_once)
+  if (called_once) {
     defer(iodine_print_http_msg2, (www ? (void *)www : NULL), (void *)port);
-  else {
+  } else {
     called_once = 1;
     defer(iodine_print_http_msg1, (www ? (void *)www : NULL), (void *)port);
   }
@@ -781,10 +866,83 @@ VALUE iodine_http_listen(VALUE self, VALUE opt) {
   (void)self;
 }
 
+static void initialize_env_template(void) {
+  if (env_template_no_upgrade)
+    return;
+  env_template_no_upgrade = rb_hash_new();
+  rb_global_variable(&env_template_no_upgrade);
+
+#define add_str_to_env(env, key, value)                                        \
+  {                                                                            \
+    VALUE k = rb_enc_str_new((key), strlen((key)), IodineBinaryEncoding);      \
+    rb_obj_freeze(k);                                                          \
+    VALUE v = rb_enc_str_new((value), strlen((value)), IodineBinaryEncoding);  \
+    rb_obj_freeze(v);                                                          \
+    rb_hash_aset(env, k, v);                                                   \
+  }
+#define add_value_to_env(env, key, value)                                      \
+  {                                                                            \
+    VALUE k = rb_enc_str_new((key), strlen((key)), IodineBinaryEncoding);      \
+    rb_obj_freeze(k);                                                          \
+    rb_hash_aset((env), k, value);                                             \
+  }
+
+  /* Set global template */
+  rb_hash_aset(env_template_no_upgrade, RACK_UPGRADE_Q, Qnil);
+  rb_hash_aset(env_template_no_upgrade, RACK_UPGRADE, Qnil);
+  rb_hash_aset(env_template_no_upgrade, UPGRADE_WEBSOCKET_Q, Qnil);
+  rb_hash_aset(env_template_no_upgrade, UPGRADE_WEBSOCKET, Qnil);
+  rb_hash_aset(env_template_no_upgrade, UPGRADE_TCP_Q, Qnil);
+  rb_hash_aset(env_template_no_upgrade, UPGRADE_TCP, Qnil);
+  {
+    /* add the rack.version */
+    static VALUE rack_version = 0;
+    if (!rack_version) {
+      rack_version = rb_ary_new(); // rb_ary_new is Ruby 2.0 compatible
+      rb_ary_push(rack_version, INT2FIX(1));
+      rb_ary_push(rack_version, INT2FIX(3));
+      rb_global_variable(&rack_version);
+      rb_ary_freeze(rack_version);
+    }
+    add_value_to_env(env_template_no_upgrade, "rack.version", rack_version);
+  }
+  add_str_to_env(env_template_no_upgrade, "SCRIPT_NAME", "");
+  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);
+  add_value_to_env(env_template_no_upgrade, "rack.multithread", Qtrue);
+  add_value_to_env(env_template_no_upgrade, "rack.run_once", Qfalse);
+  /* default schema to http, it might be updated later */
+  rb_hash_aset(env_template_no_upgrade, R_URL_SCHEME, HTTP_SCHEME);
+  /* placeholders... minimize rehashing*/
+  rb_hash_aset(env_template_no_upgrade, HTTP_VERSION, QUERY_STRING);
+  rb_hash_aset(env_template_no_upgrade, IODINE_R_HIJACK, QUERY_STRING);
+  rb_hash_aset(env_template_no_upgrade, PATH_INFO, QUERY_STRING);
+  rb_hash_aset(env_template_no_upgrade, QUERY_STRING, QUERY_STRING);
+  rb_hash_aset(env_template_no_upgrade, REMOTE_ADDR, QUERY_STRING);
+  rb_hash_aset(env_template_no_upgrade, REQUEST_METHOD, QUERY_STRING);
+  rb_hash_aset(env_template_no_upgrade, SERVER_NAME, QUERY_STRING);
+  rb_hash_aset(env_template_no_upgrade, SERVER_PORT, QUERY_ESTRING);
+  rb_hash_aset(env_template_no_upgrade, SERVER_PROTOCOL, QUERY_STRING);
+
+  /* WebSocket upgrade support */
+  env_template_websockets = rb_hash_dup(env_template_no_upgrade);
+  rb_global_variable(&env_template_websockets);
+  rb_hash_aset(env_template_websockets, UPGRADE_WEBSOCKET_Q, Qtrue);
+  rb_hash_aset(env_template_websockets, RACK_UPGRADE_Q, RACK_UPGRADE_WEBSOCKET);
+  rb_hash_aset(env_template_websockets, UPGRADE_TCP_Q, Qtrue);
+
+  /* SSE upgrade support */
+  env_template_sse = rb_hash_dup(env_template_no_upgrade);
+  rb_global_variable(&env_template_sse);
+  rb_hash_aset(env_template_sse, RACK_UPGRADE_Q, RACK_UPGRADE_SSE);
+
+#undef add_value_to_env
+#undef add_str_to_env
+}
 /* *****************************************************************************
 Initialization
-*****************************************************************************
-*/
+***************************************************************************** */
 
 void Iodine_init_http(void) {
 
@@ -806,6 +964,8 @@ void Iodine_init_http(void) {
   rack_set(R_URL_SCHEME, "rack.url_scheme");
   rack_set(R_INPUT, "rack.input");
   rack_set(XSENDFILE, "X-Sendfile");
+  rack_set(XSENDFILE_TYPE, "sendfile.type");
+  rack_set(XSENDFILE_TYPE_HEADER, "HTTP_X_SENDFILE_TYPE");
   rack_set(CONTENT_LENGTH_HEADER, "Content-Length");
 
   rack_set(IODINE_R_HIJACK_IO, "rack.hijack_io");
@@ -817,9 +977,10 @@ void Iodine_init_http(void) {
 
   rack_set(UPGRADE_TCP_Q, "upgrade.tcp?");
   rack_set(UPGRADE_WEBSOCKET_Q, "upgrade.websocket?");
-
-  rack_set(QUERY_ESTRING, "");
-  rack_set(QUERY_ESTRING, "");
+  rack_set(RACK_UPGRADE, "rack.upgrade");
+  rack_set(RACK_UPGRADE_Q, "rack.upgrade?");
+  rack_set_sym(RACK_UPGRADE_SSE, "sse");
+  rack_set_sym(RACK_UPGRADE_WEBSOCKET, "websocket");
 
   hijack_func_sym = ID2SYM(rb_intern("_hijack"));
   close_method_id = rb_intern("close");
@@ -827,4 +988,6 @@ void Iodine_init_http(void) {
   attach_method_id = rb_intern("attach_fd");
 
   IodineRackIO.init();
+  initialize_env_template();
+  Iodine_init_json();
 }