rage-iodine 5.4.0 → 5.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ef6e88ecbc5910815537ef78329c6bc965261fb4514c479be7594fb6de61dca
-  data.tar.gz: '09632895e2ed3a00f6300a418c46b7f10332403f83aceeaffe77af57258f9baf'
+  metadata.gz: ce6be54873c53f93352aa7c739c74e73f5510eaeaab015bd2afc5e0fe261ff38
+  data.tar.gz: 45bba38d8c14f66e780981c13a05a7ca1d036a6809f71f33833e8743e285c32b
 SHA512:
-  metadata.gz: 6ce3edb67d9029b9a9bf73a941dcbcd7378214246cbbb5a09084f085dda5c2b41003dc75338a595f054e28db146cc713e887a3d43fffebefc80567d87348a94a
-  data.tar.gz: 3b2f347ecc8732f23ecac55bbc5c8c3d9d51b6e814bbb9b87f23d538f211ab6a605972b879f4449c3ce10fe95bc1920930304e604f53f5f593d5d889f4095c25
+  metadata.gz: be4a8fd787b970fb21e30d6ec21e590ca27da1122d62f7efeac532f5b2fffd920c7016d489bd5c1e748e9d559058c23c3f567edc0e99e1da34a4a81b2bdde70c
+  data.tar.gz: 25e51f20a4a572caab13708ca5496e73cbcbb90810c13bf1000d8cbb0a1ec75bf797ade820d756a2c30237ac37c254e89303d0adeb7b6f060133a6cc1edc708e

data/CHANGELOG.md

@@ -6,6 +6,16 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.5.5.0 (2026-07-06)
+
+**Update**: Update `pre_start` callbacks to fail the server launch in case of errors
+
+**Update**: Update media types in the MIME table
+
+**Update**: Ensure users can override headers when serving files
+
+**Update**: Support `x-sendfile-root` headers
+
 #### Change log v.5.4.0 (2026-06-08)
 
 **Update**: Optimize `fio_run_every` timers

data/ext/iodine/http.c

@@ -188,6 +188,26 @@ int http_set_header2(http_s *r, fio_str_info_s n, fio_str_info_s v) {
   return ret;
 }
 
+/**
+ * Sets a response header if it hasn't already been set.
+ *
+ * Returns -1 on error and 0 on success.
+ */
+static inline int http_set_header_if_none(http_s *r, FIOBJ name, FIOBJ value) {
+  if (HTTP_INVALID_HANDLE(r) || !name) {
+    fiobj_free(value);
+    return -1;
+  }
+
+  if (fiobj_hash_get2(r->private_data.out_headers, fiobj_obj2hash(name))) {
+    fiobj_free(value);
+    return 0;
+  }
+
+  fiobj_hash_set(r->private_data.out_headers, name, value);
+  return 0;
+}
+
 /**
  * Sets a response cookie, taking ownership of the value object, but NOT the
  * name object (so name objects could be reused in future responses).
@@ -461,12 +481,12 @@ no_gzip_support:
     return -1;
 found_file:
   /* set cache-control */
-  http_set_header(h, HTTP_HEADER_CACHE_CONTROL, fiobj_dup(HTTP_HVALUE_MAX_AGE));
+  http_set_header_if_none(h, HTTP_HEADER_CACHE_CONTROL, fiobj_dup(HTTP_HVALUE_MAX_AGE));
   /* set last-modified */
   FIOBJ last_modified_str = fiobj_str_buf(32);
   fiobj_str_resize(
       last_modified_str, http_time2str(fiobj_obj2cstr(last_modified_str).data, file_data.st_mtime));
-  http_set_header(h, HTTP_HEADER_LAST_MODIFIED, last_modified_str);
+  http_set_header_if_none(h, HTTP_HEADER_LAST_MODIFIED, last_modified_str);
   /* set & test etag */
   FIOBJ etag_str = fiobj_str_buf(1);
   fiobj_str_printf(etag_str, "%lx-%llx", file_data.st_mtime, file_data.st_size);
@@ -605,7 +625,7 @@ open_file:
       tmp = http_mimetype_find(s.data + pos, s.len - pos);
     }
     if (tmp)
-      http_set_header(h, HTTP_HEADER_CONTENT_TYPE, tmp);
+      http_set_header_if_none(h, HTTP_HEADER_CONTENT_TYPE, tmp);
   }
   http_sendfile(h, file, length, offset);
   return 0;

data/ext/iodine/http_internal.c

