iodine 0.2.17 → 0.3.0

data/ext/iodine/iodine_core.h

@@ -17,9 +17,11 @@ Feel free to copy, use and enjoy according to the license provided.
 #include <ruby/io.h>
 // clang-format on
 
-#include "libserver.h"
 #include "rb-call.h"
 #include "rb-registry.h"
+
+#include "facil.h"
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

data/ext/iodine/iodine_http.c

@@ -8,6 +8,9 @@ Feel free to copy, use and enjoy according to the license provided.
 #include "iodine_websocket.h"
 #include "websockets.h"
 
+#include <arpa/inet.h>
+#include <sys/socket.h>
+
 /* the Iodine::Rack HTTP server class*/
 VALUE IodineHttp;
 /* these three are used also by rb-rack-io.c */
@@ -38,6 +41,8 @@ static _Bool iodine_http_static_file_server = 0;
 
 #define rack_autoset(rack_name) rack_set((rack_name), #rack_name)
 
+static uint8_t IODINE_IS_DEVELOPMENT_MODE = 0;
+
 static VALUE ENV_TEMPLATE;
 
 rack_declare(HTTP_SCHEME);
@@ -80,8 +85,9 @@ static inline VALUE copy2env(http_request_s *request) {
       env, REQUEST_METHOD,
       rb_enc_str_new(request->method, request->method_len, BinaryEncoding));
 
-  rb_hash_aset(env, PATH_INFO, rb_enc_str_new(request->path, request->path_len,
-                                              BinaryEncoding));
+  rb_hash_aset(
+      env, PATH_INFO,
+      rb_enc_str_new(request->path, request->path_len, BinaryEncoding));
   rb_hash_aset(
       env, QUERY_STRING,
       (request->query
@@ -98,10 +104,22 @@ static inline VALUE copy2env(http_request_s *request) {
   rb_hash_aset(env, SERVER_PROTOCOL, hname);
   rb_hash_aset(env, HTTP_VERSION, hname);
 
-  // rack_declare(REMOTE_ADDR);
+  // 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);
+  }
 
   /* setup input IO + hijack support */
-  rb_hash_aset(env, R_INPUT, (hname = RackIO.new(request, env)));
+  rb_hash_aset(env, R_INPUT, (hname = RackIO.create(request, env)));
 
   /* publish upgrade support */
   if (request->upgrade) {
@@ -135,36 +153,37 @@ static inline VALUE copy2env(http_request_s *request) {
   rb_hash_aset(env, R_URL_SCHEME, HTTP_SCHEME);
 
   /* add all headers, exclude special cases */
-  http_headers_s *header = request->headers;
-  for (size_t i = 0; i < request->headers_count; i++, header++) {
-    if (header->name_length == 14 &&
-        strncasecmp("content-length", header->name, 14) == 0) {
+  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_length, BinaryEncoding));
+          rb_enc_str_new(header.value, header.value_len, BinaryEncoding));
+      header = http_request_header_next(request);
       continue;
-    } else if (header->name_length == 12 &&
-               strncasecmp("content-type", header->name, 12) == 0) {
+    } 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_length, BinaryEncoding));
+          rb_enc_str_new(header.value, header.value_len, BinaryEncoding));
+      header = http_request_header_next(request);
       continue;
-    } else if (header->name_length == 27 &&
-               strncasecmp("x-forwarded-proto", header->name, 27) == 0) {
-      if (header->value_length >= 5 &&
-          !strncasecmp(header->value, "https", 5)) {
+    } else if (header.name_len == 27 &&
+               strncasecmp("x-forwarded-proto", header.name, 27) == 0) {
+      if (header.value_len >= 5 && !strncasecmp(header.value, "https", 5)) {
         rb_hash_aset(env, R_URL_SCHEME, HTTPS_SCHEME);
-      } else if (header->value_length == 4 &&
-                 *((uint32_t *)header->value) == *((uint32_t *)"http")) {
+      } else if (header.value_len == 4 &&
+                 *((uint32_t *)header.value) == *((uint32_t *)"http")) {
         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_length,
-                                    BinaryEncoding));
+        rb_hash_aset(
+            env, R_URL_SCHEME,
+            rb_enc_str_new(header.value, header.value_len, BinaryEncoding));
       }
