iodine 0.3.6 → 0.4.0

data/ext/iodine/http1.c

@@ -27,6 +27,7 @@ typedef struct http1_protocol_s {
   void (*on_request)(http_request_s *request);
   struct http1_protocol_s *next;
   http1_request_s request;
+  ssize_t len; /* used as a persistent socket `read` indication. */
 } http1_protocol_s;
 
 static void http1_on_data(intptr_t uuid, http1_protocol_s *protocol);
@@ -42,7 +43,7 @@ static struct {
   http1_protocol_s protocol_mem[HTTP1_POOL_SIZE];
 } http1_pool = {.lock = SPN_LOCK_INIT, .init = 0};
 
-static void http1_free(http1_protocol_s *pr) {
+static void http1_free(intptr_t uuid, http1_protocol_s *pr) {
   if ((uintptr_t)pr < (uintptr_t)http1_pool.protocol_mem ||
       (uintptr_t)pr >= (uintptr_t)(http1_pool.protocol_mem + HTTP1_POOL_SIZE))
     goto use_free;
@@ -54,14 +55,15 @@ static void http1_free(http1_protocol_s *pr) {
 use_free:
   free(pr);
   return;
+  (void)uuid;
 }
 
 static inline void http1_set_protocol_data(http1_protocol_s *pr) {
-  pr->protocol =
-      (protocol_s){.on_data = (void (*)(intptr_t, protocol_s *))http1_on_data,
-                   .on_close = (void (*)(protocol_s *))http1_free};
+  pr->protocol = (protocol_s){
+      .on_data = (void (*)(intptr_t, protocol_s *))http1_on_data,
+      .on_close = (void (*)(intptr_t uuid, protocol_s *))http1_free};
   pr->request.request = (http_request_s){.fd = 0, .http_version = HTTP_V1};
-  pr->request.header_pos = pr->request.buffer_pos = 0;
+  pr->request.header_pos = pr->request.buffer_pos = pr->len = 0;
 }
 
 static http1_protocol_s *http1_alloc(void) {
@@ -73,6 +75,8 @@ static http1_protocol_s *http1_alloc(void) {
   http1_pool.next = pr->next;
   spn_unlock(&http1_pool.lock);
   http1_request_clear(&pr->request.request);
+  pr->request.request.settings = pr->settings;
+  pr->len = 0;
   return pr;
 use_malloc:
   if (http1_pool.init == 0)
@@ -107,24 +111,29 @@ static void http1_on_header_found(http_request_s *request,
   ((http1_request_s *)request)->header_pos += 1;
 }
 
+static void http1_on_data(intptr_t uuid, http1_protocol_s *pr);
+static void http1_on_data_def(intptr_t uuid, protocol_s *pr, void *ignr) {
+  sock_touch(uuid);
+  http1_on_data(uuid, (http1_protocol_s *)pr);
+  (void)ignr;
+}
 /* parse and call callback */
-static void http1_on_data(intptr_t uuid, http1_protocol_s *protocol) {
-  ssize_t len = 0;
+static void http1_on_data(intptr_t uuid, http1_protocol_s *pr) {
   ssize_t result;
   char buff[HTTP_BODY_CHUNK_SIZE];
-  char *buffer;
-  http1_request_s *request = &protocol->request;
+  http1_request_s *request = &pr->request;
+  char *buffer = request->buffer;
   for (;;) {
     // handle requests with no file data
     if (request->request.body_file <= 0) {
       // request headers parsing
-      if (len == 0) {
+      if (pr->len == 0) {
         buffer = request->buffer;
         // make sure headers don't overflow
-        len = sock_read(uuid, buffer + request->buffer_pos,
-                        HTTP1_MAX_HEADER_SIZE - request->buffer_pos);
+        pr->len = sock_read(uuid, buffer + request->buffer_pos,
+                            HTTP1_MAX_HEADER_SIZE - request->buffer_pos);
         // update buffer read position.
-        request->buffer_pos += len;
+        request->buffer_pos += pr->len;
         // if (len > 0) {
         //   fprintf(stderr, "\n----\nRead from socket, %lu bytes, total
         //   %lu:\n",
@@ -135,9 +144,8 @@ static void http1_on_data(intptr_t uuid, http1_protocol_s *protocol) {
         //   fprintf(stderr, "\n");
         // }
       }
-      if (len <= 0) {
-        return;
-      }
+      if (pr->len <= 0)
+        goto finished_reading;
 
       // parse headers
       result =
@@ -149,12 +157,11 @@ static void http1_on_data(intptr_t uuid, http1_protocol_s *protocol) {
         if (request->request.content_length == 0 || request->request.body_str) {
           goto handle_request;
         }
-        if (request->request.content_length >
-            protocol->settings->max_body_size) {
+        if (request->request.content_length > pr->settings->max_body_size) {
           goto body_to_big;
         }
         // initialize or submit body data
-        result = http1_parse_request_body(buffer + result, len - result,
+        result = http1_parse_request_body(buffer + result, pr->len - result,
                                           (http_request_s *)request);
         if (result >= 0) {
           request->buffer_pos += result;
@@ -165,7 +172,7 @@ static void http1_on_data(intptr_t uuid, http1_protocol_s *protocol) {
       } else if (result == -1) // parser error
         goto parser_error;
       // assume incomplete (result == -2), even if wrong, we're right.
-      len = 0;
+      pr->len = 0;
       continue;
     }
     if (request->request.body_file > 0) {
@@ -173,16 +180,16 @@ static void http1_on_data(intptr_t uuid, http1_protocol_s *protocol) {
     parse_body:
       buffer = buff;
       // request body parsing
-      len = sock_read(uuid, buffer, HTTP_BODY_CHUNK_SIZE);
-      if (len <= 0)
-        return;
-      result = http1_parse_request_body(buffer, len, &request->request);
+      pr->len = sock_read(uuid, buffer, HTTP_BODY_CHUNK_SIZE);
+      if (pr->len <= 0)
+        goto finished_reading;
+      result = http1_parse_request_body(buffer, pr->len, &request->request);
       if (result >= 0) {
         goto handle_request;
       } else if (result == -1) // parser error
         goto parser_error;
-      if (len < HTTP_BODY_CHUNK_SIZE) // pause parser for more data
-        return;
+      if (pr->len < HTTP_BODY_CHUNK_SIZE) // pause parser for more data
+        goto finished_reading;
       goto parse_body;
     }
     continue;
@@ -190,24 +197,25 @@ static void http1_on_data(intptr_t uuid, http1_protocol_s *protocol) {
     // review required headers / data
     if (request->request.host == NULL)
       goto bad_request;
-    http_settings_s *settings = protocol->settings;
+    http_settings_s *settings = pr->settings;
+    request->request.settings = settings;
     // call request callback
-    if (protocol && settings &&
+    if (pr && settings &&
         (request->request.upgrade || settings->public_folder == NULL ||
          http_response_sendfile2(
              NULL, &request->request, settings->public_folder,
              settings->public_folder_length, request->request.path,
              request->request.path_len, settings->log_static))) {
-      protocol->on_request(&request->request);
+      pr->on_request(&request->request);
       // fprintf(stderr, "Called on_request\n");
     }
     // rotate buffer for HTTP pipelining
     if ((ssize_t)request->buffer_pos <= result) {
-      len = 0;
+      pr->len = 0;
       // fprintf(stderr, "\n----\nAll data consumed.\n");
     } else {
       memmove(request->buffer, buffer + result, request->buffer_pos - result);
-      len = request->buffer_pos - result;
+      pr->len = request->buffer_pos - result;
       // fprintf(stderr, "\n----\ndata after move, %lu long:\n%.*s\n", len,
       //         (int)len, request->buffer);
     }
@@ -215,14 +223,22 @@ static void http1_on_data(intptr_t uuid, http1_protocol_s *protocol) {
     //         request->buffer);
     // clear request state
     http1_request_clear(&request->request);
-    request->buffer_pos = len;
+    request->buffer_pos = pr->len;
     // make sure to use the correct buffer.
     buffer = request->buffer;
+    if (pr->len) {
+      /* prevent this connection from hogging the thread by pipelining endless
+       * requests.
+       */
+      facil_defer(.task = http1_on_data_def, .task_type = FIO_PR_LOCK_TASK,
+                  .uuid = uuid);
+      return;
+    }
   }
   // no routes lead here.
   fprintf(stderr,
           "I am lost on a deserted island, no code can reach me here :-)\n");
-  return; // How did we get here?
+  goto finished_reading; // How did we get here?
 parser_error:
   if (request->request.headers_count >= HTTP1_MAX_HEADER_COUNT)
     goto too_big;
@@ -231,34 +247,54 @@ bad_request:
   {
     http_response_s *response = http_response_create(&request->request);
     response->status = 400;
-    http_response_write_body(response, "Bad Request", 11);
-    http_response_finish(response);
+    if (!pr->settings->public_folder ||
+        http_response_sendfile2(response, &request->request,
+                                pr->settings->public_folder,
+                                pr->settings->public_folder_length, "400.html",
+                                8, pr->settings->log_static)) {
+      http_response_write_body(response, "Bad Request", 11);
+      http_response_finish(response);
+    }
     sock_close(uuid);
     request->buffer_pos = 0;
-    return;
+    goto finished_reading;
   }
 too_big:
   /* handle oversized headers */
   {
     http_response_s *response = http_response_create(&request->request);
     response->status = 431;
-    http_response_write_body(response, "Request Header Fields Too Large", 31);
-    http_response_finish(response);
+    if (!pr->settings->public_folder ||
+        http_response_sendfile2(response, &request->request,
+                                pr->settings->public_folder,
+                                pr->settings->public_folder_length, "431.html",
+                                8, pr->settings->log_static)) {
+      http_response_write_body(response, "Request Header Fields Too Large", 31);
+      http_response_finish(response);
+    }
     sock_close(uuid);
     request->buffer_pos = 0;
-    return;
+    goto finished_reading;
   body_to_big:
     /* handle oversized body */
     {
       http_response_s *response = http_response_create(&request->request);
       response->status = 413;
-      http_response_write_body(response, "Payload Too Large", 17);
-      http_response_finish(response);
+      if (!pr->settings->public_folder ||
+          http_response_sendfile2(response, &request->request,
+                                  pr->settings->public_folder,
+                                  pr->settings->public_folder_length,
+                                  "413.html", 8, pr->settings->log_static)) {
+        http_response_write_body(response, "Payload Too Large", 17);
+        http_response_finish(response);
+      }
       sock_close(uuid);
       request->buffer_pos = 0;
-      return;
+      goto finished_reading;
     }
   }
+finished_reading:
+  pr->len = 0;
 }
 
 /* *****************************************************************************

data/ext/iodine/http_request.c

@@ -4,10 +4,16 @@ License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
 #include "http.h"
 #include "http1_request.h"
 
 #include <signal.h>
+#include <sys/types.h>
+
 /* *****************************************************************************
 Unsupported function placeholders
 ***************************************************************************** */

data/ext/iodine/http_request.h

@@ -7,11 +7,14 @@ Feel free to copy, use and enjoy according to the license provided.
 #ifndef H_HTTP_REQUEST_H
 #define H_HTTP_REQUEST_H
 typedef struct http_request_s http_request_s;
+
 #include "http.h"
 
 struct http_request_s {
   /** the HTTP version, also controlls the `http_request_s` flavor. */
   enum HTTP_VERSION http_version;
+  /** A pointer to the protocol's settings */
+  const http_settings_s *settings;
   /** the HTTP connection identifier. */
   intptr_t fd;
   /** this is an opaque pointer, intended for request pooling / chaining */

data/ext/iodine/http_response.c

@@ -4,6 +4,10 @@ License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
 #include "base64.h"
 #include "http.h"
 #include "http1_response.h"
@@ -232,6 +236,8 @@ int http_response_sendfile2(http_response_s *response, http_request_s *request,
 
   if (file_path_unsafe && path_unsafe_len == 0)
     path_unsafe_len = strlen(file_path_unsafe);
+  if (!path_unsafe_len)
+    return -1;
 
   const char *mime = NULL;
   const char *ext = NULL;
@@ -241,7 +247,7 @@ int http_response_sendfile2(http_response_s *response, http_request_s *request,
   // char *fname = malloc(path_safe_len + path_unsafe_len + 1 + 11);
   if ((path_safe_len + path_unsafe_len) >= (PATH_MAX - 1 - 11))
     return -1;
-  char fname[path_safe_len + path_unsafe_len + 1 + 11];
+  char fname[path_safe_len + path_unsafe_len + (1 + 11 + 3)];
   // if (fname == NULL)
   //   return -1;
   if (file_path_safe)
@@ -249,10 +255,10 @@ int http_response_sendfile2(http_response_s *response, http_request_s *request,
   fname[path_safe_len] = 0;
   // if the last character is a '/', step back.
   if (file_path_unsafe) {
-    if (fname[path_safe_len - 1] == '/')
+    if (fname[path_safe_len - 1] == '/' && file_path_unsafe[0] == '/')
       path_safe_len--;
-    ssize_t tmp = http_decode_url(fname + path_safe_len, file_path_unsafe,
-                                  path_unsafe_len);
+    ssize_t tmp = http_decode_path(fname + path_safe_len, file_path_unsafe,
+                                   path_unsafe_len);
     if (tmp < 0)
       goto no_file;
     path_safe_len += tmp;
@@ -276,8 +282,27 @@ int http_response_sendfile2(http_response_s *response, http_request_s *request,
   // fprintf(stderr, "file name: %s\noriginal request path: %s\n", fname,
   //         req->path);
   // get file data (prevent folder access and get modification date)
-  if (stat(fname, &file_data))
-    goto no_file;
+  {
+    http_header_s accept =
+        http_request_header_find(request, "accept-encoding", 15);
+    if (accept.data && strcasestr(accept.data, "gzip")) {
+      buffer[0] = 1;
+      fname[path_safe_len] = '.';
+      fname[path_safe_len + 1] = 'g';
+      fname[path_safe_len + 2] = 'z';
+      fname[path_safe_len + 3] = 0;
+      if (stat(fname, &file_data)) {
+        buffer[0] = 0;
+        fname[path_safe_len] = 0;
+        if (stat(fname, &file_data))
+          goto no_file;
+      }
+    } else {
+      buffer[0] = 0;
+      if (stat(fname, &file_data))
+        goto no_file;
+    }
+  }
   // check that we have a file and not something else
   if (!S_ISREG(file_data.st_mode) && !S_ISLNK(file_data.st_mode))
     goto no_file;
@@ -288,9 +313,9 @@ int http_response_sendfile2(http_response_s *response, http_request_s *request,
     if (log)
       http_response_log_start(response);
   }
-
   // we have a file, time to handle response details.
   int file = open(fname, O_RDONLY);
+
   // free the allocated fname memory
   // free(fname);
   // fname = NULL;
@@ -298,6 +323,12 @@ int http_response_sendfile2(http_response_s *response, http_request_s *request,
     goto no_fd_available;
   }
 
+  if (buffer[0]) {
+    fname[path_safe_len] = 0;
+    http_response_write_header(response, .name = "Content-Encoding",
+                               .name_len = 16, .value = "gzip", .value_len = 4);
+  }
+
   // get the mime type (we have an ext pointer and the string isn't empty)
   if (ext && ext[1]) {
     mime = http_response_ext2mime(ext + 1);
@@ -307,8 +338,8 @@ int http_response_sendfile2(http_response_s *response, http_request_s *request,
     }
   }
   /* add ETag */
-  uint64_t sip = file_data.st_size;
-  sip ^= file_data.st_mtime;
+  uint64_t sip = (uint64_t)file_data.st_size;
+  sip ^= (uint64_t)file_data.st_mtime;
   sip = siphash24(&sip, sizeof(uint64_t), SIPHASH_DEFAULT_KEY);
   bscrypt_base64_encode(buffer, (void *)&sip, 8);
   http_response_write_header(response, .name = "ETag", .name_len = 4,
@@ -441,6 +472,9 @@ void http_response_log_start(http_response_s *response) {
 prints out the log to stderr.
 */
 static void http_response_log_finish(http_response_s *response) {
+#define HTTP_REQUEST_LOG_LIMIT 128
+  char buffer[HTTP_REQUEST_LOG_LIMIT];
+
   http_request_s *request = response->request;
   intptr_t bytes_sent = response->content_length;
 
@@ -455,8 +489,6 @@ static void http_response_log_finish(http_response_s *response) {
   // TODO Guess IP address from headers (forwarded) where possible
   sock_peer_addr_s addrinfo = sock_peer_addr(response->fd);
 
-#define HTTP_REQUEST_LOG_LIMIT 128
-  char buffer[HTTP_REQUEST_LOG_LIMIT];
   size_t pos = 0;
   if (addrinfo.addrlen) {
     if (inet_ntop(

data/ext/iodine/iodine.c

@@ -0,0 +1,380 @@
+#include "iodine.h"
+#include "iodine_helpers.h"
+#include "iodine_http.h"
+#include "iodine_protocol.h"
+#include "iodine_pubsub.h"
+#include "iodine_websockets.h"
+#include "rb-rack-io.h"
+/*
+Copyright: Boaz segev, 2016-2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+
+VALUE Iodine;
+VALUE IodineBase;
+VALUE Iodine_Version;
+
+ID iodine_fd_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_shutdown_func_id;
+ID iodine_on_close_func_id;
+ID iodine_ping_func_id;
+ID iodine_buff_var_id;
+ID iodine_to_s_method_id;
+ID iodine_to_i_func_id;
+
+rb_encoding *IodineBinaryEncoding;
+rb_encoding *IodineUTF8Encoding;
+int IodineBinaryEncodingIndex;
+int IodineUTF8EncodingIndex;
+
+/* *****************************************************************************
+Internal helpers
+***************************************************************************** */
+
+static void iodine_run_task(void *block_) {
+  RubyCaller.call((VALUE)block_, iodine_call_proc_id);
+}
+
+static void iodine_perform_deferred(void *block_, void *ignr) {
+  RubyCaller.call((VALUE)block_, iodine_call_proc_id);
+  Registry.remove((VALUE)block_);
+  (void)ignr;
+}
+
+/* *****************************************************************************
+Published functions
+***************************************************************************** */
+
+/** Returns the number of total connections managed by Iodine. */
+static VALUE iodine_count(VALUE self) {
+  size_t count = facil_count(NULL);
+  return ULL2NUM(count);
+  (void)self;
+}
+
+/**
+Runs the required block after the specified number of milliseconds have passed.
+Time is counted only once Iodine started running (using {Iodine.start}).
+
+Tasks scheduled before calling {Iodine.start} will run once for every process.
+
+Always returns a copy of the block object.
+*/
+static VALUE iodine_run_after(VALUE self, VALUE milliseconds) {
+  (void)(self);
+  if (TYPE(milliseconds) != T_FIXNUM) {
+    rb_raise(rb_eTypeError, "milliseconds must be a number");
+    return Qnil;
+  }
+  size_t milli = FIX2UINT(milliseconds);
+  // requires a block to be passed
+  rb_need_block();
+  VALUE block = rb_block_proc();
+  if (block == Qnil)
+    return Qfalse;
+  Registry.add(block);
+  facil_run_every(milli, 1, iodine_run_task, (void *)block,
+                  (void (*)(void *))Registry.remove);
+  return block;
+}
+/**
+Runs the required block after the specified number of milliseconds have passed.
+Time is counted only once Iodine started running (using {Iodine.start}).
+
+Accepts:
+
+milliseconds:: the number of milliseconds between event repetitions.
+
+repetitions:: the number of event repetitions. Defaults to 0 (never ending).
+
+block:: (required) a block is required, as otherwise there is nothing to
+perform.
+
+The event will repeat itself until the number of repetitions had been delpeted.
+
+Always returns a copy of the block object.
+*/
+static VALUE iodine_run_every(int argc, VALUE *argv, VALUE self) {
+  (void)(self);
+  VALUE milliseconds, repetitions, block;
+
+  rb_scan_args(argc, argv, "11&", &milliseconds, &repetitions, &block);
+
+  if (TYPE(milliseconds) != T_FIXNUM) {
+    rb_raise(rb_eTypeError, "milliseconds must be a number.");
+    return Qnil;
+  }
+  if (repetitions != Qnil && TYPE(repetitions) != T_FIXNUM) {
+    rb_raise(rb_eTypeError, "repetitions must be a number or `nil`.");
+    return Qnil;
+  }
+
+  size_t milli = FIX2UINT(milliseconds);
+  size_t repeat = (repetitions == Qnil) ? 0 : FIX2UINT(repetitions);
+  // requires a block to be passed
+  rb_need_block();
+  Registry.add(block);
+  facil_run_every(milli, repeat, iodine_run_task, (void *)block,
+                  (void (*)(void *))Registry.remove);
+  return block;
+}
+
+static VALUE iodine_run(VALUE self) {
+  rb_need_block();
+  VALUE block = rb_block_proc();
+  if (block == Qnil)
+    return Qfalse;
+  Registry.add(block);
+  defer(iodine_perform_deferred, (void *)block, NULL);
+  return block;
+  (void)self;
+}
+
+/* *****************************************************************************
+Idling
+***************************************************************************** */
+#include "fio_list.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);
+
+/**
+Schedules a single occuring event for the next idle cycle.
+
+To schedule a reoccuring event, simply reschedule the event at the end of it's
+run.
+
+i.e.
+
+      IDLE_PROC = Proc.new { puts "idle"; Iodine.on_idle &IDLE_PROC }
+      Iodine.on_idle &IDLE_PROC
+*/
+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);
+  spn_lock(&iodine_on_idle_lock);
+  fio_list_push(iodine_idle_block_s, node, iodine_on_idle_list, b);
+  spn_unlock(&iodine_on_idle_lock);
+  return b->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);
+  }
+  spn_unlock(&iodine_on_idle_lock);
+}
+/* *****************************************************************************
+Running the server
+***************************************************************************** */
+
+#include "spnlock.inc"
+#include <pthread.h>
+
+static volatile int sock_io_thread = 0;
+static pthread_t sock_io_pthread;
+
+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};
+    nanosleep(&tm, NULL);
+  }
+  return NULL;
+}
+static void iodine_start_io_thread(void *a1, void *a2) {
+  (void)a1;
+  (void)a2;
+  pthread_create(&sock_io_pthread, NULL, iodine_io_thread, NULL);
+}
+static void iodine_join_io_thread(void) {
+  sock_io_thread = 0;
+  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
+  sock_io_thread = 1;
+  defer(iodine_start_io_thread, NULL, NULL);
+  fprintf(stderr, "\n");
+  facil_run(.threads = threads, .processes = processes,
+            .on_idle = iodine_on_idle, .on_finish = iodine_join_io_thread);
+  return NULL;
+}
+
+static int iodine_review_rack_app(void) {
+  /* Check for Iodine::Rack.app and perform the C equivalent:
+   *  Iodine::HTTP.listen app: @app, port: @port, address: @address, log: @log,
+   *          max_msg: max_msg, max_body: max_body, public: @public, ping:
+   *          @ws_timeout, timeout: @timeout
+   */
+
+  VALUE rack = rb_const_get(Iodine, rb_intern("Rack"));
+  VALUE app = rb_ivar_get(rack, rb_intern("@app"));
+  VALUE www = rb_ivar_get(rack, rb_intern("@public"));
+  if ((app == Qnil || app == Qfalse) && (www == Qnil || www == Qfalse))
+    return 0;
+  VALUE opt = rb_hash_new();
+  Registry.add(opt);
+
+  rb_hash_aset(opt, ID2SYM(rb_intern("app")),
+               rb_ivar_get(rack, rb_intern("@app")));
+  rb_hash_aset(opt, ID2SYM(rb_intern("port")),
+               rb_ivar_get(rack, rb_intern("@port")));
+  rb_hash_aset(opt, ID2SYM(rb_intern("app")),
+               rb_ivar_get(rack, rb_intern("@app")));
+  rb_hash_aset(opt, ID2SYM(rb_intern("address")),
+               rb_ivar_get(rack, rb_intern("@address")));
+  rb_hash_aset(opt, ID2SYM(rb_intern("log")),
+               rb_ivar_get(rack, rb_intern("@log")));
+  rb_hash_aset(opt, ID2SYM(rb_intern("max_msg")),
+               rb_ivar_get(rack, rb_intern("@max_msg")));
+  rb_hash_aset(opt, ID2SYM(rb_intern("max_body")),
+               rb_ivar_get(rack, rb_intern("@max_body")));
+  rb_hash_aset(opt, ID2SYM(rb_intern("public")),
+               rb_ivar_get(rack, rb_intern("@public")));
+  rb_hash_aset(opt, ID2SYM(rb_intern("ping")),
+               rb_ivar_get(rack, rb_intern("@ping")));
+  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)
+    return -1;
+  return 0;
+}
+
+/**
+Starts the Iodine event loop. This will hang the thread until an interrupt
+(`^C`) signal is received.
+
+Returns the Iodine module.
+*/
+static VALUE iodine_start(VALUE self) {
+  /* 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);
+  return self;
+}
+
+/* *****************************************************************************
+Debug
+***************************************************************************** */
+
+VALUE iodine_print_registry(VALUE self) {
+  Registry.print();
+  return Qnil;
+  (void)self;
+}
+
+/* *****************************************************************************
+Library Initialization
+***************************************************************************** */
+
+////////////////////////////////////////////////////////////////////////
+// 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) {
+  // initialize globally used IDs, for faster access to the Ruby layer.
+  iodine_fd_var_id = rb_intern("scrtfd");
+  iodine_call_proc_id = rb_intern("call");
+  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_data_func_id = rb_intern("on_data");
+  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");
+
+  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.
+  Iodine = rb_define_module("Iodine");
+
+  // the Iodine singleton functions
+  rb_define_module_function(Iodine, "start", iodine_start, 0);
+  rb_define_singleton_method(Iodine, "count", iodine_count, 0);
+  rb_define_module_function(Iodine, "run", iodine_run, 0);
+  rb_define_module_function(Iodine, "run_after", iodine_run_after, 1);
+  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.
+  IodineBase = rb_define_module_under(Iodine, "Base");
+  rb_define_module_function(IodineBase, "db_print_registry",
+                            iodine_print_registry, 0);
+
+  // Initialize the registry under the Iodine core
+  Registry.init(Iodine);
+
+  /* Initialize the rest of the library. */
+  Iodine_init_protocol();
+  Iodine_init_pubsub();
+  Iodine_init_http();
+  Iodine_init_websocket();
+  Iodine_init_helpers();
+}