@@ -610,7 +610,7 @@ static void http_lib_init(void *ignr_) {
   REGISTER_MIME("jpgm", "video/jpm");
   REGISTER_MIME("jpgv", "video/jpeg");
   REGISTER_MIME("jpm", "video/jpm");
-  REGISTER_MIME("js", "application/javascript");
+  REGISTER_MIME("js", "text/javascript");
   REGISTER_MIME("json", "application/json");
   REGISTER_MIME("jsonml", "application/jsonml+json");
   REGISTER_MIME("kar", "audio/midi");
@@ -694,6 +694,7 @@ static void http_lib_init(void *ignr_) {
   REGISTER_MIME("mie", "application/x-mie");
   REGISTER_MIME("mif", "application/vnd.mif");
   REGISTER_MIME("mime", "message/rfc822");
+  REGISTER_MIME("mjs", "text/javascript");
   REGISTER_MIME("mj2", "video/mj2");
   REGISTER_MIME("mjp2", "video/mj2");
   REGISTER_MIME("mk3d", "video/x-matroska");
@@ -803,7 +804,7 @@ static void http_lib_init(void *ignr_) {
   REGISTER_MIME("osf", "application/vnd.yamaha.openscoreformat");
   REGISTER_MIME("osfpvg", "application/vnd.yamaha.openscoreformat.osfpvg+xml");
   REGISTER_MIME("otc", "application/vnd.oasis.opendocument.chart-template");
-  REGISTER_MIME("otf", "application/x-font-otf");
+  REGISTER_MIME("otf", "font/otf");
   REGISTER_MIME("otg", "application/vnd.oasis.opendocument.graphics-template");
   REGISTER_MIME("oth", "application/vnd.oasis.opendocument.text-web");
   REGISTER_MIME("oti", "application/vnd.oasis.opendocument.image-template");
@@ -1066,8 +1067,8 @@ static void http_lib_init(void *ignr_) {
   REGISTER_MIME("trm", "application/x-msterminal");
   REGISTER_MIME("tsd", "application/timestamped-data");
   REGISTER_MIME("tsv", "text/tab-separated-values");
-  REGISTER_MIME("ttc", "application/x-font-ttf");
-  REGISTER_MIME("ttf", "application/x-font-ttf");
+  REGISTER_MIME("ttc", "font/collection");
+  REGISTER_MIME("ttf", "font/ttf");
   REGISTER_MIME("ttl", "text/turtle");
   REGISTER_MIME("twd", "application/vnd.simtech-mindmapper");
   REGISTER_MIME("twds", "application/vnd.simtech-mindmapper");
@@ -1163,7 +1164,8 @@ static void http_lib_init(void *ignr_) {
   REGISTER_MIME("wmx", "video/x-ms-wmx");
   REGISTER_MIME("wmz", "application/x-ms-wmz");
   // REGISTER_MIME("wmz", "application/x-msmetafile");
-  REGISTER_MIME("woff", "application/font-woff");
+  REGISTER_MIME("woff", "font/woff");
+  REGISTER_MIME("woff2", "font/woff2");
   REGISTER_MIME("wpd", "application/vnd.wordperfect");
   REGISTER_MIME("wpl", "application/vnd.ms-wpl");
   REGISTER_MIME("wps", "application/vnd.ms-works");

data/ext/iodine/iodine_caller.c

@@ -152,6 +152,18 @@ static VALUE iodine_call(VALUE obj, ID method) {
   return (VALUE)rv;
 }
 
+/** Calls a Ruby method on a given object, without protecting against exceptions. */
+static VALUE iodine_call_unprotected(VALUE obj, ID method) {
+  iodine_rb_task_s task = {
+      .obj = obj,
+      .argc = 0,
+      .argv = NULL,
+      .method = method,
+  };
+  void *rv = iodine_enterGVL((void *(*)(void *))iodine_ruby_caller_perform, &task);
+  return (VALUE)rv;
+}
+
 /** Calls a Ruby method on a given object, protecting against exceptions. */
 static VALUE iodine_call2(VALUE obj, ID method, int argc, VALUE *argv) {
   iodine_rb_task_s task = {
@@ -223,6 +235,8 @@ struct IodineCaller_s IodineCaller = {
     .call = iodine_call,
     /** Calls a Ruby method on a given object, protecting against exceptions. */
     .call2 = iodine_call2,
+    /** Calls a Ruby method on a given object, without protecting against exceptions. */
+    .call_unprotected = iodine_call_unprotected,
     /** Returns the GVL state flag. */
     .in_GVL = iodine_in_GVL,
     /** Forces the GVL state flag. */

data/ext/iodine/iodine_caller.h

@@ -14,6 +14,8 @@ extern struct IodineCaller_s {
   VALUE (*call)(VALUE obj, ID method);
   /** Calls a Ruby method on a given object, protecting against exceptions. */
   VALUE (*call2)(VALUE obj, ID method, int argc, VALUE *argv);
+  /** Calls a Ruby method on a given object, without protecting against exceptions. */
+  VALUE (*call_unprotected)(VALUE obj, ID method);
   /** Calls a Ruby method on a given object, protecting against exceptions. */
   VALUE(*call_with_block)
   (VALUE obj, ID method, int argc, VALUE *argv, VALUE udata,

data/ext/iodine/iodine_defer.c

@@ -323,6 +323,12 @@ static void iodine_perform_state_callback_persist(void *blk_) {
   IodineCaller.call(blk, call_id);
 }
 
+/* performs a Ruby state callback without protecting against exceptions */
+static void iodine_perform_unprotected_state_callback_persist(void *blk_) {
+  VALUE blk = (VALUE)blk_;
+  IodineCaller.call_unprotected(blk, call_id);
+}
+
 // clang-format off
 /**
 Sets a block of code to run when Iodine's core state is updated.
@@ -357,7 +363,7 @@ static VALUE iodine_on_state(VALUE self, VALUE event) {
 
   if (state == STATE_PRE_START) {
     fio_state_callback_add(FIO_CALL_PRE_START,
-                           iodine_perform_state_callback_persist,
+                           iodine_perform_unprotected_state_callback_persist,
                            (void *)block);
   } else if (state == STATE_BEFORE_FORK) {
     fio_state_callback_add(FIO_CALL_BEFORE_FORK,

data/ext/iodine/iodine_http.c

@@ -102,6 +102,7 @@ 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_ROOT);        // 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
@@ -112,6 +113,7 @@ rack_declare(IODINE_HAS_BODY);
 typedef struct {
   http_s *h;
   FIOBJ body;
+  FIOBJ root;
   enum iodine_http_response_type_enum {
     IODINE_HTTP_NONE,
     IODINE_HTTP_SENDBODY,
@@ -716,6 +718,14 @@ static inline void *iodine_handle_request_in_GVL(void *handle_) {
     handle->body = fiobj_str_new(RSTRING_PTR(xfiles), RSTRING_LEN(xfiles));
     handle->type = IODINE_HTTP_XSENDFILE;
     rb_hash_delete(response_headers, XSENDFILE);
+    // extract optional root directory for path validation
+    VALUE xroot = rb_hash_aref(response_headers, XSENDFILE_ROOT);
+    if (xroot != Qnil && TYPE(xroot) == T_STRING) {
+      handle->root = fiobj_str_new(RSTRING_PTR(xroot), RSTRING_LEN(xroot));
+      rb_hash_delete(response_headers, XSENDFILE_ROOT);
+    } else {
+      handle->root = FIOBJ_INVALID;
+    }
     // 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.
@@ -782,8 +792,22 @@ iodine_perform_handle_action(iodine_http_request_handle_s handle) {
             .len == 7)
       fiobj_hash_delete2(handle.h->private_data.out_headers,
                          fiobj_obj2hash(HTTP_HEADER_CONTENT_ENCODING));
-    fio_str_info_s data = fiobj_obj2cstr(handle.body);
-    if (http_sendfile2(handle.h, data.data, data.len, NULL, 0)) {
+    fio_str_info_s file_data = fiobj_obj2cstr(handle.body);
+    int err;
+    if (handle.root != FIOBJ_INVALID) {
+      /* root dir specified - treat x-sendfile as relative/encoded path */
+      fio_str_info_s root_data = fiobj_obj2cstr(handle.root);
+      err = http_sendfile2(handle.h, root_data.data, root_data.len,
+                           file_data.data, file_data.len);
+      fiobj_free(handle.root);
+    } else {
+      /* no root dir - original behavior (absolute path as prefix) */
+      err = http_sendfile2(handle.h, file_data.data, file_data.len, NULL, 0);
+    }
+    if (err) {
+      fiobj_hash_clear(handle.h->private_data.out_headers);
+      http_set_header(handle.h, HTTP_HEADER_CACHE_CONTROL,
+                      fiobj_str_new("no-cache, max-age=0", 19));
       http_send_error(handle.h, 404);
     }
     fiobj_free(handle.body);
@@ -1181,10 +1205,11 @@ void iodine_init_http(void) {
   rack_set(QUERY_ESTRING, "");
   rack_set(R_URL_SCHEME, "rack.url_scheme");
   rack_set(R_INPUT, "rack.input");
-  rack_set(XSENDFILE, "X-Sendfile");
+  rack_set(XSENDFILE, "x-sendfile");
+  rack_set(XSENDFILE_ROOT, "x-sendfile-root");
   rack_set(XSENDFILE_TYPE, "sendfile.type");
   rack_set(XSENDFILE_TYPE_HEADER, "HTTP_X_SENDFILE_TYPE");
-  rack_set(CONTENT_LENGTH_HEADER, "Content-Length");
+  rack_set(CONTENT_LENGTH_HEADER, "content-length");
 
   rack_set(IODINE_R_INPUT, "rack.input");
   rack_set(IODINE_R_HIJACK_IO, "rack.hijack_io");

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '5.4.0'.freeze
+  VERSION = '5.5.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rage-iodine
 version: !ruby/object:Gem::Version
-  version: 5.4.0
+  version: 5.5.0
 platform: ruby
 authors:
 - Boaz Segev