-    } else if (header->name_length == 9 &&
-               strncasecmp("forwarded", header->name, 9) == 0) {
-      pos = (char *)header->value;
+    } else if (header.name_len == 9 &&
+               strncasecmp("forwarded", header.name, 9) == 0) {
+      pos = (char *)header.value;
       if (pos) {
         while (*pos) {
           if (((*(pos++) | 32) == 'p') && ((*(pos++) | 32) == 'r') &&
@@ -189,18 +208,20 @@ static inline VALUE copy2env(http_request_s *request) {
       }
     }
 
-    hname = rb_str_buf_new(6 + header->name_length);
+    hname = rb_str_buf_new(6 + header.name_len);
     memcpy(RSTRING_PTR(hname), "HTTP_", 5);
     pos = RSTRING_PTR(hname) + 5;
-    reader = header->name;
+    reader = header.name;
     while (*reader) {
       *(pos++) = *reader == '-' ? '_' : to_upper(*reader);
       ++reader;
     }
     *pos = 0;
-    rb_str_set_len(hname, 5 + header->name_length);
-    rb_hash_aset(env, hname, rb_enc_str_new(header->value, header->value_length,
-                                            BinaryEncoding));
+    rb_str_set_len(hname, 5 + header.name_len);
+    rb_hash_aset(
+        env, hname,
+        rb_enc_str_new(header.value, header.value_len, BinaryEncoding));
+    header = http_request_header_next(request);
   }
   return env;
 }
@@ -227,8 +248,8 @@ static int for_each_header_data(VALUE key, VALUE val, VALUE _res) {
     while (pos_e < val_len && val_s[pos_e] != '\n')
       pos_e++;
     http_response_write_header(
-        (void *)_res, .name = RSTRING_PTR(key), .name_length = RSTRING_LEN(key),
-        .value = val_s + pos_s, .value_length = pos_e - pos_s);
+        (void *)_res, .name = RSTRING_PTR(key), .name_len = RSTRING_LEN(key),
+        .value = val_s + pos_s, .value_len = pos_e - pos_s);
     // fprintf(stderr, "For_each - headers: wrote header\n");
     // move forward (skip the '\n' if exists)
     pos_s = pos_e + 1;
@@ -258,7 +279,6 @@ static VALUE for_each_body_string(VALUE str, VALUE _res, int argc, VALUE argv) {
       return Qfalse;
     }
   } else {
-    http_response_finish((void *)_res);
     return Qfalse;
   }
   return Qtrue;
@@ -285,24 +305,19 @@ static inline int ruby2c_response_send(http_response_s *response,
     // fprintf(stderr, "Review body as String\n");
     if (RSTRING_LEN(body))
       http_response_write_body(response, RSTRING_PTR(body), RSTRING_LEN(body));
-    http_response_finish(response);
     return 0;
   } else if (body == Qnil) {
-    http_response_finish(response);
     return 0;
   } else if (rb_respond_to(body, each_method_id)) {
     // fprintf(stderr, "Review body as for-each ...\n");
-    if (!response->metadata.connection_written &&
-        !response->metadata.content_length_written) {
+    if (!response->connection_written && !response->content_length_written) {
       // close the connection to indicate message length...
       // protection from bad code
-      response->metadata.should_close = 1;
+      response->should_close = 1;
       response->content_length = -1;
     }
     rb_block_call(body, each_method_id, 0, NULL, for_each_body_string,
                   (VALUE)response);
-    // make sure the response is sent even if it was an empty collection
-    http_response_finish(response);
     // 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);
@@ -318,24 +333,22 @@ static inline int ruby2c_review_upgrade(http_response_s *response,
     // send headers
     http_response_finish(response);
     //  remove socket from libsock and libserver
-    server_hijack(response->metadata.request->metadata.fd);
+    facil_attach(response->fd, NULL);
     // call the callback
     VALUE io_ruby = RubyCaller.call(rb_hash_aref(env, R_HIJACK), call_proc_id);
     RubyCaller.call2(handler, call_proc_id, 1, &io_ruby);
   } else if ((handler = rb_hash_aref(env, R_HIJACK_IO)) != Qnil) {
     // send nothing.
-    if (iodine_http_request_logging)
-      http_response_log_finish(response);
     http_response_destroy(response);
     // remove socket from libsock and libserver
-    server_hijack(response->metadata.request->metadata.fd);
+    facil_attach(response->fd, NULL);
   } else if ((handler = rb_hash_aref(env, UPGRADE_WEBSOCKET)) != Qnil ||
              (handler = rb_hash_aref(env, IODINE_WEBSOCKET)) != Qnil) {
     // use response as existing base for native websocket upgrade
-    iodine_websocket_upgrade(response->metadata.request, response, handler);
+    iodine_websocket_upgrade(response->request, response, handler);
   } else if ((handler = rb_hash_aref(env, UPGRADE_TCP)) != Qnil ||
              (handler = rb_hash_aref(env, IODINE_UPGRADE)) != Qnil) {
-    intptr_t fduuid = response->metadata.request->metadata.fd;
+    intptr_t fduuid = response->fd;
     // send headers
     http_response_finish(response);
     // upgrade protocol
@@ -353,9 +366,9 @@ static inline int ruby2c_review_upgrade(http_response_s *response,
 }
 
 static void *on_rack_request_in_GVL(http_request_s *request) {
-  http_response_s response = http_response_init(request);
+  http_response_s *response = http_response_create(request);
   if (iodine_http_request_logging)
-    http_response_log_start(&response);
+    http_response_log_start(response);
   // create /register env variable
   VALUE env = copy2env(request);
   // will be used later
@@ -371,7 +384,7 @@ static void *on_rack_request_in_GVL(http_request_s *request) {
     tmp = rb_funcall2(tmp, to_fixnum_func_id, 0, NULL);
   if (TYPE(tmp) != T_FIXNUM)
     goto internal_error;
-  response.status = FIX2ULONG(tmp);
+  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)
@@ -386,35 +399,37 @@ static void *on_rack_request_in_GVL(http_request_s *request) {
     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));
+  rb_hash_foreach(response_headers, for_each_header_data, (VALUE)(response));
   // If the X-Sendfile header was provided, send the file directly and finish
   if (xfiles != Qnil &&
-      http_response_sendfile2(&response, request, RSTRING_PTR(xfiles),
-                              RSTRING_LEN(xfiles), NULL, 0, 1) == 0) {
-    goto finish;
-  }
+      http_response_sendfile2(response, request, RSTRING_PTR(xfiles),
+                              RSTRING_LEN(xfiles), NULL, 0, 1) == 0)
+    goto external_done;
   // review for belated (post response headers) upgrade.
-  if (ruby2c_review_upgrade(&response, rbresponse, env) == 0) {
-    // send the request body.
-    if (ruby2c_response_send(&response, rbresponse, env))
-      goto internal_error;
-    // http_response_finish(&response);
-  }
-finish:
+  if (ruby2c_review_upgrade(response, rbresponse, env))
+    goto external_done;
+  // send the request body.
+  if (ruby2c_response_send(response, 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);
-  http_response_destroy(&response);
   return NULL;
 internal_error:
   Registry.remove(rbresponse);
   Registry.remove(env);
-  http_response_destroy(&response);
-  response = http_response_init(request);
+  http_response_destroy(response);
+  response = http_response_create(request);
   if (iodine_http_request_logging)
-    http_response_log_start(&response);
-  response.status = 500;
-  http_response_write_body(&response, "Error 500, Internal error.", 26);
-  http_response_finish(&response);
+    http_response_log_start(response);
+  response->status = 500;
+  http_response_write_body(response, "Error 500, Internal error.", 26);
+  http_response_finish(response);
   return NULL;
 }
 
@@ -484,6 +499,10 @@ Rack object API
 */
 
 int iodine_http_review(void) {
+  if ((getenv("RACK_ENV") && !strcasecmp(getenv("RACK_ENV"), "development")) ||
+      (getenv("RAILS_ENV") && !strcasecmp(getenv("RAILS_ENV"), "development")))
+    IODINE_IS_DEVELOPMENT_MODE = 1;
+
   rack_app_handler = rb_iv_get(IodineHttp, "@app");
   if (rack_app_handler != Qnil &&
       rb_respond_to(rack_app_handler, call_proc_id)) {
@@ -504,8 +523,11 @@ int iodine_http_review(void) {
         TYPE(rbport) != Qnil)
       rb_raise(rb_eTypeError,
                "The port variable must be either a Fixnum or a String.");
-    if (TYPE(rbport) == T_FIXNUM)
+    if (TYPE(rbport) == T_FIXNUM) {
       rbport = rb_funcall2(rbport, rb_intern("to_s"), 0, NULL);
+      // rb_ivar_set(self, rb_intern("_port"), port);
+      rb_iv_set(IodineHttp, "@port", rbport);
+    }
     if (TYPE(rbport) == T_STRING)
       port = StringValueCStr(rbport);
     // review address
@@ -554,26 +576,28 @@ int iodine_http_review(void) {
     VALUE iodine_version = rb_const_get(Iodine, rb_intern("VERSION"));
     VALUE ruby_version = rb_const_get(Iodine, rb_intern("RUBY_VERSION"));
     if (public_folder)
-      fprintf(stderr, "Starting up Iodine HTTP Server:\n"
-                      " * Ruby v.%s\n * Iodine v.%s \n"
-                      " * %lu max concurrent connections / open files\n"
-                      " * Serving static files from:\n"
-                      "           %s\n\n",
+      fprintf(stderr,
+              "Starting up Iodine HTTP Server:\n"
+              " * Ruby v.%s\n * Iodine v.%s \n"
+              " * %lu max concurrent connections / open files\n"
+              " * Serving static files from:\n"
+              "           %s\n\n",
               StringValueCStr(ruby_version), StringValueCStr(iodine_version),
               (size_t)sock_max_capacity(), public_folder);
     else
-      fprintf(stderr, "Starting up Iodine HTTP Server:\n"
-                      " * Ruby v.%s\n * Iodine v.%s \n"
-                      " * %lu max concurrent connections / open files\n"
-                      "\n",
+      fprintf(stderr,
+              "Starting up Iodine HTTP Server:\n"
+              " * Ruby v.%s\n * Iodine v.%s \n"
+              " * %lu max concurrent connections / open files\n"
+              "\n",
               StringValueCStr(ruby_version), StringValueCStr(iodine_version),
               (size_t)sock_max_capacity());
 
     // listen
-    return http1_listen(port, address, .on_request = on_rack_request,
-                        .log_static = iodine_http_request_logging,
-                        .max_body_size = max_body_size,
-                        .public_folder = public_folder, .timeout = timeout);
+    return http_listen(port, address, .on_request = on_rack_request,
+                       .log_static = iodine_http_request_logging,
+                       .max_body_size = max_body_size,
+                       .public_folder = public_folder, .timeout = timeout);
   }
   return 0;
 }

data/ext/iodine/iodine_websocket.c

@@ -25,7 +25,7 @@ size_t iodine_websocket_max_msg_size = 0;
 uint8_t iodine_websocket_timeout = 0;
 
 #define set_uuid(object, request)                                              \
-  rb_ivar_set((object), fd_var_id, ULONG2NUM((request)->metadata.fd))
+  rb_ivar_set((object), fd_var_id, ULONG2NUM((request)->fd))
 
 inline static intptr_t get_uuid(VALUE obj) {
   VALUE i = rb_ivar_get(obj, fd_var_id);
@@ -42,8 +42,8 @@ inline static ws_s *get_ws(VALUE obj) {
   return (ws_s *)FIX2ULONG(i);
 }
 
-#define set_handler(ws, handler) websocket_set_udata((ws), (VALUE)handler)
-#define get_handler(ws) ((VALUE)websocket_get_udata((ws_s *)(ws)))
+#define set_handler(ws, handler) websocket_udata_set((ws), (VALUE)handler)
+#define get_handler(ws) ((VALUE)websocket_udata((ws_s *)(ws)))
 
 /*******************************************************************************
 Buffer management - update to change the way the buffer is handled.
@@ -154,8 +154,8 @@ static VALUE iodine_ws_write(VALUE self, VALUE data) {
 /** Returns the number of active websocket connections (including connections
  * that are in the process of closing down). */
 static VALUE iodine_ws_count(VALUE self) {
-  ws_s *ws = get_ws(self);
-  return LONG2FIX(websocket_count(ws));
+  return LONG2FIX(websocket_count());
+  (void)self;
 }
 
 /**
@@ -165,7 +165,7 @@ return `true`, otherwise `false` will be returned.
 */
 static VALUE iodine_ws_has_pending(VALUE self) {
   intptr_t uuid = get_uuid(self);
-  return sock_packets_pending(uuid) ? Qtrue : Qfalse;
+  return sock_has_pending(uuid) ? Qtrue : Qfalse;
 }
 
 /**
@@ -236,7 +236,8 @@ static VALUE iodine_defer(int argc, VALUE *argv, VALUE self) {
     return Qfalse;
   Registry.add(block);
 
-  server_task(fd, iodine_perform_defer, (void *)block, iodine_defer_fallback);
+  facil_defer(.uuid = fd, .task = iodine_perform_defer, .arg = (void *)block,
+              .fallback = iodine_defer_fallback);
   return block;
 }
 
@@ -245,6 +246,8 @@ Websocket Multi-Write
 */
 
 static uint8_t iodine_ws_if_callback(ws_s *ws, void *block) {
+  if (!ws)
+    return 0;
   VALUE handler = get_handler(ws);
   uint8_t ret = 0;
   if (handler)
@@ -305,16 +308,15 @@ static void iodine_ws_perform_each_task(intptr_t fd, protocol_s *protocol,
   if (handler)
     RubyCaller.call2((VALUE)data, call_proc_id, 1, &handler);
 }
-static void iodine_ws_finish_each_task(intptr_t fd, protocol_s *protocol,
-                                       void *data) {
+static void iodine_ws_finish_each_task(intptr_t fd, void *data) {
   (void)(fd);
-  (void)(protocol);
   Registry.remove((VALUE)data);
 }
 
 inline static void iodine_ws_run_each(intptr_t origin, VALUE block) {
-  server_each(origin, WEBSOCKET_ID_STR, iodine_ws_perform_each_task,
-              (void *)block, iodine_ws_finish_each_task);
+  facil_each(.origin = origin, .service = WEBSOCKET_ID_STR,
+             .task = iodine_ws_perform_each_task, .arg = (void *)block,
+             .on_complete = iodine_ws_finish_each_task);
 }
 
 /** Performs a block of code for each websocket connection. The function returns
@@ -395,7 +397,8 @@ static VALUE iodine_class_defer(VALUE self, VALUE ws_uuid) {
     return Qfalse;
   Registry.add(block);
 
-  server_task(fd, iodine_perform_defer, (void *)block, iodine_defer_fallback);
+  facil_defer(.uuid = fd, .task = iodine_perform_defer, .arg = (void *)block,
+              .fallback = iodine_defer_fallback);
   return block;
 }
 
@@ -413,6 +416,7 @@ void ws_on_close(ws_s *ws) {
   if (!handler)
     return;
   RubyCaller.call(handler, on_close_func_id);
+  set_ws(handler, Qnil);
   Registry.remove(handler);
 }
 void ws_on_shutdown(ws_s *ws) {